SOP/SOP_BrushBase.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,  M5V 3E7
 *      Canada
 *      416-504-9876
 *
 * NAME:        SOP Library (C++)
 *
 * COMMENTS: This is the base class for all brushes.
 *
 */

#ifndef __SOP_BrushBase_h__
#define __SOP_BrushBase_h__

#include "SOP_API.h"
#include <GDT/GDT_MirrorTransform.h>
#include <GU/GU_Brush.h>

#include "SOP_GDT.h"

class GEO_PointTree;
class GU_RayIntersect;
class TIL_TextureMap;
class GEO_Primitive;

class PRM_MenuEntry;

enum SOP_BrushEvent {
    SOP_BRUSHSTROKE_BEGIN,
    SOP_BRUSHSTROKE_ACTIVE,
    SOP_BRUSHSTROKE_END,
    SOP_BRUSHSTROKE_CLICK,
    SOP_BRUSHSTROKE_NOP
};

enum SOP_BrushOp {
    SOP_BRUSHOP_DEFORM,
    SOP_BRUSHOP_COMB,
    SOP_BRUSHOP_PAINT,
    SOP_BRUSHOP_SMOOTH,
    SOP_BRUSHOP_SCRIPT,
    SOP_BRUSHOP_SMOOTHDEFORM,
    SOP_BRUSHOP_EYEDROP,
    SOP_BRUSHOP_ERASE,
    SOP_BRUSHOP_SMOOTHATTRIB,
    SOP_BRUSHOP_SMOOTHNORMAL,
    SOP_BRUSHOP_CALLBACK,
    SOP_BRUSHOP_DRAGTEXTURE,
    SOP_BRUSHOP_SCALETEXTURE,
    SOP_BRUSHOP_SMOOTHTEXTURE,
    SOP_BRUSHOP_SMOOTHLAYER,
    SOP_BRUSHOP_SMOOTHSINGLE,
    SOP_BRUSHOP_REDUCE,
    SOP_BRUSHOP_ERASESINGLE
};

enum SOP_BrushShape {
    SOP_BRUSHSHAPE_CIRCLE,
    SOP_BRUSHSHAPE_SQUARE,
    SOP_BRUSHSHAPE_BITMAP
};

enum SOP_BrushUpType {
    SOP_BRUSHUP_STROKEDIR,
    SOP_BRUSHUP_FIXED
};

enum SOP_BrushVisType {
    SOP_BRUSHVIS_FALSECOLOUR,
    SOP_BRUSHVIS_CAPTUREWEIGHT
};

class SOP_API SOP_BrushBase : public SOP_GDT
{
public:
             SOP_BrushBase(OP_Network *net, const char *name, OP_Operator *entry);
    virtual ~SOP_BrushBase();

    virtual OP_ERROR             cookInputGroups(OP_Context &context,
                                                 int alone = 0);

    // These set functions adjust the brushes current state.
    // The MSS State will use them to inform the SOP how to recook.
    virtual void setAccumulateStencil(bool yesno) = 0;
    virtual void setRayOrigin(const UT_Vector3 &orig, float t) = 0;
    virtual void setRayOrientation(const UT_Vector3 &orient, float t) = 0;
    virtual void setHitPrimitive(int primidx, float t) = 0;
    virtual void setHitPoint(int /* ptidx */, float /* t */) {}
    virtual void setHitUV(float u, float v, float t) = 0;
    virtual void setHitPressure(float pressure, float t) = 0;
    virtual void setHitInUV(bool inuv) { myHitInUV = inuv; }
    virtual void setBrushEvent(SOP_BrushEvent event) = 0;
    virtual void setBrushOp(SOP_BrushOp op) = 0;
    virtual void setBrushShape(SOP_BrushShape shape) = 0;
    virtual void setProjectionType(int projtype) = 0;
    virtual void useForegroundColor(void) = 0;
    virtual void useBackgroundColor(void) = 0;
    // These are used to update the current radius.
    virtual void setRadius(float radius, float t) = 0;
    virtual void setUVRadius(float radius, float t) = 0;

    virtual const GB_PrimitiveGroup     *getPrimitiveSelection(void) const
                                 {
                                     return (const GB_PrimitiveGroup*) myGroup;
                                 }
                            
    // Gets the rayintersector for this current group setup...
    // If the checkgeo is true, it will test to see if the intersect geo
    // has changed.  We normally do NOT want to do this as rebuilding the
    // cache is expensive if it was our own change.  However, when locating
    // or mouse down we should enable this to catch other triggers.
    // The probeonly, if set to true, will prevent the rebuilding of
    // the GU_RayIntersect, so may return 0.  This provides a fast way
    // to update the flags needed to check if geometry changes and
    // a rebuild is necessary later.
    virtual GU_RayIntersect     *getRayIntersect(int checkgeochange = 0,
                                                 int probeonly = 0);

    // Gets the GEO_PointTree for the current group setup.
    GEO_PointTree               *getPointTree();

    // Gets or creates the cursor geometry:
    GU_Detail                   *getCursorGdp();

    // This both orients the cursor and tracks what the current brush
    // direction is.
    // isuv is true if the intersection is from the UV viewport.
    // hitu & hitv will be the parametric coordinates of the hit location
    // on prim.  prim will be null for 2d viewports (or in the 3d viewport
    // if there was no hit)
    void                         orientCursor(float t, const UT_Vector3 &orig,
                                        const UT_Vector3 &dir,
                                        float scalehistory,
                                        bool isuv,
                                        const GEO_Primitive *prim,
                                        float hitu, float hitv);

    // Gets the interesction gdp.
    virtual const GU_Detail     *getIsectGdp();

    // The *Static methods can be hooked into buttons as callbacks to
    // perform the listed function.

    // applyStencil will copy the current delta into the permament delta
    // and clear the current.
    static int                   applyStencilStatic(void *op, int idx, float t,
                                        const PRM_Template *);
    void                         applyStencil(float t, int recook = 1);

    // resetNormal recalculates the surface normals off the current deformed
    // geometry.
    static int                   resetNormalStatic(void *op, int idx, float t,
                                        const PRM_Template *);
    void                         resetNormal(float t);

    // flood applies the current operation (as found using OP()) to the
    // entire selection.
    static int                   floodStatic(void *op, int idx, float t,
                                        const PRM_Template *);
    virtual void                 flood(float t);
    
    // NOTE: There is a SOP_GDT::clearallStatic which can be used
    // for reset all changes.
    virtual void                 clearAllDeltas(float t);

    static void                  customMergeModeStatic(GEO_Point *pt,
                                            GEO_Vertex *vtx, 
                                            UT_Vector3 &result, 
                                            const UT_Vector3 &cd, 
                                            const UT_Vector3 &origcol, 
                                            void *data);
    void                         customMergeMode(GEO_Point *pt,
                                            GEO_Vertex *vtx,
                                            UT_Vector3 &result, 
                                            const UT_Vector3 &cd, 
                                            const UT_Vector3 &origcol);

    static void         brushOpCallbackStatic(
                            GEO_Point *pt,
                            const UT_PtrArray<const GEO_Point *> *ptneighbour,
                            GEO_Vertex *vtx, 
                            const UT_PtrArray<const GEO_Vertex*> *vtxneighbor,
                            GEO_Primitive *vtx_prim,
                            int prim_vtx_idx,
                            float alpha,
                            GEO_Delta *delta,
                            void *data);
    virtual void        brushOpCallback(
                            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);

    // Returns 1 if there is anything in the brush's accumulation buffer
    bool                         hasStencil() const;

    virtual void                 setCurrentColor(const UT_Vector3 &cd);

    // Use our brush & visualization mode to do the visualization:
    void                         applyVisualizeStencil();
    void                         applyVisualize();
    void                         applyCaptureVisualize();

    void                         setIsectNodeId(int node_id)
                                 {
                                    myIsectNodeId = node_id;
                                 }

    virtual void                 unloadDataHack();
    virtual bool                 unloadData();

protected:
    // cookMySop will apply the GDT and react to the Brush events,
    // but you won't be able to patch in your own code.
    virtual OP_ERROR             cookMySop(OP_Context &context);

    // A wrapper function for duplicateChangedSource.  At this level,
    // it simply calls duplicateChnagedSource, but can be overridden
    // in subclasses to define attributes on the duplicated gdp
    // (for instance)
    virtual void                 duplicateChangedSourceWrapper(
                                                    unsigned idx,
                                                    OP_Context &context,
                                                    int *changed,
                                                    bool force=false);

    // Call this method do all the GDT application and brush parsing.
    // After calling this, any current brush strokes triggerd by the
    // brush state will be processed, and your gdp will have the result
    // of applying the GDT.
    // This should be called after you have duplicateSource (and/or merely
    // did a rollback), and have created any attributes you wish.
    // Note that as a result of this, new attributes may be created,
    // so attribute offsets should be refetched.
    virtual OP_ERROR             processBrushOp(OP_Context &context,
                                        bool changed_input, bool changed_group);

    // This determines whether the given undoblock name matches one of our
    // undoblocks. If it matches, then our undo is collapsed with this block.
    // Remember to call the base class!
    virtual bool                 matchesUndo(const char *undoname) const;

protected:
    // These apply the named operation through the brush's stencil,
    // taking into account the various unusual parameters.
    void                         doDeformation(float t, const UT_Vector3 &cd);
    void                         doPaint(float t, const UT_Vector3 &cd,
                                        int enablestamping = 1);
    virtual void                 doErase() = 0;
    virtual void                 addEraseAttributes(GU_Brush &brush) {}

    // Finds the seed point from a seed primitive.  This is the closest
    // point.  Somewhat complicated with hulls to avoid n^2 search.
    const GEO_Point             *getSeedPoint(const GEO_Primitive *prim,
                                        float u, float v, 
                                        const UT_Vector3 &orig);

    virtual OP_Node             *getRestGeoInput() { return 0; }

public:
    // If the action of the brush will change point positions, altersGeometry
    // should return 1.
    virtual int          altersGeometry() const = 0;
    // If the action of the brush will change point colours, altersColor
    // should return 1.
    virtual int          altersColor() const = 0;
    
    // The RADIUS and OPACITY are defined locally as they take into
    // account the current RAY_HITPRESSURE.
    // The RADIUS function will also switch its output between RAWRADIUS
    // and RAWUVRADIUS depending on the state of the brush cursor.
    virtual float        RADIUS(float t);
    virtual float        RAWRADIUS(float t) = 0;
    virtual float        RAWUVRADIUS(float t) = 0;
    virtual float        RADIUSPRESSURE(float t) = 0;
    virtual float        OPACITY(float t);
    virtual float        RAWOPACITY(float t) = 0;
    virtual float        OPACITYPRESSURE(float t) = 0;

    // DEPTH is how far into the surface the brush should stick,
    // and HEIGHT is how far above.
    virtual float        DEPTH(float /* t */) { return 1.0f; }
    virtual float        HEIGHT(float /* t */) { return 1.0f; }

    virtual int          USEDEPTH() { return 0; }
    virtual int          USECONNECTIVITY() { return 1; }
    
    virtual SOP_BrushOp  OP(void) = 0;
    virtual int          ACCUMSTENCIL(void)  = 0;
    virtual int          PROJECTIONTYPE(void) = 0;
    virtual int          REALTIME(void) = 0;
    virtual int          SHAPE(float t) = 0;
protected:
    virtual int    MERGEMODE() = 0;
    // Script does not yet do anything, and is reserved.
    virtual void   SCRIPT(UT_String &s, float t) = 0;
    virtual int    AXIS(void) = 0;
    virtual float  USERX(float t) = 0;
    virtual float  USERY(float t) = 0;
    virtual float  USERZ(float t) = 0;

    virtual float  RAYORIENTX(float t) = 0;
    virtual float  RAYORIENTY(float t) = 0;
    virtual float  RAYORIENTZ(float t) = 0;
    virtual float  RAYHITX(float t) = 0;
    virtual float  RAYHITY(float t) = 0;
    virtual float  RAYHITZ(float t) = 0;
    virtual float  RAYHITU(float t) = 0;
    virtual float  RAYHITV(float t) = 0;
    virtual float  RAYHITPRESSURE(float t) = 0;
    virtual int    PRIMHIT(float t) = 0;
    virtual int    PTHIT(float /* t */) { return -1; }
    virtual int    EVENT()      = 0;
    
    virtual bool  USE_FOREGROUND(void) = 0;
    virtual float FGR(float t) = 0;
    virtual float FGG(float t) = 0;
    virtual float FGB(float t) = 0;
    virtual float BGR(float t) = 0;
    virtual float BGG(float t) = 0;
    virtual float BGB(float t) = 0;

    virtual float SOFTEDGE(float t) = 0;
    virtual void  KERNEL(UT_String &str, float t)  = 0;
    virtual int   UPTYPE(float t) = 0;
    virtual float UPX(float t)   = 0;
    virtual float UPY(float t)   = 0;
    virtual float UPZ(float t)   = 0;

    virtual float PAPERNOISE(float t) = 0;
    virtual float SPLATTER(float t) = 0;
    virtual void  BITMAP(UT_String &str, float t) = 0;
    virtual int   BITMAPCHAN(float t) = 0;
    virtual float ANGLE(float t) = 0;
    virtual float SQUASH(float t) = 0;
    virtual int   DOSTAMPING() = 0;
    virtual int   WRITEALPHA() = 0;
    virtual int   OVERRIDECD() = 0;
    virtual void  CDNAME(UT_String &str, float t) = 0;
    virtual int   OVERRIDEALPHA() = 0;
    virtual void  ALPHANAME(UT_String &str, float t) = 0;
    virtual int   PRESERVENML() { return 0; }
    virtual int   OVERRIDENML() = 0;
    virtual void  NMLNAME(UT_String &str, float t) = 0;

    virtual float SYMMETRYDIRX(float t) = 0;
    virtual float SYMMETRYDIRY(float t) = 0;
    virtual float SYMMETRYDIRZ(float t) = 0;
    virtual float SYMMETRYORIGX(float t) = 0;
    virtual float SYMMETRYORIGY(float t) = 0;
    virtual float SYMMETRYORIGZ(float t) = 0;
    virtual int   DOREFLECTION() = 0;
    virtual int   DOPOINTREFLECTION() { return 0; };
    virtual int   DOROTATION() = 0;
    virtual int   SYMMETRYROT(float t) = 0;
    virtual float SYMMETRYDIST(float t) = 0;

    virtual int   DOUVREFLECTION() { return 0; }
    virtual float SYMMETRYUVORIGU(float /*t*/) { return 0.5f; }
    virtual float SYMMETRYUVORIGV(float /*t*/) { return 0.5f; }
    virtual float SYMMETRYUVANGLE(float /*t*/) { return 0.0f; }

    virtual int   ADDATTRIB() = 0;
    virtual int   VISUALIZE() { return 0; }
    virtual int   VISTYPE()   { return 0; }
    virtual float VISLOW(float /*t*/) { return 0.0f; }
    virtual float VISHIGH(float /*t*/) { return 1.0f; }
    virtual int   VISMODE()   { return 0; }
    virtual float ZEROWEIGHTCOLOR_R() { return 1.0f; }
    virtual float ZEROWEIGHTCOLOR_G() { return 1.0f; }
    virtual float ZEROWEIGHTCOLOR_B() { return 1.0f; }

    virtual int   NORMALIZEWEIGHT() { return 0; }

    virtual int   USECAPTURE() { return 0; }
    virtual int   CAPTUREIDX(float /*t*/) { return 0; }
    virtual GEO_Detail::CaptureType CAPTURETYPE() 
                  { return GEO_Detail::CAPTURE_BONE; }

    // Find out if the brush has moved or done anything to cause us to add its
    // effect to the current gdp.
    virtual bool         hasStrokeChanged(float t) = 0;
    virtual bool         hasStyleChanged (float t) = 0;

    // Find if the nib file has changed:
    virtual bool         hasNibFileChanged(float t) = 0;

    // Find if any of the nib description values have changed:
    virtual bool         hasNibLookChanged(float t) = 0;
    virtual bool         hasAccumStencilChanged(float t) = 0;

    virtual bool         hasCaptureIdxChanged(float /*t*/) { return 0; }
    
    virtual bool         hasVisrangeChanged(float /*t*/) { return 0; }

    // Do we want our cook selection to be updated and displayed?
    virtual bool         wantsCookSelection(void) const { return false; }

    virtual void         rollbackCurrentDelta();
    virtual void         applyAndClearCurrentDelta();

    virtual const GB_PointGroup *getPointGroup() { return 0; }
    virtual bool isGroupParmDirty(OP_Context &context)
                        {
                            return isParmDirty(SOP_GDT_GRP_IDX, context.myTime);
                        }

    UT_Vector3           myLastPos;
    UT_Vector3           myBrushDir;
    
    // This stores the last uv location chosen in the 3d viewport.
    int                  myPendingLastUVPrimitive;
    UT_Vector3           myPendingLastUVPrimitiveUV;

    // This is the last uv location chosen in the 3d viewport that
    // was cooked with.
    int                  myLastUVPrimitive;
    UT_Vector3           myLastUVPrimitiveUV;

    // This is the last uv position that was cooked with.
    bool                 myLastUVPosValid;
    UT_Vector3           myLastUVPos;

    UT_Vector3           myUVBrushDir;
    UT_Vector3           myUVBrushPos;
    GU_Brush             myBrush;
    GU_RayIntersect     *myRayIntersect;
    TIL_TextureMap      *myNibFile;
    GU_Detail           *myBrushCursor;
    UT_Matrix3           myCursorOrient;

    // These two are intentionally ephemeral variable which is NOT saved.
    // The state tweaks this to turn on/off visualization.
    int                  myForceVisualize;
    int                  myIsectNodeId;

    // This tracks our last isectgeo to see if it has changed.
    int                  myLastIsectGDPId;
    int                  myLastIsectGDPCacheCount;

    // This is so our callbacks know our cook time...
    float                myCookTime;

    bool                 myHitInUV;

    GDT_Detail           myMirroredDelta;

    GDT_MirrorTransform  myMirrorTransform;
};

#endif

---