CUPathNode.h

//
//  CUPathNode.h
//  Cornell University Game Library (CUGL)
//
//  This module provides a scene graph node that supports extruded paths. When
//  extruding paths, this node is better than PolygonNode, because it will align
//  the extruded path to the original wireframe.
//
//  This class is loosely coupled with PathExtruder.  You can use PathExtruder
//  independent of the PathNode, but all functionality is present in this class.
//
//  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_PATH_NODE_H__
#define __CU_PATH_NODE_H__

#include <string>
#include <cugl/2d/CUTexturedNode.h>
#include <cugl/math/CUPoly2.h>
#include <cugl/math/polygon/CUPathExtruder.h>
#include <cugl/math/polygon/CUPathOutliner.h>

#define PATH_SEGMENTS 8

namespace cugl {
    
class PathNode : public TexturedNode {
#pragma mark Values
protected:
    static PathExtruder _extruder;
    static PathOutliner _outliner;

    Poly2 _extrusion;
    Rect _extrbounds;
    
    bool _closed;
    float _stroke;
    PathJoint _joint;
    PathCap _endcap;

public:
#pragma mark -
#pragma mark Constructors

    PathNode();
    
    ~PathNode() { dispose(); }

    bool initWithVertices(const std::vector<Vec2>& vertices, float stroke,
                          PathJoint joint = PathJoint::NONE, PathCap cap = PathCap::NONE,
                          bool closed=true);

    bool initWithPoly(const Poly2& poly, float stroke,
                      PathJoint joint = PathJoint::NONE, PathCap cap = PathCap::NONE);

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

    
#pragma mark -
#pragma mark Static Constructors

    static std::shared_ptr<PathNode> alloc() {
        std::shared_ptr<PathNode> node = std::make_shared<PathNode>();
        return (node->init() ? node : nullptr);
    }
    
    static std::shared_ptr<PathNode> allocWithVertices(const std::vector<Vec2>& vertices, float stroke,
                                                       PathJoint joint = PathJoint::NONE,
                                                       PathCap cap = PathCap::NONE, bool closed = true) {
        std::shared_ptr<PathNode> node = std::make_shared<PathNode>();
        return (node->initWithVertices(vertices,stroke,joint,cap,closed) ? node : nullptr);
    }
    
    static std::shared_ptr<PathNode> allocWithPoly(const Poly2& poly, float stroke,
                                                   PathJoint joint = PathJoint::NONE,
                                                   PathCap cap = PathCap::NONE) {
        std::shared_ptr<PathNode> node = std::make_shared<PathNode>();
        return (node->initWithPoly(poly,stroke,joint,cap) ? node : nullptr);
    }
    
    static std::shared_ptr<PathNode> allocWithRect(const Rect& rect, float stroke,
                                                   PathJoint joint = PathJoint::NONE,
                                                   PathCap cap = PathCap::NONE) {
        std::shared_ptr<PathNode> node = std::make_shared<PathNode>();
        return (node->initWithPoly(Poly2(rect,false),stroke,joint,cap) ? node : nullptr);
    }
    
    static std::shared_ptr<PathNode> allocWithLine(const Vec2 &origin, const Vec2 &dest, float stroke,
                                                   PathJoint joint = PathJoint::NONE,
                                                   PathCap cap = PathCap::NONE) {
        std::shared_ptr<PathNode> node = std::make_shared<PathNode>();
        return (node->initWithPoly(Poly2::createLine(origin, dest),stroke,joint,cap) ? node : nullptr);
    }
    
    static std::shared_ptr<PathNode> allocWithEllipse( const Vec2& center, const Size& size, float stroke,
                                                      unsigned int segments = PATH_SEGMENTS,
                                                      PathJoint joint = PathJoint::NONE,
                                                      PathCap cap = PathCap::NONE) {
        std::shared_ptr<PathNode> node = std::make_shared<PathNode>();
        return (node->initWithPoly(Poly2::createEllipse(center,size,segments,false),stroke,joint,cap) ?
                node : nullptr);
    }

    static std::shared_ptr<Node> allocWithData(const SceneLoader* loader,
                                               const std::shared_ptr<JsonValue>& data) {
        std::shared_ptr<PathNode> result = std::make_shared<PathNode>();
        if (!result->initWithData(loader,data)) { result = nullptr; }
        return std::dynamic_pointer_cast<Node>(result);
    }
    
    
#pragma mark -
#pragma mark Attributes

    void setStroke(float stroke);
    
    float getStroke() const { return _stroke; }
    
    void setClosed(bool closed);
    
    bool getClosed() const { return _closed; }
    
    void setJoint(PathJoint joint);
    
    PathJoint getJoint() const { return _joint; }
    
    void setCap(PathCap cap);
    
    PathCap getCap() const { return _endcap; }
    
#pragma mark -
#pragma mark Polygons

    virtual void setPolygon(const std::vector<Vec2>& vertices) override;
    
    virtual void setPolygon(const Poly2& poly) override;
    
    virtual void setPolygon(const Rect& rect) override;
    
    float getExtrudedContentWidth() const { return _extrbounds.size.width; }
    
    float getExtrudedContentHeight() const { return _extrbounds.size.height; }
    
    const Size& getExtrudedContentSize() const { return _extrbounds.size; }
    
    const Rect& getExtrudedContentBounds() const { return _extrbounds; }

    
#pragma mark Rendering

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

    
#pragma mark Internal Helpers
private:
    virtual void generateRenderData() override;
    
    void updateExtrusion();

    CU_DISALLOW_COPY_AND_ASSIGN(PathNode);
};

}

#endif /* __CU_PATH_NODE_H__ */