GEO/GEO_PrimPasteDAG.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:
 *      Cristin Barghiel
 *      Side Effects Software Inc.
 *      477 Richmond Street West
 *      Toronto, Ontario  
 *      Canada   M5V 3E7
 *      416-504-9876      
 *
 * NAME:        Geometry Library (C++)
 *
 * COMMENTS:    Paste surface class.
 *
 */

#ifndef __GEO_PrimPasteDAG_h__
#define __GEO_PrimPasteDAG_h__

#include "GEO_API.h"
#include "GEO_PasteSurfDAG.h"
#include "GEO_Primitive.h"

class GB_PrimitiveGroup;
class GEO_AttributeHandleList;


class GEO_API GEO_PrimPasteDAG : public GEO_Primitive, public GEO_PasteSurfDAG
{
public:
                 GEO_PrimPasteDAG(GEO_Detail *d);
    virtual     ~GEO_PrimPasteDAG();

    virtual unsigned     getPrimitiveId() const;
    virtual int          isDegenerate() const;

    virtual int          save(ostream &os, int binary) const;
    virtual bool         load(UT_IStream &is);
    virtual int          getBBox(UT_BoundingBox *bbox) const;
    virtual void         addToBSphere(UT_BoundingSphere *bsphere) const;
    virtual UT_Vector3   baryCenter() const;
    virtual UT_Vector3   computeNormal() const;
    virtual void         reverse();

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

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

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

    virtual unsigned     getVertexCount() const;

    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;

    virtual int          isPrimary(void) const;

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

    // 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;
    // and vice versa
    virtual void         unitToRealPair(float  uunit, float  vunit,
                                        float &ureal, float &vreal) const;

    // 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 bool         evaluatePoint(GEO_Vertex &result,
                                        GEO_AttributeHandleList &hlist,
                                        fpreal u, fpreal v,
                                        unsigned du, unsigned 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;
    virtual int          evaluateNormalVector(UT_Vector3 &nml, float u,
                                        float v = 0) const;

    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;

    // Tell the dag it's obsolete. This will happen when the dag has been
    // pasted onto some other dag, and should be deleted. This method clears
    // the nodes and deletes "this", so don't use the dag thereafter.
    virtual void         obsolete(void);

    // Remove all the references to GEO_TPSurf and clear.
    virtual void         isolate(void);

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

    // Add all the TPSurfs to the given group. We DON'T CLEAR the group first.
    void                 toGroup(GB_PrimitiveGroup &surfgroup) const;

    // Resolve all the load links: parenting of domains and their frames,
    // base surfaces, CV displacements, pointers to TPSurf, etc. Return 0
    // if OK and -1 otherwise. Call this method only after loading the gdp.
    int                  resolveLinks(void);

    // Resolve the remaining copy links, ie. the pointers to the spline
    // surfaces. What we carry now is the indices of the spline primitives
    // in the source DAG. Return 0 if all resolved, -1 otherwise.
    int                  resolveSplines(int primoffset, int maxprims);
    int                  resolveSplines(GEO_Detail &srcgdp, 
                                        GEO_Primitive **primredirect);

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

protected:
    // Methods for finding out about point references
    virtual void         pointDeleted  (GB_Element *);
    virtual int          pointCanDelete(GB_Element *) const;
    
    virtual void         copyOffsetPrimitive(const GEO_Primitive *src,
                                             int basept);

private:

    char                 myStashedState;
};

#endif

---