GU/GU_Curve.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Cristin Barghiel
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        GU_Curve.h (C++)
 *
 * COMMENTS:
 *      Header file for GU_Curve.h class...
 * 
 */

#ifndef __GU_Curve_h__
#define __GU_Curve_h__

#include "GU_API.h"
#include <GEO/GEO_Curve.h>
#include "GU_Prim.h"

class UT_Matrix;
class UT_Vector4Array;
class GEO_Hull;
class GU_PrimPoly;
class GU_Detail;
class GU_CurveCache;
class GU_RayCache;
class GU_RayInfoHit;
class GU_ConvertMethod;

/////////////////////////////////////////////////////////////
//                                                         //
// Class:     GU_Curve                                     //
// Descr:     This class is responsible for general type   //
//       of operations on the spline    curve classes.     //
//                                                         //
/////////////////////////////////////////////////////////////

class GU_API GU_Curve : public GU_Primitive
{
public:
    virtual ~GU_Curve(); 

    // Conversion Methods 

     GEO_Primitive      *convert(GU_ConvertParms &parms, 
                                 GB_PointGroup *usedpts = 0);

     GEO_Primitive      *convertNew(GU_ConvertParms &parms);
     GEO_Hull           *convertToSurfNew(GU_ConvertParms &parms);

     // This is more powerful than convertNew. It always returns a NEW
     // object, so free it when you're done with it. It may return
     // a NURB curve or a Bezier curve depending on the type.
     virtual GEO_Face   *reconfigure(unsigned type, int order, int open, 
                                     int interpends, int nonrational) const=0;

     // Grab the pointer to the actual curve:
     GEO_Curve         *getCurve(void) const     { return theCurve; }

     // Takes the curve and converts it to a polygon with vertices at the
     // Greville points of the curve and places the polygon in the given
     // destination detail.  If no detail is given place in the curves
     // parent detail.
     GU_PrimPoly        *makeGrevillePoly(GU_Detail *dest = 0);

    // Methods to handle caching.
    virtual GU_DisplayCache     *getDisplayCache(void) const;
    virtual int                  buildDisplayCache(GU_CacheParms &parms);

    virtual GU_DisplayMesh      *getDisplayMesh(int noff, float lod);

    virtual GU_RayIntersect     *getRayCache(void) const;
    virtual int                  buildRayCache(void);
    // Persistent is true if the returned cache is not to be deleted by
    // the caller.
    virtual GU_RayIntersect     *createRayCache(int &persistent);

    virtual void         destroyCache(void);
    virtual void         notifyCache(int type);
    virtual void         notifyCache(int type, const GEO_Point &ppt);
    virtual void         notifyCache(int type, const GB_PointGroup &grp);
    virtual void         notifyCache(int type, const UT_Matrix4 &xform, 
                                     int push);
    virtual void         notifyCache(int type, const UT_Vector3 &delta);

     // Elevate the curve to the given order. Return 0 if OK and -1 otherwise.
     int                 elevateOrder(int order);

    // Methods for helping curve fitting on a set of data points.

    // Given a set of data points dataPts[0..n][0..2].
    // Compute the unit tangent vectors for local interpolation methods,
    // and indicate possible corner points if needed.
    // To specify that you want to detect corners, set the column
    // dimensions of tangents to [0..5] (ie. tangents[0..n][0..5],
    // to allow for 2 tangents (in/out) per point) 
    // else set tangents[0..n][0..2].
    // Output: tangents[0..n][0..2||5]. 
    void                 computeDataPtsUnitTangents(const UT_Matrix &dataPts,
                                                    UT_Matrix &tangents);


    // Calculate the normal of a curve
     void               curveNormal(UT_Vector3 &n) const;
     virtual void       normal(int noff) const;
     virtual void       normal(UT_Vector3Array &output) const;

    // Cut a wedge of the primitive given a domain range
    // ind1 and ind2 are indices to the refined values
    // They are updated if negative on input, else used as is.
    // If keep is zero the curve is only refined and the indices
    // updated.

    virtual GU_Curve    *cut(float u1, float u2, 
                             int &ind1, int &ind2, int keep) = 0;

    // Open the primitive at the given domain value
    virtual void         openAt(float u) = 0;

    // Returns number of hits appended, or minus one if error.
    virtual int          intersect(GU_Primitive &prim,
                                    UT_RefArray<GU_RayInfoHit> &hitList, 
                                    float tol = 0.01F, int ignoretrim = 1);

    // Puts the location of the breakpoint at index idx on the curve in p.
    // Returns 1 if idx is valid, 0 otherwise.
    int                  interpretBreakpoint(int idx, UT_Vector3 &p);


protected:
     // We don't want anybody to instantiate a GU_Curve.
     GU_Curve() : GU_Primitive() { theDisplayCache = 0; theRayCache = 0;} 

     // Build the vextex list, and optionally append points to the detail.
     // Return 0 if OK, and -1 if error.
     int                create(GEO_Curve *crv, int nelems, int closed,
                                              int appendPoints = 1);

     // Trust us that is is the pointer to use to access the actual curve.
     void               setCurve(GEO_Curve *crv) { theCurve = crv;  }

    // Return the start and and knots for a full uniform evaluation of the
    // curve.
    void                 evaluationInterval(float lod, 
                                 float &ustart, float &ustop, int &nu) const;

    // Fill with values within the valid interval. Return 0 if OK and -1
    // otherwise.
public:
    int                  evaluateCurve( GU_ConvertMethod &method,
                                        UT_Vector4Array &pos) const;
protected:
    int                  evaluateCurve( GU_ConvertMethod &method,
                                        UT_Vector4Array &pos,
                                        GB_AttributeData *&adata,
                                        int &vtxattrib) const;

private:
     GEO_Curve          *theCurve;              // the "real" curve
     GU_CurveCache      *theDisplayCache;       // display cache
     GU_RayCache        *theRayCache;           // ray cache

     GEO_Primitive      *convertToPoly(GU_ConvertParms &parms);
     GEO_Hull           *convertToTrim(GU_ConvertParms &p);
     GEO_Hull           *convertToPotatoChip(void);
};

#endif

---