GU/GU_Prim.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:
 *      Dale Ducharme
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        GU_Prim.h (C++)
 *
 * COMMENTS:    The GU_Prim class is a the base class for which all
 *              the primitive classes are subclassed off of.  Common 
 *              utility operations are done here like conversion from one
 *              primitive to another.
 * 
 */

#ifndef __GU_Prim_h__
#define __GU_Prim_h__

#include "GU_API.h"
#include <UT/UT_RefArray.h>
#include <UT/UT_Vector3Array.h>

class GEO_Point;
class UT_BitArray;
class GEO_Primitive;
class GB_PointGroup;
class GU_DisplayCache;
class GU_DisplayMesh;
class GU_CacheParms;
class GU_RayIntersect;
class GU_ConvertParms;
class GU_RayInfoHit;

class GU_API GU_Primitive
{
public:

    // Trivial constructor and destructor for now
    GU_Primitive() {} 
    virtual ~GU_Primitive();

    // Conversion Methods

    // This method converts the primitive to the specified toType and deletes
    // the old primitive. 

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

    // This method creates a new primitive by converting the old primitive to 
    // the specified toType.

    virtual GEO_Primitive       *convertNew(GU_ConvertParms &parms) = 0;

    virtual const GEO_Primitive *castToGeo(void) const = 0;

    virtual void        normal(const GB_AttributeRef &noff) const = 0;
    virtual void        normal(UT_Vector3Array &output) const = 0;
    virtual void        clip(UT_Vector3 &nml, float d = 0, int normalize = 1,
                                GEO_Primitive *prim=0, 
                                GB_PrimitiveGroup *clipgrp = 0);

    virtual int         intersectRay(const UT_Vector3 &o, const UT_Vector3 &d,
                                float tmax = 1E17F, float tol = 1E-12F,
                                float *distance = 0, UT_Vector3 *pos = 0,
                                UT_Vector3 *nml = 0, int accurate = 0,
                                float *u = 0, float *v = 0,
                                int ignoretrim = 1) const = 0;

    // Intersect this with the primitive.  Only defined for
    // faces (poly and curves), must be done this low as GU
    // does not have a GU_Face level.
    virtual int         intersect(GU_Primitive &prim, 
                                  UT_RefArray<GU_RayInfoHit> &hitList, 
                                  float tol = 0.01F, int ignoretrim=1);

    // Find minimum distance to a point:
    virtual int          minimum(const UT_Vector3 &p, float distmax = 1E17F,
                                 float *distance = 0, float *u = 0,
                                 float *v = 0, int accurate = 1);
    // Find minimum distance between two primitives:
    // (u1,v1) is place on this primitive, (u2,v2) is place on prim.
    virtual int          minimum(GU_Primitive &prim, float distmax = 1E17F,
                                 float *distance = 0, float *u1 = 0,
                                 float *v1 = 0, float *u2 = 0, float *v2 = 0,
                                 int accurate = 1);

    // Methods to handle caching.
    virtual GU_DisplayMesh      *getDisplayMesh(
                                        const GB_AttributeRef &noff,
                                        float lod);
    virtual GU_DisplayCache     *getDisplayCache(void) const;
    virtual int                  buildDisplayCache(GU_CacheParms &parms);

    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) = 0;

    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);
                                 
protected:
private:
};

#endif

---