CUPoly2.h

//
//  CUPoly2.h
//  Cornell University Game Library (CUGL)
//
//  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.  The class provides the index data necessary
//  for rendering. In addition, it has some primitive geometry methods such as
//  containment.
//
//  In OpenGL style, the object is defined by a set of vertices, and a set of
//  indices that define a mesh over the vertices.  This class is intentionally
//  (based on experience in previous semesters) lightweight.  There is no
//  verification that indices are properly defined.  It is up to the user to
//  verify and specify the components.  If you need help with triangulation
//  or path extrusion, use one the the related factory classes.
//
//  Because math objects are intended to be on the stack, we do not provide
//  any shared pointer support in this class.
//
//  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/20/16

#ifndef __CU_POLY2_H__
#define __CU_POLY2_H__

#include <vector>
#include "CUVec2.h"
#include "CURect.h"

namespace cugl {

// Forward references
class Mat4;
class Affine2;
    
class Poly2 {
#pragma mark Values
public:
    enum class Type {
        UNDEFINED,
        SOLID,
        PATH
    };
    
private:
    std::vector<Vec2> _vertices;
    std::vector<unsigned short> _indices;
    Rect _bounds;
    Type _type;
    
#pragma mark -
#pragma mark Constructors
public:
    Poly2() : _type(Type::UNDEFINED) { }
    
    Poly2(const std::vector<Vec2>& vertices) { set(vertices); }
    
    Poly2(const std::vector<Vec2>& vertices, const std::vector<unsigned short>& indices) {
        set(vertices, indices);
    }
    
    Poly2(const std::vector<float>& vertices)    { set(vertices); }
    
    Poly2(const std::vector<float>& vertices, const std::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(Poly2&& poly) :
        _vertices(std::move(poly._vertices)), _indices(std::move(poly._indices)),
        _bounds(std::move(poly._bounds)), _type(poly._type) {}
    
    Poly2(const Rect& rect, bool solid=true) { set(rect,solid); }
    
    ~Poly2() { }
    

#pragma mark -
#pragma mark Static Constructors

    static Poly2 createLine(const Vec2& origin, const Vec2& dest);
    
    static Poly2* createLine(const Vec2& origin, const Vec2& dest, Poly2* dst);
    
    static Poly2 createTriangle(const Vec2& a, const Vec2& b, const Vec2& c, bool solid=true);

    static Poly2* createTriangle(const Vec2& a, const Vec2& b, const Vec2& c, Poly2* dst, bool solid=true);

    static Poly2 createEllipse(const Vec2& center, const Size& size, unsigned int segments, bool solid=true);
    
    static Poly2* createEllipse(const Vec2& center, const Size& size, unsigned int segments, Poly2* dst,
                                bool solid=true);
    
#pragma mark -
#pragma mark Setters

    Poly2& operator= (const Poly2& other) { return set(other); }

    Poly2& operator=(Poly2&& other) {
        _vertices = std::move(other._vertices);
        _indices = std::move(other._indices);
        _bounds = std::move(other._bounds);
        _type = other._type;
        return *this;
    }

    
    Poly2& operator= (const Rect& rect) { return set(rect); }

    Poly2& set(const std::vector<Vec2>& vertices);
    
    Poly2& set(const std::vector<Vec2>& vertices, const std::vector<unsigned short>& indices);
    
    Poly2& set(const std::vector<float>& vertices);
    
    Poly2& set(const std::vector<float>& vertices, const std::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 solid=true);
    
    Poly2& clear() {
        _vertices.clear();
        _indices.clear();
        _type = Type::UNDEFINED;
        _bounds = Rect::ZERO;
        return *this;
    }

#pragma mark -
#pragma mark Index Methods

    Poly2& setIndices(const std::vector<unsigned short>& indices);
    
    Poly2& setIndices(unsigned short* indices, int indxsize, int ioffset=0);
    
    bool isStandardized();
    
    bool isValid();
    

#pragma mark -
#pragma mark Polygon Attributes

    size_t size() const { return _vertices.size(); }

    size_t indexSize() const { return _indices.size(); }

    Vec2& at(int index) { return _vertices.at(index); }

    const std::vector<Vec2>& getVertices() const { return _vertices; }

    const std::vector<unsigned short>& getIndices() const  { return _indices; }

    std::vector<unsigned short>& getIndices()  { return _indices; }

    const Rect& getBounds() const { return _bounds; }
    
    Type getType() const { return _type; }
    
    void setType(Type type) { _type = type; }
    
    
#pragma mark -
#pragma mark Operators

    Poly2& operator*=(float scale);
    
    Poly2& operator*=(const Vec2& scale);

    Poly2& operator*=(const Affine2& transform);
    
    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 Affine2& transform) const { return Poly2(*this) *= transform; }

    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; }
    
#pragma mark -
#pragma mark Geometry Methods

    std::vector<Vec2> convexHull() const;
    
    bool contains(const Vec2& point) const;
    
    bool incident(const Vec2& point, float variance=CU_MATH_EPSILON) const;

    
#pragma mark -
#pragma mark Internal Helper Methods
private:
    void computeBounds();

    void computeType();

    Vec3 getBarycentric(const Vec2& point, unsigned short index) const;

    // Make friends with the factory classes
    friend class CubicSplineApproximator;
    friend class SimpleTriangulator;
    friend class DelaunayTriangulator;
    friend class PathOutliner;
    friend class PathExtruder;
};

}
#endif /* __CU_POLY2_H__ */