CUScene.h

//
//  CUScene.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for the root node of a (2d) scene graph.  After
//  much debate, we have decided to decouple this from the application class
//  (which is different than Cocos2d).  However, scenes are still permitted
//  to contain controller code.  They are in a sense a "subapplication".
//
//  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: 7/1/16
 
#ifndef __CU_SCENE_H__
#define __CU_SCENE_H__
 
#include <cugl/math/cu_math.h>
#include <cugl/2d/CUNode.h>
#include <cugl/renderer/CUOrthographicCamera.h>
 
namespace cugl {
    
class Scene {
#pragma mark Values
protected:
    std::string _name;
    std::shared_ptr<OrthographicCamera> _camera;
    std::vector<std::shared_ptr<Node>> _children;
    Color4 _color;
    bool _zDirty;
    bool _zSort;
  
    GLenum _blendEquation;
    GLenum _srcFactor;
    GLenum _dstFactor;
 
    bool _active;
 
#pragma mark -
#pragma mark Constructors
public:
    Scene();
    
    ~Scene() { dispose(); }
    
    virtual void dispose();
    
    virtual bool init(const Size& size) {
        return init(0,0,size.width,size.height);
    }
    
    bool init(float width, float height) {
        return init(0,0,width,height);
    }
    
    virtual bool init(const Rect& rect) {
        return init(rect.origin.x,rect.origin.y,rect.size.width, rect.size.height);
    }
    
    virtual bool init(const Vec2& origin, const Size& size) {
        return init(origin.x,origin.y,size.width, size.height);
    }
    
    bool init(float x, float y, float width, float height);
 
#pragma mark -
#pragma mark Static Constructors
 
    static std::shared_ptr<Scene> alloc(const Size& size) {
        std::shared_ptr<Scene> result = std::make_shared<Scene>();
        return (result->init(size) ? result : nullptr);
    }
    
    static std::shared_ptr<Scene> alloc(float width, float height) {
        std::shared_ptr<Scene> result = std::make_shared<Scene>();
        return (result->init(width,height) ? result : nullptr);
    }
 
    static std::shared_ptr<Scene> alloc(const Rect& rect) {
        std::shared_ptr<Scene> result = std::make_shared<Scene>();
        return (result->init(rect) ? result : nullptr);
    }
 
    static std::shared_ptr<Scene> alloc(const Vec2& origin, const Size& size) {
        std::shared_ptr<Scene> result = std::make_shared<Scene>();
        return (result->init(origin,size) ? result : nullptr);
    }
    
    static std::shared_ptr<Scene> alloc(float x, float y, float width, float height) {
        std::shared_ptr<Scene> result = std::make_shared<Scene>();
        return (result->init(x,y,width,height) ? result : nullptr);
    }
    
#pragma mark -
#pragma mark Attributes
 
    const std::string& getName() const { return _name; }
 
    void setName(const std::string& name) { _name = name; }
 
    std::shared_ptr<Camera> getCamera();
 
    const std::shared_ptr<Camera> getCamera() const;
    
    Color4 getColor() { return _color; }
 
    void setColor(Color4 color) { _color = color; }
    
    virtual std::string toString(bool verbose = false) const;
    
    operator std::string() const { return toString(); }
 
#pragma mark -
#pragma mark View Size
 
    void setSize(const Size& size) {
        _camera->set(size);
    }
    
    void setSize(float width, float height) {
        _camera->set(width,height);
    }
    
 
    void setWidth(float width) {
        _camera->set(width,_camera->getViewport().size.height);
    }
    
    void setHeight(float height) {
        _camera->set(_camera->getViewport().size.width,height);
    }
    
    void setBounds(const Rect& rect) {
        _camera->set(rect);
    }
    
    void setBounds(const Vec2& origin, const Size& size) {
         _camera->set(origin,size);
    }
    
    void setBounds(float x, float y, float width, float height) {
        _camera->set(x,y,width,height);
    }
    
    void setOffset(const Vec2& origin) {
        _camera->set(origin,_camera->getViewport().size);
    }
    
    Vec3 screenToWorldCoords(const Vec2& screenCoords) const {
        return _camera->screenToWorldCoords(screenCoords);
    }
    
    Vec2 worldToScreenCoords(const Vec3& worldCoords) const {
        return _camera->worldToScreenCoords(worldCoords);
    }
    
#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->getZOrder());
    }
    
    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);
    
    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 Z-order
 
    bool isZAutoSort() { return _zSort; }
    
    void setZAutoSort(bool value) { _zSort = value; }
    
    bool isZDirty() const { return _zDirty; }
    
    void sortZOrder();
    
#pragma mark -
#pragma mark Scene Logic
 
    bool isActive( ) const { return _active; }
 
    virtual void setActive(bool value) { _active = value; }
 
    virtual void update(float timestep) {}
 
    virtual void reset() {}
    
    void render(const std::shared_ptr<SpriteBatch>& batch);
    
private:
#pragma mark -
#pragma mark Internal Helpers
 
    void setZDirty(bool value) { _zDirty = value; }
    
    // Tightly couple with Node
    friend class Node;
};
 
}
#endif /* __CU_SCENE_H__ */