CUTexturedNode.h

//
//  CUTexturedNode.h
//  Cornell University Game Library (CUGL)
//
//  This module provides an abstract class for textured scene graph nodes. It
//  is the core scene graph node in CUGL.
//
//  You should never instantiate an object of this class.  Instead, you should
//  use one of the concrete subclasses: WireNode, PolygonNode, or PathNode.
//  Because it is abstract, it has no allocators.  It only has initializers.
//
//  CUGL zlib 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_TEXTURED_NODE_H__
#define __CU_TEXTURED_NODE_H__

#include <string>
#include "../math/CUPoly2.h"
#include "CUNode.h"
#include "../renderer/CUTexture.h"
#include "../renderer/CUVertex.h"

namespace cugl {
class TexturedNode : public Node {
#pragma mark Values
protected:
    std::string _classname;
    
    std::shared_ptr<Texture>    _texture;
    
    Poly2   _polygon;
    
    bool _absolute;
    
    bool _rendered;
    std::vector<Vertex2> _vertices;
    
    GLenum _blendEquation;
    GLenum _srcFactor;
    GLenum _dstFactor;
    
    bool _flipHorizontal;
    bool _flipVertical;
    
#pragma mark -
#pragma mark Constructors
public:
    TexturedNode();
    
    virtual ~TexturedNode() { _texture = nullptr; }
    
    virtual void dispose() override;
    
    virtual bool init() override {
        return initWithTexture(nullptr, Rect::ZERO);
    }
    
    bool init(const std::vector<Vec2>& vertices) {
        return initWithTexture(nullptr, vertices);
    }
    
    bool  init(const Poly2& poly) {
        return initWithTexture(nullptr, poly);
    }
    
    bool  init(const Rect& rect) {
        return initWithTexture(nullptr, rect);
    }
    
    bool initWithFile(const std::string& filename);
    
    bool initWithFile(const std::string& filename, const std::vector<Vec2>& vertices) {
        _polygon.set(vertices);
        return initWithFile(filename, _polygon);
    }
    
    bool initWithFile(const std::string& filename, const Poly2& poly);
    
    bool initWithFile(const std::string& filename, const Rect& rect);
    
    bool initWithTexture(const std::shared_ptr<Texture>& texture);
    
    bool initWithTexture(const std::shared_ptr<Texture>&  texture, const std::vector<Vec2>& vertices) {
        setPolygon(vertices);
        return initWithTexture(texture, _polygon);
    }
    
    bool initWithTexture(const std::shared_ptr<Texture>& texture, const Poly2& poly);
    
    bool initWithTexture(const std::shared_ptr<Texture>& texture, const Rect& rect);
    
    
#pragma mark -
#pragma mark Attributes

    void setTexture(const std::string &filename) {
        std::shared_ptr<Texture> texture =  Texture::allocWithFile(filename);
        setTexture(texture);
    }
    
    void setTexture(const std::shared_ptr<Texture>& texture);
    
    std::shared_ptr<Texture>& getTexture() { return _texture; }

    const std::shared_ptr<Texture>& getTexture() const { return _texture; }

    virtual void setPolygon(const std::vector<Vec2>& vertices) = 0;
    
    virtual void setPolygon(const Poly2& poly);
    
    virtual void setPolygon(const Rect& rect) = 0;
    
    const Poly2& getPolygon() const { return _polygon; }
    
    virtual void shiftPolygon(float dx, float dy);
    
    const Rect& getBoundingRect() const { return _polygon.getBounds(); }
    
    void setBlendFunc(GLenum srcFactor, GLenum dstFactor);
    
    GLenum getSourceBlendFactor() const { return _srcFactor; }
    
    GLenum getDestinationBlendFactor() const { return _srcFactor; }
    
    void setBlendEquation(GLenum equation);
    
    GLenum getBlendEquation() const { return _blendEquation; }
    
    void flipHorizontal(bool flag) { _flipHorizontal = flag; updateTextureCoords(); }
    
    bool isFlipHorizontal() const { return _flipHorizontal; }
    
    void flipVertical(bool flag) { _flipVertical = flag; updateTextureCoords(); }
    
    bool isFlipVertical() const { return _flipVertical; }

    virtual std::string toString(bool verbose=false) const override;
    
#pragma mark -
#pragma mark Absolute Position

    bool isAbsolute() const { return _absolute; }
    
    void setAbsolute(bool flag) {
        _absolute = flag;
        _anchor = Vec2::ANCHOR_BOTTOM_LEFT;
    }
    
    virtual void setAnchor(const Vec2& anchor) override {
        if (!_absolute) { Node::setAnchor(anchor); }
    }

    
#pragma mark -
#pragma mark Rendering

    virtual void draw(const std::shared_ptr<SpriteBatch>& batch,
                      const Mat4& transform, Color4 tint) override = 0;
    
    void refresh() { clearRenderData(); generateRenderData(); }
    
#pragma mark -
#pragma mark Internal Helpers
protected:
    virtual void generateRenderData();
    
    void clearRenderData();

    void updateTextureCoords();

    CU_DISALLOW_COPY_AND_ASSIGN(TexturedNode);

};

}

#endif /* __CU_TEXTURED_NODE_H__ */