CUPoly2.h

//
//  CUPoly2.h
//  Cornell Extensions to Cocos2D
//
//  This module provides a class that represents a simple polygon.  The purpose of
//  this class is to separate the geometry (and math) of a polygon from the rendering
//  data of a pipeline.  This concept is way too tightly coupled throughout all of
//  Cocos2d, and it makes very simple things extremely complicated. Instead, rendering
//  is pushed to the scene graph nodes (the subclasses of TexturedNode), where it
//  belongs.
//
//  The class supports automatic triangulation when desired.  Triangulation must
//  be called explicitly, because not all applications (e.g. wireframes) want
//  triangulation. This module uses ear-clipping for triangulation, which is faster
//  than poly2tri for our simple applications.
//
//  Math data types are much lighter-weight than other objects, and are intended to
//  be copied.  That is why we do not use reference counting for these objects.
//
//  Author: Walker White
//  Version: 11/15/15
//
#ifndef __CU_POLY2_H__
#define __CU_POLY2_H__

#include <vector>
#include <math/CCGeometry.h>

using namespace std;

NS_CC_BEGIN

#pragma mark -
#pragma mark Poly2

class CC_DLL Poly2 {
public:
#pragma mark Renderer Enums

    enum class Traversal {
        OPEN,
        CLOSED,
        INTERIOR
    };
    enum class Joint {
        NONE,
        MITRE,
        BEVEL,
        ROUND
    };
    enum class Cap {
        NONE,
        SQUARE,
        ROUND
    };
    
private:
    vector<Vec2> _vertices;
    vector<unsigned short> _indices;
    // CACHED DATA
    Rect _bounds;
    

    void computeBounds();
    
    
public:
#pragma mark Constructors

    Poly2() { }

    Poly2(const vector<Vec2>& vertices) { set(vertices); }

    Poly2(const vector<Vec2>& vertices, const vector<unsigned short>& indices) {
        set(vertices, indices);
    }

    Poly2(const vector<float>& vertices)    { set(vertices); }
    
    Poly2(const vector<float>& vertices, const vector<unsigned short>& indices) {
        set(vertices, indices);
    }

    Poly2(Vec2* vertices,  int vertsize, int voffset=0) {
        set(vertices, vertsize, voffset);
    }

    Poly2(float* vertices,  int vertsize, int voffset=0) {
        set(vertices, vertsize, voffset);
    }

    Poly2(Vec2* vertices,  int vertsize, unsigned short* indices, int indxsize,
          int voffset=0, int ioffset=0) {
        set(vertices, vertsize, indices, indxsize, voffset, ioffset);
    }

    Poly2(float* vertices,  int vertsize, unsigned short* indices, int indxsize,
          int voffset=0, int ioffset=0) {
        set(vertices, vertsize, indices, indxsize, voffset, ioffset);
    }

    Poly2(const Poly2& poly) { set(poly); }
    
    Poly2(const Rect& rect, bool index=true) { set(rect,index); }

    ~Poly2() { }

     
#pragma mark Initializers

    Poly2& set(const vector<Vec2>& vertices);

    Poly2& set(const vector<Vec2>& vertices, const vector<unsigned short>& indices);
    
    Poly2& set(const vector<float>& vertices);
    
    Poly2& set(const vector<float>& vertices, const vector<unsigned short>& indices);
    
    Poly2& set(Vec2* vertices, int vertsize, int voffset=0);

    Poly2& set(float* vertices,  int vertsize, int voffset=0) {
        return set((Vec2*)vertices, vertsize/2, voffset/2);
    }
    
    Poly2& set(Vec2* vertices, int vertsize, unsigned short* indices, int indxsize,
               int voffset=0, int ioffset=0);
    
    Poly2& set(float* vertices, int vertsize, unsigned short* indices, int indxsize,
               int voffset=0, int ioffset=0) {
        return set((Vec2*)vertices, vertsize/2, indices, indxsize, voffset/2, ioffset);
    }

    Poly2& set(const Poly2& poly);
    
    Poly2& set(const Rect& rect, bool index=true);

    Poly2& setLine(const Vec2& origin, const Vec2& dest);

    Poly2& setEllipse(const Vec2& center, const Size& size, unsigned int segments);

    
#pragma mark Index Generation

    Poly2& setIndices(const vector<unsigned short>& indices);

    Poly2& setIndices(unsigned short* indices, int indxsize, int ioffset=0);
    
    Poly2& triangulate();
    
    Poly2& traverse(Traversal traversal=Traversal::CLOSED);
    
    Poly2* extrude(Poly2& poly, float stroke, bool closed=true, Joint joint=Joint::NONE, Cap cap=Cap::NONE);


#pragma mark Accessors

    const vector<Vec2>& getVertices() const { return _vertices; }
    
    const vector<unsigned short>& getIndices() const  { return _indices; }
    
    const Rect& getBounds() const { return _bounds; }
    

#pragma mark Operators

    Poly2& operator= (const Poly2& other) { return set(other); }
    
    Poly2& operator*=(float scale);
    
    Poly2& operator*=(const Vec2& scale);
    
    Poly2& operator*=(const Mat4& transform);
    
    Poly2& operator/=(float scale);
    
    Poly2& operator/=(const Vec2& scale);
    
    Poly2& operator+=(float offset);
    
    Poly2& operator+=(const Vec2& offset);
    
    Poly2& operator-=(float offset);
    
    Poly2& operator-=(const Vec2& offset);
    
    Poly2 operator*(float scale) const { return Poly2(*this) *= scale; }
    
    Poly2 operator*(const Vec2& scale) const { return Poly2(*this) *= scale; }
    
    Poly2 operator*(const Mat4& transform) const { return Poly2(*this) *= transform; }
    
    Poly2 operator/(float scale) const { return Poly2(*this) /= scale; }
    
    Poly2 operator/(const Vec2& scale) const { return Poly2(*this) /= scale; }
    
    Poly2 operator+(float offset) const { return Poly2(*this) += offset; }
    
    Poly2 operator+(const Vec2& offset) const { return Poly2(*this) += offset; }
    
    Poly2 operator-(float offset) { return Poly2(*this) -= offset; }
    
    Poly2 operator-(const Vec2& offset) { return Poly2(*this) -= offset; }
    
    friend Poly2 operator*(float scale, const Poly2& poly) { return poly*scale; }
    
    friend Poly2 operator*(const Vec2& scale, const Poly2& poly) { return poly*scale; }
    
    friend Poly2 operator+(float offset, const Poly2& poly) { return poly+offset; }
    
    friend Poly2 operator+(const Vec2& offset, const Poly2& poly) { return poly+offset; }
    
};

NS_CC_END
#endif /* defined(__CU_POLY2_H__) */