CUPolygonNode.h

//
//  CUPolygonNode.h
//  Cornell University Game Library (CUGL)
//
//  This module provides a scene graph node that supports basic sprite graphics.
//  The sprites do not have to be rectangular.  They may be any shape represented
//  by Poly2.
//
//  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 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_POLYGON_NODE_H__
#define __CU_POLYGON_NODE_H__

#include <string>
#include "CUTexturedNode.h"
#include "../math/polygon/CUSimpleTriangulator.h"

namespace cugl {
    
class PolygonNode : public TexturedNode {
#pragma mark Values
protected:
    static SimpleTriangulator _triangulator;

public:
#pragma mark -
#pragma mark Constructor

    PolygonNode() : TexturedNode() {
        _classname = "PolygonNode";
        _name = "PolygonNode";
    }

    virtual ~PolygonNode() { }

#pragma mark -
#pragma mark Static Constructors

    static std::shared_ptr<PolygonNode> alloc() {
        std::shared_ptr<PolygonNode> node = std::make_shared<PolygonNode>();
        return (node->init() ? node : nullptr);
    }
    
    static std::shared_ptr<PolygonNode> alloc(const std::vector<Vec2>& vertices) {
        std::shared_ptr<PolygonNode> node = std::make_shared<PolygonNode>();
        return (node->init(vertices) ? node : nullptr);
    }
    
    static std::shared_ptr<PolygonNode> alloc(const Poly2& poly) {
        std::shared_ptr<PolygonNode> node = std::make_shared<PolygonNode>();
        return (node->init(poly) ? node : nullptr);
    }
    
    static std::shared_ptr<PolygonNode> alloc(const Rect& rect) {
        std::shared_ptr<PolygonNode> node = std::make_shared<PolygonNode>();
        return (node->init(rect) ? node : nullptr);
    }
    
    static std::shared_ptr<PolygonNode> allocWithFile(const std::string& filename) {
        std::shared_ptr<PolygonNode> node = std::make_shared<PolygonNode>();
        return (node->initWithFile(filename) ? node : nullptr);
    }
    
    static std::shared_ptr<PolygonNode> allocWithFile(const std::string& filename,
                                                      const std::vector<Vec2>& vertices) {
        std::shared_ptr<PolygonNode> node = std::make_shared<PolygonNode>();
        return (node->initWithFile(filename,vertices) ? node : nullptr);
    }
    
    static std::shared_ptr<PolygonNode> allocWithFile(const std::string& filename, const Poly2& poly) {
        std::shared_ptr<PolygonNode> node = std::make_shared<PolygonNode>();
        return (node->initWithFile(filename,poly) ? node : nullptr);
    }
    
    static std::shared_ptr<PolygonNode> allocWithFile(const std::string& filename, const Rect& rect) {
        std::shared_ptr<PolygonNode> node = std::make_shared<PolygonNode>();
        return (node->initWithFile(filename,rect) ? node : nullptr);
    }
    
    static std::shared_ptr<PolygonNode> allocWithTexture(const std::shared_ptr<Texture>& texture) {
        std::shared_ptr<PolygonNode> node = std::make_shared<PolygonNode>();
        return (node->initWithTexture(texture) ? node : nullptr);
    }
    
    static std::shared_ptr<PolygonNode> allocWithTexture(const std::shared_ptr<Texture>& texture,
                                                         const std::vector<Vec2>& vertices) {
        std::shared_ptr<PolygonNode> node = std::make_shared<PolygonNode>();
        return (node->initWithTexture(texture,vertices) ? node : nullptr);
    }
    static std::shared_ptr<PolygonNode> allocWithTexture(const std::shared_ptr<Texture>& texture,
                                                         const Poly2& poly) {
        std::shared_ptr<PolygonNode> node = std::make_shared<PolygonNode>();
        return (node->initWithTexture(texture,poly) ? node : nullptr);
    }
    
    static std::shared_ptr<PolygonNode> allocWithTexture(const std::shared_ptr<Texture>& texture,
                                                         const Rect& rect)  {
        std::shared_ptr<PolygonNode> node = std::make_shared<PolygonNode>();
        return (node->initWithTexture(texture,rect) ? node : nullptr);
    }

#pragma mark -
#pragma mark Attributes

    virtual void setPolygon(const std::vector<Vec2>& vertices) override;
    
    virtual void setPolygon(const Poly2& poly) override;
    
    virtual void setPolygon(const Rect& rect) override;
    
#pragma mark -
#pragma mark Rendering

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

    
#pragma mark -
#pragma mark Internal Helpers
private:
    CU_DISALLOW_COPY_AND_ASSIGN(PolygonNode);

};
    
}

#endif /* __CU_POLYGON_NODE_H__ */