GU/GU_IsoMeta.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:
 *      Mark Elendt
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        GU_IsoMeta.h ( GU Library, C++)
 *
 * COMMENTS:    Fast meta-ball polygonization.
 *
 * CAVEATS:     The conversion can only happen once (i.e. it's not possible to
 *              convert multiple times since the data queue gets used up and
 *              needs to be re-initialized.
 */

#ifndef __GU_IsoMeta__
#define __GU_IsoMeta__
#include "GU_API.h"
#endif

#include "GU_Iso.h"
#include <UT/UT_BoundingBox.h>
#include <UT/UT_IntArray.h>
#include <GEO/GEO_AttributeHandle.h>
#include <GEO/GEO_AttributeHandleList.h>

class GB_PrimitiveGroup;
class GEO_Primitive;
class GEO_MetaPrim;
class TS_MetaExpression;

class gu_MetaCorner;

class GU_API GU_IsoMeta : public GU_IsoSurface {
public:
             GU_IsoMeta(GU_Detail *dest, GU_Detail *src,
                        GB_PrimitiveGroup *grp = 0);
             GU_IsoMeta(GU_Detail *dest, GU_Detail *src,
                        GEO_MetaExpression *expr);
    virtual ~GU_IsoMeta();

    void                        initData();
    const UT_BoundingBox        getBounds() const       { return myBox; }

    // This is the evaluator which should be used when evaluating points
    // The corner evaluator is optimized for evaluating at corners,
    // The general evaluator should be used for other evaluations.
    virtual float       evalCorner(const ISO_Corner &corner);
    virtual float       evalEdge(const UT_Vector3 &pt);
    virtual float       evalFace(const UT_Vector3 &pt);

private:
    void                clearAndDestroy(int fulldestroy = 1);

    virtual void        resetPass(const UT_BoundingBox &box);
    virtual void        prepEvalFunc(ISO_Corner *c0, ISO_Corner *c1, int dir);
    virtual void        prepFaceFunc(ISO_Corner *c0[8]);
    virtual void        prepInsideOut(int xdivs, int ydivs, float z,
                                      ISO_Corner *array);
    virtual void        cleanCorners(int xdivs, int ydivs, ISO_Corner *array);
    virtual void        fillPointVertexAttributes(GEO_Vertex &vtx);
    virtual void        fillPrimitiveAttributes(GU_PrimPoly *poly);
    unsigned            bumpSerial() { mySerial++; return mySerial; }

    // A recursive pruning function for meta expressions.  Takes an expression and
    // prunes it in to chunks each containing a certain number of corners.  The
    // purpose of this is to speed up density queries by reducing the number of
    // metaballs that are considered for each corner
    void                pruneRecursive(float zmin, float zmax, int xrow1, int xrow2, 
                                       int yrow1, int yrow2, TS_MetaExpression *expr,
                                       ISO_Corner *array, int xdivs, int ydivs,
                                       int max_corners = 30);
private:
    void                 construct(GU_Detail *dest, GU_Detail *src,
                                   GB_PrimitiveGroup *grp,
                                   GEO_MetaExpression *geoexpr);

    // Functions for allocating and deallocating gu_MetaCorners
    gu_MetaCorner       *allocCorner();
    void                 freeCorner(gu_MetaCorner *node);

    UT_BoundingBox       myBox;         // Bounding box for the set of balls
    unsigned             mySerial;      // My serial number counter

    GEO_AttributeHandleList      myVertexHandles;
    GEO_AttributeHandleList      myPrimitiveHandles;
    GEO_AttributeHandle          myN;
    TS_MetaExpression           *myExpr;
    TS_MetaExpression           *myActiveExpr;
    TS_MetaExpression           *myPrunedExpr;
    ISO_Corner                  *myActiveCorner[8];

    // Store a pool of corner objects to avoid repeatedly
    // allocating and deleting them for each slice.
    gu_MetaCorner       *myCornerHead;
    gu_MetaCorner       *myCornerTail;
};

---