GU/GU_Iso.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:        Geometry Utility Library (C++)
 *
 * COMMENTS:    The callbacks should return a "density".  A density greater
 *              than zero indicates that the point is inside the surface.  A
 *              density less than or equal to zero indicates that it's
 *              outside.
 */

#include "GU_API.h"
#include <UT/UT_Vector3.h>
#include <UT/UT_Assert.h>
#include <GEO/GEO_Point.h>

class GEO_Vertex;
class GU_Detail;
class GU_PrimPoly;
class UT_BoundingBox;

class GU_API ISO_Corner {
public:
    ISO_Corner()
    {
        myUserData = 0;
        myGdp = 0;
        myEdge[0] = myEdge[1] = myEdge[2] = 0;
    }
    ~ISO_Corner()
    {
        UT_ASSERT(!myUserData);
        freeVertexData();
    }

    void                 setDetail(GU_Detail *gdp);
    void                 freeVertexData();
    void                 clearPoints();
    GEO_Vertex          *getEdge(int idx)
                         {
                             if (!myEdge[0])
                                 allocateVertices();
                             return myEdge[idx];
                         }

    GU_Detail           *myGdp;
    void                *myUserData;    // User defined data block
    UT_Vector3           myPos;         // coordinates of the corner
    fpreal               myDensity;     // density less than zero means outside
    bool                 isInside;
private:
    void                 allocateVertices();
    GEO_Vertex          *myEdge[3];     // The three edge attributes
};

// Function to determine inside/outside tests.
typedef float   (*GU_IsoCallback)(const UT_Vector3 &pos);
typedef float   (*GU_IsoCornerFunc)(const ISO_Corner &corner);

class GU_API GU_IsoSurface {
public:
             GU_IsoSurface();
    virtual ~GU_IsoSurface();

    // There are two evaluators specified.  The first is used for simple corner
    // testing (i.e. inside/outside).  The second is used for computing the
    // edge intersections.  If the edge_eval function is not specified, the
    // corner_test function will be used.
    // The face evaluation is a general evaluator which is passed some point
    // within a volume (see below).
    void        setCallback(GU_IsoCallback   edge_eval,
                            GU_IsoCallback   face_eval = 0,
                            GU_IsoCornerFunc corner_test = 0);
    void        polygonize(GU_Detail *gdp, const UT_BoundingBox &box,
                           int xdivs, int ydivs, int zdivs);

    // Evaluate the functions - the proper preparation routines will have been
    // called
    virtual float       evalCorner(const ISO_Corner &c)
                        {
                            return (myCorner) ? myCorner(c) : myEdge(c.myPos);
                        }
    virtual float       evalEdge(const UT_Vector3 &pos) { return myEdge(pos); }
    virtual float       evalFace(const UT_Vector3 &pos) { return myFace(pos); }

    ISO_Corner  *getZ0()        { return myZ0; }
    ISO_Corner  *getZ1()        { return myZ1; }
    void         swapZ();

    // Indexed by 0=x 1=y 2=z
    int          getDivs(int idx)       { return myDivs[idx]; }

    // Prepare the evaluation function for a given edge between two corners
    // For example, given the point in space, the function may be different
    // than in another point in space (i.e. meta-ball evaluation).
    // This is used for computing the actual intersection point along an edge
    // of a box.  The two corners will lie on a dominant axis.
    virtual void        prepEvalFunc(ISO_Corner *c0, ISO_Corner *c1, int dir);

    // Prepare the face test evaluation function.  This function is passed two
    // opposing corners of a box.  The evaluation is guaranteed to be within
    // the bounds of the corners.
    virtual void        prepFaceFunc(ISO_Corner *c0[8]);

    // This function can be used to fill attribute information.  The position
    // of the point will be set to its final position when this function is
    // called.  The evalEdge() method will have just been used so that you can
    // use any information that would have been set up for this.
    virtual void        fillPointVertexAttributes(GEO_Vertex &vtx);

    // This function can be used to fill out primitive attribute information.
    virtual void        fillPrimitiveAttributes(GU_PrimPoly *poly);

protected:
    // Prepare for inside-outside tests for the corners in the array given.
    // The array contains (xdivs+1)*(ydivs+1) corners.  The positions of the
    // corners are already setup.
    virtual void        prepInsideOut(int xdivs, int ydivs, float z,
                                      ISO_Corner *array);


    // It's possible that the polygonizer may break the data into multiple
    // passes.  In this case, resetPass() is called before every pass except
    // the first one.
    virtual void        resetPass(const UT_BoundingBox &box);

    // After the slice has been evaluated, this is the cleanup call to allow
    // the user to free up any data which might have been allocated.
    // This may be called multiple times, so please ensure that you zero out
    // the data ptr in the corner when you're done.
    virtual void        cleanCorners(int xdivs, int ydivs, ISO_Corner *array);

    // Returns the size of each of the tiny boxes
    float       getXInc() const { return myXInc; }
    float       getYInc() const { return myYInc; }
    float       getZInc() const { return myZInc; }

private:
    void                fillArray(ISO_Corner *corner, float z);

    // We generate the polygons by moving the corner arrays through z-space
    // We simply swap the Z0 and Z1 arrays and re-fill the Z1 array for the
    // next step.
    int                  myDivs[3];
    float                myXInc, myYInc, myZInc;
    ISO_Corner          *myZ0, *myZ1;
    GU_IsoCornerFunc     myCorner;
    GU_IsoCallback       myEdge;
    GU_IsoCallback       myFace;
};

---