SOP/SOP_SlideModifierPaint.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 Chadwick
 *      Side Effects Software Inc.
 *      123 Front Street West
 *      Toronto, Ontario,  M5J 2M2
 *      Canada
 *      416-504-9876
 *
 * NAME:        SOP Library (C++)
 *
 * COMMENTS: The SlideModifierPaint SOP, which is used to paint a per-point
 *           sliding attribute for use in muscle sliding
 *
 */

#ifndef __SOP_SlideModifierPaint_h__
#define __SOP_SlideModifierPaint_h__

#include "SOP_API.h"
#include <GU/GU_Brush.h>
#include <GEO/GEO_Detail.h>

#include "SOP_GDT.h"
#include "SOP_BrushBase.h"

class PRM_MenuEntry;

enum {
    // Group parameters
    SOP_SLIDEPAINT_GRP_IDX = SOP_GDT_GRP_IDX,

    SOP_SLIDEPAINT_SWITCHER_IDX,

#define SOP_SLIDEPAINT_NUM_DEFORM_PARMS (10)
    SOP_SLIDEPAINT_ATTRIB_IDX,
    SOP_SLIDEPAINT_OP_IDX,
    SOP_SLIDEPAINT_MERGEMODE_IDX,
    SOP_SLIDEPAINT_STENCILACCUM_IDX,
    SOP_SLIDEPAINT_STENCILAPPLY_IDX,
    SOP_SLIDEPAINT_FLOODAPPLY_IDX,
    SOP_SLIDEPAINT_CLEARALL_IDX,
    SOP_SLIDEPAINT_VISUALIZE_IDX,
    SOP_SLIDEPAINT_VISRANGE_IDX,
    SOP_SLIDEPAINT_VISMODE_IDX,

#define SOP_SLIDEPAINT_NUM_NIB_PARMS (18)
    SOP_SLIDEPAINT_SHAPE_IDX,
    SOP_SLIDEPAINT_BITMAP_IDX,
    SOP_SLIDEPAINT_BITMAPCHAN_IDX,
    SOP_SLIDEPAINT_RAD_IDX,
    SOP_SLIDEPAINT_UVRAD_IDX,
    SOP_SLIDEPAINT_RADPRESSURE_IDX,
    SOP_SLIDEPAINT_USEDEPTH_IDX,
    SOP_SLIDEPAINT_DEPTH_IDX,
    SOP_SLIDEPAINT_ANGLE_IDX,
    SOP_SLIDEPAINT_SQUASH_IDX,
    SOP_SLIDEPAINT_OPAC_IDX,
    SOP_SLIDEPAINT_OPACPRESSURE_IDX,
    SOP_SLIDEPAINT_SPLATTER_IDX,
    SOP_SLIDEPAINT_PAPER_IDX,
    SOP_SLIDEPAINT_SOFTEDGE_IDX,
    SOP_SLIDEPAINT_KERNEL_IDX,
    SOP_SLIDEPAINT_UPTYPE_IDX,
    SOP_SLIDEPAINT_UPVECTOR_IDX,

#define SOP_SLIDEPAINT_NUM_SYM_PARMS (9)
    SOP_SLIDEPAINT_DOREFLECT_IDX,
    SOP_SLIDEPAINT_DOROTATION_IDX,
    SOP_SLIDEPAINT_SYMAXIS_IDX,
    SOP_SLIDEPAINT_SYMORIG_IDX,
    SOP_SLIDEPAINT_SYMROT_IDX,
    SOP_SLIDEPAINT_SYMDIST_IDX,
    SOP_SLIDEPAINT_DOUVREFLECT_IDX,
    SOP_SLIDEPAINT_SYMUVORIG_IDX,
    SOP_SLIDEPAINT_SYMUVANGLE_IDX,

#define SOP_SLIDEPAINT_NUM_RAY_PARMS    (10)
    SOP_SLIDEPAINT_PROJTYPE_IDX,
    SOP_SLIDEPAINT_USECONNECTIVITY_IDX,
    SOP_SLIDEPAINT_REALTIME_IDX,
    SOP_SLIDEPAINT_RAY_ORIENT_IDX,
    SOP_SLIDEPAINT_RAY_HITPOS_IDX,
    SOP_SLIDEPAINT_RAY_HITPRIM_IDX,
    SOP_SLIDEPAINT_RAY_HITUV_IDX,
    SOP_SLIDEPAINT_RAY_HITPRESSURE_IDX,
    SOP_SLIDEPAINT_RAY_HITPT_IDX,
    SOP_SLIDEPAINT_RAY_EVENT_IDX
};

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

    virtual unsigned             disableParms();

    static OP_Node              *myConstructor(OP_Network *net,
                                               const char *name,
                                               OP_Operator *entry);

    static PRM_Template          myTemplateList[];

    virtual void setAccumulateStencil(bool yesno)
                 {
                     setInt(SOP_SLIDEPAINT_STENCILACCUM_IDX, 0, 0, yesno);
                 }
    virtual void setRayOrigin(const UT_Vector3 &orig, float t)
                 {
                     setFloat(SOP_SLIDEPAINT_RAY_HITPOS_IDX, 0, t, orig.x());
                     setFloat(SOP_SLIDEPAINT_RAY_HITPOS_IDX, 1, t, orig.y());
                     setFloat(SOP_SLIDEPAINT_RAY_HITPOS_IDX, 2, t, orig.z());
                 }
    virtual void setRayOrientation(const UT_Vector3 &orient, float t)
                 {
                     setFloat(SOP_SLIDEPAINT_RAY_ORIENT_IDX, 0, t, orient.x());
                     setFloat(SOP_SLIDEPAINT_RAY_ORIENT_IDX, 1, t, orient.y());
                     setFloat(SOP_SLIDEPAINT_RAY_ORIENT_IDX, 2, t, orient.z());
                 }
    virtual void setHitPrimitive(int primidx, float t)
                 {
                     setInt(SOP_SLIDEPAINT_RAY_HITPRIM_IDX, 0, t, primidx);
                 }
    virtual void setHitPoint(int pt, float t)
                 {
                     setInt(SOP_SLIDEPAINT_RAY_HITPT_IDX, 0, t, pt);
                 }
    virtual void setHitUV(float u, float v, float t)
                 {
                     setFloat(SOP_SLIDEPAINT_RAY_HITUV_IDX, 0, t, u);
                     setFloat(SOP_SLIDEPAINT_RAY_HITUV_IDX, 1, t, v);
                 }
    virtual void setHitPressure(float p, float t)
                 {
                     setFloat(SOP_SLIDEPAINT_RAY_HITPRESSURE_IDX, 0, t, p);
                 }   
    virtual void setRadius(float r, float t)
                 {
                     setFloat(SOP_SLIDEPAINT_RAD_IDX, 0, t, r);
                 }
    virtual void setUVRadius(float r, float t)
                 {
                     setFloat(SOP_SLIDEPAINT_UVRAD_IDX, 0, t, r);
                 }
    virtual void setBrushEvent(SOP_BrushEvent event)
                 {
                     setInt(SOP_SLIDEPAINT_RAY_EVENT_IDX, 0, 0, int(event));
                 }
    virtual void setBrushOp(SOP_BrushOp op)
                 {
                     int iop;
                     switch (op)
                     {
                         case SOP_BRUSHOP_SMOOTHATTRIB: iop = 1; break;
                         case SOP_BRUSHOP_ERASE:        iop = 2; break;
                         case SOP_BRUSHOP_PAINT:
                         default:                       iop = 0; break;
                     }
                     setInt(SOP_SLIDEPAINT_OP_IDX, 0, 0, iop);
                 }
    virtual void setBrushShape(SOP_BrushShape shape)
                 {
                     setInt(SOP_SLIDEPAINT_SHAPE_IDX, 0, 0, int(shape));
                 }
    virtual void setProjectionType(int projtype)
                 {
                     setInt(SOP_SLIDEPAINT_PROJTYPE_IDX, 0, 0, projtype);
                 }
    virtual void useForegroundColor(void)
                 { myUseFG = true; }
    virtual void useBackgroundColor(void)
                 { myUseFG = false; }

    virtual void setCurrentColor(const UT_Vector3 &cd)
                { }
    virtual void setVisualization(int state)
                {
                    // only trigger recooks if different!
                    if( myForceVisualize != state )
                    {
                        myForceVisualize = state;
                        forceRecook();
                    }
                }

protected:
    virtual const char  *inputLabel(unsigned idx) const;

    // Override this function, so that we can recreate the
    // slideModifier attribute every time the source is
    // duplicated
    virtual void         duplicateChangedSourceWrapper(
                                                unsigned idx,
                                                OP_Context &context,
                                                int *changed,
                                                bool force=false);

protected:
    virtual void        doErase();

public:
    virtual int         altersGeometry() const { return 0; }
    virtual int         altersColor() const { return 1; }
    virtual float       RAWRADIUS(float t)
                            { return evalFloat(SOP_SLIDEPAINT_RAD_IDX, 0, t); }
    virtual float       RAWUVRADIUS(float t)
                            { return evalFloat(SOP_SLIDEPAINT_UVRAD_IDX, 0, t); }
    virtual float       RADIUSPRESSURE(float t)
                        { return evalFloat(SOP_SLIDEPAINT_RADPRESSURE_IDX, 0, t); }
    virtual float       RAWOPACITY(float t)
                            {return evalFloat(SOP_SLIDEPAINT_OPAC_IDX, 0, t) ; }
    virtual float       OPACITYPRESSURE(float t)
                        {return evalFloat(SOP_SLIDEPAINT_OPACPRESSURE_IDX, 0, t) ; }

    virtual SOP_BrushOp  OP(void) 
                        { 
                            switch (evalInt(SOP_SLIDEPAINT_OP_IDX, 0, 0))
                            {
                                case 0:
                                    return SOP_BRUSHOP_PAINT;
                                case 1: 
                                    return SOP_BRUSHOP_SMOOTHATTRIB;
                                case 2: 
                                default:
                                    return SOP_BRUSHOP_ERASE;
                            }
                        }

    virtual int         ACCUMSTENCIL(void) 
                            { return evalInt(SOP_SLIDEPAINT_STENCILACCUM_IDX, 0, 0);}
    virtual int         PROJECTIONTYPE(void)
                            { return evalInt(SOP_SLIDEPAINT_PROJTYPE_IDX, 0, 0); }
    virtual int         REALTIME(void)
                            { return evalInt(SOP_SLIDEPAINT_REALTIME_IDX, 0, 0); }
    virtual int         SHAPE(float t)
                            { return evalInt(SOP_SLIDEPAINT_SHAPE_IDX,  0, t); }

protected:
    enum AttribToPaint {
        SOP_SLIDE_MODIFIER,
        SOP_INFLATE_MODIFIER
    };

    virtual int         MERGEMODE()
                            { return evalInt(SOP_SLIDEPAINT_MERGEMODE_IDX, 0, 0); }
    virtual void        SCRIPT  (UT_String &, float  ) {}
    virtual int         AXIS(void)      { return   0 ;  }
    virtual float       USERX(float)    { return 0.0f;  }
    virtual float       USERY(float)    { return 0.0f;  }
    virtual float       USERZ(float)    { return 0.0f;  }

    virtual float       RAYORIENTX(float t)
                            { return evalFloat(SOP_SLIDEPAINT_RAY_ORIENT_IDX,0,t); }
    virtual float       RAYORIENTY(float t)
                            { return evalFloat(SOP_SLIDEPAINT_RAY_ORIENT_IDX,1,t); }
    virtual float       RAYORIENTZ(float t)
                            { return evalFloat(SOP_SLIDEPAINT_RAY_ORIENT_IDX,2,t); }
    virtual float       RAYHITX(float t)
                            { return evalFloat(SOP_SLIDEPAINT_RAY_HITPOS_IDX,0,t); }
    virtual float       RAYHITY(float t)
                            { return evalFloat(SOP_SLIDEPAINT_RAY_HITPOS_IDX,1,t); }
    virtual float       RAYHITZ(float t)
                            { return evalFloat(SOP_SLIDEPAINT_RAY_HITPOS_IDX,2,t); }
    virtual float       RAYHITU(float t)
                            { return evalFloat(SOP_SLIDEPAINT_RAY_HITUV_IDX, 0,t); }
    virtual float       RAYHITV(float t)
                            { return evalFloat(SOP_SLIDEPAINT_RAY_HITUV_IDX, 1,t); }
    virtual float       RAYHITPRESSURE(float t)
                            { return evalFloat(SOP_SLIDEPAINT_RAY_HITPRESSURE_IDX, 0, t); }
    virtual int         PRIMHIT(float t)
                            { return evalInt(SOP_SLIDEPAINT_RAY_HITPRIM_IDX, 0,t); }
    virtual int         PTHIT(float t)
                            { return evalInt(SOP_SLIDEPAINT_RAY_HITPT_IDX, 0, t); }
    virtual int         EVENT()
                            { return evalInt(SOP_SLIDEPAINT_RAY_EVENT_IDX,   0,0); }
    virtual bool        USE_FOREGROUND(void)
                            { return myUseFG; }

    virtual float FGR(float t)   { return 1.0; }
    virtual float FGG(float t)   { return 1.0; }
    virtual float FGB(float t)   { return 1.0; }
    virtual float BGR(float t)   { return 0.0; }
    virtual float BGG(float t)   { return 0.0; }
    virtual float BGB(float t)   { return 0.0; }

    virtual float       SOFTEDGE(float t)
                            { return evalFloat(SOP_SLIDEPAINT_SOFTEDGE_IDX, 0, t); }
    virtual void        KERNEL(UT_String &str, float t) 
                            { evalString(str, SOP_SLIDEPAINT_KERNEL_IDX, 0, t); }
    virtual int         UPTYPE(float t)
                            { return evalInt(SOP_SLIDEPAINT_UPTYPE_IDX, 0, t); }
    virtual float       UPX(float t)
                            { return evalFloat(SOP_SLIDEPAINT_UPVECTOR_IDX, 0, t); }
    virtual float       UPY(float t)
                            { return evalFloat(SOP_SLIDEPAINT_UPVECTOR_IDX, 1, t); }
    virtual float       UPZ(float t)
                            { return evalFloat(SOP_SLIDEPAINT_UPVECTOR_IDX, 2, t); }

    virtual float       PAPERNOISE(float t)
                            { return evalFloat(SOP_SLIDEPAINT_PAPER_IDX, 0, t); }
    virtual float       SPLATTER(float t)
                            { return evalFloat(SOP_SLIDEPAINT_SPLATTER_IDX, 0, t); }
    virtual void        BITMAP(UT_String &str, float t)
                            { evalString(str, SOP_SLIDEPAINT_BITMAP_IDX, 0, t); }
    virtual int         BITMAPCHAN(float t)
                            { return evalInt(SOP_SLIDEPAINT_BITMAPCHAN_IDX, 0, t); }
    virtual float       ANGLE(float t)
                            { return evalFloat(SOP_SLIDEPAINT_ANGLE_IDX,  0, t); }
    virtual float       SQUASH(float t)
                            { return evalFloat(SOP_SLIDEPAINT_SQUASH_IDX, 0, t); }
    virtual int         DOSTAMPING()
                            { return 0; }
    virtual int         WRITEALPHA()
                            { return 0; }

    virtual int         OVERRIDECD()
                            { return 1; }   // Always override an attribute

    // Chose the attribute name to override.  We base this on the current
    // value in the 'Attribute to Paint' menu.  Ideally, it should be
    // straightforward to add additional muscle-related attributes to
    // paint by just adding to the menu and setting the attribute to
    // paint accordingly.
    virtual void        CDNAME(UT_String &str, float t)
                            {
                                int attrib_to_paint;

                                attrib_to_paint
                                    = evalInt(SOP_SLIDEPAINT_ATTRIB_IDX, 0, 0);

                                switch ( attrib_to_paint )
                                {
                                    case SOP_SLIDE_MODIFIER:
                                    {
                                        str = GEO_STD_ATTRIB_META_SLIDE;
                                        break;
                                    }
                                    case SOP_INFLATE_MODIFIER:
                                    {
                                        str = GEO_STD_ATTRIB_INFLATE_MODIFIER;
                                        break;
                                    }
                                    default:
                                    {
                                        str = GEO_STD_ATTRIB_META_SLIDE;
                                        break;
                                    }
                                }
                            }

    virtual int         OVERRIDEALPHA()
                            { return 0; }
    virtual void        ALPHANAME(UT_String & /*str*/, float /*t*/)
                            {}
    virtual int         OVERRIDENML() { return 0; }
    virtual void        NMLNAME(UT_String & /*str*/, float /*t*/) {}

    virtual float SYMMETRYDIRX(float t) 
                            { return evalFloat(SOP_SLIDEPAINT_SYMAXIS_IDX, 0, t); }
    virtual float SYMMETRYDIRY(float t) 
                            { return evalFloat(SOP_SLIDEPAINT_SYMAXIS_IDX, 1, t); }
    virtual float SYMMETRYDIRZ(float t) 
                            { return evalFloat(SOP_SLIDEPAINT_SYMAXIS_IDX, 2, t); }
    virtual float SYMMETRYORIGX(float t) 
                            { return evalFloat(SOP_SLIDEPAINT_SYMORIG_IDX, 0, t); }
    virtual float SYMMETRYORIGY(float t) 
                            { return evalFloat(SOP_SLIDEPAINT_SYMORIG_IDX, 1, t); }
    virtual float SYMMETRYORIGZ(float t) 
                            { return evalFloat(SOP_SLIDEPAINT_SYMORIG_IDX, 2, t); }
    virtual int   DOREFLECTION() 
                            { return evalInt(SOP_SLIDEPAINT_DOREFLECT_IDX,0, 0); }
    virtual int   DOROTATION() 
                            { return evalInt(SOP_SLIDEPAINT_DOROTATION_IDX,0, 0); }
    virtual int   SYMMETRYROT(float t) 
                            { return evalInt(SOP_SLIDEPAINT_SYMROT_IDX,0, t); }
    virtual float SYMMETRYDIST(float t) 
                            { return evalFloat(SOP_SLIDEPAINT_SYMDIST_IDX,0, t); }

    virtual int   DOUVREFLECTION()
                    { return evalInt(SOP_SLIDEPAINT_DOUVREFLECT_IDX, 0, 0); }
    virtual float SYMMETRYUVORIGU(float t)
                    { return evalFloat(SOP_SLIDEPAINT_SYMUVORIG_IDX, 0, t); }
    virtual float SYMMETRYUVORIGV(float t)
                    { return evalFloat(SOP_SLIDEPAINT_SYMUVORIG_IDX, 1, t); }
    virtual float SYMMETRYUVANGLE(float t)
                    { return evalFloat(SOP_SLIDEPAINT_SYMUVANGLE_IDX, 0, t);}

    virtual int         ADDATTRIB()
                            { return 0; }
    virtual int         VISUALIZE()
                            { return myForceVisualize ||
                                    evalInt(SOP_SLIDEPAINT_VISUALIZE_IDX, 0, 0); }
    virtual float       VISLOW(float t)
                            { return evalFloat(SOP_SLIDEPAINT_VISRANGE_IDX, 0, t); }
    virtual float       VISHIGH(float t)
                            { return evalFloat(SOP_SLIDEPAINT_VISRANGE_IDX, 1, t); }
    virtual int         VISMODE()
                            { return evalInt(SOP_SLIDEPAINT_VISMODE_IDX, 0, 0); }

    virtual int         USECONNECTIVITY()
                            { return evalInt(SOP_SLIDEPAINT_USECONNECTIVITY_IDX, 0, 0); }
    virtual int         USEDEPTH()
                            { return evalInt(SOP_SLIDEPAINT_USEDEPTH_IDX, 0, 0); }
    virtual float       DEPTH(float t)
                            { return evalFloat(SOP_SLIDEPAINT_DEPTH_IDX, 0, t); }
    virtual float       HEIGHT(float t)
                            { return evalFloat(SOP_SLIDEPAINT_DEPTH_IDX, 1, t); }


    // 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);
    virtual bool        hasStyleChanged(float t);

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

    virtual bool        hasVisrangeChanged(float t);

private:
    // Store attribute offsets for the various attributes we can affect
    int                 mySlideOffset;
    int                 myInflateOffset;

    // Inidicates whether or not we should use the
    // foreground or background colour when painting.
    bool                myUseFG;

};

#endif

---