GU/GU_Brush.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:
 *      Jeff Lait
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        GU_Brush.h ( GU Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GU_Brush__
#define __GU_Brush__

#include "GU_API.h"
#include <UT/UT_Color.h>
#include <UT/UT_BitArray.h>
#include <UT/UT_Vector3Array.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_IntArray.h>
#include <UT/UT_FloatArray.h>
#include <UT/UT_RefArray.h>

#include <GEO/GEO_Delta.h>
#include <GEO/GEO_Detail.h>

class GB_PrimitiveGroup;
class GB_PointGroup;
class GEO_Delta;
class GU_Detail;
class GEO_Primitive;
class GEO_Point;
class GEO_PointTree;
class GEO_Vertex;
class GEO_Hull;

class GU_API GU_StencilPixel
{
public:
    int         idx;            // Which point this is.
    float       val;            // Stencil value
};


enum GU_BrushStencilMode {
    GU_BRUSHMERGEMODE_NONE,
    GU_BRUSHMERGEMODE_POINT,
    GU_BRUSHMERGEMODE_VERTEX
};


//
// GU_BrushStencil abstracts a per point or per vertex stencil.
// This stencil has a current value of 0 .. 1 for every point or vertex
// in the gdp.
//
// Stencils are in one of two modes: point or vertex; which determines the
// native mode of the stencil.
//
class GU_API GU_BrushStencil
{
public:
             GU_BrushStencil();
    virtual ~GU_BrushStencil();
    
    void                clearStencil();
    bool                isEmpty() const;

    // These will clear out the stencil as well if the mode changes.
    void                setVertexMode();
    void                setPointMode();
    bool                isVertexMode() const;
    bool                isPointMode() const;

    void                setPointVal(int ptidx, float val, float alpha);
    void                setVertexVal(int vtxidx, float val, float alpha);

    void                setPointVal(int ptidx, float val, 
                                    const UT_Vector3 &colour, float alpha);
    void                setVertexVal(int vtxidx, float val, 
                                    const UT_Vector3 &colour, float alpha);

    void                startPointIterate();
    bool                iteratePoint(int &ptidx, float &alpha);
    bool                iteratePoint(int &ptidx, float &alpha, UT_Vector3 &color);

    void                startVertexIterate();
    bool                iterateVertex(int &vtxidx, float &alpha);
    bool                iterateVertex(int &vtxidx, float &alpha, UT_Vector3 &color);

    // These are used to ensure we can convert between vertex & point
    // iterators
    void                setVtxTables(UT_PtrArray<UT_IntArray *> *pt2vtx, 
                                     UT_PtrArray<const GEO_Vertex *> *vtx,
                                     const GU_Detail *gdp);

protected:
    // The actual entries of the stencil
    UT_RefArray<GU_StencilPixel>         myEntries;

    // This has for each of our type (whether vertex or point) the stencil
    // which corresponds to it.
    UT_IntArray                          myStencilRef;

    // This is any array, one per point, which allows us to avoid
    // double counting points in a point iterate.
    UT_IntArray                          myPointPass;
    
    // This is the unpremultiplied stencil colour.
    UT_Vector3Array                      myColours;

    UT_PtrArray<UT_IntArray *>          *myPt2Vtx;
    UT_PtrArray<const GEO_Vertex *>     *myVtx;
    const GU_Detail                     *myGdp;

    // We are either a vertex stencil or point stencil:
    GU_BrushStencilMode                  myMode;

    // Iterator information:
    int                                  myCurPixel, myCurSubIdx;
    int                                  myCurIteratePass;
    bool                                 myCurIsVertexIterate;
};

typedef void (*GU_BrushMergeModeCallback)(GEO_Point *pt, GEO_Vertex *vtx,
                    UT_Vector3 &result,
                    const UT_Vector3 &cd, const UT_Vector3 &orig, void *data);

typedef void (*GU_BrushCallback)(GEO_Point *pt, 
                    const UT_PtrArray<const GEO_Point *> *ptneighbour, 
                    GEO_Vertex *vtx,
                    const UT_PtrArray<const GEO_Vertex *> *vtxneighbour,
                    GEO_Primitive *vtx_prim, int prim_vtx_idx,
                    float alpha, GEO_Delta *delta, void *data);

// This must match the order in the SOP.
enum GU_BrushMergeMode {
    GU_BRUSHMERGEMODE_REPLACE,
    GU_BRUSHMERGEMODE_ADD,
    GU_BRUSHMERGEMODE_SUB,
    GU_BRUSHMERGEMODE_MULT,
    GU_BRUSHMERGEMODE_SCREEN,
    GU_BRUSHMERGEMODE_HUE,
    GU_BRUSHMERGEMODE_SAT,
    GU_BRUSHMERGEMODE_LIGHT,
    GU_BRUSHMERGEMODE_RED,
    GU_BRUSHMERGEMODE_GREEN,
    GU_BRUSHMERGEMODE_BLUE,
    GU_BRUSHMERGEMODE_INVERT,
    GU_BRUSHMERGEMODE_CALLBACK
};

class GU_BrushNib;

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

    // These create and destroy all the cached structures which
    // describe the topology of the geometry.
    void                 buildCaches(GU_Detail *gdp, const GU_Detail *isectgdp,
                                    const GB_PrimitiveGroup *group,
                                    const GB_PointGroup *ptgroup,
                                    int usevisibility);
    // This makes the myVtxClass valid.
    void                 buildVertexClasses();
    void                 clearCaches();
    // This lets you check to see if the brush has a valid cache built yet.
    bool                 hasValidCache() { return myPointTree ? true : false; }

    // These allow you to tell it what name to use for custom attributes:
    // They return true if they successfully found the attribute, and false
    // otherwise.
    bool                 overrideColour(const char *name);
    bool                 overrideAlpha(const char *name);
    bool                 overrideNml(const char *name);

    // This tells it to use a capture region as the colour.
    void                 useCaptureRegion(int captureidx, int normalizeweight,
                                          GEO_Detail::CaptureType capturetype 
                                                    = GEO_Detail::CAPTURE_BONE);

    // These retrieve the default colour and alpha:
    // They return non-zero if they added an attribute.
    int                  defaultColour(bool create = 0);
    int                  defaultAlpha(bool create = 0);
    int                  defaultNormal(bool create = 0);
    int                  defaultTexture(bool create = 0);

    // This deals with the visualization colour.
    // Initializes it:
    void                 visualizeColor(float low, float high, 
                                        UT_ColorRamp mode);
    int                  doVisualize() const { return myVisualizeOffset >= 0; }
    void                 setVisualizeCd(GEO_Point *pt, const UT_Vector3 &cd);
    void                 clearVisualize() { myVisualizeOffset = -1; }
    void                 applyVisualize(GU_Detail *gdp);
    void                 applyVisualizeStencil(GU_Detail *gdp);

    // Retrieves the colour of a point taking overrides into account.
    void                 getPointCd(const GEO_Point *pt, UT_Vector3 &cd) const;
    void                 getVertexCd(const GEO_Vertex *vtx, UT_Vector3 &cd) const;

    // These update just the GEO_PointTrees that control where
    // the points are.
    void                 addPrimPoints(const GEO_Primitive *prim, 
                            UT_BitArray &ptused,
                            UT_Vector3Array &pts, UT_IntArray &idxlist);
    void                 buildTrees(int usevisibility);
    void                 addUVPrimPoints(const GEO_Primitive *prim,
                            int uvoffset,
                            UT_BitArray &ptused,
                            UT_Vector3Array &uvpts, UT_IntArray &idxlist);
    void                 buildUVTrees(int usevisibility);
    void                 destroyTrees();
    GEO_PointTree       *getPointTree() { return myPointTree; }
    GEO_PointTree       *getUVPointTree() { return myUVPointTree; }

    // These are the ring zero caches, marking neighbours in point topology.
    void                 connectRingPts(const GEO_Point *pt1, 
                                        const GEO_Point *pt2,
                                        bool doublevalence = false);
    void                 connectRingVtx(int vtxnum, 
                                        const GEO_Vertex *vtx2,
                                        bool doublevalence = false);
    void                 addToRingCache(GEO_Primitive *prim);
    void                 buildRingCache(int usevisibility);
    void                 clearRingCache();

    // Stencil controls:

    // Determines if we try to blend the alpha or just the colour.
    void                 setWriteAlpha(int val) { myWriteAlpha = val; }
    int                  getWriteAlpha() const { return myWriteAlpha; }
    // Returns if there is anything in the stencil buffer.
    int                  hasStencil() const;
    // Zeros out the stencil - MUST be done if the geometry changes!
    void                 clearStencil();
    // Sets the callback for the callback merge mode type.
    void                 setMergeModeCallback(GU_BrushMergeModeCallback cb,
                                        void *data)
                         {
                             myMergeModeCallback = cb;
                             myMergeModeCallbackData = data;
                         }
    // Applies a merge mode:
    void                 applyMergeMode(GEO_Point *pt, GEO_Vertex *vtx, 
                            UT_Vector3 &result, 
                            const UT_Vector3 &src, const UT_Vector3 &dst, 
                            GU_BrushMergeMode mergemode);
    // Sets entire stencil to a specific alpha:
    void                 setStencil(float val, int usevisibility);
    // Colour according to the stencil:
    void                 colourStencil(GEO_Delta *delta, const UT_Vector3 &cd,
                                        GU_BrushMergeMode mergemode);
    // Colour according to the stencil & the stencil colours:
    void                 stampColourStencil(GEO_Delta *delta, 
                                        GU_BrushMergeMode mergemode);

    void                 callbackStencil(GEO_Delta *delta, 
                                        GU_BrushCallback cb, void *data);
    // Comb the normals.
    // Lift is the amount to raise the comb above or below the tangent
    // plane.
    void                 combNormals(GEO_Delta *delta, const UT_Vector3 &dir,
                                     float lift, int preservenmllen);

    void                 dragTexture(GEO_Delta *delta, const UT_Vector3 &dir);
    void                 scaleTexture(GEO_Delta *delat, float scale, 
                                      const UT_Vector3 &orig);
    
    // Displace points along their normals
    void                 displaceNormals(GEO_Delta *delta, float amt);
    // Displace points along a specified vector:
    void                 displaceVector(GEO_Delta *delta, 
                                const UT_Vector3 &dir, float amt);
    // Smooths all the points for one iteration...
    void                 smoothPoints(GEO_Delta *delta);
    // Smooths the current point attribute for one iteration.
    void                 smoothAttribute(GEO_Delta *delta);
    // Smooths teh normals keeping them normalized.
    void                 smoothNormals(GEO_Delta *delta, int preservenmllen);
    // Smooths the current texture attribute for one iteration.
    void                 smoothTexture(GEO_Delta *delta);

    // This undoes the specified delta, putting the changes into
    // the second delta
    void                 eraseAttributes(GEO_Delta *old, GEO_Delta *change);
    void                 erasePositions(GEO_Delta *old, GEO_Delta *change);
    void                 eraseCapture(GEO_Delta *old, GEO_Delta *change);

    // In UV mode, it will find the closest point to the origin
    // Returns -1 on failure.
    int                  findUVSeedPtNum(const UT_Vector3 &orig);

    // This applies a single dab to the stencil.
    // The seed primitive is a primitive in the ISECT gdp, as is the seedpt
    void                 applyDab(GU_BrushNib *nib, float stencil_val,
                                const UT_Vector3 &orig, const UT_Vector3 &dir,
                                float rad,
                                const GEO_Primitive *seed,
                                const GEO_Point *seedpt,
                                bool useconnectivity,
                                bool inuv);

    // Returns cached normal value of a primitive.
    void                 getNormal(int primidx, UT_Vector3 &nml);

    void                 getPtNormal(int ptidx, UT_Vector3 &nml);
    // Resets all the normals:
    void                 clearNormalCache();

private:        
#ifdef INTEL_COMPILER
         GU_Brush(const GU_Brush& ) { }
#endif
        
protected:
    int                  testPrimitive(const GEO_Primitive *test, 
                                const UT_Vector3 &orig, const UT_Vector3 &dir,
                                float radius2, int seeddir);
    int                  testPoint(int ptnum, 
                                const UT_Vector3 &orig, const UT_Vector3 &dir,
                                float radius2, int seeddir);
    void                 evaluateHullsNormal(const GEO_Hull *hull);
    bool                 isPointEditable(int ptnum);
    
    const GB_PrimitiveGroup     *myGroup;
    const GB_PointGroup *myPointGroup;
    GU_Detail           *myGdp;
    const GU_Detail     *myIsectGdp;

    UT_BitArray          myNmlSet;
    UT_Vector3Array      myNmlCache;
    UT_BitArray          myPtNmlSet;
    UT_Vector3Array      myPtNmlCache;

    GEO_PointTree       *myPointTree;
    GEO_PointTree       *myUVPointTree;
    UT_Vector3Array      myPointPos;
    UT_Vector3Array      myUVPointPos;

    UT_PtrArray<UT_PtrArray<const GEO_Primitive *> *>   myPt2Prim;
    UT_PtrArray<const GEO_Vertex *>                     myIsectVtx;
    UT_PtrArray<GEO_Vertex *>                           myGeoVtx;
    UT_PtrArray<GEO_Primitive *>                        myVtx2Prim;
    UT_IntArray                                         myVtx2PrimIdx;
    UT_PtrArray<UT_IntArray *>                          myPt2Vtx;

    // This assigns each vertex to a unique number depending on
    // its texture coordinate & point number.  Thus, vertices with
    // matching texture coordinates & point numbers will have
    // the same class.
    UT_IntArray                                         myVtxClass;
    
    // First ring of each point...
    UT_PtrArray<UT_PtrArray<const GEO_Point *> *> myRingZero;
    // This is the number of edges attached to each point ring.
    // If it is less than twice the myRingZero.entries(), we have
    // a boundary point.
    UT_IntArray                                   myRingValence;

    UT_PtrArray<UT_PtrArray<const GEO_Vertex *> *> myVtxRingZero;
    UT_PtrArray<UT_IntArray *>                    myVtxRingClass;
    
    int                  myColorOffset;
    int                  myColorSize;
    bool                 myColorVertex;
    int                  myAlphaOffset;
    bool                 myAlphaVertex;
    int                  myTextureOffset;
    int                  myTextureSize;
    bool                 myTextureVertex;
    int                  myNormalOffset;
    int                  myVisualizeOffset;
    float                myVisLow, myVisHigh;
    UT_ColorRamp         myVisMode;
    int                  myWriteAlpha;
    int                  myCaptureOffset, myCaptureIdx, myNormalizeWeight;
    GEO_Detail::CaptureType myCaptureType;
    bool                 myUseVisibility;

    GU_BrushMergeModeCallback    myMergeModeCallback;
    void                        *myMergeModeCallbackData;

private:
    GU_BrushStencil                     myStencil;
};

#endif

---