#include "ccMacros.h"

#include "CCAffineTransform.h"

#include "CCGL.h"

#include "ccGLStateCache.h"

#include "CCGLProgram.h"

#include "CCScriptSupport.h"

#include "CCProtocols.h"

#include "CCEventDispatcher.h"

#include "CCVector.h"

#include "kazmath/kazmath.h"

NS_CC_BEGIN

class GridBase;

class Point;

class Touch;

class Action;

class LabelProtocol;

class Scheduler;

class ActionManager;

class Component;

class ComponentContainer;

class EventDispatcher;

class Scene;

class Renderer;

#if CC_USE_PHYSICS

class PhysicsBody;

#endif

/**

 * @addtogroup base_nodes

 * @{

 */

enum {

    kNodeOnEnter,

    kNodeOnExit,

    kNodeOnEnterTransitionDidFinish,

    kNodeOnExitTransitionDidStart,

    kNodeOnCleanup

};

bool nodeComparisonLess(Node* n1, Node* n2);

class EventListener;

/**

     * Sets the rotation (X,Y,Z) in degrees.

     * Useful for 3d rotations

     */

    virtual void setRotation3D(const Vertex3F& rotation);

    /**

     * returns the rotation (X,Y,Z) in degrees.

     */

    virtual Vertex3F getRotation3D() const;

struct

Vertex3F { Vertex3F(float _x, float _y, float _z) : x(_x) , y(_y) , z(_z) {} Vertex3F(): x(.f), y(.f), z(

.f) {}

    GLfloat x;

    GLfloat y;

    GLfloat z;

};

 /**

     * Sets the rotation (angle) of the node in degrees.

     *

     * 0 is the default rotation angle.

     * Positive values rotate node clockwise, and negative values for anti-clockwise.

     *

     * @param rotation     The rotation of the node in degrees.

     */

    virtual void setRotation(float rotation);

    /**

     * Returns the rotation of the node in degrees.

     *

     * @see `setRotation(float)`

     *

     * @return The rotation of the node in degrees.

     */

    virtual float getRotation() const;

/**

     * Sets the X rotation (angle) of the node in degrees which performs a horizontal rotational skew.

     *

     * The difference between `setRotationalSkew()` and `setSkew()` is that the first one simulate Flash's skew functionality

     * while the second one uses the real skew function.

     *

     * 0 is the default rotation angle.

     * Positive values rotate node clockwise, and negative values for anti-clockwise.

     *

     * @param rotationX    The X rotation in degrees which performs a horizontal rotational skew.

     */

    virtual void setRotationSkewX(float rotationX);

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

    /**

     * Gets the X rotation (angle) of the node in degrees which performs a horizontal rotation skew.

     *

     * @see `setRotationSkewX(float)`

     *

     * @return The X rotation in degrees.

     */

    virtual float getRotationSkewX() const;

    CC_DEPRECATED_ATTRIBUTE virtual float getRotationX() const { return getRotationSkewX(); }

    /**

     * Sets the Y rotation (angle) of the node in degrees which performs a vertical rotational skew.

     *

     * The difference between `setRotationalSkew()` and `setSkew()` is that the first one simulate Flash's skew functionality

     * while the second one uses the real skew function.

     *

     * 0 is the default rotation angle.

     * Positive values rotate node clockwise, and negative values for anti-clockwise.

     *

     * @param rotationY    The Y rotation in degrees.

     */

    virtual void setRotationSkewY(float rotationY);

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

    /**

     * Gets the Y rotation (angle) of the node in degrees which performs a vertical rotational skew.

     *

     * @see `setRotationSkewY(float)`

     *

     * @return The Y rotation in degrees.

     */

    virtual float getRotationSkewY() const;

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

void Node::setRotationSkewX(float rotationX)

{

    if (_rotationZ_X == rotationX)

        return;

    _rotationZ_X = rotationX;

    _transformUpdated = _transformDirty = _inverseDirty = true;

}

  // "cache" variables are allowed to be mutable

    mutable kmMat4 _transform;      ///< 变换矩阵

    mutable bool _transformDirty;   ///< 是否应该进行变换矩阵计算

    mutable kmMat4 _inverse;        ///< 倒转变换矩阵

    mutable bool _inverseDirty;     ///< 标记是否应该进行倒转计算

    mutable kmMat4 _additionalTransform; ///附加的变换矩阵

    bool _useAdditionalTransform;   ///< 使用附加变换

    bool _transformUpdated;         ///< 标记是否需要在场景更新的最后进行矩阵变换计算。

 /**

     * _scaleX的 get set 方法

     */

    virtual void setScaleX(float scaleX);

    virtual float getScaleX() const;

    /**

     * _scaleY的 get set 方法

     */

    virtual void setScaleY(float scaleY);

    virtual float getScaleY() const;

    /**

     * _scaleZ的get set 方法

     */

    virtual void setScaleZ(float scaleZ);

    virtual float getScaleZ() const;

    /**

     * 将_scaleX _scaleY  _scaleZ设置成相同值的 get set 方法

     */

    virtual void setScale(float scale);

    virtual float getScale() const;

class

CC_DLL Point { public: float x; float y;

const Point& Node::getAnchorPointInPoints() const

{

    return _anchorPointInPoints;

}

/// anchorPoint getter

const Point& Node::getAnchorPoint() const

{

    return _anchorPoint;

}

void Node::setAnchorPoint(const Point& point)

{

#if CC_USE_PHYSICS

    if (_physicsBody != nullptr && !point.equals(Point::ANCHOR_MIDDLE))

    {

        CCLOG("Node warning: This node has a physics body, the anchor must be in the middle, you cann't change this to other value.");

        return;

    }

#endif

    if( ! point.equals(_anchorPoint))

    {

        _anchorPoint = point;

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

        _transformUpdated = _transformDirty = _inverseDirty = true;

    }

}

class CC_DLL Size

{

public:

    float width;

    float height;

int _localZOrder;               ///< Local order (relative to its siblings) used to sort the node

    float _globalZOrder;            ///< Global order used to sort the node

    Vector<Node*> _children;        ///< array of children nodes

    Node *_parent;                  ///< weak reference to parent node

    int _tag;                         ///可以给当前的Node对象定义一个 int类型的标识

    std::string _name;               ///可以给当前Node对象起一个字符串类型的名称。

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

{

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

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

    if (_children.empty())

    {

        this->childrenAlloc();

    }

    this->insertChild(child, zOrder);

#if CC_USE_PHYSICS

    if (child->getPhysicsBody() != nullptr)

    {

        child->getPhysicsBody()->setPosition(this->convertToWorldSpace(child->getPosition()));

    }

    for (Node* node = this->getParent(); node != nullptr; node = node->getParent())

    {

        if (dynamic_cast<Scene*>(node) != nullptr)

        {

            (dynamic_cast<Scene*>(node))->addChildToPhysicsWorld(child);

            break;

        }

    }

#endif

    child->_tag = tag;

    child->setParent(this);

    child->setOrderOfArrival(s_globalOrderOfArrival++);

    if( _running )

    {

        child->onEnter();

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

        if (_isTransitionFinished) {

            child->onEnterTransitionDidFinish();

        }

    }

    if (_cascadeColorEnabled)

    {

        updateCascadeColor();

    }

    if (_cascadeOpacityEnabled)

    {

        updateCascadeOpacity();

    }

}

void Node::insertChild(Node* child, int z)

{

    _reorderChildDirty = true;

    _children.pushBack(child);

    child->_setLocalZOrder(z);

}

void Node::sortAllChildren()

{

    if( _reorderChildDirty ) {

        std::sort( std::begin(_children), std::end(_children), nodeComparisonLess );

        _reorderChildDirty = false;

    }

}

void Node::setOrderOfArrival(int orderOfArrival)

{

    CCASSERT(orderOfArrival >=, "Invalid orderOfArrival");

    _orderOfArrival = orderOfArrival;

}

int _orderOfArrival;            ///< used to preserve sequence while sorting children with the same localZOrder

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

        if (_isTransitionFinished) {

            child->onEnterTransitionDidFinish();

        }

    if (_cascadeColorEnabled)

    {

        updateCascadeColor();

    }

    if (_cascadeOpacityEnabled)

    {

        updateCascadeOpacity();

    }

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

{

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

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

}

void Node::addChild(Node *child)

{

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

    this->addChild(child, child->_localZOrder, child->_tag);

}

/**

     * 通过tag得到child指针     *

     * @param tag   An identifier to find the child node.

     *

     * @return a Node object whose tag equals to the input parameter

     */

    virtual Node * getChildByTag(int tag);

    /**

     * 返回_children的引用，与const引用     *

     * @return the array the node's children

     */

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

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

    /**

     * 返回子结点的数量

     *

     * @return The amount of children.

     */

    virtual ssize_t getChildrenCount() const;

   /**

     * 将当前结点从它的父结点中清除，并且调用了clean方法做了清除，clean方法是什么后面我们有分析。.

     */

    virtual void removeFromParent();

    /** 同上面的removeFromParent方法，有一个参数可以指定是否调用 clean方法做清除

     */

    virtual void removeFromParentAndCleanup(bool cleanup);

    /**

     * 通过 child的指针来删除一个指定的结点

     */

    virtual void removeChild(Node* child, bool cleanup = true);

    /**

     * 通过tag值来删除一个子结点

     */

    virtual void removeChildByTag(int tag, bool cleanup = true);

    /**

     * 清除所有的子结点并且所有的子结点都会调用 cleanup 方法

     */

    virtual void removeAllChildren();

    /**

     * 清除所有子结点，根据cleanup的参数设置来决定是否调用cleanup方法 (这里出现了多次cleanup这个函数后面我们重点分析一下源码）

     */

    virtual void removeAllChildrenWithCleanup(bool cleanup);

    /**

     * 这个函数干了几件事，

     * 1. 设置了_reorderChildDirty = true 设置当前结点的子结点进行排序

     * 2. 重新更新了child的 _orderOfArrival 值为最新的

     * 3. 设置 child的 _localZOrder值为 localZOrder

     */

    virtual void reorderChild(Node * child, int localZOrder);

    /**

     * 根据 子结点的的 _localZOrder排列当前结点所有的child ,有了这个方法不用每加一个结点或者改变某个子结点的zOrder就排一次，这个排列方法要在结点显示到屏幕之前调用。

*/

    virtual void sortAllChildren();

    /**

     * tag的get set 方法

     */

    virtual int getTag() const;

    virtual void setTag(int tag);

// XXX: Yes, nodes might have a sort problem once every 15 days if the game runs at 60 FPS and each frame sprites are reordered.

int Node::s_globalOrderOfArrival = ;

void Node::cleanup()

{

    // actions

    this->stopAllActions();

    this->unscheduleAllSelectors();

#if CC_ENABLE_SCRIPT_BINDING

    if ( _scriptType != kScriptTypeNone)

    {

        int action = kNodeOnCleanup;

        BasicScriptData data(this,(void*)&action);

        ScriptEvent scriptEvent(kNodeEvent,(void*)&data);

        ScriptEngineManager::getInstance()->getScriptEngine()->sendEvent(&scriptEvent);

    }

#endif // #if CC_ENABLE_SCRIPT_BINDING

    // timers

    for( const auto &child: _children)

        child->cleanup();

}

    void *_userData;                ///< A user assingned void pointer, Can be point to any cpp object

    Ref *_userObject;               ///< A user assigned Object

    GLProgram *_shaderProgram;      ///< OpenGL shader

    Scheduler *_scheduler;          ///< scheduler used to schedule timers and updates

    ActionManager *_actionManager;  ///< a pointer to ActionManager singleton, which is used to handle all the actions

    EventDispatcher* _eventDispatcher;  ///< event dispatcher used to dispatch all kinds of events

bool _visible;                  ///< is this node visible

// opacity controls

    GLubyte        _displayedOpacity;

    GLubyte     _realOpacity;

    Color3B        _displayedColor;

    Color3B     _realColor;

Node::Node(void)

: _rotationX(0.0f)

, _rotationY(0.0f)

, _rotationZ_X(0.0f)

, _rotationZ_Y(0.0f)

, _scaleX(1.0f)

, _scaleY(1.0f)

, _scaleZ(1.0f)

, _positionZ(0.0f)

, _position(Point::ZERO)

, _skewX(0.0f)

, _skewY(0.0f)

, _anchorPointInPoints(Point::ZERO)

, _anchorPoint(Point::ZERO)

, _contentSize(Size::ZERO)

, _useAdditionalTransform(false)

, _transformDirty(true)

, _inverseDirty(true)

, _transformUpdated(true)

// children (lazy allocs)

// lazy alloc

, _localZOrder()

, _globalZOrder()

, _parent(nullptr)

// "whole screen" objects. like Scenes and Layers, should set _ignoreAnchorPointForPosition to true

, _tag(Node::INVALID_TAG)

// userData is always inited as nil

, _userData(nullptr)

, _userObject(nullptr)

, _shaderProgram(nullptr)

, _orderOfArrival()

, _running(false)

, _visible(true)

, _ignoreAnchorPointForPosition(false)

, _reorderChildDirty(false)

, _isTransitionFinished(false)

#if CC_ENABLE_SCRIPT_BINDING

, _updateScriptHandler()

#endif

, _componentContainer(nullptr)

#if CC_USE_PHYSICS

, _physicsBody(nullptr)

#endif

, _displayedOpacity()

, _realOpacity()

, _displayedColor(Color3B::WHITE)

, _realColor(Color3B::WHITE)

, _cascadeColorEnabled(false)

, _cascadeOpacityEnabled(false)

{

    // set default scheduler and actionManager

    Director *director = Director::getInstance();

    _actionManager = director->getActionManager();

    _actionManager->retain();

    _scheduler = director->getScheduler();

    _scheduler->retain();

    _eventDispatcher = director->getEventDispatcher();

    _eventDispatcher->retain();

#if CC_ENABLE_SCRIPT_BINDING

    ScriptEngineProtocol* engine = ScriptEngineManager::getInstance()->getScriptEngine();

    _scriptType = engine != nullptr ? engine->getScriptType() : kScriptTypeNone;

#endif

    kmMat4Identity(&_transform);

    kmMat4Identity(&_inverse);

    kmMat4Identity(&_additionalTransform);

}

Node::~Node()

{

    CCLOGINFO( "deallocing Node: %p - tag: %i", this, _tag );

#if CC_ENABLE_SCRIPT_BINDING

    if (_updateScriptHandler)

    {

        ScriptEngineManager::getInstance()->getScriptEngine()->removeScriptHandler(_updateScriptHandler);

    }

#endif

    // User object has to be released before others, since userObject may have a weak reference of this node

    // It may invoke `node->stopAllAction();` while `_actionManager` is null if the next line is after `CC_SAFE_RELEASE_NULL(_actionManager)`.

    CC_SAFE_RELEASE_NULL(_userObject);

    // attributes

    CC_SAFE_RELEASE_NULL(_shaderProgram);

    for (auto& child : _children)

    {

        child->_parent = nullptr;

    }

    removeAllComponents();

    CC_SAFE_DELETE(_componentContainer);

#if CC_USE_PHYSICS

    setPhysicsBody(nullptr);

#endif

    CC_SAFE_RELEASE_NULL(_actionManager);

    CC_SAFE_RELEASE_NULL(_scheduler);

    _eventDispatcher->removeEventListenersForTarget(this);

#if CC_NODE_DEBUG_VERIFY_EVENT_LISTENERS && COCOS2D_DEBUG > 0

    _eventDispatcher->debugCheckNodeHasNoEventListenersOnDestruction(this);

#endif

    CCASSERT(!_running, "Node still marked as running on node destruction! Was base class onExit() called in derived class onExit() implementations?");

    CC_SAFE_RELEASE(_eventDispatcher);

}

private:

    CC_DISALLOW_COPY_AND_ASSIGN(Node);

Node * Node::create(void)

{

    Node * ret = new Node();

    if (ret && ret->init())

    {

        ret->autorelease();

    }

    else

    {

        CC_SAFE_DELETE(ret);

    }

    return ret;

}

virtual bool init();

bool Node::init()

{

    return true;

}

/**

     * Override this method to draw your own node.

     * The following GL states will be enabled by default:

     * - `glEnableClientState(GL_VERTEX_ARRAY);`

     * - `glEnableClientState(GL_COLOR_ARRAY);`

     * - `glEnableClientState(GL_TEXTURE_COORD_ARRAY);`

     * - `glEnable(GL_TEXTURE_2D);`

     * AND YOU SHOULD NOT DISABLE THEM AFTER DRAWING YOUR NODE

     * But if you enable any other GL state, you should disable it after drawing your node.

     */

    virtual void draw(Renderer *renderer, const kmMat4& transform, bool transformUpdated);

    virtual void draw() final;

/**

     * Visits this node's children and draw them recursively.

     */

    virtual void visit(Renderer *renderer, const kmMat4& parentTransform, bool parentTransformUpdated);

    virtual void visit() final;

void Node::visit(Renderer* renderer, const kmMat4 &parentTransform, bool parentTransformUpdated)

{

    // quick return if not visible. children won't be drawn.

    if (!_visible)

    {

        return;

    }

    bool dirty = _transformUpdated || parentTransformUpdated;

    if(dirty)

        _modelViewTransform = this->transform(parentTransform);

    _transformUpdated = false;

    // IMPORTANT:

    // To ease the migration to v3.0, we still support the kmGL stack,

    // but it is deprecated and your code should not rely on it

    kmGLPushMatrix();

    kmGLLoadMatrix(&_modelViewTransform);

    int i = ;

    if(!_children.empty())

    {

        sortAllChildren();

        // draw children zOrder < 0

        for( ; i < _children.size(); i++ )

        {

            auto node = _children.at(i);

            if ( node && node->_localZOrder <  )

                node->visit(renderer, _modelViewTransform, dirty);

            else

                break;

        }

        // self draw

        this->draw(renderer, _modelViewTransform, dirty);

        for(auto it=_children.cbegin()+i; it != _children.cend(); ++it)

            (*it)->visit(renderer, _modelViewTransform, dirty);

    }

    else

    {

        this->draw(renderer, _modelViewTransform, dirty);

    }

    // reset for next frame

    _orderOfArrival = ;

    kmGLPopMatrix();

}

void Node::resume()

{

    _scheduler->resumeTarget(this);

    _actionManager->resumeTarget(this);

    _eventDispatcher->resumeEventListenersForTarget(this);

}

void Node::pause()

{

    _scheduler->pauseTarget(this);

    _actionManager->pauseTarget(this);

    _eventDispatcher->pauseEventListenersForTarget(this);

}

class CC_DLL __NodeRGBA : public Node, public __RGBAProtocol

{

public:

    // overrides

    virtual GLubyte getOpacity() const override { return Node::getOpacity(); }

    virtual GLubyte getDisplayedOpacity() const  override { return Node::getDisplayedOpacity(); }

    virtual void setOpacity(GLubyte opacity) override { return Node::setOpacity(opacity); }

    virtual void updateDisplayedOpacity(GLubyte parentOpacity) override { return Node::updateDisplayedOpacity(parentOpacity); }

    virtual bool isCascadeOpacityEnabled() const  override { return Node::isCascadeOpacityEnabled(); }

    virtual void setCascadeOpacityEnabled(bool cascadeOpacityEnabled) override { return Node::setCascadeOpacityEnabled(cascadeOpacityEnabled); }

    virtual const Color3B& getColor(void) const override { return Node::getColor(); }

    virtual const Color3B& getDisplayedColor() const override { return Node::getDisplayedColor(); }

    virtual void setColor(const Color3B& color) override { return Node::setColor(color); }

    virtual void updateDisplayedColor(const Color3B& parentColor) override { return Node::updateDisplayedColor(parentColor); }

    virtual bool isCascadeColorEnabled() const override { return Node::isCascadeColorEnabled(); }

    virtual void setCascadeColorEnabled(bool cascadeColorEnabled) override { return Node::setCascadeColorEnabled(cascadeColorEnabled); }

    virtual void setOpacityModifyRGB(bool bValue) override { return Node::setOpacityModifyRGB(bValue); }

    virtual bool isOpacityModifyRGB() const override { return Node::isOpacityModifyRGB(); }

protected:

    __NodeRGBA();

    virtual ~__NodeRGBA() {}

private:

    CC_DISALLOW_COPY_AND_ASSIGN(__NodeRGBA);

};