jmVectorShapes.h

#ifndef JUGIMAP_VECTOR_SHAPES_H
#define JUGIMAP_VECTOR_SHAPES_H
 
#include <vector>
 
#include "jmCommonFunctions.h"
#include "jmGlobal.h"
 
 
 
namespace jugimap{
 
 
class JugiMapBinaryLoader;
 
 
 
 
struct TShapePoint : public Vec2f
{
    float distance = 0.0;
    float angle = 0.0;
    bool smoothCorner = false;
 
    TShapePoint():Vec2f(){}
    TShapePoint(Vec2f _p): Vec2f(_p){}
    TShapePoint(Vec2f _p, float _distance) : Vec2f(_p), distance(_distance) {}
    TShapePoint(Vec2f _p, float _distance, bool _smoothCorner) : Vec2f(_p), distance(_distance), smoothCorner(_smoothCorner){}
};
 
 
 
struct GeometricShape
{
 
    friend class JugiMapBinaryLoader;
 
 
    virtual ~GeometricShape(){}
 
    static GeometricShape *Copy(GeometricShape *_geomShape);
 
 
    static void Assign(GeometricShape *sSrc, GeometricShape *sDst);
 
 
    ShapeKind GetKind(){ return kind; }
 
 
    virtual bool IsValid()  = 0;
 
 
    bool IsClosed(){ return closed; }
 
 
    void _SetClosed(bool _closed) { closed = _closed; }
 
 
    std::vector<TShapePoint>& GetPath(){ return path; }
 
 
    virtual void RebuildPath() = 0;
 
 
    float GetPathLength(){ return pathLength; }
 
 
    virtual Vec2f GetPathPoint(float p);
 
 
    virtual Vec2f GetPathPoint(float p, float &directionAngle);
 
 
 
 
protected:
    ShapeKind kind = ShapeKind::NOT_DEFINED;
 
    std::vector<TShapePoint>path;
    float pathLength = 0.0f;
    bool closed = false;
 
};
 
 
 
struct PolyLineShape : public GeometricShape
{
 
    std::vector<Vec2f>vertices;     // closed curves have added extra point at the end as duplicate of the first point
    bool convex = true;
    bool rectangle = false;
    Vec2f boundingBoxMin;
    Vec2f boundingBoxMax;
 
 
    PolyLineShape(){ kind = ShapeKind::POLYLINE; }
    bool IsValid() override { return  !vertices.empty(); }
    void RebuildPath() override;
 
    void UpdateBoundingBox();
};
 
 
struct BezierVertex
{
    Vec2f P;
    Vec2f CPprevious;       // used for bezier curves
    Vec2f CPnext;
 
    BezierVertex(Vec2f _P, Vec2f _BPprevious, Vec2f _BPnext) : P(_P),CPprevious(_BPprevious),CPnext(_BPnext){}
};
 
 
struct BezierShape : public GeometricShape
{
    std::vector<BezierVertex>vertices;
    float toPolyThreshold = 1.0f;
 
    BezierShape(){ kind = ShapeKind::BEZIER_POLYCURVE; }
    bool IsValid() override { return  !vertices.empty(); }
    void RebuildPath() override;
 
private:
 
    void _GetShapePointsFromBezierSegment(std::vector<TShapePoint> &path, Vec2f BP1, Vec2f BP2, Vec2f BP3, Vec2f BP4, int i);
 
};
 
 
struct EllipseShape : public GeometricShape
{
    Vec2f center;
    float a = 0;
    float b = 0;
 
 
    EllipseShape(){ kind = ShapeKind::ELLIPSE;  closed = true; }
    bool IsValid() override {return  a>0 && b>0;}
    void RebuildPath() override;
};
 
 
struct SinglePointShape : public GeometricShape
{
    Vec2f point;
 
    SinglePointShape(){ kind = ShapeKind::SINGLE_POINT; }
    bool IsValid() override { return true;}
    void RebuildPath() override;
 
 
    Vec2f GetPathPoint(float p) override { return point;}
    Vec2f GetPathPoint(float p, float &directionAngle) override { return point;}
 
};
 
 
 class VectorShape
{
public:
    friend class JugiMapBinaryLoader;
 
 
    VectorShape(){}
 
 
    VectorShape(bool _extra, int _dataFlags, const std::vector<jugimap::Parameter> &_parameters) : extra(_extra), dataFlags(_dataFlags), parameters(_parameters){}
 
 
    VectorShape(GeometricShape *_geomShape) : shape(_geomShape){}
 
 
    VectorShape(const VectorShape &vs);
 
 
    ~VectorShape(){if(shape) delete shape;}
 
 
    std::string GetName(){ return name; }
 
 
    GeometricShape * GetGeometricShape() {return shape;}
 
 
    void SetGeometricShape(GeometricShape *_geomShape){ shape = _geomShape;}
 
 
    ShapeKind GetKind() {return shape->GetKind();}
 
    /*
    bool IsProbe() {return extra;}
    */
 
    int GetDataFlags() {return dataFlags;}
 
 
    std::vector<jugimap::Parameter>& GetParameters() {return parameters;}
 
 
    void RebuildPath(){ shape->RebuildPath(); }
 
 
    float GetPathLength() { return shape->GetPathLength();}
 
 
    Vec2f GetPathPoint(float r) { return shape->GetPathPoint(r); }
 
 
    Vec2f GetPathPoint(float r, float &directionAngle) { return shape->GetPathPoint(r,directionAngle); }
 
 
    std::vector<TShapePoint>& GetPath(){ return shape->GetPath(); }
 
 
    bool IsValid() {return shape->IsValid();}
 
 
    bool IsClosed() {return shape->IsClosed();}
 
 
private:
    std::string name;
    int id = 0;
    GeometricShape * shape = nullptr;                   // OWNED
    bool extra = false;                                 // custom identifier
    int dataFlags = 0;                                  // custom data
    std::vector<jugimap::Parameter> parameters;            // custom parameters
    float pathLength = 0.0;
};
 
 
 
 
 
}
#endif // VECTORSHAPE_H