curve.h

Go to the documentation of this file.

//**************************************************************************/
// Copyright (c) 2008 Autodesk, Inc.
// All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
//
//**************************************************************************/
// DESCRIPTION:
// CREATED: September 2011
//**************************************************************************/

namespace mudbox {

class NURBSCurve;

class MBDLL_DECL CurveBase : public GroupNode
{
    DECLARE_CLASS;

public:

    CurveBase();
    virtual ~CurveBase();

    virtual void Render();

    virtual void Serialize(Stream &s);

    void SetSelected(bool bTOrF) { m_bSelected = bTOrF; }
    bool Selected() { return m_bSelected; }

    virtual void SetClosed(bool bTOrF) { m_bClosed = bTOrF; }
    bool Closed() { return m_bClosed; }

    virtual void SetGeometry(mudbox::Geometry *pGeom);
    mudbox::Geometry *Geometry() const;

    virtual const AxisAlignedBoundingBox &BoundingBox() { return m_AABB; }

    virtual void CopyTo( Node *pNode) const;

    virtual float Length() const;

protected:

    abool m_bSelected;
    abool m_bClosed;

    aptr<mudbox::Geometry> m_pGeometry;


    AxisAlignedBoundingBox m_AABB;
    bool m_bRefreshBoundingBox;
};

struct MBDLL_DECL CurvePoint
{
    CurvePoint();

    Vector WorldPosition;

    // Surface point contains all of the above info
    mudbox::SurfacePoint SurfacePt;
};

class MBDLL_DECL MudboxCurve : public CurveBase
{
    DECLARE_CLASS;
public:
    MudboxCurve();
    virtual ~MudboxCurve();

    virtual int AddPoint(const CurvePoint &pt);

    virtual bool SetPoint(int index, const CurvePoint &pt);

    virtual bool SetPoint(int index, const Vector &pt);

    virtual const CurvePoint &Point(int index) const;

    virtual Vector WorldPosition(int iIndex) const;
               
    virtual int PointCount() const;

    virtual bool Point(int index, CurvePoint &point);

    virtual const QList<CurvePoint> &Points();

    virtual bool InsertPoint(int before, const CurvePoint &pt);

    virtual bool RemovePoint(int index);

    virtual void Serialize(Stream &s);

    virtual const AxisAlignedBoundingBox &BoundingBox();

    virtual void CopyTo(Node *pNode) const;

    virtual bool IsConstrainedToSurface( void ) const;
    
    virtual void CreateSpline( float fSmoothness );

    virtual void BeginEdit();

    virtual void EndEdit();
    
    virtual NURBSCurve *Spline() const;

    virtual bool IsSpline( void ) const;

    virtual void ProjectPoint( const Vector &vPoint, Vector &vResult ) const;

    enum CurveType
    {
        CT_3D = 0,
        CT_2D,
    };

    virtual void SetCurveType(enum CurveType ct);

    virtual enum CurveType CurveType() const;

    virtual NURBSCurve *FalloffCurve();
protected:

    QList<CurvePoint> m_vPoints;
    enum CurveType m_eCurveType;     
};

Vector MBDLL_DECL WindowPositionNormalized(const MudboxCurve *pCurve, int iIndex) ;

Vector MBDLL_DECL WindowPosition(const MudboxCurve *pCurve, int iIndex) ;
 
class MBDLL_DECL CurvePicker {
public:
    struct MBDLL_DECL CurveHit
    {
        CurveHit(MudboxCurve *pCurve, int iPointIndex, Vector point3D, Vector point2D, float distanceToMouse)
        { Curve = pCurve; PointIndex = iPointIndex; Point3D = point3D; Point2D = point2D; DistanceToMouse = distanceToMouse; }

        CurveHit();

        MudboxCurve *Curve;
        int PointIndex;
        Vector Point3D;
        Vector Point2D;
        float DistanceToMouse;
    };

    enum CurveTestPoints
    {
        CTP_NONE = 0,
        CTP_START,
        CTP_END,
        CTP_START_END,
        CTP_ALL,
    };

public:
    static void hitTestCurves(float fMouseX, float fMouseY, float distanceTolerance, QVector<CurveHit> &hitCurves, CurveTestPoints ctp = CTP_START_END, bool bTestLockedCurves = false);
    // Returns the nearest point to the mouse position. Returns -1 if no point is inside the distance tolerance.
    // On CTP_ALL mode, the curveHit will always be set to the nearest curve point, even it's out of distance tolerance.
    static int hitTestCurvePoints(float fMouseX, float fMouseY, float distanceTolerance, MudboxCurve *pCurve, CurveHit &curveHit, CurveTestPoints ctp = CTP_START_END);
    static float projectPointToCurve(float fMouseX, float fMouseY, MudboxCurve * pCurve, int iPointIndex, Vector &vProjection);
    static bool snapMouse(float fMouseX, float fMouseY, float fSnappingDistance, MudboxCurve *pCurve, float &fNewMouseX, float &fNewMouseY);
};


class MBDLL_DECL CurveOperator : public Node
{
    DECLARE_CLASS;

public:
    CurveOperator( MudboxCurve *pC = 0 );

    void Close( bool bMerge = false );
    
private:
    MudboxCurve *m_pCurve;
};


}; // end of namespace mudbox