GEO/GEO_Primitive.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:
 *      Mark Elendt
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        Geometry Library (C++)
 *
 * COMMENTS:
 *      The className method is used for saving/loading so there should
 *        be no spaces in the name.
 *
 */

#ifndef __GEO_Primitive_H__
#define __GEO_Primitive_H__

#include "GEO_API.h"
#include <iostream.h>
#include <UT/UT_Matrix4.h>
#include <GB/GB_Primitive.h>
#include <GB/GB_Attribute.h>
#include "GEO_Point.h"

class   GB_FloatOffsets;
class   GB_Edge;
class   GEO_Detail;
class   GEO_Vertex;
class   GEO_VertexAttribDict;
class   GEO_MetaPrim;
class   GEO_AttributeHandleList;

typedef void (* GEO_EdgeApplyFunc)(GEO_Primitive &prim, GEO_Point &a,
                                   GEO_Point &b, void *data);
typedef void (* GEO_EdgeApplyIndexFunc)(GEO_Primitive &prim, int v1,
                                        int v2, void *data);

class GEO_API GEO_Primitive : public GB_Primitive, public GB_AttributeElem
{
public:
    GEO_Primitive(GEO_Detail *d);
    virtual ~GEO_Primitive();

    virtual int          isPrimary(void) const;

    void                 copyAttributeData(const GEO_Primitive *src, int asize)
                         {
                             copyAttribData(src, asize);
                         }
            void         copyAttributeData(const GEO_Primitive *src);
            
    // The ptredirect array is allocated to the number of points in the gdp 
    // which src belongs to.  It maps point numbers in src's gdp to
    // point numbers in this' gdp.
    // If src->getVertex(0) has point number 10, this->getVertex(0)
    // will have point number ptredirect[10].
    // copyPrimitive is used internally in the copy/merge methods,
    // thus has support for a non-uniform relationship.
    virtual void         copyPrimitive(const GEO_Primitive *src, 
                                        GEO_Point **ptredirect)=0;
    virtual GEO_Primitive       *copy(int preserve_shared_pts = 0) const;

    // Transforms the matrix associated with this primitive.  The
    // translate component is ignored: Translate the vertices of
    // the primitive to translate the primitive.
    // This only works with quadrics (sphere, tube, metaballs) and volumes.
    virtual void         transform(const UT_Matrix4 &);

    // Convert the real domain values of the primitive to unit values to be
    // used in the evaluation methods below:
    virtual void         realToUnitPair(float  ureal, float  vreal,
                                        float &uunit, float &vunit) const;

    // Convert the unit values of the primitive to the real domain values
    virtual void         unitToRealPair(float  uunit, float  vunit,
                                        float &ureal, float &vreal) const;

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

 
    // Evaluate a set of attributes at a u,v position.  Optionally, evaluate
    // the derivative in the u or v direction.
    // The method returns true if the point could be evaluated
    virtual bool         evaluatePoint(GEO_Vertex &result,
                                        GEO_AttributeHandleList &gah,
                                        fpreal u, fpreal v=0,
                                        uint du=0, uint dv=0) const = 0;
    // Evaluate the position, the derivative or the normal at domain point
    // (u,v), where u and v MUST be in [0,1]. "v" and "dv" will be ignored
    // when dealing with one-dimensional types such as circles and polygons.
    // Return 0 if OK and -1 otherwise. The normal is not normalized.
    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;
    virtual int          evaluateNormalVector(UT_Vector3 &nml, float u,
                                        float v = 0) const;
    
    // Evaluate the position at domain point (u,v) in the interior of the
    // geometry.  This calls evaluatePoint by default, but has a different
    // implementation for triangles and quadrilaterals, where barycentric
    // coords or bilinear interpolants are used to get an interior point,
    // rather than a point on the perimeter of the poly.  This was added
    // so particles can stick to triangles and quads.
    virtual bool        evaluateInteriorPoint(GEO_Vertex &result,
                                        GEO_AttributeHandleList &hlist,
                                        fpreal u, fpreal v) const;
    virtual int          evaluateInteriorPoint(UT_Vector4 &pos, 
                                               float u, float v) const;
    virtual int          evaluateInteriorPointWAttrib
                                         (UT_Vector4 &pos,
                                          GB_AttributeData &adata,
                                          const GB_FloatOffsets &foffsets,
                                          float u, float v) const;

    GEO_Detail          *getParent() const      { return (GEO_Detail*)parent; }
    static unsigned      getPrimitiveType(const char *name);
    static const char   *getPrimitiveName(unsigned type);
    static unsigned      getPrimitiveMask(const char *maskstr);

    virtual void        *castTo() const;

    virtual int          hasEdge(const GEO_Point &a, const GEO_Point &b) const;
    virtual int          hasEdge(const GB_Edge &edge) const;
    virtual int          hasGuideEdge(int edgeid, UT_Vector4 &a, 
                                                  UT_Vector4 &b) const;
    virtual int          hasXsectPoint(int pointid, UT_Vector4 &p) const; 

    virtual void         edgeApply(GEO_EdgeApplyFunc apply , void  *data = 0);
    virtual void         edgeApplyIndex(GEO_EdgeApplyIndexFunc apply,
                                        void  *data = 0);

    virtual const GEO_Vertex    &getVertex(unsigned index) const = 0;
    virtual GEO_Vertex          &getVertex(unsigned index) = 0;

//
//  Method to get the tessera data for meta-primitives
    virtual GEO_MetaPrim        *castToMetaPrim(void);
    virtual const GEO_MetaPrim  *castToMetaPrim(void) const;

    // Return the surrounding values of the real-space u,v parameters.
    // Returns 1 if succesful, 0 if out-of-range.

    virtual int          parametricBBox(float u, float v, 
                                        float *u0, float *u1,
                                        float *v0, float *v1);

    // Returns distance between two points in parameter space, aware
    // of any possible wrapping.
    virtual float        uvDist(float u1, float v1, float u2, float v2) const;

    // Have we been deactivated and stashed?
    virtual              void   stashed(int onoff);

    // Intersects a ray with the bounding box, iteratively growing it until
    // an intersection is found or maxtries is reached.
    int                  bboxIntersectRay(const UT_Vector3 &rayorig,
                                          const UT_Vector3 &raydir,
                                          int   maxtries = 10,
                                          float tmax = 1E17F,
                                          float *distance = 0,
                                          UT_Vector3 *nml=0) const;

    // If the method isn't known, or doesn't make sense, we return 0.
    virtual float        calcVolume(UT_Vector3 &refpt) const { return 0; }
    virtual float        calcArea() const { return 0; }
    virtual float        calcPerimeter() const { return 0; }

    // Is this primitive a GEO_Quadric?
    virtual bool         isQuadric() const { return false; }

protected:
    virtual void         copyOffsetPrimitive(const GEO_Primitive *src,
                                            int basept) = 0;
    void                 copyBasePrimitive(const GEO_Primitive *src,
                                            GEO_Point **ptredirect);
    void                 copyOffsetBasePrimitive(const GEO_Primitive *src,
                                            int basept);

private:
    friend class         GEO_Detail;    // Allow detail to get at private stuff

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

---