cocos2dx基础篇(3) 常用重要类

• ----------------------------------------

• 入口类main.cpp

• 主要控制类AppDelegate.cpp

• ----------------------------------------

• 对象类CCObject

• 节点类CCNode

• ----------------------------------------

• 导演类CCDirector

• 场景类CCScene

• 图层类CCLayer

• 精灵类CCSprite

• ----------------------------------------

• 坐标类CCPoint

• 尺寸大小类CCSize

• 矩形类CCRect

• ----------------------------------------

• 数组类CCArray

• ----------------------------------------

入口类main.cpp

    这是应用程序的入口类，用于创建cocos2dx的AppDelegate实例、窗口大小、以及运行程序。

    主要代码如下：

	// 创建一个主控制类AppDelegate
    AppDelegate app;  
	// 使用OpenGL进行图形渲染
    CCEGLView* eglView = CCEGLView::sharedOpenGLView();
	// 窗口名
    eglView->setViewName("CocosStudy");
	// 窗口大小
    eglView->setFrameSize(480, 320);
	// 运行
    return CCApplication::sharedApplication()->run();

主要控制类AppDelegate.cpp

    游戏的入口，用于游戏的初始化，并创建第一个游戏界面。

    里面有3个方法：

	// 初始化
    virtual bool applicationDidFinishLaunching();

	// 切换到后台
    virtual void applicationDidEnterBackground();

	// 切换到前台
    virtual void applicationWillEnterForeground();

    源码：

// 初始化
bool AppDelegate::applicationDidFinishLaunching() { 

	// 创建导演
	CCDirector* pDirector = CCDirector::sharedDirector();
	// 使用OpenGLView
	pDirector->setOpenGLView(CCEGLView::sharedOpenGLView());
	// 设置游戏的设计分辨率
	CCEGLView::sharedOpenGLView()->setDesignResolutionSize(480, 320, kResolutionShowAll);

	// 关闭帧数显示
	pDirector->setDisplayStats(false);

	// 刷新频率，每秒60帧
	pDirector->setAnimationInterval(1.0 / 60);

	// 创建一个场景HelloWorld，游戏程序的第一个界面
	CCScene *pScene = HelloWorld::scene();

	// 运行场景
	pDirector->runWithScene(pScene);

	return true;
}

// 切换到后台
void AppDelegate::applicationDidEnterBackground() {

	// 暂停游戏
	CCDirector::sharedDirector()->stopAnimation();

	// 暂停音乐，需要时打开
	//SimpleAudioEngine::sharedEngine()->pauseBackgroundMusic();
}

// 切换到前台
void AppDelegate::applicationWillEnterForeground() {

	// 游戏恢复
	CCDirector::sharedDirector()->startAnimation();

	// 音乐恢复，需要时打开
	//SimpleAudioEngine::sharedEngine()->resumeBackgroundMusic();
}

  在main.cpp中，我们设置了分辨率“eglView->setFrameSize(480, 320)”(1)，在这里我们又设置了分辨率“CCEGLView::sharedOpenGLView()->setDesignResolutionSize(480,320,kResolutionShowAll)”(2)，但是它们的意义不同。(1)是根据我们的期望屏幕大小设置的，(2)是设计时的游戏分辨率，我们最初的设计是在电脑上完成的，这个大小是在电脑上显示的大小，但是游戏移植到手机后，手机型号不同，所以后面的参数kResolutionShowAll表示按照原比例(480x320)进行缩放来适配手机屏幕。

    如果图片的大小为1x1，setFrameSize(1, 1),那么setDesignResolutionSize(1,1)后，即使没有设置kResolutionShowAll，图片也能铺满整个屏幕。但是，如果setFrameSize(2, 2)，如果setDesignResolutionSize(2,2)后，如果没有设置kResolutionShowAll，那么图片只会铺满屏幕的1/4，只有设置kResolutionShowAll，屏幕才会缩放到整个屏幕。

对象类CCObject

    这个类是所有类的开始，主要包含了节点的内存管理机制，内存的释放、保留、复制等操作。

    有兴趣的可以自己去找资料学一下内存管理机制。

    主要函数如下：

void release(void);                                   //释放资源
void retain(void);                                    //保留资源,不被回收
CCObject* autorelease(void);                          //设置实例对象的释放由内存管理器进行管理,实现自动释放
CCObject* copy(void);                                 //拷贝对象
bool isSingleReference(void) const;                   //判断对象是否只有一个使用者
unsigned int retainCount(void) const;                 //返回内存计数器,即对象的使用者个数
virtual bool isEqual(const CCObject* pObject);        //判断是否与pObject对象相同
virtual void update(float dt) {CC_UNUSED_PARAM(dt);}; //更新函数,与scheduleUpdate()对应
friend class CCAutoreleasePool;                       //友元类,管理对象的内存使用情况
//

 

节点类CCNode

    CCNode类是绝大部分类的父类（并不是所有的类，例如CCDirector类是直接继承CCObject类的），如CCScene、CCLayer、CCSprite以及精灵集合CCSpriteBatchNode等等等等的父类都是CCNode。

    CCNode类包含了一些基本的属性、节点相关、Action动作的执行、以及定时器等相关的操作。

    当然CCNode也有父类，其父类为CCObject。

    继承关系如下：

主要函数如下：

/**
 *    属性相关函数
 *    Visible , ContentSize , Position , AnchorPoint , 
 *    ZOrder , Scale , Skew , Rotation
 */

//设置节点是否可见.
virtual void setVisible(bool visible);
virtual bool isVisible();

//设置节点的尺寸大小.即节点的容器大小.
virtual void setContentSize(const CCSize& contentSize);
virtual const CCSize& getContentSize() const;

//设置节点的坐标(x,y).在OpenGL中的坐标
virtual void setPosition(const CCPoint &position); //传参为坐标类CCPoint
virtual const CCPoint& getPosition();
virtual void setPosition(float x, float y);
virtual void getPosition(float* x, float* y);
virtual void  setPositionX(float x);
virtual float getPositionX(void);
virtual void  setPositionY(float y);
virtual float getPositionY(void);

//设置节点的锚点.
//锚点就像一枚图钉,将图片钉在屏幕上.而锚点就是图片的坐标.
//当然图钉可以钉在图片的左下角,右上角,或者中心都可以.
//一般由CCNode继承的子类大多锚点都在中心,也有些是在左下角.
virtual void setAnchorPoint(const CCPoint& anchorPoint);
virtual const CCPoint& getAnchorPoint();
virtual const CCPoint& getAnchorPointInPoints();

//设置节点的Z轴.
//当有多个节点在Z轴显示时,引擎会根据它们Z轴的大小决定绘制顺序,Z轴大的会遮盖Z轴小的
virtual void setZOrder(int zOrder);
virtual int getZOrder();

//设置节点的放缩比例.对X轴或Y轴进行放缩
//例如一张图片. 放缩它的宽X,和高Y
virtual void setScaleX(float fScaleX);              //放缩宽X
virtual float getScaleX();
virtual void setScaleY(float fScaleY);              //放缩高Y
virtual float getScaleY();
virtual void setScale(float scale);                 //同时放缩X与Y
virtual float getScale();
virtual void setScale(float fScaleX,float fScaleY); //X放缩fScaleX倍,Y放缩fScaleY倍

//设置节点的倾斜角度.与平面的倾斜角度
//如一张图片. X轴倾斜fSkewX角度,Y轴倾斜fSkewY角度
virtual void setSkewX(float fSkewX);
virtual float getSkewX();
virtual void setSkewY(float fSkewY);
virtual float getSkewY();

//设置节点旋转角度.
virtual void setRotation(float fRotation);
virtual float getRotation();
virtual void setRotationX(float fRotaionX);
virtual float getRotationX();
virtual void setRotationY(float fRotationY);
virtual float getRotationY();


/**
 *    节点相关函数
 *    addChild , removeChild , setParent , removeFromParent ,
 *    reorderChild , sortAllChildren , setTag , 
 *    getCamera , isRunning , cleanup , 
 *    draw , visit , boundingBox ,
 *    onEnter , onEnterTransitionDidFinish , onExit
 */

//添加子节点.zOrder默认为0.
//tag为节点编号,可以通过tag获取子节点.
virtual void addChild(CCNode * child);
virtual void addChild(CCNode * child, int zOrder);
virtual void addChild(CCNode* child, int zOrder, int tag);
virtual CCNode * getChildByTag(int tag);
virtual CCArray* getChildren();                    //获得所有子节点,并以CCArray数组返回
virtual unsigned int getChildrenCount(void) const; //子节点个数

//删除子节点.
virtual void removeChild(CCNode* child);
virtual void removeChild(CCNode* child, bool cleanup);
virtual void removeChildByTag(int tag);
virtual void removeChildByTag(int tag, bool cleanup);
virtual void removeAllChildren();                        //删除所有节点
virtual void removeAllChildrenWithCleanup(bool cleanup); //cleanup为true则删除子节点的所有动作

//设置父节点.
virtual void setParent(CCNode* parent);
virtual CCNode* getParent();

//从父节点中移除该节点.
//Cleanup为true则删除当前节点的所有动作及回调函数.
virtual void removeFromParent();
virtual void removeFromParentAndCleanup(bool cleanup);

//重新设定节点的zOrder
virtual void reorderChild(CCNode * child, int zOrder);
//重新排序所有子节点
virtual void sortAllChildren();

//设置节点的tag编号
virtual void setTag(int nTag);
virtual int getTag() const;

//获取节点的CCCamera摄像机
virtual CCCamera* getCamera();
//判断节点是否在运行
virtual bool isRunning();
//停止所有运行的动作和回调函数
virtual void cleanup(void);

//绘制节点.
//draw里有好多绘制方法.如直线,曲线,矩形,圆等
virtual void draw(void);
//递归访问所有子节点,并重新绘制
virtual void visit(void);

//返回节点的矩形边界框
CCRect boundingBox(void);

//节点开始进入舞台时调用.即创建时调用.
virtual void onEnter();
//节点进入舞台后调用.即创建完后调用.
virtual void onEnterTransitionDidFinish();
//节点离开舞台时调用.即移除时调用
virtual void onExit();


/**
 *    Action动作相关
 *    runAction , stopAction , getActionByTag , numberOfRunningActions
 */

//执行动作
CCAction* runAction(CCAction* action);

//暂停动作
void stopAllActions(void);
void stopAction(CCAction* action);
void stopActionByTag(int tag);

CCAction* getActionByTag(int tag);         //根据tag标记获取动作
unsigned int numberOfRunningActions(void); //获取正在运行的动作数量


/**
 *    定时器相关函数
 *    scheduleUpdate , schedule , update
 */

//开启默认定时器.刷新次数为60次/秒.即每秒60帧.
//与update(float delta)回调函数相对应.
//给予定时器优先级priority.其中priority越小,优先级越高
void scheduleUpdate(void);
void scheduleUpdateWithPriority(int priority);
void unscheduleUpdate(void);      //取消默认定时器
virtual void update(float delta); //update为scheduleUpdate定时器的回调函数.

//设置自定义定时器.默认为每秒60帧.
//interval	:	每隔interval秒,执行一次.
//repeat	:	重复次数.
//delay		:	延迟时间,即创建定时器delay后开始执行.
void schedule(SEL_SCHEDULE selector, float interval, unsigned int repeat, float delay);
void schedule(SEL_SCHEDULE selector, float interval);
void scheduleOnce(SEL_SCHEDULE selector, float delay); //只执行一次,delay秒后执行
void schedule(SEL_SCHEDULE selector);                  //默认为每秒60帧
void unschedule(SEL_SCHEDULE selector);                //取消定时器

void unscheduleAllSelectors(void);                     //取消所有定时器
void pauseSchedulerAndActions(void);                   //暂停所有定时器和动作
void resumeSchedulerAndActions(void);                  //恢复所有定时器和动作
//

导演类CCDirector

    就和现实中的导演一样，这里的导演也是起到指导的作用的。导演在这里负责的就是让不同的场景切换，控制整个游戏的流程，包括开始，继续，暂停等。以及设置、获取系统信息，比如调整OpenGL相关的设置，获取屏幕的大小等。

    和CCScene、CCLayer、CCSprite等不同的是，导演类CCDirector是直接继承CCObject类的，而不是CCNode类。

    继承关系如下：

  主要函数如下：

class CC_DLL CCDirector : public CCObject, public TypeInfo
{

//获取全局唯一的CCDirector实例
//使用方法：CCDirector::sharedDirector()->replaceScene(scene);
static CCDirector* sharedDirector(void);


/**
 *	场景管理相关
 *	runWithScene , pushScene , popScene , popToRootScene , replaceScene ,
 *	pause , resume , end , 
 */

//指定进入Director的主循环运行的场景.
//ps：仅在运行第一个场景时调用,如果已经存在运行中的场景,不能调用本方法.
//本方法调用后将调用pushScene方法,然后调用startAnimation.
void runWithScene(CCScene *pScene);

//将运行中的场景暂停,并push到场景堆栈中,运行新的场景.
void pushScene(CCScene *pScene);

//从场景堆栈中pop出一个场景,替换现在正运行的场景,而运行中的场景将被删除.
void popScene(void);

//从场景堆栈中pop出所有场景,最后一个栈底的场景将替换现在正运行的场景,而运行中的场景将被删除.
void popToRootScene(void);

//使用新场景替换当前场景,而运行中的场景将被删除.
//PS：旧场景不压入堆栈,而是直接删除.
void replaceScene(CCScene *pScene);

void pause(void);  //暂停场景
void resume(void); //恢复被暂停的场景
void end(void);    //终止执行,释放运行中的场景. 而OpenGL view需要手动移除.

//获取当前运行的场景. 导演在某一时刻只能运行一个场景
inline CCScene* getRunningScene(void) { return m_pRunningScene; }

//是否暂停
inline bool isPaused(void) { return m_bPaused; }

//场景替换时是否接收到Cleanup事件.即是否清除场景.
//若新场景是push进来的，旧场景不会接收到Cleanup事件  
//若新场景是replace进来的，旧场景会接收到Cleanup事件
inline bool isSendCleanupToScene(void) { return m_bSendCleanupToScene; }


/**
 *	刷新帧数FPS相关
 *	setAnimationInterval , setDisplayStats
 */

//设置程序的FPS值. 即刷新频率,相连两帧的时间间隔.
//如dValue = 1.0/60.0 表示每秒60帧.
virtual void setAnimationInterval(double dValue) = 0;
inline double getAnimationInterval(void) { return m_dAnimationInterval; }

//是否在程序屏幕的左下角显示FPS值
inline void setDisplayStats(bool bDisplayStats) { m_bDisplayStats = bDisplayStats; }
//判断是否有显示FPS值
inline bool isDisplayStats(void) { return m_bDisplayStats; }

//获取每帧间隔的秒数
inline float getSecondsPerFrame() { return m_fSecondsPerFrame; }

//从CCDirector开机后,总共已经渲染了多少帧
inline unsigned int getTotalFrames(void) { return m_uTotalFrames; }


/**
 *	OpenGL图形渲染相关
 */

//设置CCEGLView.即OpenGL图形渲染
inline CCEGLView* getOpenGLView(void) { return m_pobOpenGLView; }
void setOpenGLView(CCEGLView *pobOpenGLView);

//设置OpenGL的Projection
void setProjection(ccDirectorProjection kProjection);
inline ccDirectorProjection getProjection(void) { return m_eProjection; }

//设置OpenGL的glViewport
void setViewport();


/**
 *	OpenGL View视图相关
 */

//获取OpenGL view的大小,单位为点.
//类似手机屏幕的大小.参照"主要控制类AppDelegate.cpp"中的图片.
CCSize getWinSize(void);
//获取OpenGL view的大小,单位为像素.
CCSize getWinSizeInPixels(void);

//获取OpenGL View可视区域大小,单位为点.
//类似程序的游戏区域.参照"主要控制类AppDelegate.cpp"中的图片.
CCSize getVisibleSize();

//获取可视区域的原点坐标.一般为程序游戏区域的左下角坐标.
CCPoint getVisibleOrigin();

//将UIKit坐标与OpenGL坐标的相互转换
//UIKit坐标：原点在屏幕的左上角. 从左到右,从上到下.
//OpenGL坐标：原点在屏幕的左下角.从左到右,从下到上.
CCPoint convertToGL(const CCPoint& obPoint); //转为GL坐标
CCPoint convertToUI(const CCPoint& obPoint); //转为UI坐标


/**
 *	其他
 */

//开始动画
virtual void startAnimation(void) = 0; 
//停止动画
virtual void stopAnimation(void) = 0; 

//绘制场景,每帧都会自动调用,无需手动.
void drawScene(void); 

//删除缓存数据。包括CCTextureCache、CCSpriteFrameCache、CCLabelBMFont缓存数据
void purgeCachedData(void);

}
//

场景类CCScene

    CCScene是继承与CCNode类的。作为场景类，它却只有两个函数init和create。因为场景就像是一个容器，将不同的图层（CCLayer）组合在一起，方便管理。

    一个游戏会有很多的场景，比如，主界面，游戏界面，载入界面等等都是一个场景。而每一个场景都是由多个图层组合在一起，形成一个完整的游戏画面。

    其实在 cocos2dx基础篇(3)——第一个程序HelloWorld 中就出现了CCScene的创建，以及将HelloWorld图层放入该CCScene中。

    继承关系如下：

以下为CCScene的源码：

class CC_DLL CCScene : public CCNode
{
public:
    CCScene();
    virtual ~CCScene();
    bool init();
    static CCScene *create(void);
};

bool CCScene::init()
{
    bool bRet = false;
     do {
         CCDirector * pDirector;
         CC_BREAK_IF( ! (pDirector = CCDirector::sharedDirector()) );
         this->setContentSize(pDirector->getWinSize());
         // success
         bRet = true;
     } while (0);
     return bRet;
}

CCScene *CCScene::create()
{
    CCScene *pRet = new CCScene();
    if (pRet && pRet->init()) {
        pRet->autorelease();
        return pRet;
    }
    else {
        CC_SAFE_DELETE(pRet);
        return NULL;
    }
}
//

图层类CCLayer

    CCLayer继承于四个父类: CCNode, CCTouchDelegate, CCAccelerometerDelegate, CCKeypadDelegate。

    CCLayer不仅继承了CCNode的所有操作，还附加触屏、重力加速度计、支持输入功能。

    一个图层(CCLayer)可以包含多个元素，如标签(CCLabel)、菜单(CCMenu)、精灵(CCSprite)等等。

    注意：CCLayer的锚点默认为(0,0)，即左下角。并且忽略锚点的设置，即使你setAnchorPoint了锚点，CCLayer的锚点也不会改变，依然是（0,0）。

  继承关系如下：

主要函数如下：

class CC_DLL CCLayer : public CCNode, public CCTouchDelegate, public CCAccelerometerDelegate, public CCKeypadDelegate
{

//创建一个静态图层对象
static CCLayer *create(void);

virtual void onEnter();                    //进入图层回调函数
virtual void onExit();                     //退出图层回调函数
virtual void onEnterTransitionDidFinish(); //场景转换后的回调函数


/**
 *	触屏事件相关
 *	分为单点触屏、多点触屏
 *	ccTouchBegan , ccTouchMoved , ccTouchEnded , ccTouchCancelled ,
 *	registerWithTouchDispatcher , TouchEnabled , TouchMode , TouchPriority
 */

//单点触屏接口的回调函数
virtual bool ccTouchBegan(CCTouch *pTouch, CCEvent *pEvent);     //触屏开始
virtual void ccTouchMoved(CCTouch *pTouch, CCEvent *pEvent);     //触屏移动
virtual void ccTouchEnded(CCTouch *pTouch, CCEvent *pEvent);     //触屏结束
virtual void ccTouchCancelled(CCTouch *pTouch, CCEvent *pEvent); //触屏取消
//多点触屏接口的回调函数
virtual void ccTouchesBegan(CCSet *pTouches, CCEvent *pEvent);
virtual void ccTouchesMoved(CCSet *pTouches, CCEvent *pEvent);
virtual void ccTouchesEnded(CCSet *pTouches, CCEvent *pEvent);
virtual void ccTouchesCancelled(CCSet *pTouches, CCEvent *pEvent);

//注册触屏侦听事件
//默认是：CCTouchDispatcher::sharedDispatcher()->addStandardDelegate(this,0);
//例如：
//	void CCLayer::registerWithTouchDispatcher() {
//		CCTouchDispatcher::sharedDispatcher()->addTargetedDelegate(this,INT_MIN+1,true); }
virtual void registerWithTouchDispatcher(void); 
//注册脚本触屏事件
virtual void registerScriptTouchHandler(int nHandler, bool bIsMultiTouches = false, int nPriority = INT_MIN, bool bSwallowsTouches = false); 
//注销脚本触屏事件
virtual void unregisterScriptTouchHandler(void); 

//设置是否接受触屏
virtual void setTouchEnabled(bool value); 
virtual bool isTouchEnabled();

//设置触屏模式. 同时响应,还是逐个响应
virtual void setTouchMode(ccTouchesMode mode);
virtual int getTouchMode();

//设置触屏的优先级. 默认为0,且priority越小优先级越高.
virtual void setTouchPriority(int priority);
virtual int getTouchPriority();
	

/**
 *	键盘输入相关
 */

//设置是否接受键盘输入
virtual bool isKeypadEnabled();
virtual void setKeypadEnabled(bool value);

//注册,注销 脚本键盘输入
void registerScriptKeypadHandler(int nHandler); 
void unregisterScriptKeypadHandler(void);

//返回键和菜单键的回调函数,需要设置接收键盘事件
virtual void keyBackClicked(void);
virtual void keyMenuClicked(void);


/**
 *	加速度计相关. 即重力感应.
 *	类似重力加速,不同的是加速度计分别在X轴,Y轴,Z轴都有一个相应的加速度.
 *	didAccelerate , registerScriptAccelerateHandler ,
 *	AccelerometerEnabled , AccelerometerInterval
 */

//加速度计信息
virtual void didAccelerate(CCAcceleration* pAccelerationValue); //加速度计信息
void registerScriptAccelerateHandler(int nHandler);             //注册加速度计
void unregisterScriptAccelerateHandler(void);                   //注销加速度计

//设置是否接受加速度计的信息
virtual bool isAccelerometerEnabled();
virtual void setAccelerometerEnabled(bool value);
virtual void setAccelerometerInterval(double interval);         //设置加速度计的时间间隔

}
//

精灵类CCSprite

    精灵说简单一点，其实就是一个2D的图片。并赋予图片各种属性以及特性。如大小、颜色、放缩、旋转、动作等。精灵一般都是放在图层(CCLayer)上面的，即一个图层(CCLayer)应当有许多的精灵存在。精灵可以用来当做背景、人物、鸟、白云等内容。

    CCSprite不仅继承了CCNode，还继承两个协议类：CCNodeRGBAProtocol和 CCTextureProtocol。

    其中CCNodeRGBAProtocol协议类主要负责颜色的管理；而CCTextureProtocol协议类主要负责纹理图片的管理。

    注意：精灵的锚点默认为(0.5,0.5)，即中心点。

    继承关系如下：

    主要函数如下：

class CC_DLL CCSprite : public CCNodeRGBA, public CCTextureProtocol
{

/**
 *	创建精灵相关create
 *	create , createWithTexture , 
 *	createWithSpriteFrame , createWithSpriteFrameName
 */

//注意事项：
//从大图中截取某一区域的图片的CCRect rect的构造应该是这样的：
//		CCRect("小图左上角坐标x", "小图左上角坐标y", 小图宽, 小图高)
//这与cocos2dx的坐标系是不一样的
static CCSprite* create();                                                     //默认创建空精灵对象
static CCSprite* create(const char *pszFileName);                              //图片文件
static CCSprite* create(const char *pszFileName, const CCRect& rect);          //截取图片文件中某一区域图片
static CCSprite* createWithTexture(CCTexture2D *pTexture);                     //纹理图片
static CCSprite* createWithTexture(CCTexture2D *pTexture, const CCRect& rect); //截取纹理图片中某一区域图片
static CCSprite* createWithSpriteFrame(CCSpriteFrame *pSpriteFrame);           //精灵帧. 精灵帧一般是从plist中读取的
static CCSprite* createWithSpriteFrameName(const char *pszSpriteFrameName);    //精灵帧的名字


/**
 *	初始化精灵相关init
 *	一般在精灵create的时候,就会调用相对应的init函数. 
 *	init , initWithTexture , 
 *	initWithSpriteFrame , initWithSpriteFrameName , 
 *	initWithFile
 */

virtual bool init(void);                                                               //默认初始化
virtual bool initWithTexture(CCTexture2D *pTexture);                                   //纹理图片
virtual bool initWithTexture(CCTexture2D *pTexture, const CCRect& rect);               //截取纹理图片中某一区域图片
virtual bool initWithTexture(CCTexture2D *pTexture, const CCRect& rect, bool rotated); //截取纹理图片中某一区域图片,是否旋转
virtual bool initWithSpriteFrame(CCSpriteFrame *pSpriteFrame);                         //精灵帧. 精灵帧一般是从plist中读取的
virtual bool initWithSpriteFrameName(const char *pszSpriteFrameName);                  //精灵帧的名字
virtual bool initWithFile(const char *pszFilename);                                    //图片文件
virtual bool initWithFile(const char *pszFilename, const CCRect& rect);                //截取图片文件中某一区域图片
    

/**
 *	继承于节点类CCNode的函数
 *	Scale , Position , Rotation , Skew , VertexZ
 *	addChild , removeChild , reorderChild , sortAllChildren , 
 *	AnchorPoint , Visible , draw
 */

virtual void setScale(float fScale);
virtual void setScaleX(float fScaleX);
virtual void setScaleY(float fScaleY);
virtual void setPosition(const CCPoint& pos);
virtual void setRotation(float fRotation);
virtual void setRotationX(float fRotationX);
virtual void setRotationY(float fRotationY);
virtual void setSkewX(float sx);
virtual void setSkewY(float sy);
virtual void setVertexZ(float fVertexZ);
virtual void addChild(CCNode *pChild);
virtual void addChild(CCNode *pChild, int zOrder);
virtual void addChild(CCNode *pChild, int zOrder, int tag);
virtual void removeChild(CCNode* pChild, bool bCleanup);
virtual void removeAllChildrenWithCleanup(bool bCleanup);
virtual void reorderChild(CCNode *pChild, int zOrder);
virtual void sortAllChildren();
virtual void setAnchorPoint(const CCPoint& anchor);
virtual void ignoreAnchorPointForPosition(bool value);
virtual void setVisible(bool bVisible);
virtual void draw(void);


/**
 *	继承于颜色协议类CCNodeRGBA的函数
 *	Color , Opacity
 */

//RGB颜色
virtual void setColor(const ccColor3B& color3);                  //设置颜色
virtual void updateDisplayedColor(const ccColor3B& parentColor); //传递颜色

//透明度
virtual void setOpacity(GLubyte opacity);                   //设置透明度
virtual void setOpacityModifyRGB(bool modify);              //设置透明度是否随RGB颜色的变化而变化
virtual bool isOpacityModifyRGB(void);                      //判断透明度是否随RGB颜色的变化而变化
virtual void updateDisplayedOpacity(GLubyte parentOpacity); //传递透明度


/**
 *	继承于纹理协议类CCTextureProtocol的函数
 *	Texture , BlendFunc
 */
 
//设置精灵的纹理图片
virtual void setTexture(CCTexture2D *texture);
virtual CCTexture2D* getTexture(void);

//设置颜色混合方式
inline void setBlendFunc(ccBlendFunc blendFunc) { m_sBlendFunc = blendFunc; }
inline ccBlendFunc getBlendFunc(void) { return m_sBlendFunc; }


/**
 *	批节点CCSpriteBatchNode相关的函数
 *	CCSpriteBatchNode是精灵集合类,都使用同一张纹理图片.
 *	故将这些精灵成批进行渲染,以提高渲染速度.
 */

virtual void updateTransform(void);                               //更新四个值：position(x,y), rotation, scale
virtual CCSpriteBatchNode* getBatchNode(void);                    //如果精灵是由批节点渲染的，则返回批节点
virtual void setBatchNode(CCSpriteBatchNode *pobSpriteBatchNode); //设置批节点,不推荐使用


/**
 *	纹理Texture相关的函数
 */

//设置纹理区域
virtual void setTextureRect(const CCRect& rect);
virtual void setTextureRect(const CCRect& rect, bool rotated, const CCSize& untrimmedSize);
virtual void setVertexRect(const CCRect& rect);
    
	
/**
 *	精灵帧SpriteFrames & 动画Animation相关的函数
 *	
 */

virtual void setDisplayFrame(CCSpriteFrame *pNewFrame);  //设置新的显示精灵帧
virtual bool isFrameDisplayed(CCSpriteFrame *pFrame);    //返回精灵帧是否正在显示
virtual CCSpriteFrame* displayFrame(void);               //返回当前显示的精灵帧

//通过动画帧的第frameIndex那一帧来设置显示精灵帧
//动画帧是从CCAnimationCache中读取的
virtual void setDisplayFrameWithAnimationName(const char *animationName, int frameIndex);


/**
 * 	属性相关的函数
 */

//设置精灵是否需要更新
inline virtual void setDirty(bool bDirty) { m_bDirty = bDirty; }
inline virtual bool isDirty(void) { return m_bDirty; }

//返回四个值的信息：坐标(x,y),顶点,颜色
inline ccV3F_C4B_T2F_Quad getQuad(void) { return m_sQuad; }

//判断纹理是否被旋转
inline bool isTextureRectRotated(void) { return m_bRectRotated; }

//设置精灵在地图集TextureAtlas中的索引
inline void setAtlasIndex(unsigned int uAtlasIndex) { m_uAtlasIndex = uAtlasIndex; }
inline unsigned int getAtlasIndex(void) { return m_uAtlasIndex; }

//返回精灵区域,单位为点
inline const CCRect& getTextureRect(void) { return m_obRect; }

//如果采用批渲染,设置纹理地图集
inline void setTextureAtlas(CCTextureAtlas *pobTextureAtlas) { m_pobTextureAtlas = pobTextureAtlas; }
inline CCTextureAtlas* getTextureAtlas(void) { return m_pobTextureAtlas; }

//获取偏移值
inline const CCPoint& getOffsetPosition(void) { return m_obOffsetPosition; }

//设置是否翻转
void setFlipX(bool bFlipX);
void setFlipY(bool bFlipY);
bool isFlipX(void);
bool isFlipY(void);

};
//

坐标类CCPoint

    CCPoint既可以表示坐标点，又可以表示一个坐标向量。

    同时CCPoint对运算符进行的重载,可以很方便的完成CCPoint的赋值、加减乘除等操作。另外还有与坐标向量相关的：距离、角度、点积、叉积、投影、标准化等操作。

    当然cocos2dx也提供了许多有关CCPoint运算的宏定义与常量，如CCPointZero，CCPointMake，ccp，ccpAdd，ccpSub等。

    CCPoint可以使一个坐标点，也可以是一个坐标向量。

    主要函数如下：

class CC_DLL CCPoint
{
public:
    float x; //X坐标
    float y; //Y坐标

/**
 *	构造函数
 */
CCPoint();
CCPoint(float x, float y);
CCPoint(const CCPoint& other);
CCPoint(const CCSize& size);


/**
 *	运算符重载
 *	直接像int型一样相加减.如 p3 = p1 + p2
 */
CCPoint& operator= (const CCPoint& other);     //(other.x , other.y)
CCPoint& operator= (const CCSize& size);       //(size.width , size.height)
CCPoint operator+(const CCPoint& right) const; //(x1+x2 , y1+y2)
CCPoint operator-(const CCPoint& right) const; //(x1-x2 , y1-y2)
CCPoint operator-() const;                     //(-x , -y)
CCPoint operator*(float a) const;              //(x*a , y*a)
CCPoint operator/(float a) const;              //(x/a , y/a)


/**
 *	CCPoint的相关函数
 *	setPoint , forAngle , equals , fuzzyEquals ,
 *	getLength , getDistance , getAngle , getPerp , rotateByAngle , 
 *	dot , cross , project , normalize ,
 *	rotate , unrotate , lerp
 */

//设置坐标
void setPoint(float x, float y);

//根据角度,计算向量坐标x=cos(a) , y=sin(a)
//这是一个static静态函数
static inline CCPoint forAngle(const float a) { return CCPoint(cosf(a), sinf(a)); }

//判断是否与target相等
bool equals(const CCPoint& target) const;

//判断target是否在坐标点模糊偏差为var的范围内.
//if( (x - var <= target.x && target.x <= x + var) && 
//	  (y - var <= target.y && target.y <= y + var) ) 
//		return true;
bool fuzzyEquals(const CCPoint& target, float variance) const;


//与原点的距离
//与原点的距离平方,即x*x + y*y.
//与other的距离
//与other的距离平方
inline float getLength() const { return sqrtf(x*x + y*y); };
inline float getLengthSq() const { return dot(*this); };
inline float getDistance(const CCPoint& other) const { return (*this - other).getLength(); };
inline float getDistanceSq(const CCPoint& other) const { return (*this - other).getLengthSq(); };

//与X轴的夹角; 与other向量的夹角. 单位为:弧度
inline float getAngle() const { return atan2f(y, x); };
float getAngle(const CCPoint& other) const;

//Perp逆时针旋转90度; RPerp顺时针旋转90度
inline CCPoint getPerp() const { return CCPoint(-y, x); };
inline CCPoint getRPerp() const { return CCPoint(y, -x); };

//以pivot为圆心,将坐标逆时针旋转angle度
CCPoint rotateByAngle(const CCPoint& pivot, float angle) const;


//计算两点的 "点积dot" 和 "叉积cross"
inline float dot(const CCPoint& other) const { return x*other.x + y*other.y; };
inline float cross(const CCPoint& other) const { return x*other.y - y*other.x; };

//向量在other上的投影向量
//公式参考: http://www.cnblogs.com/graphics/archive/2010/08/03/1791626.html
inline CCPoint project(const CCPoint& other) const { return other * (dot(other)/other.dot(other)); };

//向量标准化,即长度为1. PS: 如果是零向量,返回(1,0);
inline CCPoint normalize() const {
	float length = getLength();
	if(length == 0.0) return CCPoint(1.0f, 0);
	return *this / getLength();
};


/**
 *	未知函数
 */

//复合乘法???
//angle = this.getAngle() + other.getAngle()
//length = this.getLength() * other.getLength()
inline CCPoint rotate(const CCPoint& other) const { 
	return CCPoint(x*other.x - y*other.y, x*other.y + y*other.x); 
};

//反复合乘法???
//angle = this.getAngle() - other.getAngle()
//length = this.getLength() * other.getLength()
inline CCPoint unrotate(const CCPoint& other) const { 
	return CCPoint(x*other.x + y*other.y, y*other.x - x*other.y); 
};

//线性内插法???
inline CCPoint lerp(const CCPoint& other, float alpha) const {
	return *this * (1.f - alpha) + other * alpha;
};

};
//

尺寸大小类CCSize

    CCSize比较简单，只是一个用来表示尺寸大小的类。宽为width，高为height。

    和CCPoint一样，也对运算符进行了重载。

    目前好像就找到两个宏定义与常量：CCSizeMake 和 CCSizeZero。

    主要函数如下：

class CC_DLL CCSize
{
public:
    float width;  //宽度
    float height; //高度

/**
 *	构造函数
 */
CCSize();                          //(0 , 0)
CCSize(float width, float height); //(width , height)
CCSize(const CCSize& other);       //(other.width , other.height)
CCSize(const CCPoint& point);      //(point.x , point.y)

/**
 *	运算符重载
 *	直接像int型一样相加减.如 p3 = p1 + p2
 */
CCSize& operator= (const CCSize& other);     //this = other
CCSize& operator= (const CCPoint& point);    //width=point.x , height=point.y
CCSize operator+(const CCSize& right) const; //width+right.width , height+right.height
CCSize operator-(const CCSize& right) const; //width-right.width , height-right.height
CCSize operator*(float a) const;             //width*a , height*a
CCSize operator/(float a) const;             //width/a , height/a
	
/**
 *	CCSize的相关函数
 *	setSize , equals
 */

//设置尺寸大小
void setSize(float width, float height);

//判断两尺寸是否相等
bool equals(const CCSize& target) const;

};
//

矩形类CCRect

    CCRect是一个矩形类。包含：起始坐标（左下角坐标）CCPoint、矩阵的尺寸大小CCSize两个属性。

    CCRect只对“=”运算符进行了重载。目前好像就找到两个宏定义与常量：CCRectMake，CCRectZero。

    值得注意的是CCRect类中：

        intersectsRect函数，可以用作两个CCRect矩形是否相交，即碰撞检测。

        containsPoint 函数，可以用作判断点CCPoint是否在CCRect矩形中。

    若用CCRect来作为创建CCSprite精灵的参数，需要注意，从大图中截取某一区域的图片的CCRect rect的构造应该是这样的：

    CCRect("小图左上角坐标x", "小图左上角坐标y", 小图宽, 小图高);

    这与cocos2dx的坐标系是不一样的。

    如下图所示：

  主要函数如下：

class CC_DLL CCRect
{
public:
    CCPoint origin; //起始坐标: 左下角坐标
    CCSize  size;   //尺寸大小

/**
 *	构造函数
 */
CCRect();
CCRect(float x, float y, float width, float height);
CCRect(const CCRect& other);


/**
 *	运算符重载
 *	只重载了 “=” 运算符
 */
CCRect& operator= (const CCRect& other);


/**
 *	CCRect的相关函数
 *	setRect , getMinX , getMidX , getMaxX
 *	equals , containsPoint , intersectsRect
 */

//设置矩形
void setRect(float x, float y, float width, float height);

//
float getMinX() const; //origin.x
float getMidX() const; //origin.x + size.width/2
float getMaxX() const; //origin.x + size.width
float getMinY() const; //origin.y
float getMidY() const; //origin.y + size.height/2
float getMaxY() const; //origin.y + size.height
	
//判断是否与rect相同. 原点相同,尺寸相同.
bool equals(const CCRect& rect) const;

//判断point是否包含在矩形内或四条边上
bool containsPoint(const CCPoint& point) const;

//判断矩形是否相交. 常常用作碰撞检测.
bool intersectsRect(const CCRect& rect) const;

};
//

数组类CCArray

    继承于CCObject类，本质是将ccArray相关的函数操作进行了封装处理。对于ccArray有兴趣的自己了解一下。

    宏定义：

        CCARRAY_FOREACH(CCArray* arr, CCObject* obj);         //遍历CCArrray数组
        CCARRAY_FOREACH_REVERSE(CCArray* arr, CCObject* obj); //逆序遍历

CCArray类终点数据类型为ccArray：

typedef struct _ccArray {
	unsigned int num; //元素个数
	unsigned int max; //数组容量. 和num不一样,一般max>=num.
	//二重指针,相当于是指向 CCobject*数组 的指针.
	//每个元素用arr[i]来读取,这是一个指向第i个索引的CCObject*
	CCObject** arr; 
} ccArray;
//

    当然在我们添加元素的时候,不一定非是CCObject类型不可,可以是其他类型，如CCNode。

    CCArray类的主要函数如下：

class CC_DLL CCArray : public CCObject
{
public:
	ccArray* data; //元素是一个ccArray类型

public:

/**
 *		构造、创建、初始化函数
 *		CCArray , create , init
 */

//构造函数
CCArray();
CCArray(unsigned int capacity);

//创建函数
static CCArray* create();
static CCArray* create(CCObject* pObject, ...);
static CCArray* createWithObject(CCObject* pObject);
static CCArray* createWithCapacity(unsigned int capacity);
static CCArray* createWithArray(CCArray* otherArray);
//通过plist文件导入数组
static CCArray* createWithContentsOfFile(const char* pFileName);
//同上. 但不设置autorelease自动释放内存,需要手动调用release()释放
static CCArray* createWithContentsOfFileThreadSafe(const char* pFileName);

//初始化函数
bool init();
bool initWithObject(CCObject* pObject);
bool initWithObjects(CCObject* pObject, ...);
bool initWithCapacity(unsigned int capacity);
bool initWithArray(CCArray* otherArray);


/**
 *		查询
 *		count , capacity ,
 *		indexOfObject , objectAtIndex , lastObject , randomObject , 
 *		containsObject , isEqualToArray
 */

unsigned int count() const;    //元素个数
unsigned int capacity() const; //数组容量

//用元素查找的索引(下标从0开始). 
//若不存在,返回无符号整形最大值UINT_MAX=0xFFFFFFFF
unsigned int indexOfObject(CCObject* object) const;
//用索引查找元素
CCObject* objectAtIndex(unsigned int index); 

CCObject* lastObject();                      //返回最后一个元素
CCObject* randomObject();                    //返回随机一个元素
bool containsObject(CCObject* object) const; //判断object是否存在于CCArray中
bool isEqualToArray(CCArray* pOtherArray);   //两数组每个索引位置上的元素是否全部相同


/**
 *		添加删除元素
 *		addObject , insertObject
 *		removeObject , fastRemoveObject , removeAllObjects
 */

//添加元素
void addObject(CCObject* object);
void addObjectsFromArray(CCArray* otherArray);
void insertObject(CCObject* object, unsigned int index);

//删除元素. bReleaseObj表示是否释放资源
//被删除的元素后面的元素都往前挪动一个位置
void removeLastObject(bool bReleaseObj = true);                        //删除最后一个元素
void removeObject(CCObject* object, bool bReleaseObj = true);          //删除object元素
void removeObjectAtIndex(unsigned int index, bool bReleaseObj = true); //删除索引为index的元素
void removeObjectsInArray(CCArray* otherArray);                        //删除与otherArray数组中相同的所有元素

//快速删除元素.
//和普通删除不同的是: 只将最后一个元素覆盖被删除的元素,不进行元素挪动
void fastRemoveObject(CCObject* object);          //快速删除object元素
void fastRemoveObjectAtIndex(unsigned int index); //快速删除索引为index的元素

//删除所有元素
void removeAllObjects(); 


/**
 *		重排数组
 *		exchangeObject , replaceObjectAtIndex
 *		reverseObjects , reduceMemoryFootprint
 */

//交换两个元素的位置
void exchangeObject(CCObject* object1, CCObject* object2);
void exchangeObjectAtIndex(unsigned int index1, unsigned int index2);

//用pObject替换索引为index的元素
void replaceObjectAtIndex(unsigned int uIndex, CCObject* pObject, bool bReleaseObject = true);

//将数组元素反序, a b c d --> d c b a.
void reverseObjects();

//缩小内存,将内存缩小为 max = num
void reduceMemoryFootprint();

};
//