GB/GB_Detail.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:
 *      This defines the detail class (the container for all points/primitives)
 *
 */

#ifndef __GB_Detail_h__
#define __GB_Detail_h__

#include "GB_API.h"
#include <iostream.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_Lock.h>
#include <UT/UT_Notifier.h>
#include "GB_Element.h"
#include "GB_ElementList.h"
#include "GB_GroupList.h"
#include "GB_Group.h"
#include "GB_Primitive.h"
#include "GB_Error.h"
#include "GB_Macros.h"

class UT_BoundingBox;
class UT_BoundingSphere;
class UT_Options;
class UT_IStream;
class GB_Vertex;
class GB_Primitive;
class GB_PrimGroupClosure;
class GB_AttributeDict;
class GB_AttributeHandleBase;
class GB_Breakpoint;
class GEO_Primitive;

#define GB_COPY_ONCE            0
#define GB_COPY_START           1
#define GB_COPY_ADD             2
#define GB_COPY_END             3

class GB_API GB_Detail {
public:
             GB_Detail(GB_ElementList *ptlist,GB_ElementList *primlist);
    virtual ~GB_Detail();

    //
    //  Clear all the points/primitives out of this detail
    //
    virtual void clearAndDestroy();

    //
    //  Stream I/O METHODS
    //
    virtual int  save(const char *, int binary,
                        const UT_Options *options) const = 0;
    virtual int  save(ostream& os, int binary,
                        const UT_Options *options) const = 0;
    virtual int  load(const char *, const UT_Options *options) = 0;
    virtual bool load(UT_IStream &is, const UT_Options *options) = 0;

    //
    //  Load and save a vertex. b is for binary.
    //
    virtual int  saveVertex(ostream &os,const GB_Vertex &vtx,int b) const;
    virtual bool loadVertex(UT_IStream &is, GB_Vertex &vtx);

    //
    // Insert a point element that has already been created.
    //
    GB_Element  *insertPointElem(GB_Element &pt, const GB_Element *prev = 0);

    // Find out if a point is being used by any primitive, or how many 
    // primitives (up to max or all if -1) use it:
    int                     isPointUsed(const GB_Element &p) const;
    int                  countPointUsed(const GB_Element &p, 
                                        int maxcount = -1) const;

    //
    //  DeleteFast assumes that there are no primitives referencing the pt
    //
    void                 deletePoint(GB_Element &p, unsigned deleteFast = 0)
                         { 
                             deletePoint((unsigned)p.getNum(), deleteFast);
                         }
    void                 deletePoint(unsigned int num, unsigned deleteFast=0);

    // return 1 if all the points deleted, 0 otherwise 
    // (causes degenerate primitives)
    int                 deletePoint(const GB_PointGroup &ptGrp,
                                     unsigned deleteFast = 0,
                                     bool remove_degenerate = false);

    //
    //  Methods for adding/deleting from the primitive list
    //  Insertion works the same way as insertion of points.  However,
    //  The primitive is not allocated since the type is determined
    //  by the allocator.
    //
    GB_Primitive        *insertPrimElem(GB_Primitive *prim, 
                                    const GB_Primitive *beforeWhich = 0,
                                    int cleargroups = 1);
    GB_Primitive        *appendPrimElem(GB_Primitive *prim,
                                    int cleargroups = 1)
                         {
                            return insertPrimElem(prim, 0, cleargroups);
                         }
    virtual void         deletePrimitive(GB_Primitive &p,int andpoints=0)
                         {
                            UT_ASSERT(p.getBaseParent() == this);
                            deletePrimitive((unsigned)p.getNum(), andpoints);
                         }
    virtual void         deletePrimitive(unsigned int num, int andpoints = 0);

    // Delete a whole group of primitives:
    virtual void         deletePrimitives(const GB_PrimitiveGroup &primGrp,
                                          int andpoints = 0);
    virtual void         deletePrimitives(const UT_PtrArray<GEO_Primitive*> &prims_in,
                                          int andpoints = 0);

    //
    //  Remove any unused points, and zero area polygons, zero volume
    //  spheres etc.
    //  If a primitive group is specified, then only primitives in that
    //  group are checked for degeneracy.
    //

    int          removeUnusedPointGroups();
    int          removeUnusedPrimGroups();
    void         removeUnusedGroups() 
                 {
                     removeUnusedPointGroups();
                     removeUnusedPrimGroups();
                 }
    int          removeUnusedPoints(const GB_PointGroup *ptgrp = 0);
    int          removeDegeneratePrimitives(const GB_PrimitiveGroup *prims=0,
                                        int andpoints = 0);
    void         removeUnused(const GB_PrimitiveGroup *prims = 0, const GB_PointGroup *ptgrp = 0)
                 {
                    removeDegeneratePrimitives(prims, 0);
                    removeUnusedPoints(ptgrp);
                 }

    // A virtual hook so that GEO_Detail can allocate GEO_Breakpoint for the
    // GB_BreakpointGroup::load() method.
    virtual GB_Breakpoint       *allocBreakpoint() const;


    //  Find the bounding box (optionally of a group of primitives)
    // instantiation. Return 0 if the box is empty and 1 otherwise.
    int                  getBBox     (UT_BoundingBox *bbox,
                                      const GB_PrimitiveGroup *g=0,
                                      const GB_PrimGroupClosure *c=0,
                                      bool closure_is_hidden = true) const;
    /// Find the bounding box (optionally of a group of primitives) of transformed
    /// instantiation. Return 0 if the box is empty and 1 otherwise.
    int                  getBBox     (UT_BoundingBox& bbox, const UT_Matrix4& transform,
                                      const GB_PrimitiveGroup *g=0,
                                      const GB_PrimGroupClosure *c=0,
                                      bool closure_is_hidden = true) const;
    int                  getBSphere  (UT_BoundingSphere *bsphere,
                                      const GB_PrimitiveGroup *g=0,
                                      int updateRequired = 0,
                                      const GB_PrimGroupClosure *c=0,
                                      bool closure_is_hidden = true) const;
    virtual int          getPointBBox(UT_BoundingBox *bbox,
                                      const GB_PointGroup *g=0) const = 0;

    virtual int          getPointBBox(UT_BoundingBox& bbox, const UT_Matrix4& transform,
                                      const GB_PointGroup *g=0) const = 0;

    virtual int          getPointBSphere(UT_BoundingSphere *bsphere,
                                      const GB_PointGroup *g=0,
                                      int updateRequired = 0) const = 0;

    // Create a new point or primitive group. These methods are wrappers
    // around GB_GroupList::newGroup() meant to hide the size information.

    GB_PointGroup       *newPointGroup(const char *name, int internal = 0)
                         {
                             return (GB_PointGroup*)ptGroups.newGroup(name,
                                                                internal);
                         }
    void                 destroyPointGroup(GB_PointGroup *grp)
                         {
                             ptGroups.destroy(grp);
                             if (grp == myHomogGroup) myHomogGroup = 0;
                         }
    void                 destroyPointGroup(const char *name)
                         {
                             GB_PointGroup *grp = (GB_PointGroup *)
                                                        ptGroups.find(name);
                             if (grp)
                             {
                                 ptGroups.destroy(grp);
                                 if (grp == myHomogGroup) myHomogGroup = 0;
                             }
                         }
    GB_PointGroup       *findPointGroup(const char *name) const
                         {
                             return (GB_PointGroup*)ptGroups.find(name);
                         }


    GB_PrimitiveGroup   *newPrimitiveGroup(const char *name, int internal = 0)
                         {
                             return (GB_PrimitiveGroup*)primGroups.newGroup(
                                                        name, internal);
                         }
    void                 destroyPrimitiveGroup(GB_PrimitiveGroup *grp)
                         {
                             primGroups.destroy(grp);
                         }
    void                 destroyPrimitiveGroup(const char *name)
                         {
                             primGroups.destroy(primGroups.find(name));
                         }
    GB_PrimitiveGroup   *findPrimitiveGroup(const char *name) const
                         {
                             return (GB_PrimitiveGroup*)primGroups.find(name);
                         }

    void                 destroyGroup(GB_BaseGroup *grp);

    // Get (create if necessary) an internal groups dedicated to storing
    // homogeneous point flags:
    GB_PointGroup       *getHomogeneousGroup(void)
                         {
                             if (!myHomogGroup)
                             {
                                 myHomogGroup = (GB_PointGroup*)
                                    ptGroups.newGroup("_gb_homogpoints_",1);
                             }
                             return myHomogGroup;
                         }

    // Copy a point or primitive group. You must pass a reference to the group
    // you want copied and give the new name of the copy.
    GB_PointGroup       *copyGroup(const GB_PointGroup &grp, const char *name);
    GB_PrimitiveGroup   *copyGroup(const GB_PrimitiveGroup &grp,
                                   const char *name);

    // Attempt to "copy" groups from one detail to another. This method
    // simply runs through both detail element lists and copies over the
    // group status from one detail to the other. If override is non-zero,
    // existing groups with the same names as src groups are cleared,
    // otherwise existing groups are not affected by the merge. The
    // status (ordered/unordered, internal/external) of the source group
    // is also copied.
    void                 mergeGroups(const GB_Detail &src, int override = 1);
    GB_PointGroup       *mergeGroup(const GB_Detail &src,
                                    const GB_PointGroup &group,
                                    int override = 1);
    GB_PrimitiveGroup   *mergeGroup(const GB_Detail &src,
                                    const GB_PrimitiveGroup &group,
                                    int override = 1);

    // Query the internal structures:
    GB_GroupList        &pointGroups()                  { return ptGroups;   }
    GB_GroupList        &primitiveGroups()              { return primGroups; }

    const GB_GroupList  &pointGroups() const            { return ptGroups;   }
    const GB_GroupList  &primitiveGroups() const        { return primGroups; }

    GB_ElementList      &basePoints()                   { return ptList;     }
    GB_ElementList      &basePrims ()                   { return primList;   }

    const GB_ElementList        &basePoints() const     { return ptList;     }
    const GB_ElementList        &basePrims () const     { return primList;   }

    // Get the file version:
    int                  getVersion(void) const         { return myVersion;  }
    int                  getUniqueId() const            { return myUniqueId; }

    //
    //  Renumber the lists, optionally, the renumbering can start at the
    //  point/primitive specified.
    //
    void                 renumberPoints(int start = 0);
    void                 renumberPrimitives(int start = 0);

    /// Registers a GB_AttributeHandleBase with a detail. Should only be called
    /// by GB_AttributeHandleBase constructors and operator=.
    void                 registerAttributeHandle(
                                    GB_AttributeHandleBase *gah) const;
    
    /// Releases the GB_AttributeHandleBase from the detail's list.  Should only
    /// be called by GB_AttributeHandleBase destructor.
    void                 unregisterAttributeHandle(
                                    GB_AttributeHandleBase *gah) const;

    UT_NotifierImpl<GB_Element *> &edgeGroupNotifier() const { return myEdgeGroupNotifier; }

protected:
    GB_ElementList      &ptList;        // list of points
    GB_ElementList      &primList;      // list of primitives

    // The "prim" will replace the "prev" in the list of primitives.  The
    // "prev" primitive will be destroyed (without destroying points)
    // This is only called during a fastMerge() when we're replacing primitives
    // from the recycle bin.  This code makes some assumptions about this.
    GB_Primitive        *replacePrimElem(GB_Primitive *prim, 
                                    GB_Primitive *axeme,
                                    int cleargroups);

    // Get or set the file version.
    int                  getLatestVersion(void) const;
    void                 setVersion(int v)              { myVersion = v;     }

    //
    //  Insert the point into the point list and update the point groups.
    //
    GB_Element          *attachPoint(GB_Element &crt,const GB_Element *prv=0);

    //
    // Save and load all the primitives. Return 0 if OK, -1 if error.
    //
    int                  savePrimitives(int n, ostream &os, int binary) const;
    bool                 loadPrimitives(int n, UT_IStream &is);

    //
    //  Save and load the group information:
    //
    int                  saveGroups(ostream& os, int binary,
                                    bool savepointgroups,
                                    bool saveprimgroups) const;
    bool                 loadGroups(UT_IStream& is, int nptgrps, int nprimgrps);

    // Clear the groups of a primitive:
    void                 clearAllGroups(GB_Primitive &prim);
    //
    //  Figure out what type of geo file we're dealing with:
    //
    int                  checkMagic(UT_IStream &is) const;
    int                  asciiMagic(void) const
                         {
                             return (('P'<<24) + ('G'<<16) + ('E'<<8) + 'O');
                         }
    int                  binaryMagic(void) const
                         {
                             return (('B'<<24) + ('g'<<16) + ('e'<<8) + 'o');
                         }
    //
    // Create a primitive of a specific type:
    //
    virtual GB_Primitive *appendNewPrimitive(unsigned type) = 0;

    // Primitive type and name:
    virtual unsigned     getPrimitiveType(const char *name) const       = 0;
    virtual const char  *getPrimitiveName(unsigned type) const          = 0;

    //
    // These methods are used to flag a more efficient way of 
    // copying ourselves from another without invoking excessive 
    // memory management
    //

    int                  useRecycledData() const
                         { return myUseRecycledData; }
    void                 useRecycledData(int yesno) 
                         { myUseRecycledData = yesno; }

    /// Transforms the given bbox by a given matrix, and computes a new bounding
    /// box around all the points of the transformed input bbox. Puts the result
    /// into bbox_out.
    void                 getTransformedBBoxBBox(const UT_BoundingBox& bbox, 
                                                const UT_Matrix4& transform, 
                                                UT_BoundingBox& bbox_out) const;

private:
    void                 mergeGroup(GB_ElementList &destList,
                                    GB_Group &destGroup,
                                    const GB_ElementList &srcList,
                                    const GB_Group &srcGroup);

    GB_PointGroupList    ptGroups;      // list of groups of points
    GB_PrimGroupList     primGroups;    // list of groups of primitives

    GB_PointGroup       *myHomogGroup;  // homogeneous point group

    mutable UT_NotifierImpl<GB_Element *> myEdgeGroupNotifier;

    int                  myVersion;     // file version

    int                  myUniqueId;
    int                  myUseRecycledData;

    mutable UT_PtrArray<GB_AttributeHandleBase *>       myAttributeHandles;

    mutable UT_Lock      myAttribHandleLock;

};

#endif

---