CUWireNode.h

//
//  CUWireNode.h
//  Cornell University Game Library (CUGL)
//
//  This module provides a scene graph node that supports wireframes.  The
//  primary use case is to have a node that outlines physics bodies.
//
//  This class is loosely coupled with PathOutliner.  You can use PathOutliner
//  independent of the WireNode, 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 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_WIRE_NODE_H__
#define __CU_WIRE_NODE_H__

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

#define WIRE_SEGMENTS 8

namespace cugl {
    
class WireNode : public TexturedNode {
#pragma mark Values
protected:
    static PathOutliner _outliner;
    
    PathTraversal _traversal;

public:
#pragma mark -
#pragma mark Constructors

    WireNode() : TexturedNode(), _traversal(PathTraversal::CLOSED) {
        _classname = "WireNode";
        _name = "WireNode";
    }
    
    ~WireNode() { dispose(); }
    
    bool initWithVertices(const std::vector<Vec2>& vertices, PathTraversal traversal);
    
    bool initWithLine(const Vec2 &origin, const Vec2 &dest);
    
    bool initWithEllipse(const Vec2& center, const Size& size, unsigned int segments = WIRE_SEGMENTS);
    
    bool initWithData(const SceneLoader* loader, const std::shared_ptr<JsonValue> data) override;

    
#pragma mark -
#pragma mark Static Constructors

    static std::shared_ptr<WireNode> alloc() {
        std::shared_ptr<WireNode> node = std::make_shared<WireNode>();
        return (node->init() ? node : nullptr);
    }
    
    static std::shared_ptr<WireNode> allocWithVertices(const std::vector<Vec2>& vertices) {
        std::shared_ptr<WireNode> node = std::make_shared<WireNode>();
        return (node->init(vertices) ? node : nullptr);
    }
    
    static std::shared_ptr<WireNode> allocWithVertices(const std::vector<Vec2>& vertices,
                                                       PathTraversal traversal) {
        std::shared_ptr<WireNode> node = std::make_shared<WireNode>();
        return (node->initWithVertices(vertices,traversal) ? node : nullptr);
    }
    
    static std::shared_ptr<WireNode> allocWithPoly(const Poly2& poly) {
        std::shared_ptr<WireNode> node = std::make_shared<WireNode>();
        return (node->init(poly) ? node : nullptr);
    }
    
    static std::shared_ptr<WireNode> allocWithRect(const Rect& rect) {
        std::shared_ptr<WireNode> node = std::make_shared<WireNode>();
        return (node->init(rect) ? node : nullptr);
    }
    
    static std::shared_ptr<WireNode> allocWithLine(const Vec2 &origin, const Vec2 &dest) {
        std::shared_ptr<WireNode> node = std::make_shared<WireNode>();
        return (node->initWithLine(origin,dest) ? node : nullptr);
    }
    
    static std::shared_ptr<WireNode> allocWithEllipse(const Vec2& center, const Size& size,
                                                      unsigned int segments = WIRE_SEGMENTS) {
        std::shared_ptr<WireNode> node = std::make_shared<WireNode>();
        return (node->initWithEllipse(center,size,segments) ? node : nullptr);
    }
    
    static std::shared_ptr<Node> allocWithData(const SceneLoader* loader,
                                               const std::shared_ptr<JsonValue> data) {
        std::shared_ptr<WireNode> result = std::make_shared<WireNode>();
        if (!result->initWithData(loader,data)) { result = nullptr; }
        return std::dynamic_pointer_cast<Node>(result);
    }
    
#pragma mark -
#pragma mark Attributes

    void setTraversal(PathTraversal traversal);

    PathTraversal getTraversal() const { return _traversal; }

    virtual void setPolygon(const std::vector<Vec2>& vertices) override;

    void setPolygon(const std::vector<Vec2>& vertices, PathTraversal traversal);

    virtual void setPolygon(const Poly2& poly) override;
    
    virtual void setPolygon(const Rect& rect) override;

    void setLine(const Vec2 &origin, const Vec2 &dest);
    
    void setEllipse(const Vec2& center, const Size& size, unsigned int segments = WIRE_SEGMENTS);

#pragma mark -
#pragma mark Rendering

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

private:
    CU_DISALLOW_COPY_AND_ASSIGN(WireNode);
};
    
}


#endif /* __CU_WIRE_NODE_H__ */