GEO/GEO_TriMesh.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_PrimTriMesh.h ( GEO Library, C++)
 *
 * COMMENTS:    This is the base class for all triangle mesh types.
 */

#ifndef __GEO_TriMesh__
#define __GEO_TriMesh__

#include "GEO_API.h"
#include <UT/UT_RefArray.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_TriMesh : public GEO_Primitive {
public:
    GEO_TriMesh(GEO_Detail *d);
    virtual ~GEO_TriMesh();

    virtual unsigned    getPrimitiveId() const = 0;
    virtual int         getBBox(UT_BoundingBox *bbox) const;
    virtual void        addToBSphere(UT_BoundingSphere *bsphere) const;
    virtual UT_Vector3  baryCenter() const;
    virtual bool        evaluatePoint(GEO_Vertex &vertex,
                                GEO_AttributeHandleList &hlist,
                                fpreal u, fpreal v, uint du, uint dv) 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 size of the vertex array.
    void                 setSize(unsigned int sz);

    // 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);

    // Insert or delete vertices. The insertion methods return the index if
    // successful and -1 otherwise. The deletion methods return 0 if ok and
    // -1 otherwise.
    virtual int         insertVertex(GEO_Point  *ppt, unsigned int where=0);
    virtual int         appendVertex(GEO_Point  *ppt);
    virtual int         deleteVertex(GEO_Vertex &vtx);
    virtual int         deleteVertex(unsigned int num);

    // Query the number of vertices in the array. This number may be smaller
    // than the actual size of the array.
    virtual unsigned    getVertexCount() const;
    unsigned            getFastVertexCount() const
                        { return vtxList.entries(); }

    // 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;

    // Subscript operators. The () operator does not check the boundaries.
    const GEO_Vertex    &operator()(unsigned i) const { return vtxList(i); }
    GEO_Vertex          &operator()(unsigned i)       { return vtxList(i); }
    const GEO_Vertex    &operator[](unsigned i) const 
                        {
                            return (i < vtxList.entries()) ? vtxList(i)
                                                           : vtxList(0);
                        }
    GEO_Vertex          &operator[](unsigned i)  
                        {
                            return (i < vtxList.entries()) ? vtxList(i) 
                                                           : vtxList(0);
                        }
    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);
                                 }

    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(GEO_AttributeHandleList &hlist,
                                    int startcv=0, int endcv=-1);
    void                dehomogenize(GEO_AttributeHandleList &hlist,
                                    int startcv=0, int endcv=-1);
    void                homogenize  (int startcv = 0, int endcv = -1);
    void                dehomogenize(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);
    void                homogenizeWAttrib(const GB_FloatOffsets *ptoffsets,
                                          const GB_FloatOffsets *vtxoffsets,
                                          int startcv = 0, int endcv = -1);
    void                dehomogenizeWAttrib(const GB_FloatOffsets *ptoffsets,
                                          const GB_FloatOffsets *vtxoffsets,
                                          int startcv = 0, int endcv = -1);

    // Map the normalized length (distance value [0,1]) parameter to the unit 
    // parameterization of the primitve
    virtual void         unitLengthToUnitPair(float  ulength, float  vlength,
                                              float &uparm,  float &vparm)const;

    virtual void         unitToUnitLengthPair(float  uparm,   float  vparm,
                                              float &ulength, float &vlength)
                                                                        const;

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 = 0;
    virtual bool loadPrivate(UT_IStream &is) = 0;
    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.
    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                 setSizeFast(int new_entries, int src_size);

    UT_RefArray<GEO_Vertex>     vtxList;


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

---