CURootLayer.h

//
//  CURootLayer.h
//  Cornell Extensions to Cocos2D
//
//  A module for the top layer for a Cocos2d Scene.  This class automates a lot of
//  of the start-up requirements for working in Cocos2d.  To create a Cocos2d
//  game, you just need to subclass the class and implement three methods:
//  start, stop, and update.
//
//  This class is based on the Cocos2d class LayerColor, which is used by their
//  HelloWorld application.  However, it's rendering is much more efficient, as
//  it does not inject a custom drawing command into the pipeline.
//
//  Author: Walker White
//  Version: 12/5/15
//
#ifndef __CU_ROOT_LAYER_H__
#define __CU_ROOT_LAYER_H__

#include <cocos2d.h>
#include <renderer/CCTrianglesCommand.h>

NS_CC_BEGIN

#pragma mark -
#pragma mark Static Constructor Template


namespace GameRoot {
    template<class T>
    Scene* createScene() {
        T* layer = new (std::nothrow)T();
        if (layer && layer->init()) {
            layer->autorelease();

            // 'scene' is an autorelease object
            auto scene = Scene::create();
            // add layer as a child to scene
            scene->addChild(layer);
            layer->start();
            // return the scene
            return scene;
        }
        CC_SAFE_DELETE(layer);
        return nullptr;
    }

    template<class T>
    Scene* createScene(const Size& size) {
        T* layer = new (std::nothrow)T();
        if (layer && layer->init(size)) {
            layer->autorelease();
            
            // 'scene' is an autorelease object
            auto scene = Scene::create();
            // add layer as a child to scene
            scene->addChild(layer);
            layer->start();
            // return the scene
            return scene;
        }
        CC_SAFE_DELETE(layer);
        return nullptr;
    }
}

#pragma mark -
#pragma mark Root Layer

class CC_DLL RootLayer: public Layer, public BlendProtocol {
    
#pragma mark Internal Helpers
private:
    CC_DISALLOW_COPY_AND_ASSIGN(RootLayer);
    
protected:
    Texture2D*       _texture;
    BlendFunc        _blendFunc;
    
    TrianglesCommand _command;
    TrianglesCommand::Triangles _triangles;
    
    bool _active;
    
    void clearRenderData();

    void updateColor(void) override;

    void updateBlendFunc(void);
    

public:
#pragma mark Attribute Accessors

    virtual void setContentSize(const Size & size) override;

    void setBlendFunc(const BlendFunc &blendFunc) override { _blendFunc = blendFunc; }
    
    const BlendFunc& getBlendFunc() const override { return _blendFunc; }
    
    virtual void draw(Renderer *renderer, const Mat4& transform, uint32_t flags) override;
    
    virtual void cleanup() override;
    
    
#pragma mark Primary Designer Methods

    bool isActive() const { return _active; }

    virtual void start() {
        _active = true;
        scheduleUpdate();
    }

    virtual void stop() {
        unscheduleUpdate();
        _active = false;
    }

    virtual void update(float dt) override {
        CCASSERT(_active, "Update called on inactive root layer");
        Node::update(dt);
    }
    
    void shutdown();

    
CC_CONSTRUCTOR_ACCESS:
#pragma mark Initializers

    RootLayer(void);
    
    virtual ~RootLayer(void);
    
    virtual bool init() override;

    virtual bool initWithSize(const Size& size);

    virtual bool initWithColor(const Color4B& color, const Size& size);

    template<class T>
    friend Scene* GameRoot::createScene();
    
    template<class T>
    friend Scene* GameRoot::createScene(const Size& size);
};

NS_CC_END

#endif /* defined(__CU_ROOT_LAYER_H__) */