CUNode.h

//
//  CUNode.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a (2d) scene graph node.  It uses an anchor
//  based approach, much like Cocos2d.  However, it is much more streamlined
//  and removes a lot of the Cocos2d nonsense when it comes to transforms.
//
//  This class uses our standard shared-pointer architecture.
//
//  1. The constructor does not perform any initialization; it just sets all
//     attributes to their defaults.
//
//  2. All initialization takes place via init methods, which can fail if an
//     object is initialized more than once.
//
//  3. All allocation takes place via static constructors which return a shared
//     pointer.
//
//  CUGL MIT License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 6/27/16

#ifndef __CU_NODE_H__
#define __CU_NODE_H__

#include <cugl/math/cu_math.h>
#include <cugl/renderer/CUSpriteBatch.h>
#include <cugl/util/CUDebug.h>
#include <cugl/assets/CUJsonValue.h>
#include <vector>
#include <string>

namespace cugl {
    
class Scene;
class SceneLoader;
class Layout;
    
class Node {
#pragma mark Values
protected:
    Vec2   _position;
    
    Vec2  _anchor;
    
    Size   _contentSize;
    
    Color4 _tintColor;
    bool  _hasParentColor;
    bool  _isVisible;
    
    Vec2  _scale;

    float  _angle;
    
    Mat4  _transform;
    
    bool _useTransform;
    
    Mat4  _combined;
    
    std::vector<std::shared_ptr<Node>> _children;

    Node* _parent;
    Scene* _graph;
    std::shared_ptr<Layout> _layout;

    int _childOffset;

    unsigned int _tag;
    
    std::string _name;
    
    size_t _hashOfName;
    
    int  _zOrder;
    bool _zDirty;
    
#pragma mark -
#pragma mark Constructors
public:
    Node();
    
    ~Node() { dispose(); }
    
    virtual void dispose();

    virtual bool init() {
        return initWithPosition(0, 0);
    }

    
    virtual bool initWithPosition(const Vec2& pos);
    
    bool initWithPosition(float x, float y) {
        return initWithPosition(Vec2(x,y));
    }

    virtual bool initWithBounds(const Size& size);

    bool initWithBounds(float width, float height) {
        return initWithBounds(Size(width,height));
    }

    virtual bool initWithBounds(const Rect& rect);
    
    bool initWithBounds(float x, float y, float width, float height) {
        return initWithBounds(Rect(x,y,width,height));
    }

    virtual bool initWithData(const SceneLoader* loader, const std::shared_ptr<JsonValue>& data);

    virtual Node* copy(Node* dst);

    
#pragma mark -
#pragma mark Static Constructors
    
    static std::shared_ptr<Node> alloc() {
        std::shared_ptr<Node> result = std::make_shared<Node>();
        return (result->init() ? result : nullptr);
    }
    
    static std::shared_ptr<Node> allocWithPosition(const Vec2& pos) {
        std::shared_ptr<Node> result = std::make_shared<Node>();
        return (result->initWithPosition(pos) ? result : nullptr);
    }
    
    static std::shared_ptr<Node> allocWithPosition(float x, float y) {
        std::shared_ptr<Node> result = std::make_shared<Node>();
        return (result->initWithPosition(x,y) ? result : nullptr);
    }

    static std::shared_ptr<Node> allocWithBounds(const Size& size) {
        std::shared_ptr<Node> result = std::make_shared<Node>();
        return (result->initWithBounds(size) ? result : nullptr);
    }
    
    static std::shared_ptr<Node> allocWithBounds(float width, float height) {
        std::shared_ptr<Node> result = std::make_shared<Node>();
        return (result->initWithBounds(width,height) ? result : nullptr);
    }
    
    static std::shared_ptr<Node> allocWithBounds(const Rect& rect) {
        std::shared_ptr<Node> result = std::make_shared<Node>();
        return (result->initWithBounds(rect) ? result : nullptr);
    }
    
    static std::shared_ptr<Node> allocWithBounds(float x, float y, float width, float height) {
        std::shared_ptr<Node> result = std::make_shared<Node>();
        return (result->initWithBounds(x,y,width,height) ? result : nullptr);
    }
    
    static std::shared_ptr<Node> allocWithData(const SceneLoader* loader,
                                               const std::shared_ptr<JsonValue>& data) {
        std::shared_ptr<Node> result = std::make_shared<Node>();
        return (result->initWithData(loader,data) ? result : nullptr);
    }

#pragma mark -
#pragma mark Identifiers

    unsigned int getTag() const { return _tag; }
    
    void setTag(unsigned int tag) { _tag = tag; }
    
    const std::string& getName() const { return _name; }
    
    void setName(const std::string& name) {
        _name = name;
        _hashOfName = std::hash<std::string>()(_name);
    }

    virtual std::string toString(bool verbose = false) const;
    
    operator std::string() const { return toString(); }
    
    
#pragma mark -
#pragma mark Position

    const Vec2& getPosition() const { return _position; }
    
    void setPosition(const Vec2 &position) { setPosition(position.x,position.y); }
    
    void setPosition(float x, float y);
    
    float getPositionX(void) const { return getPosition().x; }
    
    void setPositionX(float x) { setPosition(x,getPositionY()); }
    
    float getPositionY(void) const { return getPosition().y; }

    void setPositionY(float y) { setPosition(getPositionX(),y); }
    
    Vec2 getWorldPosition() const {
        return nodeToWorldCoords(_anchor*getContentSize());
    }


#pragma mark -
#pragma mark Size

    const Size& getContentSize() const { return _contentSize; }

    virtual void setContentSize(const Size& size);

    virtual void setContentSize(float width, float height) {
        setContentSize(Size(width, height));
    }
    
    float getContentWidth() const { return getContentSize().width; }
    
    void setContentWidth(float width) { setContentSize(width,getContentHeight()); }
    
    float getContentHeight() const { return getContentSize().height; }

    void setContentHeight(float height) { setContentSize(getContentWidth(),height); }
    
    Size getSize() const;
    
    float getWidth() const { return getSize().width; }

    float getHeight() const { return getSize().height; }
    
    Rect getBoundingBox() const {
        return getNodeToParentTransform().transform(Rect(Vec2::ZERO, getContentSize()));
    }
    
#pragma mark -
#pragma mark Anchors

    virtual void setAnchor(const Vec2& anchor);
    
    void setAnchor(float x, float y) { setAnchor(Vec2(x,y)); }
    
    const Vec2& getAnchor() const { return _anchor; }

    Vec2 getAnchorInPixels() { return _anchor * _contentSize; }

    
#pragma mark -
#pragma mark Visibility

    Color4 getColor() const { return _tintColor; }
    
    virtual void setColor(Color4 color) { _tintColor = color; }

    Color4 getAbsoluteColor();

    bool isVisible() const { return _isVisible; }
    
    void setVisible(bool visible) { _isVisible = visible; }
    
    bool hasRelativeColor() { return _hasParentColor; }
    
    void setRelativeColor(bool flag) { _hasParentColor = flag; }
    
    
#pragma mark -
#pragma mark Transforms

    const Vec2& getScale() const  { return _scale;   }
    
    float getScaleX() const { return _scale.x; }
    
    float getScaleY() const { return _scale.y; }

    void setScale(float scale) {
        _scale.set(scale,scale);
        if (!_useTransform) updateTransform();
    }

    void setScale(const Vec2& vec) {
        _scale = vec;
        if (!_useTransform) updateTransform();
    }

    void setScale(float sx, float sy) {
        _scale.set(sx,sy);
        if (!_useTransform) updateTransform();
    }
    
    float getAngle() { return _angle; }

    void setAngle(float angle) {
        _angle = angle;
        if (!_useTransform) updateTransform();
    }
    
    const Mat4& getAlternateTransform() { return _transform; }
    
    void setAlternateTransform(const Mat4& transform) {
        _transform = transform;
        updateTransform();
    }
    
    bool withAlternateTransform() { return _useTransform; }

    void chooseAlternateTransform(bool active) {
        _useTransform = active; updateTransform();
    }

    const Mat4& getNodeToParentTransform() const { return _combined; }
    
    Mat4 getParentToNodeTransform() const { return _combined.getInverse(); }
    
    Mat4 getNodeToWorldTransform() const;
    
    Mat4 getWorldToNodeTransform() const {
        return getNodeToWorldTransform().getInverse();
    }
    
    Vec2 screenToNodeCoords(const Vec2& screenPoint) const;

    
    Vec2 worldToNodeCoords(const Vec2& worldPoint) const {
        return getWorldToNodeTransform().transform(worldPoint);
    }

    Vec2 nodeToScreenCoords(const Vec2& nodePoint) const;
    
    Vec2 nodeToWorldCoords(const Vec2& nodePoint) const {
        return getNodeToWorldTransform().transform(nodePoint);
    }
    
    Vec2 parentToNodeCoords(const Vec2& parentPoint) const {
        return getParentToNodeTransform().transform(parentPoint);
    }
    
    Vec2 nodeToParentCoords(const Vec2& nodePoint) const {
        return getNodeToParentTransform().transform(nodePoint);
    }

#pragma mark -
#pragma mark Z-order

    void setZOrder(int z);
    
    int getZOrder() const { return _zOrder; }
    
    bool isZDirty() const { return _zDirty; }

    void sortZOrder();
    
    
#pragma mark -
#pragma mark Scene Graph

    size_t getChildCount() const { return _children.size(); }

    std::shared_ptr<Node> getChild(unsigned int pos);

    const std::shared_ptr<Node>& getChild(unsigned int pos) const;
    
    template <typename T>
    inline std::shared_ptr<T> getChild(unsigned int pos) const {
        return std::dynamic_pointer_cast<T>(getChild(pos));
    }

    std::shared_ptr<Node> getChildByTag(unsigned int tag) const;
    
    template <typename T>
    inline std::shared_ptr<T> getChildByTag(unsigned int tag) const {
        return std::dynamic_pointer_cast<T>(getChildByTag(tag));
    }
    
    std::shared_ptr<Node> getChildByName(const std::string& name) const;
    
    template <typename T>
    inline std::shared_ptr<T> getChildByName(const std::string& name) const {
        return std::dynamic_pointer_cast<T>(getChildByName(name));
    }

    std::vector<std::shared_ptr<Node>> getChildren() { return _children; }

    const std::vector<std::shared_ptr<Node>>& getChildren() const { return _children; }
    
    void addChild(std::shared_ptr<Node> child) {
        addChild(child,child->_zOrder);
    }
    
    virtual void addChild(const std::shared_ptr<Node>& child, int zval);
    
    void addChildWithTag(const std::shared_ptr<Node>& child, unsigned int tag) {
        addChild(child);
        child->setTag(tag);
    }
    
    void addChildWithTag(const std::shared_ptr<Node>& child, unsigned int tag, int zval) {
        addChild(child,zval);
        child->setTag(tag);
    }

    void addChildWithName(const std::shared_ptr<Node>& child, const std::string &name) {
        addChild(child);
        child->setName(name);
    }
    
    void addChildWithName(const std::shared_ptr<Node>& child, const std::string &name, int zval) {
        addChild(child,zval);
        child->setName(name);
    }
    
    void swapChild(const std::shared_ptr<Node>& child1, const std::shared_ptr<Node>& child2, bool inherit=false);
    
    Node* getParent() { return _parent; }
    
    const Node* getParent() const { return _parent; }
    
    Scene* getScene() { return _graph; }
    
    const Scene* getScene() const { return _graph; }

    void removeFromParent() { if (_parent) { _parent->removeChild(_childOffset); } }
    
    virtual void removeChild(unsigned int pos);
    
    void removeChild(const std::shared_ptr<Node>& child);
    
    void removeChildByTag(unsigned int tag);
    
    void removeChildByName(const std::string &name);
    
    virtual void removeAllChildren();
    
    
#pragma mark -
#pragma mark Rendering

    virtual void render(const std::shared_ptr<SpriteBatch>& batch, const Mat4& transform, Color4 tint);

    virtual void render(const std::shared_ptr<SpriteBatch>& batch) {
        render(batch,Mat4::IDENTITY,Color4::WHITE);
    }

    virtual void draw(const std::shared_ptr<SpriteBatch>& batch, const Mat4& transform, Color4 tint) {}
    
    
#pragma mark -
#pragma mark Layout Automation

    const std::shared_ptr<Layout>& getLayout() const { return _layout; }
    
    void setLayout(const std::shared_ptr<Layout>& layout) { _layout = layout; }
    
    virtual void doLayout();

private:
#pragma mark -
#pragma mark Internal Helpers

    void setZDirty(bool value);

    void setParent(Node* parent) { _parent = parent; }

    void setScene(Scene* scene) { _graph = scene; }

    void pushScene(Scene* scene);

    static bool compareNodeSibs(const std::shared_ptr<Node>& a, const std::shared_ptr<Node>& b);
    
    virtual void updateTransform();

    // Copying is only allowed via shared pointer.
    CU_DISALLOW_COPY_AND_ASSIGN(Node);
    
    friend class Scene;
};


}
#endif /* __CU_NODE_H__ */