CorePrimAPI.h

#pragma once
 
#include "CoreAPI.h"
 
#define to_scast_obj(T,obj) static_cast<T*>(obj)
 
#pragma pack(push, 1)
 
namespace coat {
    using namespace comms;
    typedef One2DCurve curve2d;
    class APICALL prim {
    public:
        prim();
        str class_name();
        prim& name(const char* s);
        str name() const;
        void add(Volume& v);
        void subtract(Volume& v);
        void intersect(Volume& v);
        void merge(Volume& v, const BoolOpType op);
        Mesh mesh();
        prim& color(DWORD CL);
 
        prim& color(float r, float g, float b, float a);
 
        prim& color(float r, float g, float b);
 
        prim& color(const char* colorid);
 
        prim& gloss(float value);
 
        prim& roughness(float value);
 
        prim& metal(float value);
 
        prim& opacity(float value);
        prim& details(const float det_level);
        float details();
        prim& transform(const mat4& t);
        mat4 transform() const;
        prim& scale(float scale);
        prim& scale(const vec3& v);
        vec3 scale()  const;
        prim& translate(const vec3& _pos);
        vec3 translate() const;
        prim& translate(float x, float y, float z);
        prim& x(float x);
        prim& y(float y);
        prim& z(float z);
        prim& auto_divide(float average_div);
        prim& step_divide(float step);
        prim& fillet(float radius);
        static void debug_on(bool isOn=true);
        static void debug_clear();
        static void push_transform(const mat4& t);
        static void push_translate(const vec3& d);
        static void push_scale(float scale);
        static void push_scale(const vec3& s);
        static void push_details(float details_modulator);
        static void reset_transform();
        template <typename T>
        T& Obj() {  return to_cast_this<T>(); }
        template <typename T>
        bool isAs() { return dynamic_cast<const T*>(this) != NULL; }
        virtual float fillet_relative();
    protected:
        template<class T>
        T& to_cast_this()  { return *static_cast<T*>(this); }
        virtual cMeshContainer* create_mesh() { return nullptr; }
        void merge_debug(Volume& vol, Mesh& mesh);
        prim* _this;
private:
    
        int _nx;
        int _ny;
        int _nz;
 
        float _average_div;
        float _step_div;
 
        mat4 _transform;
        float _details;
        str _name;
 
        static mat4 _ovTransform;
        static float _ovDetails;
        static bool _prmDebug;
        static SceneElement _seDebug;
 
        DWORD _Color;
 
        float _fillet;
        virtual void average_devide() { ; }
        float filletRadiusRelative(float rmax);
 
        friend class box;
        friend class sphere;
        friend class ellipse;
        friend class cylinder;
        friend class cone;
        friend class tube;
        friend class gear;
        friend class ngon;
        friend class capsule;
        friend class torus;
        friend class spiral;
 
        template <typename T> T& _src(T* s) {
            auto* t = dynamic_cast<T*>(_this);
            if (t)return *t;
            return *s;
        }
    };
    class APICALL box : public prim {
    public:
        box();
        box(float sizeX, float sizeY, float sizeZ);
        box(const vec3& size);
        box(const vec3& pos, const vec3& size);
        box(const vec3& pos, const vec3& size, float fillet);
        box& axis(const vec3& directionX);
        box& axis(const vec3& directionX, const vec3& directionY);
        box& axis(const vec3& directionX, const vec3& directionY, const vec3& directionZ);
        box& reset_axis();
        vec3 axis_x();
        vec3 axis_y();
        vec3 axis_z();
        box& divide(int nx, int ny, int nz);
        box& size(const vec3& _size);
        box& size(float x, float y, float z);
        vec3 size() const;
        virtual float fillet_relative();
    protected:
        void init();
        virtual cMeshContainer* create_mesh();
    private:
        vec3 _axisx;
        vec3 _axisy;
        vec3 _axisz;
        vec3 _side;
        virtual void average_devide();
        friend class torus;
    };
    class APICALL torus :public box {
    public:
        torus();
        torus(const float& ringRadius, const float& crossSectionRadius);
        torus(const vec3& pos, const float& ringRadius, const float& crossSectionRadius);
        torus& slices(const int& _slices);
        int slices() const;
        torus& rings(const int& _rings);
        int rings() const;
        torus& radius(const float& r);
        float radius()const;
        torus& section_radius(const float& section_r);
        float section_radius() const;
        torus& diameter(const float& d);
        float diameter()const;
        torus& section_diameter(const float& section_d);
        float section_diameter() const;
        torus& sector_on(const bool& _switch);
        bool sector_on() const;
        torus& slices_angle(const float& angle);
        float slices_angle() const;
        torus& rings_angle(const float& angle);
        float rings_angle() const;
 
    protected:
        virtual cMeshContainer* create_mesh();
    private:
        float _ringRadius;
        float _crossSectionRadius;
        float _slicesAngle;
        float _ringsAngle;
        bool _isSector;
 
        virtual void average_devide();
    };
    class APICALL sphere : public prim {
    public:
        enum  DivisionMode {
            DIV_TRIANGLE = 0,
            DIV_MERIDIAN = 1,
            DIV_CUBE = 2
        };
        sphere();
        sphere(float radius);
        sphere(const vec3& pos, float radius);
        sphere& radius(const float& r);
        float radius() const;
        sphere& diameter(const float& d);
        float diameter() const;
        sphere& sub_division(const int subdiv);
        int sub_division() const;
        sphere& sub_div_mode(const sphere::DivisionMode& divmode);
        sphere::DivisionMode sub_div_mode() const;
        sphere& rings(const int& _rings);
        int rings() const;
        sphere& slices(const int& _slices);
        int slices() const;
        sphere& sector_on(const bool& _switch);
        bool sector_on() const;
        sphere& slice_from(const float& angle);
        float slice_from() const;
        sphere& slice_to(const float& angle);
        float slice_to() const;
        sphere& ring_from(const float& angle);
        float ring_from() const;
        sphere& ring_to(const float& angle);
        float ring_to() const;
    
    protected:
        virtual cMeshContainer* create_mesh();
        virtual void density_subdiv(int& slices, int& rings);
    private:
        float _radius;
        int _subdiv;
        rect _sector;
        bool _bsector;
        DivisionMode _divmode;
        virtual void average_devide();
        friend class ellipse;
    };
    class APICALL ellipse : public sphere {
    public:
        ellipse();
        ellipse(const vec3& pos, float rx, float ry, float rz);
        ellipse(const vec3& pos, const vec3& size);
        ellipse(const vec3& size);
        ellipse& axis(const vec3& directionX, const vec3& directionY = vec3::AxisY, const vec3& directionZ = vec3::AxisZ);
        ellipse& reset_axis();
        ellipse& size(const vec3& _size);
        vec3 size() const;
 
    protected:
        void init();
        virtual cMeshContainer* create_mesh();
        virtual void density_subdiv(int& slices, int& rings);
    private:
        vec3 _axisx;
        vec3 _axisy;
        vec3 _axisz;
        vec3 _side;
        virtual void average_devide();
    };
    class APICALL cylinder : public prim {
    public:
        cylinder();
        cylinder(const float& height, const float& radiusTop, const float& radiusBottom, const float& fillet=0.0);
        cylinder(const vec3& posTop, const vec3& posBottom, const float& radiusTop, const float& radiusBottom, const float& fillet=0.0);
        cylinder& positionTop(const vec3& pos);
        vec3 positionTop() const;
        cylinder& positionBottom(const vec3& pos);
        vec3 positionBottom() const;
        cylinder& radiusTop(const float& r);
        float radiusTop() const;
        cylinder& radiusBottom(const float& r);
        float radiusBottom() const;
        cylinder& radius(const float& r);
        float radius() const;
        cylinder& diameterTop(const float& d);
        float diameterTop() const;
        cylinder& diameterBottom(const float& r);
        float diameterBottom() const;
        cylinder& diameter(const float& d);
        float diameter() const;
        cylinder& height(const float& _height);
        float height() const;
        cylinder& sectorAngle(const float& angle);
        float sectorAngle() const;
        cylinder& topCapScale(const float& scale);
        float topCapScale() const;
        cylinder& bottomCapScale(const float& scale);
        float bottomCapScale() const;
        cylinder& slices(const int& nslices);
        int slices() const;
        cylinder& rings(const int& nrings);
        int rings() const;
        cylinder& caps(const int& ncaps);
        int caps() const;
        virtual float fillet_relative();
    protected:
        virtual cMeshContainer* create_mesh();
        cMeshContainer* getCylinderPrim(bool iscone = false);
        mat4 getLTransform();
    private:
        vec3  _positionTop;
        vec3  _positionBottom;
        float  _radiusTop;
        float  _radiusBottom;
        float _sectorAngle;
        float _topCapScale;
        float _bottomCapScale;
        virtual void average_devide();
        friend class cone;
        friend class capsule;
        friend class ngon;
        friend class tube;
    };
    class APICALL cone : public cylinder {
    public:
        cone();
        cone(const float& height, const float& radiusBottom, const float& fillet = 0.0);
        cone(const vec3& posTop, const vec3& posBottom, const float& radiusBottom, const float& fillet = 0.0);
        cone& radius(const float& r);
        float radius() const;
        cone& diameter(const float& d);
        float diameter() const;
        float fillet_relative() override;
    protected:
        virtual cMeshContainer* create_mesh();
    private:
        virtual void average_devide();
    };
    class APICALL tube : public cylinder {
    public:
        tube();
        tube(const float& height, const float& radiusTop, const float& radiusBottom);
        tube(const float& height, const float& radiusTop, const float& radiusBottom, const float& fillet);
        tube(const float& height, const float& radiusTop, const float& radiusBottom, const float& relativeHoleRadius, const float& fillet);
        tube(const vec3& posTop, const vec3& posBottom, const float& radiusTop, const float& radiusBottom, const float& relativeHoleRadius);
        tube(const vec3& posTop, const vec3& posBottom, const float& radiusTop, const float& radiusBottom, const float& relativeHoleRadius, const float& fillet);
        tube& relativeHoleRadius(const float& r);
        float relativeHoleRadius() const;
        tube& thickness(const float& w);
        float thickness() const;
        float fillet_relative() override;
    protected:
        virtual cMeshContainer* create_mesh();
    private:
        float _relativeHoleRadius;
        float _thickness;
        virtual void average_devide();
    };
    class APICALL gear : public tube {
    public:
        gear();
        gear(const float& height, const float& radiusTop, const float& radiusBottom);
        gear(const float& height, const float& radiusTop, const float& radiusBottom, float depth, float sharpness = 0.5, const int& order = 16);
        gear(const vec3& posTop, const vec3& posBottom, const float& radiusTop, const float& radiusBottom, float depth = 0.1, float sharpness = 0.5, const int& order = 16);
        gear& depth(const float& __depth);
        float depth() const;
        gear& sharpness(const float& sharp);
        float sharpness() const;
        gear& order(const int& nteeth);
        int order() const;
    protected:
        virtual cMeshContainer* create_mesh();
    private:
        float  _depth;
        float  _sharpness;
        int    _order;
        virtual void average_devide();
        friend class ngon;
    };
    class APICALL ngon : public gear {
    public:
        ngon();
        ngon(const float& height, const float& radiusTop, const float& radiusBottom, const int& order);
        ngon(const float& height, const float& radiusTop, const float& radiusBottom, const float& fillet, const int& order);
        ngon(const vec3& posTop, const vec3& posBottom, const float& radiusTop, const float& radiusBottom, const int& order);
        virtual float fillet_relative();
    protected:
        virtual cMeshContainer* create_mesh();
    };
    class APICALL capsule :public cylinder {
    public:
        capsule();
        capsule(const float& height, const float& radiusTop, const float& radiusBottom);
        capsule(const vec3& posTop, const vec3& posBottom, const float& radiusTop, const float& radiusBottom);
    protected:
        virtual cMeshContainer* create_mesh();
    private:
        virtual void average_devide();
    };
 
    enum class SpiralProfile {
        CIRCLE = 0,
        RECTANGLE = 1
    };
 
    class APICALL spiral:public prim {
    public:
        spiral();
        spiral(const float& out_radius, const float& in_radius, const float& _sstep, const float& nturns);
        spiral& radius(const float& r);
        float radius() const;
        spiral& profile_radius(const float& r);
        float profile_radius() const;
        spiral& diameter(const float& d);
        float diameter() const;
        spiral& profile_diameter(const float& d);
        float profile_diameter() const;
        spiral& turns(const int nturns);
        int turns() const;
        spiral& step(const float& vstep);
        float step() const;
        spiral& profile_type(const SpiralProfile type);
        spiral& profile_rect(const float width, const float height);
        spiral& clock_wise(const bool& clockWise);
        bool clock_wise() const;
        float profile_height() const;
        float profile_width() const;
        spiral& slices(const int& nslices);
        int slices() const;
        spiral& rings(const int& nrings);
        int rings() const;
        spiral& caps(const int& ncaps);
        int caps() const;
    protected:
        virtual cMeshContainer* create_mesh();
    private:
        int _turns;
        float _step;
        float _radius;
        float _profile_radius;
        float _profile_width;
        float _profile_height;
        bool _clock_wise;
        SpiralProfile _profile_type;
        virtual void average_devide();
    };
 
    enum FontStyle {
        Regular = 0,
        Italic = 1 << 0,
        Underline = 1 << 1,
        StrikeThrough = 1 << 2
    };
 
    enum FontWeight {
        Dont = 0,
        Thin = 100,
        ExtraLight = 200,
        Light = 300,
        Normal = 400,
        Medium = 500,
        DemiBold = 600,
        Bold = 700,
        ExtraBold = 800,
        Black = 900
    };
 
    class APICALL FontInfo {
    public:
        int         size;
        int         weight;
        int         style;
        std::string fname;
    };
 
    class APICALL Font {
    public:
 
        Font();
        Font(const FontInfo& _finfo);
        Font(const char* _fname);
        Font(const char* _fname, const int& _st);
        Font& size(const int& _size);
        int size() const;
        Font& weight(const int& weight);
        int weight() const;
        Font& style(const int st);
        int style() const;
        Font& name(const char* _fname);
        const char* name() const;
        void select();
    private:
        void init();
        void save(void);
        FontInfo& info() { return _finfo; }
        const FontInfo& info() const { return _finfo; }
        FontInfo _finfo;
    };
 
    class APICALL text :public prim {
    public:
        text();
        text(const char* s);
        text& string(const char* s);
        str string() const;
        text& font(const Font& f);
        Font font() const;
        text& width(const float& w);
        float width() const;
        text& depth(const float& d);
        float depth() const;
        text& bendRadius(const float& radius);
        float bendRadius() const;
        text& extraRotation(const float& rotation);
        float extraRotation() const;
        text& invertBending(const bool& _binvert);
        float invertBending() const;
    protected:
        virtual cMeshContainer* create_mesh();
        void update_mesh(cMeshContainer* mc);
    private:
        str _string;
        Font _font;
        vec2 _size;
        float _rotation;
        float _bendRadius;
        bool _invertBending;
        void init();
    };
    class APICALL lathe :public box {
        bool untouched;
    public:
        enum pointState {
            regular=0,
            bspline=1,
            sharp=2,
            locked=3,
            vertical=4,
            horizontal=5
        };
        enum Type {
            cylinder=0,
            rectangle=1
        };
        lathe();
        ~lathe();
        lathe& type(const lathe::Type& t);
        lathe::Type type() const;
        lathe& add_point(const vec2& point, int st);
        curve2d* profile() const;
        lathe& reset();
        lathe& clear();
    protected:
        virtual cMeshContainer* create_mesh();
    private:
        Type _type;
        curve2d* _profile;
        void init();
    };
 
    class APICALL image :public text {
    public:
        struct ParamInfo {
            str topTexture;
            str topBumpTexture;
            str bottomTexture;
            str bottomBumpTexture;
            str strencilTexture;
            str bottomStrencilTexture;
            float basicThickness;
            float bumpThickness;
            float taperAngle;
            float topBottomWeight;
            float sizeInScene;
        };
        image();
        image& topTexture(const char* _texture);
        str topTexture() const;
        image& topBumpTexture(const char* _texture);
        str topBumpTexture() const;
        image& bottomTexture(const char* _texture);
        str bottomTexture() const;
        image& bottomBumpTexture(const char* _texture);
        str bottomBumpTexture() const;
        image& strencilTexture(const char* _texture);
        str strencilTexture() const;
        image& bottomStrencilTexture(const char* _texture);
        str bottomStrencilTexture() const;
        image& basicThickness(const float& _thickness);
        float basicThickness() const;
        image& bumpThickness(const float& _thickness);
        float bumpThickness() const;
        image& taperAngle(const float& _angle);
        float taperAngle() const;
        image& topBottomWeight(const float& weight);
        float topBottomWeight() const;
        image& sizeInScene(const float& _size);
        float sizeInScene() const;
 
    protected:
        virtual cMeshContainer* create_mesh();
    private:
        ParamInfo _paramInfo;
        ParamInfo& paramInfo() { return _paramInfo; }
        const ParamInfo& paramInfo() const { return _paramInfo; }
    };
 
    enum ThreadProfile {
        ThreadNone = -1,
        ThreadTriangle = 0,
        ThreadTrapeze = 1,
        ThreadRectangular = 2,
        ThreadRound = 3,
        ThreadPersistent = 4
    };
 
    class APICALL thread :public prim {
    public:
        thread();
        thread& diameter(const float d);
        float diameter() const;
        thread& pitch(const float p);
        float pitch() const;
        thread& stub(const float& l);
        float stub() const;
        thread& height(const float& h);
        float height() const;
        thread& turns(const int& n);
        int turns() const;
        thread& clockwise(const bool& cw);
        bool clockwise() const;
        thread& close(const bool& b);
        bool close() const;
        thread& profile(const ThreadProfile& prf);
        ThreadProfile profile() const;
 
    protected:
        virtual cMeshContainer* create_mesh();
    private:
        ThreadProfile _profile;
        float _diameter;
        float _pitch;
        float _stub;
        float _height;
        bool _close;
        bool _clockwise;
        int _turns;
        friend class threadStud;
    };
 
    enum ThreadStudBodyType {
        StudCylinder = 0,
        StudCone = 1
    };
 
    class APICALL threadStud : public thread {
    public:
 
        threadStud();
        threadStud& diameter(const float& d);
        float diameter() const;
        threadStud& diameterTop(const float& d);
        float diameterTop() const;
        threadStud& diameterBottom(const float& d);
        float diameterBottom() const;
        threadStud& length(const float& l);
        float length() const;
        float threadLength() const;
        threadStud& enableThread(const bool& enable);
        bool enableThread() const;
        threadStud& bodyType(const ThreadStudBodyType& bt);
        ThreadStudBodyType bodyType() const;
 
    protected:
        virtual cMeshContainer* create_mesh();
    private:
        float _diameterTop;
        float _diameterBottom;
        float _length;
        bool _enableThread;
        ThreadStudBodyType _bodyType;
    };
 
    enum SlitType {
        none = -1,
        Slot = 0,
        Phillipse = 1,
        Pozidriv = 2,
        Robertson = 3,
        HexSocket = 4,
        SecurityHexSocket = 5,
        Torx = 6,
        SecurityTorx = 7,
        TriWing = 8,
        TorqSet = 9,
        TripleSquare = 10,
        Polydrive = 11,
        DoubleSquare = 12,
        SplineDrive = 13,
        DoubleHex = 14,
        Bristol = 15,
        Pentalobular = 16,
        Frearson = 17,
        SnakeEyes = 18,
        TA = 19,
        TP3 = 20,
        MorTorq = 21,
        ClutCHG = 22,
        ClutCHA = 23,
        GroupEyes = 24
    };
 
    class APICALL Slit {
    public:
        Slit();
        Slit(float w, float h, float d, SlitType t);
        Slit& type(const int& _t);
        int type() const;
        Slit& width(const float& _w);
        float width() const;
        Slit& height(const float& _h);
        float height() const;
        Slit& depth(const float& _d);
        float depth() const;
 
    private:
        float _width;
        float _height;
        float _depth;
        int _type;
    };
 
    enum BoltHeadType {
        BoltNone = -1,  // none
        BoltHexa = 0, // NutHexaParams
        Countersunk = 1,// countersunk(flat)
        BoltRound = 2,  // round    
        Pan = 3,        // pan
        Dome = 4,       // dome
        Oval = 5,       // oval
        Square = 6,     // square
        TShaped = 7,    // t-shaped
        Cylinder = 8,   // cylinder
        Lamb = 9,       // LambParams
        Rim = 10,       // RimParams
        Eye = 11,       // EyeParams
        Bugle = 12,     // bugle
        Clop = 13       // clop  (self-tapping screw)
    };
 
    class APICALL HeadParams {
    public:
        HeadParams();
        HeadParams(int _type, void* _param);
        ~HeadParams();
        HeadParams& setData(int _type, void* param);
        void* getData() const;
        HeadParams& operator = (const HeadParams& h);
        void copy(const HeadParams& h);
        void release();
    private:
        int _what;
        void* _data;
    };
 
 
    class APICALL HeadBaseParams {
    public:
        HeadBaseParams();
        HeadBaseParams(float _d, float _h);
        HeadBaseParams& diameter(float _d);
        HeadBaseParams& height(float _h);
        operator void* () const;
        float _diameter;
        float _height;
    };
 
    class APICALL TShapedParams {
    public:
        TShapedParams();
        TShapedParams(float _d, float _h, float _w);
        TShapedParams& diameter(float _d);
        TShapedParams& height(float _h);
        TShapedParams& width(float _w);
        operator void* () const;
        float _diameter;
        float _height;
        float _width;
    };
 
    class APICALL LambParams {
    public:
        LambParams();
        LambParams(float _l, float _dtop, float _dbottom, float _hh, float _h, float _thick);
        LambParams& length(float _l);
        LambParams& diameterTop(float _d);
        LambParams& diameterBottom(float _d);
        LambParams& height(float _h);
        LambParams& headHeight(float _h);
        LambParams& thickness(float _t);
        operator void* () const;
        float _length;
        float _diameterTop;
        float _diameterBottom;
        float _headHeight;
        float _height;
        float _thickness;
    };
 
    class APICALL RimParams {
    public:
        RimParams();
        RimParams(float _d, float _h, float _d1, float _d2);
        RimParams& shoulderDiameter(float _d);
        RimParams& shoulderHeight(float _h);
        RimParams& inRingDiameter(float _d);
        RimParams& outRingDiameter(float _d);
 
        operator void* () const;
        float _shoulderDiameter;
        float _shoulderHeight;
        float _inRingDiameter;
        float _outRingDiameter;
    };
 
    class APICALL EyeParams {
    public:
        EyeParams();
        EyeParams(float _thick, float _d1, float _d2);
        EyeParams& inRingDiameter(float _d);
        EyeParams& outRingDiameter(float _d);
        EyeParams& thickness(float _t);
        operator void* () const;
        float _thickness;
        float _inRingDiameter;
        float _outRingDiameter;
    };
    class APICALL boltHead : public prim {
    public:
        boltHead();
        boltHead& head(const HeadParams& _h);
        HeadParams& head();
        const HeadParams& head() const;
        boltHead& head(const int& _type, void* data);
        boltHead& slit(const Slit& _s);
         Slit& slit();
         const Slit& slit() const;
         boltHead& operator = (const boltHead& h);
    protected:
        virtual cMeshContainer* create_mesh();
    private:
        HeadParams _head;
        Slit _slit;
    };
 
    enum NutType {
        NutNone = -1,
        NutHexa = 0,
        Quard = 1,
        Acorn = 2,
        Lowacorn = 3,
        NutFlange = 4,
        Slits = 5,
        Radial = 6,
        NutLamb = 7,
        NutRim = 8,
        Selflock = 9,
        NutTShaped = 10,
        Clamplever = 11,
        NtCount = 12
    };
 
 
    class APICALL NutHeadBaseParams {
    public:
        NutHeadBaseParams();
        NutHeadBaseParams(NutType t, float d, float h);
        NutHeadBaseParams& diameter(const float& d);
        float diameter() const;
        NutHeadBaseParams& height(const float& h);
        float height()const;
        operator void* () const;
        NutHeadBaseParams& type(int t);
        int type() const;
        virtual NutHeadBaseParams* copy(NutHeadBaseParams* p = nullptr);
 
    private:
        int _type;
        float _diameter;
        float _height;
    };
 
    // NutHexaParams
    class APICALL NutHexaParams : public NutHeadBaseParams {
    public:
        NutHexaParams();
        NutHexaParams(float d, float h);
    };
 
    class APICALL NutQuardParams : public NutHeadBaseParams {
        NutQuardParams();
        NutQuardParams(float d, float h);
    };
 
    class APICALL NutAcornParams : public NutHeadBaseParams {
    public:
        NutAcornParams();
        NutAcornParams(float d, float h, float h1);
        NutAcornParams& facetHeight(const float& _h);
        float facetHeight() const;
        virtual NutHeadBaseParams* copy(NutHeadBaseParams* p = nullptr);
    private:
        float _facetHeight;
    };
 
    class APICALL NutLowAcornParams : public NutAcornParams {
    public:
        NutLowAcornParams();
        NutLowAcornParams(float d, float h, float h1);
    };
 
    class APICALL NutSelfLockParams : public NutAcornParams {
    public:
        NutSelfLockParams();
        NutSelfLockParams(float d, float h, float h1);
    };
 
    class APICALL NutTShapedParams : public NutAcornParams {
    public:
        NutTShapedParams();
        NutTShapedParams(float d, float h, float h1);
    };
 
    class APICALL NutFlangeParams : public NutHeadBaseParams {
    public:
        NutFlangeParams();
        NutFlangeParams(float d, float h);
        NutFlangeParams(float d, float h, float fw, float fh);
        NutFlangeParams& facetWidth(const float& w);
        NutFlangeParams& facetHeight(const float& h);
        float facetWidth() const;
        float facetHeight() const;
        virtual NutHeadBaseParams* copy(NutHeadBaseParams* p = nullptr);
    private:
        float _facetWidth;
        float _facetHeight;
    };
 
    class APICALL NutRadialParams : public NutHeadBaseParams {
    public:
        NutRadialParams();
        NutRadialParams(float d, float h);
        NutRadialParams(float d, float h, float d1, float d2);
        NutRadialParams& holeDiameter(const float& d);
        NutRadialParams& holeDepth(const float& d);
        float holeDiameter() const;
        float holeDepth() const;
        NutRadialParams& holePlace(const int& place);
        int holePlace() const;
        virtual NutHeadBaseParams* copy(NutHeadBaseParams* p = nullptr);
    private:
        float _holeDiameter;
        float _holeDepth;
        int _holePlace;
    };
 
    class APICALL NutLambParams : public NutHeadBaseParams {
    public:
        NutLambParams();
        NutLambParams(float d, float h);
        NutLambParams& length(const float& _l);
        NutLambParams& diameterBottom(const float& _d);
        NutLambParams& diameterTop(const float& _d);
        NutLambParams& headHeight(const float& _h);
        NutLambParams& thickness(const float& _t);
        float length() const;
        float diameterBottom() const;
        float diameterTop() const;
        float headHeight() const;
        float thickness() const;
        virtual NutHeadBaseParams* copy(NutHeadBaseParams* p = nullptr);
 
    private:
        float _diameterBottom;
        float _diameterTop;
        int _length;
        int _thickness;
        int _headHeight;
    };
 
    class APICALL NutSlitsParams : public NutHeadBaseParams {
    public:
        NutSlitsParams();
        NutSlitsParams(float d, float h);
        NutSlitsParams& width(const float& w);
        NutSlitsParams& length(const float& l);
        NutSlitsParams& count(const int& n);
        float width() const;
        float length() const;
        int count() const;
        virtual NutHeadBaseParams* copy(NutHeadBaseParams* p = nullptr);
    private:
        float _width;
        float _length;
        int _count;
    };
 
    class APICALL NutRimParams : public NutHeadBaseParams {
    public:
        NutRimParams();
        NutRimParams(float d, float h);
        NutRimParams& inRingDiameter(const float& _d);
        NutRimParams& outRingDiameter(const float& _d);
        float inRingDiameter() const;
        float outRingDiameter() const;
        virtual NutHeadBaseParams* copy(NutHeadBaseParams* p = nullptr);
    private:
        float _inRingDiameter;
        float _outRingDiameter;
    };
 
    class APICALL NutClampLever : public NutHeadBaseParams {
    public:
        NutClampLever();
        NutClampLever(float d, float h);
        NutClampLever& holderDiameter(const float& _d);
        NutClampLever& length(const float& _l);
        float holderDiameter() const;
        float length() const;
        virtual NutHeadBaseParams* copy(NutHeadBaseParams* p = nullptr);
    private:
        float _holderDiameter;
        float _length;
    };
 
    class APICALL nut : public prim {
    public:     
        nut();
        ~nut();
        nut& setTypeData(void* data);
        void* getTypeData();
        nut& threadDiameter(const float& d);
        float threadDiameter() const;
        nut& pitch(const float& p);
        float pitch() const;
        nut& enableThread(const bool& f);
        bool enableThread() const;
        nut& threadType(const int& _t);
        int threadType() const;
 
    protected:
        void release();
        virtual cMeshContainer* create_mesh();
    private:
        float _threadDiameter;
        float _pitch;
        int _threadType;
        bool _enableThread;
        void* _typeData;
    };
 
    enum ThreadSurface {
        ThreadCylinder,
        ThreadCone,
        ThreadEdge
    };
 
    class APICALL bolt : public prim {
    public:
        bolt();
        struct Info {
            float _diameter;    // thread diameter
            float _pitch;       // screw thread step
            float _theight;     // screw thread height
            float _length;      // bolt length
            float _tlength;     // screw thread length
            int   _ttype;       // screw thread profile type (triangle,trapeze,rectangular,round)
            int   _uhead;       // underhead (-1-none, 0-cylinder,1-rect)
            float _uwidth;      // underhead width
            float _uheight;     // underhead height
            boltHead _head;     // head
            int   _nuttype;     // nut type
            float _nutloc;      // nut location reference thread
            float _nutHeight;   // nut height
        };
        bolt& head(const boltHead& _h);
        const boltHead& head() const;
        bolt& diameter(const float& _d);
        float diameter();       
        bolt& pitch(const float& _p);
        float pitch();
        bolt& threadHeight(const float& _h);
        float threadHeight();
        bolt& length(const float& _l);
        float length();
        bolt& threadLength(const float& _l);
        float threadLength();   
        bolt& threadType(const int& _t);
        int threadType();
        bolt& underhead(const int& _uh);
        int underhead();
        bolt& uwidth(const int& _uw);
        float uwidth();
        bolt& uheight(const int& _uh);
        float uheight();
        bolt& nutType(const int& _t);
        int nutType();
        bolt& nutLocation(const float& _loc);
        float nutLocation();
        bolt& nutHeight(const float& _h);
        float nutHeight();
 
    protected:
        virtual cMeshContainer* create_mesh();
    private:
        Info& info();
        const Info& info() const;
        Info _info;
    };
 
    class APICALL screw : public prim {
    public:
        struct Info {
            float _diameter;    // core diameter
            float _pitch;       // screw thread step
            float _theight;     // screw thread height
            float _tlength;     // screw thread length
            float _tdiameter;   // screw thread diameter
            float _length;      // screw length
            int   _uhead;       // underhead (-1 none, 0-cylinder,1-rect)
            int   _uwidth;      // underhead width
            int   _uheight;     // underhead height
            boltHead _head;     // bolt head
        };
        screw();
        screw& head(const boltHead& _h);
        const boltHead& head() const;
        screw& diameter(const float& _d);
        float diameter();
        screw& pitch(const float& _p);
        float pitch();
        screw& threadDiameter(const float& _d);
        float threadDiameter();
        screw& threadHeight(const float& _h);
        float threadHeight();
        screw& threadLength(const float& _l);
        float threadLength();
        screw& length(const float& _l);
        float length();
        screw& underhead(const int& _uh);
        int underhead();
        screw& uwidth(const int& _uw);
        float uwidth();
        screw& uheight(const int& _uh);
        float uheight();
    protected:
        virtual cMeshContainer* create_mesh();
    private:
        Info& info();
        const Info& info() const;
        Info _info;
    };
 
    class APICALL washer : public prim {
    public:
        enum Type {
            None = -1,
            Flat = 0,
            Grover = 1,
            Plate = 2,
            Wave = 3,
            Quard = 4,
            Sphere = 5,
            Conus = 6,
            Springlock = 7
        };
        washer();
        washer& innerDiameter(const float& _d);
        float innerDiameter() const;
        washer& outerDiameter(const float& _d);
        float outerDiameter() const;
        washer& conusDiameter(const float& _d);
        float conusDiameter() const;
        washer& thickness(const float& _s);
        float thickness() const;
        washer& height(const float& _h);
        float height() const;
        washer& facet(const bool& _f);
        bool facet() const;
        washer& type(washer::Type _t);
        washer::Type type() const;
 
    protected:
        virtual cMeshContainer* create_mesh();
    private:
        float _innerDiameter;
        float _outerDiameter;
        float _conusDiameter;
        float _thickness;
        float _height;
        bool _facet;
        Type _type;
    };
 
    class APICALL freeform: public prim {
    public:
        typedef list<vec3> Points3D;
        struct ffElement {
            str name;
            list<str> subpaths;
        };
        typedef list<ffElement> ffObjsList;
        struct ffInfo {
            str name;
            str subName;
            bool symX;
            bool symY;
            bool symZ;
            Points3D points;
        };
        freeform();
        freeform(const char *_ffname, const char* _ffsubname);
        ~freeform();
         freeform& symx(const bool& x);
        freeform& symy(const bool& y);
        freeform& symz(const bool& z);
        freeform& size(float x, float y, float z);
        freeform& size(const vec3& v);
        freeform& ffname(const char* name);
        const char* ffname() const;
        freeform& ffsubname(const char* name);
        const char* ffsubname() const;
        freeform& SetPoint(int i, const vec3& point);
        int CountPoints() const;
        void ResetPoints();
        list<str>* ffSubNamesList();
        list<str>* ffSubNamesList(const str& ffName);
        ffObjsList& objsList();
        Points3D& ffControlPoints();
    protected:
        virtual cMeshContainer* create_mesh();
    private:
        void SetupPoints();
        void SetObjectPaths();
        ffInfo& info();
        const ffInfo& info() const;
        /*
         * \brief gets the current object name.
         * \return object name 
         */
        str& objName();
 
        ffInfo _info;
        ffObjsList _ffobjs;
        list<str>* _subNames;
        str _objName;
        vec3 _side;
        int _ffDim[3];
    };
 
}
#pragma pack(pop)