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 : virtual 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() const { return m_bSelected; }

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

    virtual mudbox::Color Color( void ) const { return mudbox::Color( m_aColor[0], m_aColor[1], m_aColor[2], m_aColor[3] ); };
    virtual void SetColor( const mudbox::Color &cColor ) { m_aColor[0] = cColor.r; m_aColor[1] = cColor.g; m_aColor[2] = cColor.b; m_aColor[3] = cColor.a; };
    virtual void ResetColor( void ) { m_aColor[0] = -1; };

    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;
    float m_aColor[4];

    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() const;

    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 float SplineSmoothness() const;

    virtual void SetSplineSmoothness( float fSmoothness );

    virtual void BeginEdit();

    virtual void EndEdit();

    virtual bool IsBeingEdited() const;
    
    virtual NURBSCurve *Spline() const;

    virtual int ToSplineIndex( int iPointIndex ) 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();

#ifdef _CW_DEBUG
    QVector<Vector> m_TmpPoints;
#endif

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, bool bTestClosedCurves = true);
    // 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 AbstractCurvePicker : public Node {
    DECLARE_CLASS;
public:
    struct MBDLL_DECL CurveHit {
        CurveHit();
        MudboxCurve * pCurve;
        int iPointIndex;
        // Screen space. x, y, z in [0, 1]. Origin at the bottom left.
        Vector vProjection;
    };

    struct MBDLL_DECL PickInfo {
        PickInfo(float fMouseX, float fMouseY, float fDistanceTolerance = 0, int iDepthTolerance = 0xFFF);
        float fMouseX, fMouseY; // Screen space coord. x, y in [0, 1]. Origin at the bottom left.
        float fDistanceTolerance;
        int iDepthTolerance; // [0, MAX_INT] Depth dif out of tolernace will make candidate been eliminated.
    };

    class MBDLL_DECL Eliminater {
    public:
        virtual ~Eliminater() {}
        // return false to accept the result, or true to eliminate it.
        virtual bool Eliminate(AbstractCurvePicker * pPicker, const PickInfo & pPickInfo, CurveHit & pResult) = 0;
    };

public:
    virtual ~AbstractCurvePicker() {}
    virtual void SetCamera(Camera * pCamera);
    virtual Camera * GetCamera() const;
    virtual void SetFrameBufferSize(int iWidth, int iHeight);
    virtual void GetFrameBufferSize(int & iWidth, int & iHeight);
    virtual void QuickInit();
    virtual void Invalidate();
    virtual bool Pick(const PickInfo & pPickInfo, CurveHit & pResult, Eliminater * pEliminator = NULL);
    virtual void CalculateProjection(CurveHit & pResult) const;

private:
    static AbstractCurvePicker * s_pActivePicker;
public:
    static void SetActivePicker(AbstractCurvePicker * pPicker);
    static AbstractCurvePicker * ActivePicker();
};


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