GEO/GEO_PrimTriBezier.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:
 *      Jeff Lait
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        GEO_PrimTriBezier.h ( GEO Library, C++)
 *
 * COMMENTS:    This is the base class for all triangle mesh types.
 */

#ifndef __GEO_PrimTriBezier__
#define __GEO_PrimTriBezier__

#include "GEO_API.h"
#include <UT/UT_RefArray.h>
#include <GB/GB_Defines.h>
#include "GEO_Vertex.h"
#include "GEO_Primitive.h"

class   GB_FloatOffsets;
class   GD_Face;
class   GD_Detail;
class   GEO_Detail;

#define FOR_MESH_VERTICES(mesh, vtx, cnt) \
        for (cnt=0; (cnt < mesh->getVertexCount()) && \
                    (vtx = &((*mesh)(cnt))); cnt++)

class GEO_API GEO_PrimTriBezier : public GEO_Primitive {
public:
    GEO_PrimTriBezier(GEO_Detail *d);
    virtual ~GEO_PrimTriBezier();

    virtual bool        evaluatePoint(GEO_Vertex &result,
                                GEO_AttributeHandleList &hlist,
                                fpreal u, fpreal v, uint du, uint dv) const;
    virtual int         evaluatePoint(UT_Vector4 &pos, float u, float v = 0,
                                    unsigned du=0, unsigned dv = 0) const;
    virtual int         evaluatePointWAttrib(UT_Vector4 &pos,
                                    GB_AttributeData &adata,
                                    const GB_FloatOffsets &foffsets,
                                    float u, float v=0, unsigned du=0,
                                    unsigned dv = 0) const;
    // This fills a plain point array with our positions.
    // The array is a compressed array in the same format as our own
    // native stuff.
    void                fillArray(int fakeorder, UT_Vector4 *array) const;
    void                fillArray(int fakeorder, GEO_Vertex *results,
                                    GEO_AttributeHandleList &hlist) const;
    void                fillArrayWAttrib(int fakeorder, UT_Vector4 *array,
                                    GB_AttributeData *atrarray,
                                    const GB_FloatOffsets &foffsets) const;
    void                fillArrayWAttrib(int fakeorder, UT_Vector4 *pts,
                                GB_AttributeData *ptattrib,
                                GB_AttributeData *vtxattrib) const;

    virtual unsigned    getPrimitiveId() const;
    virtual int         getBBox(UT_BoundingBox *bbox) const;
    virtual void        addToBSphere(UT_BoundingSphere *bsphere) const;
    virtual UT_Vector3  baryCenter() const;

    virtual void        reverse();
    virtual UT_Vector3  computeNormal() const;

    virtual float       calcVolume(UT_Vector3 &refpt) const;
    virtual float       calcArea() const;
    virtual float       calcPerimeter() const;

    virtual int         save(ostream &os, int binary) const;
    virtual bool        load(UT_IStream &is);

    virtual void        copyPrimitive(const GEO_Primitive *src, 
                                            GEO_Point **ptredirect);
    virtual GEO_Primitive       *copy(int preserve_shared_pts = 0) const;

    virtual void        addPointRefToGroup(GB_PointGroup &grp) const;
    virtual void        changePointRef(GB_Element *from, GB_Element *to);

    virtual int         isDegenerate() const;

    // Adjust the order of the patch.
    void                 setOrder(int order);
    int                  getOrder() const { return myOrder; }

    // Delete the vertex that uses the point.
    virtual int         detachPoint  (GB_Element *ppt, int allVertices=1);
    virtual int         ifDetachPoint(GB_Element *ppt) const;

    // Take the whole set of points into consideration when applying the
    // point removal operation to this primitive. The method returns 0 if
    // successful, -1 if it failed because it would have become degenerate,
    // and -2 if it failed because it would have had to remove the primitive
    // altogether.
    virtual int          detachPoints (GB_PointGroup &grp);

    // Query the number of vertices in the array. This number may be smaller
    // than the actual size of the array.
    virtual unsigned    getVertexCount() const;

    // Both methods find the index of the given vertex (vtx or the vertex
    // that contains ppt). Return -1 if not found. 
    int         find(const GEO_Vertex &vtx) const { return vtxList.find(vtx); }
    int         find(const GEO_Point  &ppt) const;

    virtual const GEO_Vertex    &getVertex(unsigned i) const;
    virtual GEO_Vertex          &getVertex(unsigned i);
    void                         setVertex(unsigned int i, GEO_Point *pt)
                                 {
                                    if (i < vtxList.entries())
                                        vtxList(i).setPt(pt);
                                 }

    // And now the operators that let you treat it like a portion of
    // a tensor product patch:
    unsigned             getRawIndex(unsigned row, unsigned col) const
                            { return getRawIndex(row, col, myOrder); }
    unsigned             getRawIndex(unsigned row, unsigned col, int order)const
                            { return (order - row)*(order-row-1)/2 + col; }
    const GEO_Vertex    &operator()(unsigned i, unsigned j) const 
                            { return vtxList(getRawIndex(i,j)); }
    GEO_Vertex          &operator()(unsigned i, unsigned j)       
                            { return vtxList(getRawIndex(i,j)); }
    virtual const GEO_Vertex    &getVertex(unsigned i, unsigned j) const
                                 { return getVertex(getRawIndex(i, j)); }
    virtual GEO_Vertex          &getVertex(unsigned i, unsigned j)
                                 { return getVertex(getRawIndex(i, j)); }
    void                         setVertex(unsigned int i, unsigned int j,
                                            GEO_Point *pt)
                                 {
                                    i = getRawIndex(i, j);
                                    if (i < vtxList.entries())
                                        vtxList(i).setPt(pt);
                                 }

    virtual int          isPointUsed(GB_Element *pt) const;
    virtual int          isPointGroupUsed(const GB_PointGroup &grp) const;

    // Methods to handle vertex attributes for the attribute dictionary
    virtual int          vertexApply(int (*apply)(GB_Vertex &vtx, void *),
                                    void  *data = 0);
    virtual int          vertexApply(int (*apply)(const GB_Vertex &vtx, void *),
                                    void  *data = 0) const;

    // Express the points in homogeneous coordinates or vice-versa. endcv can
    // be greater than the number of vertices or smaller than startcv. In 
    // both these cases we will wrap the index.
    void                homogenize  (int startcv = 0, int endcv = -1);
    void                dehomogenize(int startcv = 0, int endcv = -1);
    void                homogenize(GEO_AttributeHandleList &hlist,
                                          int startcv = 0, int endcv = -1);
    void                dehomogenize(GEO_AttributeHandleList &hlist,
                                          int startcv = 0, int endcv = -1);
    void                homogenizeWAttrib(const GB_FloatOffsets &foffsets,
                                          int startcv = 0, int endcv = -1);
    void                dehomogenizeWAttrib(const GB_FloatOffsets &foffsets,
                                          int startcv = 0, int endcv = -1);

protected:
    virtual void        copyOffsetPrimitive(const GEO_Primitive *src, int base);

    // Methods for finding out about point references
    virtual int  savePrivate(ostream & /*os*/,int /*binary*/) const {return 0;}
    virtual bool loadPrivate(UT_IStream &)      { return true; }
    virtual int  pointCanDelete(GB_Element *) const;
    virtual void pointDeleted(GB_Element *pt);

    // Check the validity of the data. Meant to be called especially at loading
    // time. The method returns 1 if OK and 0 if trouble.
    virtual bool         validate(void) const;

    // Insert a vertex multiple times in the list. Return the index.
    int                  multipleInsert(unsigned int where, 
                                        unsigned int count,
                                        unsigned int appendPoints = 1);

    void                 setSize(unsigned sz);

    UT_RefArray<GEO_Vertex>     vtxList;
    int                         myOrder;

private:
    // This version takes a pre-resized attribute blossom array so
    // we don't try and resize them every pass.  Remember boys and girls:
    // static data is *EVIL*.
    int         evaluateBPointWAttrib(UT_Vector4 &pos,
                                    GB_AttributeData &adata,
                                    GB_AttributeData ablossom[][GB_MAXORDER],
                                    const GB_FloatOffsets &foffsets,
                                    float u, float v=0, unsigned du=0,
                                    unsigned dv = 0) const;

    int         evaluateBPointWAttrib(UT_Vector4 &pos,
                                    GB_AttributeData *ptadata,
                                    GB_AttributeData ptablossom[][GB_MAXORDER],
                                    const GB_FloatOffsets &ptfoffsets,
                                    GB_AttributeData *vtxadata,
                                    GB_AttributeData vtxablossom[][GB_MAXORDER],
                                    const GB_FloatOffsets &vtxfoffsets,
                                    float u, float v=0, unsigned du=0,
                                    unsigned dv = 0) const;

    friend ostream      &operator<<(ostream &os, const GEO_PrimTriBezier &d)
                        {
                            d.save(os, 0);
                            return os;
                        }
};
#endif

---