GD/GD_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 __GD_Detail_h__
#define __GD_Detail_h__

#include "GD_API.h"
#include <UT/UT_PtrArray.h>
#include <UT/UT_BoundingRect.h>
#include <GB/GB_Detail.h>
#include "GD_Point.h"
#include "GD_Primitive.h"
#include "GD_PointList.h"
#include "GD_PrimList.h"
#include "GD_Macros.h"

#include <UT/UT_VectorTypes.h>
class GD_Vertex;
class GD_TrimRegion;
class GD_TrimLoop;

class GD_API GD_Detail : public GB_Detail
{
public:
             GD_Detail();
    virtual ~GD_Detail();

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

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

    //
    //  Merge the source detail into us.
    //
    void                 merge      (const GD_Detail &src,
                                     int              onlyvisible = 0);
    void                 mergePoints(const GD_Detail &src);

    //
    // Transform/translate all or some of the primitives. The methods will run
    // more efficiently if you happen to know the point closure apriori.
    // If 'quickxform' is true, we don't transform the attributes and don't
    // check for reflection matrix.
    //
    void         transform(const UT_Matrix3     &matx,
                           GB_PrimitiveGroup    *primgroup    = 0,
                           GB_PointGroup        *pointclosure = 0);
    void         translate(const UT_Vector2     &delta,
                           GB_PrimitiveGroup    *primgroup    = 0,
                           GB_PointGroup        *pointclosure = 0);

    //
    // Transform/translate all or some of the points.
    //
    void         transformPoints(const UT_Matrix3  &matx,
                                 GB_PointGroup     *pointgroup  = 0);
    void         translatePoints(const UT_Vector2  &delta,
                                 GB_PointGroup     *pointGroup  = 0);

    //
    // Methods for adding to the point list. The methods that
    // take an attribute data reference "steal" the data pointer and set
    // adata's data pointer to zero.
    //
    GD_Point            *insertPoint(const GD_Point *before = 0);
    GD_Point            *appendPoint() { return insertPoint(0); }
    GD_Point            *insertPoint(const UT_Vector3 &pos, 
                                     const GD_Point *before = 0);
    GD_Point            *appendPoint(const UT_Vector3 &pos)
                         { return insertPoint(pos); }

    //
    //  Inserting and appending a new primitive
    //  Insertion works the same way as insertion of points.  However,
    //  The primitive is not allocated since the type is determined
    //  by the allocator.
    //
    GD_Primitive        *insertPrimitive(unsigned type,
                                         const GD_Primitive *before = 0);
    GD_Primitive        *appendPrimitive(unsigned type)
                         {
                            return insertPrimitive(type, 0);
                         }
    GD_Primitive        *insertPrimitive(GD_Primitive *prim,
                                         const GD_Primitive *before = 0);
    GD_Primitive        *appendPrimitive(GD_Primitive *prim)
                         {
                            return insertPrimitive(prim, 0);
                         }
    virtual void         deletePrimitive(GB_Primitive &p,  int andpoints = 0);
    virtual void         deletePrimitive(unsigned int num, int andpoints = 0);

    //
    // Appending and deleting a trimming region:
    //
    // opencasual true will preserve direction of open profiles.
    GD_TrimRegion       *appendTrimRegion(int opencasual = 0);
    void                 deleteTrimRegion(GD_TrimRegion &region);
    void                 deleteTrimRegion(unsigned int num);
    GD_TrimLoop         *generateTrimLoops(const UT_BoundingRect &brect,
                                            float offset=1e-4F, 
                                            float tol=1e-4F);
    void                 destroyTrimRegions(int deletecurves=1);
    void                 createTrimRegion(GD_TrimLoop *loop);


    //
    //  Find the bounding box (optionally of a group of points)
    // instantiation. Return 0 if the box is empty and 1 otherwise.
    //
    virtual int          getPointBBox(UT_BoundingBox *bbox,
                                      const GB_PointGroup *g = 0) const;
    virtual int          getPointBBox(UT_BoundingBox& bbox, const UT_Matrix4& transform,
                                      const GB_PointGroup *g=0) const;
    virtual int          getPointBSphere(UT_BoundingSphere *bsphere,
                                      const GB_PointGroup *g = 0,
                                      int updateRequired = 0) const;

    //
    // Return the bounds of the valid interval of the surface we're defined
    // for.
    //
    virtual void         getDomainBBox(float &u0, float &v0,
                                       float &u1, float &v1) const = 0;

    // Return the number of (visible) faces.
    int                  getNumFaces(int *visible = 0) const;

    // Find out if it is a valid trimmer. At least one trim loop must have 
    // already been computed from the trim regions for this method to return
    // true.
    int                  hasTrimLoops(void) const;

    // Find out if there are any trim regions. A short-cut for
    // trimRegions().entries().
    int                  hasTrimRegions(void) const;

    // *Const* handle to the trimming regions:
    const UT_PtrArray<GD_TrimRegion*> &trimRegions(void) const
                         { return myTrimRegions; }

    // Build an outer trim loop to allow us to punch holes into the surface.
    // Return loop if OK and 0 otherwise. The method does not check if the 
    // outer loop already exists. The size of the loop will be increased by
    // the tolerance. The direction of the loop is counter-clockwise.
    GD_TrimRegion       *appendOuterLoop(float tol = 0, int checkduplicate = 1);

    // Get or set the altitude flag, which affects the level where we start
    // counting the nested loops for trimming. Typically, it's sea-level: zero.
    int                  altitude(void ) const  { return myAltitude; }
    void                 altitude(int a)        { myAltitude = a;    }

    // Query the internal structures:
    GD_PointList        &points()       { return (GD_PointList&)ptList;       }
    GD_PrimList         &primitives()   { return (GD_PrimList&) primList;     }
    const GD_PointList  &points() const { return (const GD_PointList&)ptList; }
    const GD_PrimList   &primitives() const
                         { return (const GD_PrimList&)primList; }
    // The trimming regions:
    UT_PtrArray<GD_TrimRegion*> &trimRegions(void) { return myTrimRegions; }

protected:
    virtual GD_Primitive *newPrimitive(unsigned type);

    // Create a primitive of a specific type:
    virtual GB_Primitive *appendNewPrimitive(unsigned type);

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

    // Not needed, but they are abstract in the base class.
    virtual int  save(const char *, int binary,
                            const UT_Options *options) const;
    virtual int  load(const char *, const UT_Options *options);

private:
    UT_PtrArray<GD_TrimRegion*>  myTrimRegions; // list of trim regions
    int                          myAltitude;    // sea-level for nested loops

    // Load and save the list of trimming regions:
    bool                 loadTrimRegions(int n, UT_IStream &is);
    int                  saveTrimRegions(int n, ostream &os, int b=0) const;

    //  Friends:
    friend ostream      &operator<<(ostream &os, const GD_Detail &d)
                        {
                            d.save(os, 0, 0);
                            return os;
                        }
};

#endif

---