CUPathOutliner.h

//
//  CUPathOutliner.h
//  Cornell University Game Library (CUGL)
//
//  This module is a factory for outlining the boundary of a polygon.  While
//  this code is very straight-forward, previous semesters have shown that it
//  is best to factor this functionality out of Poly2.
//
//  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/22/16
 
#ifndef __CU_PATH_OUTLINER_H__
#define __CU_PATH_OUTLINER_H__
 
#include <cugl/math/CUPoly2.h>
#include <cugl/math/CUVec2.h>
#include <cugl/math/polygon/CUSimpleTriangulator.h>
#include <cugl/math/polygon/CUDelaunayTriangulator.h>
#include <vector>
 
namespace cugl {
    
enum class PathTraversal : int {
    NONE = 0,
    OPEN = 1,
    CLOSED = 2,
    INTERIOR = 3
};
    
class PathOutliner {
#pragma mark Values
private:
    std::vector<Vec2> _input;
    std::vector<unsigned short> _output;
    bool _calculated;
    
    DelaunayTriangulator _triangulator;
    
#pragma mark -
#pragma mark Constructors
public:
    PathOutliner() {}
    
    PathOutliner(const std::vector<Vec2>& points) : _calculated(false) { _input = points; }
    
    PathOutliner(const Poly2& poly) :  _calculated(false) { _input = poly._vertices; }
    
    ~PathOutliner() {}
    
#pragma mark -
#pragma mark Initialization
 
    void set(const Poly2& poly) {
        reset();
        _input = poly._vertices;
    }
    
    void set(const std::vector<Vec2>& points) {
        reset();
        _input = points;
    }
    void reset() {
        _calculated = false;
        _output.clear();
    }
    
    void clear() {
        _calculated = false;
        _input.clear(); _output.clear();
    }
    
#pragma mark -
#pragma mark Calculation
 
    void calculate(PathTraversal traversal);
    
#pragma mark -
#pragma mark Materialization
 
    std::vector<unsigned short> getPath() const;
    
    size_t getPath(std::vector<unsigned short>& buffer) const;
    
    Poly2 getPolygon() const;
    
    Poly2* getPolygon(Poly2* buffer) const;
};
}
 
#endif /* __CU_PATH_OUTLINER_H__ */