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>
#include <GA/GA_Handle.h>
#include <GA/GA_AttributeRef.h>
#include <GA/GA_Detail.h>

class GEO_Point;
class UT_BitArray;
class GEO_Primitive;
class GA_PointGroup;
class GA_PrimitiveGroup;
class GU_DisplayCache;
class GU_CacheParms;
class GU_RayIntersect;
class GU_ConvertParms;
class GU_RayInfoHit;
class GA_ROAttributeRef;
class GA_RWAttributeRef;

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,
                                         GA_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;

    // Compute normals on points using a subclass of NormalComp.  This
    // class receives the point offset and vertex normal at that point, and
    // will either add or subtract the normal from the existing data.
    class GU_API NormalComp {
    public:
        virtual ~NormalComp() {}
        virtual void    add(GA_Offset offset, const UT_Vector3 &nml) {}
        virtual void    sub(GA_Offset offset, const UT_Vector3 &nml) {}
    };

    // Compute point normals into an array, indexed by the point order
    // number
    class GU_API NormalCompArray : public NormalComp {
    public:
        NormalCompArray(const GA_Detail &gdp, UT_Vector3Array &output)
            : myGdp(gdp)
            , myOutput(output) {}
        virtual void    add(GA_Offset offset, const UT_Vector3 &nml)
        { myOutput(myGdp.pointIndex(offset)) += nml; }
        virtual void    sub(GA_Offset offset, const UT_Vector3 &nml)
        { myOutput(myGdp.pointIndex(offset)) -= nml; }

    private:
        const GA_Detail &myGdp;
        UT_Vector3Array &myOutput;
    };

    // Compute normals into a normal attribute
    class GU_API NormalCompAttr : public NormalComp {
    public:
        NormalCompAttr(const GA_RWAttributeRef &attr)
            : myAttr(attr)
            , myHandle(attr.getAttribute()) {}
        virtual void    add(GA_Offset offset, const UT_Vector3 &nml)
        { myHandle.add(offset, nml); }
        virtual void    sub(GA_Offset offset, const UT_Vector3 &nml)
        { myHandle.add(offset, -nml); }

        GA_RWHandleV3   &getHandle()    { return myHandle; }

    private:
        const GA_RWAttributeRef &myAttr;
        GA_RWHandleV3            myHandle;
    };

    virtual void        normal(NormalComp &output) const = 0;
    virtual void        clip(UT_Vector3 &nml, float d = 0, int normalize = 1,
                                GEO_Primitive *prim=0, 
                                GA_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);

    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 GA_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

---