节点 Node

static const int INVALID_TAG = -1;  //设置标签初始值

enum {

        FLAGS_TRANSFORM_DIRTY = (1 << 0),  // 1

        FLAGS_CONTENT_SIZE_DIRTY = (1 << 1),  // 2

        FLAGS_RENDER_AS_3D = (1 << 3),  // 8

        FLAGS_DIRTY_MASK = (FLAGS_TRANSFORM_DIRTY | FLAGS_CONTENT_SIZE_DIRTY), // 或运算

    };

static Node * create(); //初始化节点，并返回一个加入到自动内存释放池中的节点

static int getAttachedNodeCount(); //获取附加在节点上的节点个数，(统计父节点上的子节点个数)

创建一个节点对象

Node * Node::create()

{

    Node * ret = new (std::nothrow) Node(); //创建一个名为ret的Node类型的对象

    if (ret && ret->init())									//判断ret是否创建成功并初始化对象ret

    {

        ret->autorelease();									//将对象ret加入内存自动回收池

    }

    else

    {

        CC_SAFE_DELETE(ret);								//如果创建对象失败，删除这个对象

    }

    return ret;															//返回创建成功的节点对象ret

}

获取节点依赖的计数器

int Node::getAttachedNodeCount()

{

    return __attachedNodeCount;  //返回被依赖的计数

}

获取节点的描述（获取节点的Tag）

std::string Node::getDescription() const

{

    return StringUtils::format("<Node | Tag = %d", _tag); //返回节点的Tag

  													// _tag(Node::INVALID_TAG) 实际返回的就是INVALID_TAG

}

初始化器结束

节点的局部层顺序值（LocalZOrder）

LocalZOrder是用于对节点相对于其兄弟节点进行排序的“键”。

节点的父节点将根据LocalZOrder值对所有子节点排序。

如果两个节点具有相同的LocalZOrder，那么首先添加到子数组中的节点将位于数组中另一个节点的前面。

此外，场景图使用中序遍历，先遍历左子树，然后根节点，最后是右子树。

LocalZOrder值< 0的节点是左子树

而LocalZOrder >=0的节点是右子树。

设置节点的LocalZOrder的值

void Node::setLocalZOrder(std::int32_t z)

{

    if (getLocalZOrder() == z) //如果设置前后值相等，不做操作直接返回

        return;

    _setLocalZOrder(z); //否则初始化_setLocalZOrder变量

    if (_parent) //如果存在父节点

    {

        _parent->reorderChild(this, z);  //对父节点的子节点顺序重新排序

    }

    _eventDispatcher->setDirtyForNode(this); //将这个节点加入到事件调度中(加入节点监听器中，并将子节点也做相同操作)

}

//兼容旧版本

CC_DEPRECATED_ATTRIBUTE virtual void setZOrder(std::int32_t localZOrder) { setLocalZOrder(localZOrder); }

获取节点的LocalZOrder的值

virtual std::int32_t getLocalZOrder() const { return _localZOrder; }

//兼容旧版本

CC_DEPRECATED_ATTRIBUTE virtual std::int32_t getZOrder() const { return getLocalZOrder(); }

相同等级子节点具有相同ZOrder时设置绘制顺序

void updateOrderOfArrival();

节点的全局层顺序值(GlobalZOrder)

设置节点的GlobalZOrder值

定义节点渲染的顺序。

globalZOrder较低的节点首先渲染。

如果两个或多个节点具有相同的globalZOrder，则不保证渲染顺序。

当节点的globalZOrder == 0时。在这种情况下，使用场景图顺序。

默认情况下，所有节点的globalZOrder为0。这意味着默认情况下，一定会使用场景图顺序用于呈现节点。

当需要以与场景图顺序不同的顺序呈现节点时，GlobalZOrder非常有用。

void Node::setGlobalZOrder(float globalZOrder)

{

    if (_globalZOrder != globalZOrder) //如果设置前后不相等

    {

        _globalZOrder = globalZOrder;  //给_globalZOrder赋值

        _eventDispatcher->setDirtyForNode(this);  //将这个节点加入到事件调度中(加入节点监听器中，并将子节点也做相同操作)

    }

}

获取节点的GlobalZOrder值

virtual float getGlobalZOrder() const { return _globalZOrder; }

节点的缩放（scale）

设置缩放大小

//设置一个比例因子，用于乘以节点及其 子节点 的宽度。

void Node::setScaleX(float scaleX)

{

    if (_scaleX == scaleX)

        return;

    _scaleX = scaleX;

    _transformUpdated = _transformDirty = _inverseDirty = true;

}

//设置一个比例因子，用于乘以节点及其 子节点 的高度。

void Node::setScaleY(float scaleY)

{

    if (_scaleY == scaleY)

        return;

    _scaleY = scaleY;

    _transformUpdated = _transformDirty = _inverseDirty = true;

}

//设置一个比例因子，用于乘以节点及其 子节点 的高度。

void Node::setScaleZ(float scaleZ)

{

    if (_scaleZ == scaleZ)

        return;

    _scaleZ = scaleZ;

    _transformUpdated = _transformDirty = _inverseDirty = true;

}

//设置一个比例因子，用于乘以节点及其 子节点 的宽度、高度、深度。

void Node::setScale(float scale)

{

    if (_scaleX == scale && _scaleY == scale && _scaleZ == scale)

        return;

    _scaleX = _scaleY = _scaleZ = scale;

    _transformUpdated = _transformDirty = _inverseDirty = true;

}

//它是一个比例因子，乘以节点及其子节点的宽度和高度。

void Node::setScale(float scaleX,float scaleY)

{

    if (_scaleX == scaleX && _scaleY == scaleY)

        return;

    _scaleX = scaleX;

    _scaleY = scaleY;

    _transformUpdated = _transformDirty = _inverseDirty = true; //标记脏数据

}

获取缩放大小

float Node::getScaleX() const

{

    return _scaleX;

}

float Node::getScaleY() const

{

    return _scaleY;

}

float Node::getScaleZ() const

{

    return _scaleZ;

}

//获取节点的缩放因子，当X和Y具有相同的缩放因子时

float Node::getScale(void) const

{

    CCASSERT( _scaleX == _scaleY, "CCNode#scale. ScaleX != ScaleY. Don't know which one to return"); // ?

    return _scaleX;

}

节点位置(pisition)

设置节点在父坐标系中的位置

//设置x，y轴的位置

void Node::setPosition(const Vec2& position)

{

    setPosition(position.x, position.y);  //(x, y)

}

//使用0-1设置x，y轴的位置

void Node::setPositionNormalized(const Vec2& position)

{

    if (_normalizedPosition.equals(position)) //修改前后相等，不做修改直接返回

        return;

    _normalizedPosition = position;  //给_normalizedPosition赋值

    _usingNormalizedPosition = true;  //标记 使用规范化位置

    _normalizedPositionDirty = true;	//标记 使用规范化位置的Dirty  // ? 标记脏数据

    _transformUpdated = _transformDirty = _inverseDirty = true;  // ? 标记脏数据重新计算渲染坐标矩阵  //在上面的修改之后，渲染用的坐标系矩阵未经计算，造成值的不对应，在当调用getNodeToParentTransform() 重新计算渲染用的坐标系矩阵之后会使用修改之后的值渲染，渲染之后的值对应了，不存在脏数据了，会将_transformDirty再设为false

}

//直接使用x、y设置位置

virtual void setPosition(float x, float y);

virtual void getPosition(float* x, float* y) const;

virtual void  setPositionX(float x);

virtual float getPositionX(void) const;

virtual void  setPositionY(float y);

virtual float getPositionY(void) const;

//设置节点的三维属性

void Node::setPosition3D(const Vec3& position)

{

    setPositionZ(position.z);

    setPosition(position.x, position.y);

}

//设置三维的z坐标

virtual void setPositionZ(float positionZ)

{

    if (_positionZ == positionZ)

        return;

    _transformUpdated = _transformDirty = _inverseDirty = true;

    _positionZ = positionZ;

}

获取节点在父坐标系中的位置

//_position

const Vec2& Node::getPosition() const

{

    return _position;

}

//获取节点的规范化位置 0-1

const Vec2& Node::getPositionNormalized() const

{

    return _normalizedPosition;

}

//获取节点的三维属性

Vec3 Node::getPosition3D() const

{

    return Vec3(_position.x, _position.y, _positionZ);

}

//获取节点的z坐标

float Node::getPositionZ() const

{

    return _positionZ;

}

兼容旧版本

virtual void setNormalizedPosition(const Vec2 &position) { setPositionNormalized(position); }

virtual const Vec2& getNormalizedPosition() const { return getPositionNormalized(); }

CC_DEPRECATED_ATTRIBUTE virtual void setVertexZ(float vertexZ) { setPositionZ(vertexZ); }

CC_DEPRECATED_ATTRIBUTE virtual float getVertexZ() const { return getPositionZ(); }

节点倾斜（Skew）

设置倾斜角

void Node::setSkewX(float skewX)

{

    if (_skewX == skewX)

        return;

    _skewX = skewX;

    _transformUpdated = _transformDirty = _inverseDirty = true;

}

void Node::setSkewY(float skewY)

{

    if (_skewY == skewY)

        return;

    _skewY = skewY;

    _transformUpdated = _transformDirty = _inverseDirty = true;

}

获取倾斜角

float Node::getSkewX() const

{

    return _skewX;

}

float Node::getSkewY() const

{

    return _skewY;

}

节点锚点（AnchorPoint）

锚点是所有转换和定位操作发生的点。

它就像节点上的一个大头针，它被“连接”到它的父节点上。

锚点是标准化的，比如百分比。(0,0)表示左下角，(1,1)表示右上角。

但是也可以使用大于(1,1)和小于(0,0)的值。

默认锚点是(0,0)，因此它从节点的左下角开始。

设置锚点

//以百分比设置锚点

void Node::setAnchorPoint(const Vec2& point)

{

    if (! point.equals(_anchorPoint))

    {

        _anchorPoint = point;

        _anchorPointInPoints.set(_contentSize.width * _anchorPoint.x, _contentSize.height * _anchorPoint.y);

        _transformUpdated = _transformDirty = _inverseDirty = true;

    }

}

获取锚点

//以百分比为单位返回锚点

const Vec2& Node::getAnchorPoint() const

{

    return _anchorPoint;

}

//以绝对像素点为单位返回锚点

const Vec2& Node::getAnchorPointInPoints() const

{

    return _anchorPointInPoints;

}

设置节点的锚点是否为（0，0）

//默认值为false，而在图层和场景中为true

void Node::setIgnoreAnchorPointForPosition(bool newValue)

{

    if (newValue != _ignoreAnchorPointForPosition)

    {

        _ignoreAnchorPointForPosition = newValue;

        _transformUpdated = _transformDirty = _inverseDirty = true;

    }

}

//兼容旧版本

CC_DEPRECATED_ATTRIBUTE virtual void ignoreAnchorPointForPosition(bool ignore) { setIgnoreAnchorPointForPosition(ignore); }

获取节点的锚点是否是（0，0）

bool Node::isIgnoreAnchorPointForPosition() const

{

    return _ignoreAnchorPointForPosition;

}

节点的原始大小（ContentSize）

设置节点的原始大小

void Node::setContentSize(const Size & size)

{

    if (! size.equals(_contentSize))

    {

        _contentSize = size;

        _anchorPointInPoints.set(_contentSize.width * _anchorPoint.x, _contentSize.height * _anchorPoint.y);

        _transformUpdated = _transformDirty = _inverseDirty = _contentSizeDirty = true;

    }

}

获取节点的原始大小

const Size& Node::getContentSize() const

{

    return _contentSize;

}

节点可见性（Visible）

设置节点可见性

//默认为可见的

void Node::setVisible(bool visible)

{

    if(visible != _visible)

    {

        _visible = visible;

        if(_visible)

            _transformUpdated = _transformDirty = _inverseDirty = true;

    }

}

确定节点是否可见

//可见即返回true，不可见返回false

bool Node::isVisible() const

{

    return _visible;

}

##节点的旋转角度（Rotation）

设置节点的旋转角度

//设置节点的旋转角度，这里是直接旋转，和下面的RotationSkew不一样

void Node::setRotation(float rotation)

{

    if (_rotationZ_X == rotation)

        return;

    _rotationZ_X = _rotationZ_Y = rotation;

    _transformUpdated = _transformDirty = _inverseDirty = true;

    updateRotationQuat();    //?

}

获取节点的旋转角度

float Node::getRotation() const

{

    CCASSERT(_rotationZ_X == _rotationZ_Y, "CCNode#rotation. RotationX != RotationY. Don't know which one to return");

    return _rotationZ_X;

}

节点的3d旋转（Rotation3D）

设置节点的3d旋转

void Node::setRotation3D(const Vec3& rotation)

{

    if (_rotationX == rotation.x &&

        _rotationY == rotation.y &&

        _rotationZ_X == rotation.z)

        return;

    _transformUpdated = _transformDirty = _inverseDirty = true;

    _rotationX = rotation.x;

    _rotationY = rotation.y;

    // rotation Z is decomposed in 2 to simulate Skew for Flash animations

  	//模拟flash动画的倾斜

    _rotationZ_Y = _rotationZ_X = rotation.z;

    updateRotationQuat();

}

获取节点的3d旋转

Vec3 Node::getRotation3D() const

{

    // rotation Z is decomposed in 2 to simulate Skew for Flash animations

    CCASSERT(_rotationZ_X == _rotationZ_Y, "_rotationZ_X != _rotationZ_Y");

    return Vec3(_rotationX,_rotationY,_rotationZ_X);

}

节点的四元数（Quat）

对于四元数的学习可以看我的另外一篇博客

cocos2dx 四元数

设置节点的四元数

//按四元数设置旋转

void Node::setRotationQuat(const Quaternion& quat)

{

    _rotationQuat = quat;

    updateRotation3D();

    _transformUpdated = _transformDirty = _inverseDirty = true;

}

获取节点的四元数

Quaternion Node::getRotationQuat() const

{

    return _rotationQuat;

}

节点的旋转倾斜(RotationSkew)

设置旋转倾斜

//设置水平旋转倾斜，模拟Flash的歪斜功能

void Node::setRotationSkewX(float rotationX)

{

    if (_rotationZ_X == rotationX)

        return;

    _rotationZ_X = rotationX;

    _transformUpdated = _transformDirty = _inverseDirty = true;

    updateRotationQuat();

}

//设置垂直旋转倾斜的角度，模拟Flash的歪斜功能

void Node::setRotationSkewY(float rotationY)

{

    if (_rotationZ_Y == rotationY)

        return;

    _rotationZ_Y = rotationY;

    _transformUpdated = _transformDirty = _inverseDirty = true;

    updateRotationQuat();

}

获取旋转倾斜

float Node::getRotationSkewX() const

{

    return _rotationZ_X;

}

float getRotationSkewY() const

{

    return _rotationZ_Y;

}

兼容旧版本

CC_DEPRECATED_ATTRIBUTE virtual void setRotationX(float rotationX) { return setRotationSkewX(rotationX); }

CC_DEPRECATED_ATTRIBUTE virtual void setRotationY(float rotationY) { return setRotationSkewY(rotationY); }

C_DEPRECATED_ATTRIBUTE virtual float getRotationY() const { return getRotationSkewY(); }

子节点（Child）

添加子节点

void Node::addChild(Node *child)

{

    CCASSERT( child != nullptr, "Argument must be non-nil"); //判断节点是否是空节点

    this->addChild(child, child->getLocalZOrder(), child->_name);//

}

//添加子节点同时设置localZOrder属性

void Node::addChild(Node *child, int zOrder)

{

    CCASSERT( child != nullptr, "Argument must be non-nil");

    this->addChild(child, zOrder, child->_name);

}

//添加子节点同时设置localZOrder和tag属性

void Node::addChild(Node *child, int localZOrder, int tag)

{

    CCASSERT( child != nullptr, "Argument must be non-nil");

    CCASSERT( child->_parent == nullptr, "child already added. It can't be added again");

    addChildHelper(child, localZOrder, tag, "", true);

}

//添加子节点同时设置localZOrder和name属性

void Node::addChild(Node* child, int localZOrder, const std::string &name)

{

    CCASSERT(child != nullptr, "Argument must be non-nil");

    CCASSERT(child->_parent == nullptr, "child already added. It can't be added again");

    addChildHelper(child, localZOrder, INVALID_TAG, name, false);

}

//帮助添加子节点

void Node::addChildHelper(Node* child, int localZOrder, int tag, const std::string &name, bool setTag)

{

    auto assertNotSelfChild

        ( [ this, child ]() -> bool

          {

              for ( Node* parent( getParent() ); parent != nullptr;

                    parent = parent->getParent() )

                  if ( parent == child )

                      return false;

              return true;

          } );

    (void)assertNotSelfChild;

    CCASSERT( assertNotSelfChild(),

              "A node cannot be the child of his own children" );

    if (_children.empty())

    {

        this->childrenAlloc();

    }

    this->insertChild(child, localZOrder);

    if (setTag)

        child->setTag(tag);

    else

        child->setName(name);

    child->setParent(this);

    child->updateOrderOfArrival();

    if( _running )

    {

        child->onEnter(); //调用onEnter 增加依附计数 完成过渡

        // prevent onEnterTransitionDidFinish to be called twice when a node is added in onEnter

        if (_isTransitionFinished)

        {

            child->onEnterTransitionDidFinish(); //结束过渡

        }

    }

    if (_cascadeColorEnabled)

    {

        updateCascadeColor();

    }

    if (_cascadeOpacityEnabled)

    {

        updateCascadeOpacity();

    }

}

获取子节点

//遍历子节点，通过tag找到所需的节点

Node* Node::getChildByTag(int tag) const

{

    CCASSERT(tag != Node::INVALID_TAG, "Invalid tag");

    for (const auto child : _children)

    {

        if(child && child->_tag == tag)

            return child;

    }

    return nullptr;

}

//返回具有给定名称的节点，该节点可以转换为类型T

template <typename T>

    T getChildByTag(int tag) const { return static_cast<T>(getChildByTag(tag)); }

//通过name找到所需的节点

Node* Node::getChildByName(const std::string& name) const

{

    CCASSERT(!name.empty(), "Invalid name"); //需要有名字

    std::hash<std::string> h;

    size_t hash = h(name);

    for (const auto& child : _children)

    {

        // Different strings may have the same hash code, but can use it to compare first for speed

        if(child->_hashOfName == hash && child->_name.compare(name) == 0)

            return child;

    }

    return nullptr;

}

//返回具有给定名称的节点，该节点可以转换为类型T

 template <typename T>

    T getChildByName(const std::string& name) const { return static_cast<T>(getChildByName(name)); }

//查找节点

//  '//':只能放在搜索字符串的开头。这表明它将递归搜索。

//  '..':搜索应该向上移动到节点的父节点。只能放在字符串的末尾。

//  '/' :当搜索字符串放置在除开始位置以外的任何位置时，这表示搜索应该移动到节点的子节点。

//例如：

//enumerateChildren("//MyName", ...)  // 递归查找子节点

//enumerateChildren("[[:alnum:]]+", ...) // 匹配子节点的每个节点

//enumerateChildren("A[[:digit:]]", ...) // 查找A0-A9

//enumerateChildren("Abby/Normal", ...)  // 搜索并返回名为Normal父节点为Abby的任何节点

//enumerateChildren("//Abby/Normal", ...) // 递归搜索并返回名为Normal父节点为Abby的任何节点

void Node::enumerateChildren(const std::string &name, std::function<bool (Node *)> callback) const

{

    CCASSERT(!name.empty(), "Invalid name");

    CCASSERT(callback != nullptr, "Invalid callback function");

    size_t length = name.length();

    size_t subStrStartPos = 0;  // sub string start index

    size_t subStrlength = length; // sub string length

    // Starts with '//'?

    bool searchRecursively = false;

    if (length > 2 && name[0] == '/' && name[1] == '/')

    {

        searchRecursively = true;

        subStrStartPos = 2;

        subStrlength -= 2;

    }

    // End with '/..'?

    bool searchFromParent = false;

    if (length > 3 &&

        name[length-3] == '/' &&

        name[length-2] == '.' &&

        name[length-1] == '.')

    {

        searchFromParent = true;

        subStrlength -= 3;

    }

    // Remove '//', '/..' if exist

    std::string newName = name.substr(subStrStartPos, subStrlength);

    if (searchFromParent)

    {

        newName.insert(0, "[[:alnum:]]+/");

    }

    if (searchRecursively)

    {

        // name is '//xxx'

        doEnumerateRecursive(this, newName, callback);

    }

    else

    {

        // name is xxx

        doEnumerate(newName, callback);

    }

}

//返回节点的子节点数组

virtual Vector<Node*>& getChildren() { return _children; }

virtual const Vector<Node*>& getChildren() const { return _children; }

//获取子节点的个数

ssize_t Node::getChildrenCount() const

{

    return _children.size();

}

添加父节点

void Node::setParent(Node * parent)

{

    _parent = parent;

    _transformUpdated = _transformDirty = _inverseDirty = true;

}

获取父节点

virtual Node* getParent() { return _parent; }

virtual const Node* getParent() const { return _parent; }

移除（remove）

//将这个节点从父节点中移除，如果没有父节点则不操作

void Node::removeFromParent()

{

    this->removeFromParentAndCleanup(true);

}

void Node::removeFromParentAndCleanup(bool cleanup)

{

    if (_parent != nullptr)

    {

        _parent->removeChild(this,cleanup);

    }

}

void ParallaxNode::removeChild(Node* child, bool cleanup)

{

    for( int i=0;i < _parallaxArray->num;i++)

    {

        PointObject *point = (PointObject*)_parallaxArray->arr[i];

        if (point->getChild() == child)

        {

            ccArrayRemoveObjectAtIndex(_parallaxArray, i, true);

            break;

        }

    }

    Node::removeChild(child, cleanup);

}

//移除子节点

//如果所有正在运行的动作和回调函数都在子节点上，cleanup为true，否则为false

void Node::removeChild(Node* child, bool cleanup /* = true */)

{

    if (_children.empty())

    {

        return;

    }

    ssize_t index = _children.getIndex(child);

    if( index != CC_INVALID_INDEX )

        this->detachChild( child, index, cleanup );

}

//通过tag移除子节点

void Node::removeChildByTag(int tag, bool cleanup/* = true */)

{

    CCASSERT( tag != Node::INVALID_TAG, "Invalid tag");

    Node *child = this->getChildByTag(tag);

    if (child == nullptr)

    {

        CCLOG("cocos2d: removeChildByTag(tag = %d): child not found!", tag);

    }

    else

    {

        this->removeChild(child, cleanup);

    }

}

//通过Name移除子节点

void Node::removeChildByName(const std::string &name, bool cleanup)

{

    CCASSERT(!name.empty(), "Invalid name");

    Node *child = this->getChildByName(name);

    if (child == nullptr)

    {

        CCLOG("cocos2d: removeChildByName(name = %s): child not found!", name.c_str());

    }

    else

    {

        this->removeChild(child, cleanup);

    }

}

//移除所有子节点

void Node::removeAllChildren()

{

    this->removeAllChildrenWithCleanup(true);

}

//删除所有子节点，并根据cleanup参数对所有正在运行的操作执行清理(cleanup)

void Node::removeAllChildrenWithCleanup(bool cleanup)

{

    // not using detachChild improves speed here

    for (const auto& child : _children)

    {

        // IMPORTANT:

        //  -1st do onExit

        //  -2nd cleanup

        if(_running)

        {

            child->onExitTransitionDidStart();

            child->onExit();

        }

        if (cleanup)

        {

            child->cleanup();

        }

#if CC_ENABLE_GC_FOR_NATIVE_OBJECTS

        auto sEngine = ScriptEngineManager::getInstance()->getScriptEngine();

        if (sEngine)

        {

            sEngine->releaseScriptObject(this, child);

        }

#endif // CC_ENABLE_GC_FOR_NATIVE_OBJECTS

        // set parent nil at the end

        child->setParent(nullptr);

    }

    _children.clear();

}

排序（Sort）！

void Node::reorderChild(Node *child, int zOrder)

{

    CCASSERT( child != nullptr, "Child must be non-nil");

    _reorderChildDirty = true;

    child->updateOrderOfArrival();

    child->_setLocalZOrder(zOrder);

}

//对所有的子节点排序，不需要手动调用，只会在绘制之前执行一次，以提高性能

void Node::sortAllChildren()

{

    if (_reorderChildDirty)

    {

        sortNodes(_children);

        _reorderChildDirty = false;

        _eventDispatcher->setDirtyForNode(this);

    }

}

//

template<typename _T> inline

    static void sortNodes(cocos2d::Vector<_T*>& nodes)

    {

        static_assert(std::is_base_of<Node, _T>::value, "Node::sortNodes: Only accept derived of Node!");

#if CC_64BITS

        std::sort(std::begin(nodes), std::end(nodes), [](_T* n1, _T* n2) {

            return (n1->_localZOrder$Arrival < n2->_localZOrder$Arrival);

        });

#else

        std::sort(std::begin(nodes), std::end(nodes), [](_T* n1, _T* n2) {

            return (n1->_localZOrder == n2->_localZOrder && n1->_orderOfArrival < n2->_orderOfArrival) || n1->_localZOrder < n2->_localZOrder;

        });

#endif

    }

数据和用户标签

设置

UserData基本不用，一般使用UserDefault来记录数据，生成类似xml的文件。

    virtual void setTag(int tag);

    virtual void setName(const std::string& name);

    virtual void setUserData(void *userData);//可以看到这里的UserData是void类型的，也就是说可以记录任意数据

    virtual void setUserObject(Ref *userObject);

获取

    virtual int getTag() const;

    virtual const std::string& getName() const;

    virtual void* getUserData() { return _userData; }

    virtual const void* getUserData() const { return _userData; }

    virtual Ref* getUserObject() { return _userObject; }

    virtual const Ref* getUserObject() const { return _userObject; }

    virtual int getTag() const;

    virtual const std::string& getName() const;

    virtual void* getUserData() { return _userData; }

    virtual const void* getUserData() const { return _userData; }

    virtual Ref* getUserObject() { return _userObject; }

    virtual const Ref* getUserObject() const { return _userObject; }

OPenGL

获取OPenGL程序的状态

//每个node私有的状态

GLProgram * Node::getGLProgram() const

{

    return _glProgramState ? _glProgramState->getGLProgram() : nullptr;

}

//兼容旧版本

CC_DEPRECATED_ATTRIBUTE GLProgram* getShaderProgram() const { return getGLProgram(); }

//通用的状态

GLProgramState* Node::getGLProgramState() const

{

    return _glProgramState;

}

设置OPenGL程序的状态

//设置私有的程序状态

void Node::setGLProgram(GLProgram* glProgram)

{

    if (_glProgramState == nullptr || (_glProgramState && _glProgramState->getGLProgram() != glProgram))

    {

        CC_SAFE_RELEASE(_glProgramState);

        _glProgramState = GLProgramState::getOrCreateWithGLProgram(glProgram);

        _glProgramState->retain();

        _glProgramState->setNodeBinding(this);

    }

}

//兼容旧版本

CC_DEPRECATED_ATTRIBUTE void setShaderProgram(GLProgram *glprogram) { setGLProgram(glprogram); }

//设置通用的程序状态

void Node::setGLProgramState(cocos2d::GLProgramState* glProgramState)

{

    if (glProgramState != _glProgramState)

    {

        CC_SAFE_RELEASE(_glProgramState);

        _glProgramState = glProgramState;

        CC_SAFE_RETAIN(_glProgramState);

        if (_glProgramState)

            _glProgramState->setNodeBinding(this);

    }

}

isRunning()

//返回节点是否正在运行

//如果节点正在运行，它将接受onEnter()、onExit()、update()等事件回调

bool Node::isRunning() const

{

    return _running;

}

onEnter()

//过渡效果开始之前调用，预处理一些动作

void Node::onEnter()

{

    if (!_running) //没有运行说明还未依附，之后依附，给依附计数器+1

    {

        ++__attachedNodeCount;

    }

#if CC_ENABLE_SCRIPT_BINDING

    if (_scriptType == kScriptTypeJavascript)

    {

        if (ScriptEngineManager::sendNodeEventToJS(this, kNodeOnEnter))

            return;

    }

#endif

    if (_onEnterCallback)

        _onEnterCallback(); //调用自己的回调函数

    if (_componentContainer && !_componentContainer->isEmpty())

    {

        _componentContainer->onEnter();

    }

    _isTransitionFinished = false;

    for( const auto &child: _children) //子节点也会进入场景

        child->onEnter();

    this->resume();

    _running = true; //已经依附

#if CC_ENABLE_SCRIPT_BINDING

    if (_scriptType == kScriptTypeLua)

    {

        ScriptEngineManager::sendNodeEventToLua(this, kNodeOnEnter);

    }

#endif

}

//完全进入场景时调用，添加背景乐等动作

void Node::onEnterTransitionDidFinish()

{

#if CC_ENABLE_SCRIPT_BINDING

    if (_scriptType == kScriptTypeJavascript)

    {

        if (ScriptEngineManager::sendNodeEventToJS(this, kNodeOnEnterTransitionDidFinish))

            return;

    }

#endif

    if (_onEnterTransitionDidFinishCallback)

        _onEnterTransitionDidFinishCallback(); //调用结束过渡的回调函数

    _isTransitionFinished = true;

    for( const auto &child: _children) //子节点同步

        child->onEnterTransitionDidFinish();

#if CC_ENABLE_SCRIPT_BINDING

    if (_scriptType == kScriptTypeLua)

    {

        ScriptEngineManager::sendNodeEventToLua(this, kNodeOnEnterTransitionDidFinish);

    }

#endif

}

onExit()

/* if(_running)

        {

            child->onExitTransitionDidStart();

            child->onExit();

        }

*/ //belong to void Node::removeAllChildren()

//在退出场景之前调用

void Node::onExitTransitionDidStart()

{

#if CC_ENABLE_SCRIPT_BINDING

    if (_scriptType == kScriptTypeJavascript)

    {

        if (ScriptEngineManager::sendNodeEventToJS(this, kNodeOnExitTransitionDidStart))

            return;

    }

#endif

    if (_onExitTransitionDidStartCallback)

        _onExitTransitionDidStartCallback(); //调用回调函数

    for( const auto &child: _children) //子节点同步

        child->onExitTransitionDidStart();

#if CC_ENABLE_SCRIPT_BINDING

    if (_scriptType == kScriptTypeLua)

    {

        ScriptEngineManager::sendNodeEventToLua(this, kNodeOnExitTransitionDidStart);

    }

#endif

}

//退出场景时调用

void Node::onExit()

{

    if (_running)

    {

        --__attachedNodeCount; //依附计数器-1

    }

#if CC_ENABLE_SCRIPT_BINDING

    if (_scriptType == kScriptTypeJavascript)

    {

        if (ScriptEngineManager::sendNodeEventToJS(this, kNodeOnExit))

            return;

    }

#endif

    if (_onExitCallback)

        _onExitCallback(); //调用自己的回调函数

    if (_componentContainer && !_componentContainer->isEmpty())

    {

        _componentContainer->onExit();

    }

    this->pause(); //暂停事务

    _running = false; //不在运行中

    for( const auto &child: _children) //子节点也会被退出

        child->onExit(); 

#if CC_ENABLE_SCRIPT_BINDING

    if (_scriptType == kScriptTypeLua)

    {

        ScriptEngineManager::sendNodeEventToLua(this, kNodeOnExit);

    }

#endif

}

cleanup()

//停止所有的操作和调度器

void Node::cleanup()

{

#if CC_ENABLE_SCRIPT_BINDING

    if (_scriptType == kScriptTypeJavascript)

    {

        if (ScriptEngineManager::sendNodeEventToJS(this, kNodeOnCleanup))

            return;

    }

    else if (_scriptType == kScriptTypeLua)

    {

        ScriptEngineManager::sendNodeEventToLua(this, kNodeOnCleanup);

    }

#endif // #if CC_ENABLE_SCRIPT_BINDING

    // actions

    this->stopAllActions();

    // timers

    this->unscheduleAllCallbacks();  

    for( const auto &child: _children) //子节点同步

        child->cleanup();

}

补充：

1、GlobalZorder、LocalZorder和orderOfArrival的区别

//渲染的优先级是Globalzorder > LocalZorder > orderOfArrival，类似于权重

值越大的越迟渲染，因为节点是使用二叉树的中序遍历来渲染的。

会将所有Globalzorder < 0，Globalzorder > 0，Globalzorder > 0，的节点都放在数组中。

localZorder区别节点本身与兄弟节点的渲染顺序，当两个或多个节点的localZorder值相等时会比较orderOfArrival的值。

orderOfArrival的值不需要人为的特别设置，在给节点添加子节点时会自动的自增， orderOfArrival的值默认为0。

2、setIgnoreAnchorPointForPosition()；//一般Node的锚点默认为(0.5， 0.5)，而Layer的锚点则在左下角（0，0）,这个函数用来给Layer使用，layer的_ignoreAnchorPointForPosition值默认为true，忽略了锚点设置，如果自己设置了锚点也不会生效getChildren()

3、getChildren()有const修饰的问题如果节点被const修饰，则只能调用被const修饰的getChildren函数。

4、_componentContainer的问题相当于级联的操作

巴特西

从零开始のcocos2dx生活（二）Node

节点 Node

文章目录

前言

变量初始化

创建一个节点对象

获取节点依赖的计数器

获取节点的描述（获取节点的Tag）

节点的局部层顺序值（LocalZOrder）

设置节点的LocalZOrder的值

获取节点的LocalZOrder的值

相同等级子节点具有相同ZOrder时设置绘制顺序

节点的全局层顺序值(GlobalZOrder)

设置节点的GlobalZOrder值

获取节点的GlobalZOrder值

节点的缩放（scale）

设置缩放大小

获取缩放大小

节点位置(pisition)

设置节点在父坐标系中的位置

获取节点在父坐标系中的位置

兼容旧版本

节点倾斜（Skew）

设置倾斜角

获取倾斜角

节点锚点（AnchorPoint）

设置锚点

获取锚点

设置节点的锚点是否为（0，0）

获取节点的锚点是否是（0，0）

节点的原始大小（ContentSize）

设置节点的原始大小

获取节点的原始大小

节点可见性（Visible）

设置节点可见性

确定节点是否可见

设置节点的旋转角度

获取节点的旋转角度

节点的3d旋转（Rotation3D）

设置节点的3d旋转

获取节点的3d旋转

节点的四元数（Quat）

设置节点的四元数

获取节点的四元数

节点的旋转倾斜(RotationSkew)

设置旋转倾斜

获取旋转倾斜

兼容旧版本

子节点（Child）

添加子节点

获取子节点

添加父节点

获取父节点

移除（remove）

排序（Sort） ！

数据和用户标签

设置

获取

OPenGL

获取OPenGL程序的状态

设置OPenGL程序的状态

isRunning()

onEnter()

onExit()

cleanup()

最新文章

热门文章

排序（Sort）！