GB/GB_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:
 *      Cristin Barghiel
 *      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 __GB_Primitive_H__
#define __GB_Primitive_H__

#include "GB_API.h"
#include <iostream.h>
#include <UT/UT_BoundingBox.h>
#include <UT/UT_BoundingSphere.h>
#include "GB_Element.h"
#include "GB_Group.h"

class   UT_Vector3;
class   GB_Detail;
class   GB_Vertex;

class GB_API GB_Primitive : public GB_Element {
public:
    GB_Primitive(GB_Detail *d);
    virtual ~GB_Primitive();

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

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

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

    virtual void         untransform(void);

    virtual void         isolate(void);

    // By detaching a point we mean removing the vertices that use it. You may
    // want to call ifDetachPoint() first. ifDetachPoint() returns 
    //  0 if the primitive is not affected;
    //  1 if the point can be detached without degenerating the primitive;
    //  2 if we'd end up with a degenerate primitive;
    //  3 if we'd end up having to delete the primitive itself.
    // 
    // detachPoint() returns 0 if it has removed the vertex and -1 otherwise.
    // If you have called ifDetach point beforehand, you may want to pass its
    // result to detachPoint().
    virtual int          ifDetachPoint(GB_Element *ppt) const;
    virtual int          detachPoint  (GB_Element *ppt, int allVertices = 1);

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

    GB_Detail           *getBaseParent() const  { return parent; }

    virtual int          isPointUsed(GB_Element *pt) const = 0;

    virtual int          isPointGroupUsed(const GB_PointGroup &grp) const = 0;

    virtual unsigned     getVertexCount() const = 0;

    // Apply the function to each vertex of the primitive.  Break
    // when the function returns a non-zero value.  Return the value
    // of the last function applied (0 if never called).
    virtual int          vertexApply(int (*apply)(GB_Vertex &vtx, void *),
                                     void  *data = 0) = 0;
    virtual int          vertexApply(int (*apply)(const GB_Vertex &vtx, void *),
                                     void  *data = 0) const = 0;

    int                  memberOfAnyGroup(void);

protected:
    GB_Detail           *parent;        // Who I belong to

    // Methods for finding out about point references
    virtual void         pointDeleted  (GB_Element *)         = 0;
    virtual int          pointCanDelete(GB_Element *) const   = 0;


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

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

---