自己写代码的经验告诉自己,注释往往是为了帮助理解的,所以先看一下对于CCSprite的注释.
/**
* CCSprite is a 2d image ( http://en.wikipedia.org/wiki/Sprite_(computer_graphics) )
CCSprite是一个2d的图片/图像
* CCSprite can be created with an image, or with a sub-rectangle of an image.
CCSprite可以用一个图片,或者是图片的一个子矩形来创建
精灵的父类是CCSpriteBatchNode和普通CCNode的区别如下
1> If the parent or any of its ancestors is a CCSpriteBatchNode then the following features/limitations are valid
如果它的任一父类是一个CCSpriteBatchNode那么下面的这些特性都是可靠的
* - Features when the parent is a CCBatchNode:
父类是CCBatchNode时的特性
* - MUCH faster rendering, specially if the CCSpriteBatchNode has many children. All the children will be drawn in a single batch.
渲染快很多,尤其是CCSpriteBatchNode有许多children时,所有的子节点将会一次绘制出来
* - Limitations (限制)
* - Camera is not supported yet (eg: CCOrbitCamera action doesn't work)
相机还不支持(例如:CCOrbitCamera action无效)
* - GridBase actions are not supported (eg: CCLens, CCRipple, CCTwirl)
GridBase 动作不支持(例如:CCLens, CCRipple, CCTwirl)
* - The Alias/Antialias property belongs to CCSpriteBatchNode, so you can't individually set the aliased property.
别名/反别名 特性 属于CCSpriteBatchNode, 所以无法个体的(单个的)设置别名特性
* - The Blending function property belongs to CCSpriteBatchNode, so you can't individually set the blending function property.
混合函数特性是CCSpriteBatchNode的特性,所以无法单个的设置混合函数特性
* - Parallax scroller is not supported, but can be simulated with a "proxy" sprite.
视差滚动不支持,但是可以用一个代理精灵来模拟
2> If the parent is an standard CCNode, then CCSprite behaves like any other CCNode:
如果父类是一个标准的CCNode,那么精灵拥有其他任何CCNode的特性
* - It supports blending functions
支持混合函数
* - It supports aliasing / antialiasing
支持别名/反别名
* - But the rendering will be slower: 1 draw per children.
渲染会比较慢 每次回执一个子节点
* The default anchorPoint in CCSprite is (0.5, 0.5).
CCSprite默认的锚点( 0.5, 0.5 )
*/
// 到这里,就把注释部分看完了,接下来我们看类的定义
class CC_DLL CCSprite : public CCNodeRGBA, public CCTextureProtocol
可以看出,CCSprite分别继承了CCNodeRGBA和CCTextureProtocol两个类,CCTextureProtocol这个类内容相对少一些,所以先从这个类入手,来看一下都做了什么
// CCTextureProtocol begin
同样的,我们还是先来看注释
/**
* CCNode objects that uses a CCTexture2D to render the images.
节点对象用一个CCTexture2D来渲染图像
* The texture can have a blending function.
纹理对应的有混合函数
* If the texture has alpha premultiplied the default blending function is:
如果纹理的alpha预乘了,默认的混合函数是:
* src=GL_ONE dst= GL_ONE_MINUS_SRC_ALPHA
src = GL_ONE dst = GL_ONE_MINUS_SRC_ALPHA
* else
否则
* src=GL_SRC_ALPHA dst= GL_ONE_MINUS_SRC_ALPHA
src = GL_SRC_ALPHA dst = GL_ONE_NIMUS_SRC_ALPHA
* But you can change the blending function at any time.
但是你可以在任意时间改变混合函数
* @js NA
*/
接下来我们看CCTextureProtocol类
class CC_DLL CCTextureProtocol : public CCBlendProtocol
CCTextureProtocol类又继承了CCBlendProtocol类,为了便于我们理解,所以还是刨根问底吧,继续跟进,看一下CCBlendProtocol类
// CCBlendProtocol begin
还是老规矩,先看注释
/**
* Specify the blending function according glBlendFunc
依照glBlendFunc指定混合函数
* Please refer to glBlendFunc in OpenGL ES Manual
有关glBlendFunc请参照 OpenGL ES Manual (OpenGL ES 手册)
* http://www.khronos.org/opengles/sdk/docs/man/xhtml/glBlendFunc.xml for more details.
* @js NA
* @lua NA
*/
接下来,我们来看CCBlendProtocol类
class CC_DLL CCBlendProtocol // 关于CC_DLL http://www.ziliao1.com/Article/Show/716662CB4AD94EB2D020C3E74EA62A4C.html有详解
终于没有父类了,那么接下来,我们看这个类的成员函数
老规矩,结合注释来看
/**
* Sets the source blending function.
设置资源混合函数
* @param blendFunc A structure with source and destination factor to specify pixel arithmetic,
* e.g. {GL_ONE, GL_ONE}, {GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA}.
参数 blendFunc 是一个包含源因子和目的因子的像素运算的结构体 例如 { GL_ONE, GL_ONE}, { GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA}
*/
virtual void setBlendFunc(ccBlendFunc blendFunc) = 0;
* Returns the blending function that is currently being used.
返回当前使用的混合功能(同前的混合函数,因第一次接触,所以有些地方可能翻译不是特别合适)
* @return A ccBlendFunc structure with source and destination factor which specified pixel arithmetic.
返回一个ccBlendFunc结构体包含指定了像素运算的源因子和目的因子
*/
virtual ccBlendFunc getBlendFunc(void) = 0;
// CCBlendProtocol end
到这里,CCBlendProtocol我们就看完了,接下来,返回去我们接着来看CCTextureProtocol
我们已经看过了CCTextureProtocol的继承关系,知道它继承的 CCBlendProtocol类,接下来,我们来看一下CCTextureProtocol的成员函数
1>
/**
* Returns the currently used texture
返回当前使用的texture
* @return The texture that is currenlty being used.
* @lua NA
*/
virtual CCTexture2D* getTexture(void) = 0;
2>
/**
* Sets a new texuture. It will be retained.
设置一个新的texture. 会被retained
* @param texture A valid CCTexture2D object, which will be applied to this sprite object.
参数 texture 是一个可使用的CCTexture2D对象,将被应用到这个精灵对象
* @lua NA
*/
virtual void setTexture(CCTexture2D *texture) = 0;
CCTextureProtocol end (注意一点这两个protocol类都是纯虚类,CCTextureProtocol继承了CCBlendProtocol后,并没有在类中重写它的函数,那应该是只是单纯的继承下来了两个纯虚函数,这种用法,自己还是第一次见到,以后可以看一下C++上有没有相关的说法)到这里, CCTextureProtocol我们也看完了,接下来,我们来查看精灵继承的另一个父类也就是CCNodeRGBA
// CCSprite的第二个父类CCNodeRGBA
CCNodeRGBA begin
class CC_DLL CCNodeRGBA : public CCNode, public CCRGBAProtocol
很明显CCNodeRGBA又有两个父类,从前面来看,我们认为protocol应该是方法的类,结构应该会简单一些,所以我们先来查看这个类CCRGBAProtocol begin
/**
* RGBA protocol that affects CCNode's color and opacity
RGBA协议决定了CCNo的颜色和透明度
* @js NA
*/
class CC_DLL CCRGBAProtocol
可以看到CCRGBAProtocol没有父类了,那么接下来我们来查看它的成员函数1>
/**
* Changes the color with R,G,B bytes
用R, G, B 字节改变颜色
* @param color Example: ccc3(255,100,0) means R=255, G=100, B=0
参数color 例: ccc3(255, 100, 0) 指的是 R = 255, G = 100, B = 0
*/
virtual void setColor(const ccColor3B& color) = 0;
2>
/**
* Returns color that is currently used.
返回当前正在使用的颜色
* @return The ccColor3B contains R,G,B bytes.
返回包含R,G,B字节的 ccColor3B (定义的一个结构体类型)
*/
virtual const ccColor3B& getColor(void) = 0;
3>
/**
* Returns the displayed color.
返回显示的颜色
* @return The ccColor3B contains R,G,B bytes.
返回包含R,G,B字节的 ccColor3B (定义的一个结构体类型)
*/
virtual const ccColor3B& getDisplayedColor(void) = 0;
4>
/**
* Returns the displayed opacity.
返回显示的透明度
* @return The opacity of sprite, from 0 ~ 255
返回sprite的透明度,范围0-255
*/
virtual GLubyte getDisplayedOpacity(void) = 0;
5>
/**
* Returns the opacity.
返回透明度
* The opacity which indicates how transparent or opaque this node is.
* 0 indicates fully transparent and 255 is fully opaque.
透明度表明这个node多透明或者不透明
0 表示透明度满 255 表示不透明度满
* @return The opacity of sprite, from 0 ~ 255
*/
virtual GLubyte getOpacity(void) = 0;
6>
/**
* Changes the opacity.
改变透明度
* @param value Goes from 0 to 255, where 255 means fully opaque and 0 means fully transparent.
参数 value 从0到255,255表示不透明度满 0表示透明度满
*/
virtual void setOpacity(GLubyte opacity) = 0;
// optional
7>
/**
* Changes the OpacityModifyRGB property.
改变OpacityModifyRGB属性
* If thie property is set to true, then the rendered color will be affected by opacity.
如果属性被设置为true,那么渲染的颜色会被透明度影响
* Normally, r = r * opacity/255, g = g * opacity/255, b = b * opacity/255.
通常, r = r * opacity/255, g = g * opacity/255, b = b * opacity/255
* @param bValue true then the opacity will be applied as: glColor(R,G,B,opacity);
参数 bValue 为真那么透明度将以glColor(R,G,B,opacity)应用
* false then the opacity will be applied as: glColor(opacity, opacity, opacity, opacity);
为假,那么透明度将以goColor(opacity,opacity,opacity,opacity)应用
*/
virtual void setOpacityModifyRGB(bool bValue) = 0;
8>
/**
* Returns whether or not the opacity will be applied using glColor(R,G,B,opacity)
返回透明度是否以glColor(R,G,B,opacity)应用
* or glColor(opacity, opacity, opacity, opacity)
或者 glColor(opacity, opacity, opacity, opacity)应用
* @return Returns opacity modify flag.
返回透明度修改标识
*/
virtual bool isOpacityModifyRGB(void) = 0;
9>
/**
* whether or not color should be propagated to its children.
是否颜色应该传播给它的子节点
*/
virtual bool isCascadeColorEnabled(void) = 0;
virtual void setCascadeColorEnabled( bool cascadeColorEnabled) = 0 ;10>
/**
* recursive method that updates display color
递归方法更新显示颜色
*/
virtual void updateDisplayedColor(const ccColor3B& color) = 0;
11>
/**
* whether or not opacity should be propagated to its children.
透明度是否传播给它的子节点
*/
virtual bool isCascadeOpacityEnabled(void) = 0;
virtual void setCascadeOpacityEnabled(bool cascadeOpacityEnabled) = 0;
12>
/**
* recursive method that updates the displayed opacity.
递归方法更新显示的透明度
*/
virtual void updateDisplayedOpacity(GLubyte opacity) = 0;
CCRGBAProtocol end到这里,CCRGBAProtocol就结束了然后我们回到CCNodeRGBA,接着来查看它的另一个父类
CCNode begin
/** @brief CCNode is the main element. Anything that gets drawn or contains things that get drawn is a CCNode.
The most popular CCNodes are: CCScene, CCLayer, CCSprite, CCMenu.
简介 CCNode是主要的元素.任何绘制的或者是包含能被绘制的东西的都是一个CCNode
比较特殊的CCNodes有: CCScene, CCLayer, CCSprite, CCMenu
The main features of a CCNode are:
CCNode的主要特性有:
- They can contain other CCNode nodes (addChild, getChildByTag, removeChild, etc)
他们可以包含其他的CCNode 节点 (addChild, getChildByTag, removeChild, 等)
- They can schedule periodic callback (schedule, unschedule, etc)
他们可以设定一个定期的回调 ( schedule, unschedule, 等)
- They can execute actions (runAction, stopAction, etc)
他们可以执行动作(runAction, stopAction,等)
Some CCNode nodes provide extra functionality for them or their children.
一些CCNode节点提供额外的功能给他们或他们的子节点
Subclassing a CCNode usually means (one/all) of:
子类化一个CCNode通常意味着 (一个/全部)
- overriding init to initialize resources and schedule callbacks
重载init到初始化资源和定时回调
- create callbacks to handle the advancement of time
创建回调处理时间推进
- overriding draw to render the node
重载draw来渲染node
Features of CCNode: CCNode特性:
- position -位置
- scale (x, y) -缩放(x,y)
- rotation (in degrees, clockwise) -旋转(度数,顺时针)
- CCCamera (an interface to gluLookAt ) -CCCamera(一个到gluLookAt的接口)
- CCGridBase (to do mesh transformations) -CCGridBase(做网孔转换)
- anchor point -锚点
- size -尺寸
- visible -可视化
- z-order -z坐标
- openGL z position -openGL Z轴位置
Default values: - 默认值:
- rotation: 0 -旋转: 0
- position: (x=0,y=0) -位置:(x=0, y=0)
- scale: (x=1,y=1) -缩放(x=1, y=1)
- contentSize: (x=0,y=0) 内容尺寸(x=0, y=0)
- anchorPoint: (x=0,y=0) 锚点(x=0, y=0)
Limitations: 局限:
- A CCNode is a "void" object. It doesn't have a texture 一个CCNode是一个"空"对象, 它不包含有texture
Order in transformations with grid disabled grid disabled(转换顺序)
-# The node will be translated (position) -# 节点会被转化(位置)
-# The node will be rotated (rotation) -# 节点会被旋转(旋转)
-# The node will be scaled (scale) -# 节点会被缩放(缩放)
-# The node will be moved according to the camera values (camera) -# 节点会被移动依照camera值(camera)
Order in transformations with grid enabled grid enabled(转换顺序)
-# The node will be translated (position) -# 节点会被转化(位置)
-# The node will be rotated (rotation) -# 节点会被旋转(旋转)
-# The node will be scaled (scale) -# 节点会被缩放(缩放)
-# The grid will capture the screen -# grid(网格)会捕获屏幕
-# The node will be moved according to the camera values (camera) -# 节点会依据camera值被移动
-# The grid will render the captured screen -# grid(网格)会渲染捕获的屏幕
Camera:
- Each node has a camera. By default it points to the center of the CCNode.
每个节点都有一个camera.默认指向CCNode的中心
*/
接下来,我们来查看CCNode类CCNode begin
class CC_DLL CCNode : public CCObject
可知,CCNode继承自CCObject那么接下来我们先来认识一下CCObject
CCObject begin
class CC_DLL CCObject : public CCCopying
所以,我们接下来,就先看一下CCCopying这个类CCCopying begin
/**
* @js NA
* @lua NA
*/
class CC_DLL CCCopying
{
public:
virtual CCObject* copyWithZone(CCZone* pZone);
};
比较简单的一个类,只有一个成员函数接下来,我们跳转到对应的cpp文件中,来看一下这个函数到底是怎么实现的,做了些什么
CCObject* CCCopying::copyWithZone(CCZone* pZone)
{
CC_UNUSED_PARAM(pZone); // #define CC_UNUSED_PARAM(unusedparam) (void)unusedparam
CCAssert(0, "not implement"); // 如果一个函数有返回值,而没有被使用的话会报错,这里进行了转化不让返回
return 0;
}
@param pZone 是一个CCZone类型的,那么我们跳转到CCZone了解一下
CCZone begin
class CC_DLL CCZone
没有父类,那么我们接下来就查看成员函数CCZone(CCObject *pObject = NULL);
跳转到cpp对应的函数
CCZone::CCZone(CCObject* pObject)
{
m_pCopyObject = pObject;
}
成员函数只有这么一个拷贝构造函数,接下来我们来看一下成员变量
CCObject *m_pCopyObject;
CCZone end回到CCCopying,还有一个点
CCAssert(0, "not implement"); 跳转查看
#ifndef CCAssert //如果没有定义 CCAssert
#if COCOS2D_DEBUG > 0 // 如果 COCOS2D_DEBUG > 0
extern bool CC_DLL cc_assert_script_compatible(const char *msg);
#define CCAssert(cond, msg) do { \
if (!(cond)) { \
if (!cc_assert_script_compatible(msg) && strlen(msg)) \
cocos2d::CCLog("Assert failed: %s", msg); \
CC_ASSERT(cond); \
} \
} while (0)
#else
#define CCAssert(cond, msg) ((void)(cond))
#endif
#endif // CCAssert
extern bool CC_DLL cc_assert_script_compatible(const char* msg) 先跳转到cc_assert_script_compatible(cons char* msg)
bool CC_DLL cc_assert_script_compatible(const char *msg) //compatible 兼容
{//这里涉及到的就是Lua引擎的东西了,所以暂时不再继续了解
cocos2d::CCScriptEngineProtocol* pEngine = cocos2d::CCScriptEngineManager::sharedManager()->getScriptEngine();
if (pEngine && pEngine->handleAssert(msg))
{
return true;
}
return false;
}
CCCopying end
接下来,我们就返回来看CCObject,按照一贯做法,我们应该查看它的成员函数,从CCObject.h文件中,看到先声明的成员变量,随后生成的成员函数,所以
我们遵照作者的意思,先来看一下成员变量
public:
// object id, CCScriptSupport need public m_uID // 对象id, CCScriptSupport需要public类型m_uID
unsigned int m_uID; // unsigned int m_uID; m(成员) u(unsigned)
// Lua reference id // Lua引用id
int m_nLuaID; int m_nLuaID; n(int类型,我自己认为是number方便记忆)
protected:
// count of references // 引用计数
unsigned int m_uReference; unsigned int m_uReference;
// count of autorelease // 自动释放计数
unsigned int m_uAutoReleaseCount; unsigned int m_uAutoReleaseCount;
接下来,我们就来查看成员函数1> CCObject(void);
CCObject::CCObject(void)
: m_nLuaID(0)
, m_uReference(1) // when the object is created, the reference count of it is 1 //当对象创建成功,引用计数为1
, m_uAutoReleaseCount(0)
{
static unsigned int uObjectCount = 0;
m_uID = ++uObjectCount;
}
这里涉及到了C++的一些知识点,所以我们先来了解一下C++的东西,毕竟学到最后,其实还是C++还是从上往下的顺序来,第一个点就是初始化列表了也就是
CCObject::CCObject(void)
: m_nLuaID(0)
, m_uReference(1)
, m_uAutoReleaseCount(0)
关于初始化列表也是有不少的东西在里面这里就不赘述了,找了一篇文章,需要的可以参阅
http://www.cnblogs.com/graphics/archive/2010/07/04/1770900.html //初始化列表
第二个点 static unsigned int uObjectCount = 0;
(static的用法,还是不是特别的清楚,接下来,下一篇文章搞清楚static的用法)
/**
* @lua NA
*/
2> virtual ~CCObject(void);
CCObject::~CCObject(void) //CCObject的析构函数
{
// if the object is managed, we should remove it //如果对象被管理了,那么我们应该把它从管理池移除
// from pool manager
if (m_uAutoReleaseCount > 0) //如果自动释放计数大于0
{
CCPoolManager::sharedPoolManager()->removeObject(this); //管理池移除对象, CCPoolManager,CCScriptEngineManager,在后续文章中再研究
}
// if the object is referenced by Lua engine, remove it //如果对象被Lua引擎引用,移除它
if (m_nLuaID) //如果LuaID大于0
{
CCScriptEngineManager::sharedManager()->getScriptEngine()->removeScriptObjectByCCObject(this); //脚本引擎管理器移除脚本对象
}
else //否则
{
CCScriptEngineProtocol* pEngine = CCScriptEngineManager::sharedManager()->getScriptEngine(); //LuaID = 0 时
if (pEngine != NULL && pEngine->getScriptType() == kScriptTypeJavascript) 如果脚本引擎存在并且 脚本类型是kScriptTypeJavascript
{
pEngine->removeScriptObjectByCCObject(this); //脚本引擎移除对象
}
}
}
3> void release(void);
void CCObject::release(void)
{
CCAssert(m_uReference > 0, "reference count should greater than 0"); //assert 还没有特别懂,但是大概其的知道它是一个检查报错的东西
--m_uReference; //引用计数-1
if (m_uReference == 0) 如果引用计数为0
{
delete this; 那么删除这个对象
}
}
4>void retain(void);
void CCObject::retain(void) //
{
CCAssert(m_uReference > 0, "reference count should greater than 0"); //如果m_uReference>0不成立,打印 引用计数应该大于0
++m_uReference; //引用计数+1
}
5>CCObject* autorelease(void);
CCObject* CCObject::autorelease(void)
{
CCPoolManager::sharedPoolManager()->addObject(this); //管理池添加对象
return this; //返回这个对象
}
4>CCObject* copy(void);
CCObject* CCObject::copy()
{
return copyWithZone(0); //这里调用到了父类CCCopying中得函数 copyWithZone()
}
5> bool isSingleReference(void) const;
bool CCObject::isSingleReference(void) const //是否是单一引用
{
return m_uReference == 1; //如果引用计数为1则是单一引用,否则不是单一引用
}
6> unsigned int retainCount(void) const;
unsigned int CCObject::retainCount(void) const //引用计数 这里注意函数后面加const的用法,const成员函数,不能修改数据成员的值,不能调用非const函数
{
return m_uReference; //返回引用计数
}
7> virtual bool isEqual(const CCObject* pObject);
bool CCObject::isEqual(const CCObject *pObject)
{
return this == pObject; //判断两个CCObject对象是否相等
}
8> virtual void acceptVisitor(CCDataVisitor &visitor);
void CCObject::acceptVisitor(CCDataVisitor &visitor) //接受观察者
{
visitor.visitObject(this); //这个暂时不知道是干什么的 hlq
}
9> virtual void update(float dt) {CC_UNUSED_PARAM(dt);};
到这里CCObject的成员函数,就基本上了解完了,最后这里我们看到类结束的地方,有这么一行代码friend class CCAutoreleasePool; // 友元类 到这里发现C++的知识点太多了,有必要系统的整理一下,随后将自己在学习cocos框架的过程中遇到的点整理一下
CCObject end
现在看了CCNode类,就基本把这些父类看完了,CCNode类是比较大的一个类,里面包含了很多东西,这里暂时不再看了,随后单独写一篇有关CCNode的文章
CCNode end
接下来,就回到了CCNodeRGBA这个类了
1> CCNodeRGBA();
CCNodeRGBA::CCNodeRGBA()
: _displayedOpacity(255) //显示透明度(255)
, _realOpacity(255) //实际透明度(255)
, _displayedColor(ccWHITE) //显示颜色(白色)
, _realColor(ccWHITE) //实际颜色(白色)
, _cascadeColorEnabled(false) //能否传播颜色(否)
, _cascadeOpacityEnabled(false) //能否传播透明度(否)
{}
CCNodeRGBA相比于CCNode就是多了RGB(颜色)和透明度,所以构造函数初始化了与颜色透明度相关的一些参数2> CCNodeRGBA::~CCNodeRGBA() {} 析构函数
3> virtual bool init();
bool CCNodeRGBA::init()
{
if (CCNode::init())
{
_displayedOpacity = _realOpacity = 255; //初始化透明度(255)
_displayedColor = _realColor = ccWHITE; //初始化颜色(白色)
_cascadeOpacityEnabled = _cascadeColorEnabled = false; //初始化是否传播(否)
return true; //初始化成功返回true
}
return false; //初始化失败返回false
}
/**
* Allocates and initializes a nodergba. //分配空间初始化一个nodergba
* @return A initialized node which is marked as "autorelease". //返回一个被标记为autorelease的节点 (自动释放的节点)
*/
4> static CCNodeRGBA * create(void);
CCNodeRGBA * CCNodeRGBA::create(void)
{
CCNodeRGBA * pRet = new CCNodeRGBA(); //分配内存给一个新创建的CCNodeRGBA对象
if (pRet && pRet->init()) //如果对象存在并且初始化成功了
{
pRet->autorelease(); //那么调用autorelease() 加入自动释放池
}
else //否则
{
CC_SAFE_DELETE(pRet); //释放掉分配的内存(如果创建CCNodeRGBA失败或者初始化失败)
}
return pRet; //返回一个标记为自动释放的CCNodeRGBA
}
5> virtual GLubyte getOpacity();
GLubyte CCNodeRGBA::getOpacity(void) //获取透明度
{
return _realOpacity; //返回实际透明度
}
6> virtual GLubyte getDisplayedOpacity();
GLubyte CCNodeRGBA::getDisplayedOpacity(void) //获取显示透明度
{
return _displayedOpacity; //返回显示透明度
}
7> virtual void setOpacity(GLubyte opacity);
void CCNodeRGBA::setOpacity(GLubyte opacity)
{
_displayedOpacity = _realOpacity = opacity; //显示透明度=实际透明度= opacity(参数)
if (_cascadeOpacityEnabled) //如果可以传播透明度
{ //改变子类的透明度
GLubyte parentOpacity = 255;
CCRGBAProtocol* pParent = dynamic_cast<CCRGBAProtocol*>(m_pParent);
if (pParent && pParent->isCascadeOpacityEnabled())
{
parentOpacity = pParent->getDisplayedOpacity();
}
this->updateDisplayedOpacity(parentOpacity);
}
}
8> virtual void updateDisplayedOpacity(GLubyte parentOpacity);
void CCNodeRGBA::updateDisplayedOpacity(GLubyte parentOpacity)
{//递归的改变父类下所有子类的透明度
_displayedOpacity = _realOpacity * parentOpacity/255.0;
if (_cascadeOpacityEnabled)
{
CCObject* pObj;
CCARRAY_FOREACH(m_pChildren, pObj)
{
CCRGBAProtocol* item = dynamic_cast<CCRGBAProtocol*>(pObj);
if (item)
{
item->updateDisplayedOpacity(_displayedOpacity);
}
}
}
}
9> virtual bool isCascadeOpacityEnabled();
bool CCNodeRGBA::isCascadeOpacityEnabled(void)
{
return _cascadeOpacityEnabled; //透明度能否传播
}
10> virtual void setCascadeOpacityEnabled(bool cascadeOpacityEnabled);
void CCNodeRGBA::setCascadeOpacityEnabled(bool cascadeOpacityEnabled)
{
_cascadeOpacityEnabled = cascadeOpacityEnabled; //设置透明度能否传播
}
11> virtual const ccColor3B& getColor(void);
const ccColor3B& CCNodeRGBA::getColor(void)
{
return _realColor; //返回实际颜色
}
12> virtual const ccColor3B& getDisplayedColor();
const ccColor3B& CCNodeRGBA::getDisplayedColor()
{
return _displayedColor; //返回显示的颜色
}
13> virtual void setColor(const ccColor3B& color);
void CCNodeRGBA::setColor(const ccColor3B& color)
{
_displayedColor = _realColor = color; //设置颜色 显示颜色=实际颜色=参数color
if (_cascadeColorEnabled)
{//递归的改变子类的颜色
ccColor3B parentColor = ccWHITE;
CCRGBAProtocol *parent = dynamic_cast<CCRGBAProtocol*>(m_pParent);
if (parent && parent->isCascadeColorEnabled())
{
parentColor = parent->getDisplayedColor();
}
updateDisplayedColor(parentColor);
}
}
14> virtual void updateDisplayedColor(const ccColor3B& parentColor);
void CCNodeRGBA::updateDisplayedColor(const ccColor3B& parentColor)
{//递归的改变子类的颜色
_displayedColor.r = _realColor.r * parentColor.r/255.0;
_displayedColor.g = _realColor.g * parentColor.g/255.0;
_displayedColor.b = _realColor.b * parentColor.b/255.0;
if (_cascadeColorEnabled)
{
CCObject *obj = NULL;
CCARRAY_FOREACH(m_pChildren, obj)
{
CCRGBAProtocol *item = dynamic_cast<CCRGBAProtocol*>(obj);
if (item)
{
item->updateDisplayedColor(_displayedColor);
}
}
}
}
15> virtual bool isCascadeColorEnabled();
bool CCNodeRGBA::isCascadeColorEnabled(void)
{
return _cascadeColorEnabled; //返回是否可以传播颜色
}
16> virtual void setCascadeColorEnabled(bool cascadeColorEnabled);
void CCNodeRGBA::setCascadeColorEnabled(bool cascadeColorEnabled)
{
_cascadeColorEnabled = cascadeColorEnabled; //设置颜色是否可以传播
}
17> virtual void setOpacityModifyRGB(bool bValue) {CC_UNUSED_PARAM(bValue);};
virtual bool isOpacityModifyRGB() { return false; };
CCNodeRGBA end
到这里,看完了CCSprite所有的上层的关系.
3095
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
