CUPathExtruder.h

//
//  CUPathExtruder.h
//  Cornell University Game Library (CUGL)
//
//  This module is a factory for extruding a path polgyon into a stroke with
//  width. It has support for joints and end caps.
//
//  The code in this factory is ported from the Kivy implementation of Line in
//  package kivy.vertex_instructions.  We believe that this port is acceptable
//  within the scope of the Kivy license.  There are no specific credits in that
//  file, so there is no one specific to credit.  However, thanks to the Kivy
//  team for doing the heavy lifting on this method.
//
//  Because they did all the hard work, we will recommend their picture of how
//  joints and end caps work:
//
//      http://kivy.org/docs/_images/line-instruction.png
//
//  Since math objects are intended to be on the stack, we do not provide
//  any shared pointer support in this class.
//
//  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/22/16

#ifndef __CU_PATH_EXTRUDER_H__
#define __CU_PATH_EXTRUDER_H__

#include "../CUPoly2.h"
#include "../CUVec2.h"
#include <vector>

namespace cugl {

// Forward reference to the opaque data class.
class KivyData;
    
enum class PathJoint : int {
    NONE = 0,
    MITRE = 1,
    BEVEL = 2,
    ROUND = 3
};
        
enum class PathCap :int {
    NONE = 0,
    SQUARE = 1,
    ROUND = 2
};
    
class PathExtruder {
#pragma mark Values
private:
    std::vector<Vec2> _input;
    bool _closed;
    
    std::vector<Vec2> _outverts;
    std::vector<unsigned short> _outindx;
    bool _calculated;
    
#pragma mark -
#pragma mark Constructors
public:
    PathExtruder() {}
    
    PathExtruder(const std::vector<Vec2>& points, bool closed) : _calculated(false) {
        _input = points; _closed = closed;
    }
    
    PathExtruder(const Poly2& poly) :  _calculated(false) { _input = poly._vertices; }
    
    ~PathExtruder() {}
    
#pragma mark -
#pragma mark Initialization

    void set(const Poly2& poly);
    
    void set(const std::vector<Vec2>& points, bool closed) {
        reset();
        _input = points;
        _closed = closed;
    }
    
    void reset() {
        _calculated = false;
        _outverts.clear(); _outindx.clear();
    }
    
    void clear() {
        _calculated = false;
        _input.clear(); _outverts.clear(); _outindx.clear();
    }
    
#pragma mark -
#pragma mark Calculation

    void calculate(float stroke, PathJoint joint=PathJoint::ROUND, PathCap cap = PathCap::ROUND);
    
#pragma mark -
#pragma mark Materialization

    Poly2 getPolygon();
    
    Poly2* getPolygon(Poly2* buffer);
    
#pragma mark -
#pragma mark Internal Data Generation
private:
    unsigned int computeSize(PathJoint joint, PathCap cap, unsigned int* vcount, unsigned int* icount);
    
    void makeSegment(const Vec2& a, const Vec2& b, KivyData* data);

    bool makeJoint(const Vec2& a, KivyData* data);

    bool makeMitreJoint(const Vec2& a, float jangle, KivyData* data);

    bool makeBevelJoint(const Vec2& a, float jangle, KivyData* data);

    bool makeRoundJoint(const Vec2& a, float jangle, KivyData* data);
    
    void makeCaps(int count, KivyData* data);
    
    void makeSquareCaps(int count, KivyData* data);

    void makeRoundCaps(int count, KivyData* data);
    
    bool makeLastJoint(KivyData* data);
};
}

#endif /* __CU_PATH_EXTRUDER_H__ */