SOP_Paint.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.
 *
 * NAME:        SOP Library (C++)
 *
 * COMMENTS: The Paint SOP, which works in conjunction with the
 *           Paint State and the GDT classes.
 *
 */

#ifndef __SOP_Paint_h__
#define __SOP_Paint_h__

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

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

class PRM_MenuEntry;

enum {
    // Group parameters
    SOP_PAINT_GRP_IDX = SOP_GDT_GRP_IDX,

    SOP_PAINT_SWITCHER_IDX,

#define SOP_PAINT_NUM_DEFORM_PARMS      (17)
    SOP_PAINT_MERGEMODE_IDX,
    SOP_PAINT_STENCILACCUM_IDX,
    SOP_PAINT_STENCILAPPLY_IDX,
    SOP_PAINT_COLOR_SWITCHER_IDX,
    SOP_PAINT_FG_IDX,
    SOP_PAINT_BG_IDX,
    SOP_PAINT_STAMP_IDX,
    SOP_PAINT_FLOODAPPLY_IDX,
    SOP_PAINT_OP_IDX,
    SOP_PAINT_CLEARALL_IDX,
    SOP_PAINT_ADDATTRIB_IDX,
    SOP_PAINT_WRITEALPHA_IDX,
    SOP_PAINT_OVERRIDECD_IDX,
    SOP_PAINT_CDNAME_IDX,
    SOP_PAINT_OVERRIDEALPHA_IDX,
    SOP_PAINT_ALPHANAME_IDX,
    SOP_PAINT_VISUALIZE_IDX,
    SOP_PAINT_VISRANGE_IDX,
    SOP_PAINT_VISMODE_IDX,

#define SOP_PAINT_NUM_NIB_PARMS (18)
    SOP_PAINT_SHAPE_IDX,
    SOP_PAINT_BITMAP_IDX,
    SOP_PAINT_BITMAPCHAN_IDX,
    SOP_PAINT_RAD_IDX,
    SOP_PAINT_UVRAD_IDX,
    SOP_PAINT_RADPRESSURE_IDX,
    SOP_PAINT_USEDEPTH_IDX,
    SOP_PAINT_DEPTH_IDX,
    SOP_PAINT_ANGLE_IDX,
    SOP_PAINT_SQUASH_IDX,
    SOP_PAINT_OPAC_IDX,
    SOP_PAINT_OPACPRESSURE_IDX,
    SOP_PAINT_SPLATTER_IDX,
    SOP_PAINT_PAPER_IDX,
    SOP_PAINT_SOFTEDGE_IDX,
    SOP_PAINT_KERNEL_IDX,
    SOP_PAINT_UPTYPE_IDX,
    SOP_PAINT_UPVECTOR_IDX,

#define SOP_PAINT_NUM_SYM_PARMS (9)
    SOP_PAINT_DOREFLECT_IDX,
    SOP_PAINT_DOROTATION_IDX,
    SOP_PAINT_SYMAXIS_IDX,
    SOP_PAINT_SYMORIG_IDX,
    SOP_PAINT_SYMROT_IDX,
    SOP_PAINT_SYMDIST_IDX,
    SOP_PAINT_DOUVREFLECT_IDX,
    SOP_PAINT_SYMUVORIG_IDX,
    SOP_PAINT_SYMUVANGLE_IDX,

#define SOP_PAINT_NUM_RAY_PARMS (11)
    SOP_PAINT_PROJTYPE_IDX,
    SOP_PAINT_USECONNECTIVITY_IDX,
    SOP_PAINT_USENORMALS_IDX,
    SOP_PAINT_REALTIME_IDX,
    SOP_PAINT_RAY_ORIENT_IDX,
    SOP_PAINT_RAY_HITPOS_IDX,
    SOP_PAINT_RAY_HITPRIM_IDX,
    SOP_PAINT_RAY_HITUVW_IDX,
    SOP_PAINT_RAY_HITPRESSURE_IDX,
    SOP_PAINT_RAY_HITPT_IDX,
    SOP_PAINT_RAY_EVENT_IDX
};

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

    bool                         updateParmsFlags() override;

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

    static PRM_Template          myTemplateList[];
    static PRM_Template          myObsoleteList[];

    void         setAccumulateStencil(bool yesno) override
                 {
                     setInt(SOP_PAINT_STENCILACCUM_IDX, 0, 0, yesno);
                 }
    void         setRayOrigin(const UT_Vector3 &orig, fpreal t) override
                 {
                     setFloat(SOP_PAINT_RAY_HITPOS_IDX, 0, t, orig.x());
                     setFloat(SOP_PAINT_RAY_HITPOS_IDX, 1, t, orig.y());
                     setFloat(SOP_PAINT_RAY_HITPOS_IDX, 2, t, orig.z());
                 }
    void         setRayOrientation(const UT_Vector3 &orient, fpreal t) override
                 {
                     setFloat(SOP_PAINT_RAY_ORIENT_IDX, 0, t, orient.x());
                     setFloat(SOP_PAINT_RAY_ORIENT_IDX, 1, t, orient.y());
                     setFloat(SOP_PAINT_RAY_ORIENT_IDX, 2, t, orient.z());
                 }
    void         setHitPrimitive(int primidx, fpreal t) override
                 {
                     setInt(SOP_PAINT_RAY_HITPRIM_IDX, 0, t, primidx);
                 }
    void         setHitPoint(int pt, fpreal t) override
                 {
                     setInt(SOP_PAINT_RAY_HITPT_IDX, 0, t, pt);
                 }
    void         setHitUVW(fpreal u, fpreal v, fpreal w, fpreal t) override
                 {
                     setFloat(SOP_PAINT_RAY_HITUVW_IDX, 0, t, u);
                     setFloat(SOP_PAINT_RAY_HITUVW_IDX, 1, t, v);
                     setFloat(SOP_PAINT_RAY_HITUVW_IDX, 2, t, w);
                 }
    void         setHitPressure(fpreal p, fpreal t) override
                 {
                     setFloat(SOP_PAINT_RAY_HITPRESSURE_IDX, 0, t, p);
                 }   
    void         setRadius(fpreal r, fpreal t) override
                 {
                     setFloat(SOP_PAINT_RAD_IDX, 0, t, r);
                 }
    void         setUVRadius(fpreal r, fpreal t) override
                 {
                     setFloat(SOP_PAINT_UVRAD_IDX, 0, t, r);
                 }
    void         setBrushEvent(SOP_BrushEvent event) override
                 {
                     setInt(SOP_PAINT_RAY_EVENT_IDX, 0, 0, int(event));
                 }
    void         setBrushOp(SOP_BrushOp op) override
                 {
                     int iop;
                     switch (op)
                     {
                         case SOP_BRUSHOP_EYEDROP:      iop = 1; break;
                         case SOP_BRUSHOP_SMOOTHATTRIB: iop = 2; break;
                         case SOP_BRUSHOP_ERASE:        iop = 3; break;
                         case SOP_BRUSHOP_PAINT:
                         default:                       iop = 0; break;
                     }
                     setInt(SOP_PAINT_OP_IDX, 0, 0, iop);
                 }
    void         setBrushShape(SOP_BrushShape shape) override
                 {
                     setInt(SOP_PAINT_SHAPE_IDX, 0, 0, int(shape));
                 }
    void         setProjectionType(int projtype) override
                 {
                     setInt(SOP_PAINT_PROJTYPE_IDX, 0, 0, projtype);
                 }
    void         useForegroundColor() override
                 {
                     setInt(SOP_PAINT_COLOR_SWITCHER_IDX, 0, 0, 0);
                 }
    void         useBackgroundColor() override
                 {
                     setInt(SOP_PAINT_COLOR_SWITCHER_IDX, 0, 0, 1);
                 }

    void         setCurrentColor(const UT_Vector3 &cd) override
                {
                    int         idx;
                    idx = USE_FOREGROUND() ?SOP_PAINT_FG_IDX :SOP_PAINT_BG_IDX;
                    setFloat(idx, 0, 0, cd.x());
                    setFloat(idx, 1, 0, cd.y());
                    setFloat(idx, 2, 0, cd.z());
                }
    void         setVisualization(bool state) override
                {
                    // only trigger recooks if different!
                    if (myForceVisualize != state)
                    {
                        myForceVisualize = state;
                        forceRecook();
                    }
                }

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

protected:
    void                doErase() override;

public:
    int                 altersGeometry() const override { return 0; }
    int                 altersColor() const override { return 1; }
    fpreal              RAWRADIUS(fpreal t) override
                            { return evalFloat(SOP_PAINT_RAD_IDX, 0, t); }
    fpreal              RAWUVRADIUS(fpreal t) override
                            { return evalFloat(SOP_PAINT_UVRAD_IDX, 0, t); }
    fpreal              RADIUSPRESSURE(fpreal t) override
                        { return evalFloat(SOP_PAINT_RADPRESSURE_IDX, 0, t); }
    fpreal              RAWOPACITY(fpreal t) override
                            {return evalFloat(SOP_PAINT_OPAC_IDX, 0, t) ; }
    fpreal              OPACITYPRESSURE(fpreal t) override
                        {return evalFloat(SOP_PAINT_OPACPRESSURE_IDX, 0, t) ; }

    SOP_BrushOp          OP() override 
                        { 
                            switch (evalInt(SOP_PAINT_OP_IDX, 0, 0))
                            {
                                case 0: return SOP_BRUSHOP_PAINT;
                                case 1: return SOP_BRUSHOP_EYEDROP;
                                case 2: return SOP_BRUSHOP_SMOOTHATTRIB;
                                case 3: default: return SOP_BRUSHOP_ERASE;
                            }
                        }

    int                 ACCUMSTENCIL() override 
                            { return evalInt(SOP_PAINT_STENCILACCUM_IDX, 0, 0);}
    int                 PROJECTIONTYPE() override
                            { return evalInt(SOP_PAINT_PROJTYPE_IDX, 0, 0); }
    int                 REALTIME() override
                            { return evalInt(SOP_PAINT_REALTIME_IDX, 0, 0); }
    int                 SHAPE(fpreal t) override
                            { return evalInt(SOP_PAINT_SHAPE_IDX,  0, t); }

protected:
    int                 MERGEMODE() override
                            { return evalInt(SOP_PAINT_MERGEMODE_IDX, 0, 0); }
    void                SCRIPT(UT_String &, fpreal) override {}
    int                 AXIS() override         { return   0 ;  }
    fpreal              USERX(fpreal) override  { return 0.0;  }
    fpreal              USERY(fpreal) override  { return 0.0;  }
    fpreal              USERZ(fpreal) override  { return 0.0;  }

    fpreal              RAYORIENTX(fpreal t) override
                            { return evalFloat(SOP_PAINT_RAY_ORIENT_IDX,0,t); }
    fpreal              RAYORIENTY(fpreal t) override
                            { return evalFloat(SOP_PAINT_RAY_ORIENT_IDX,1,t); }
    fpreal              RAYORIENTZ(fpreal t) override
                            { return evalFloat(SOP_PAINT_RAY_ORIENT_IDX,2,t); }
    fpreal              RAYHITX(fpreal t) override
                            { return evalFloat(SOP_PAINT_RAY_HITPOS_IDX,0,t); }
    fpreal              RAYHITY(fpreal t) override
                            { return evalFloat(SOP_PAINT_RAY_HITPOS_IDX,1,t); }
    fpreal              RAYHITZ(fpreal t) override
                            { return evalFloat(SOP_PAINT_RAY_HITPOS_IDX,2,t); }
    fpreal              RAYHITU(fpreal t) override
                            { return evalFloat(SOP_PAINT_RAY_HITUVW_IDX, 0,t); }
    fpreal              RAYHITV(fpreal t) override
                            { return evalFloat(SOP_PAINT_RAY_HITUVW_IDX, 1,t); }
    fpreal              RAYHITW(fpreal t) override
                            { return evalFloat(SOP_PAINT_RAY_HITUVW_IDX, 2,t); }
    fpreal              RAYHITPRESSURE(fpreal t) override
                            { return evalFloat(SOP_PAINT_RAY_HITPRESSURE_IDX, 0, t); }
    int                 PRIMHIT(fpreal t) override
                            { return evalInt(SOP_PAINT_RAY_HITPRIM_IDX, 0,t); }
    int                 PTHIT(fpreal t) override
                            { return evalInt(SOP_PAINT_RAY_HITPT_IDX, 0, t); }
    int                 EVENT() override
                            { return evalInt(SOP_PAINT_RAY_EVENT_IDX,   0,0); }
    bool                USE_FOREGROUND() override
                            { return evalInt(SOP_PAINT_COLOR_SWITCHER_IDX,
                                                                  0, 0) == 0; }

    fpreal              FGR(fpreal t) override
                            { return evalFloat(SOP_PAINT_FG_IDX, 0, t); }
    fpreal              FGG(fpreal t) override
                            { return evalFloat(SOP_PAINT_FG_IDX, 1, t); }
    fpreal              FGB(fpreal t) override
                            { return evalFloat(SOP_PAINT_FG_IDX, 2, t); }
    fpreal              BGR(fpreal t) override
                            { return evalFloat(SOP_PAINT_BG_IDX, 0, t); }
    fpreal              BGG(fpreal t) override
                            { return evalFloat(SOP_PAINT_BG_IDX, 1, t); }
    fpreal              BGB(fpreal t) override
                            { return evalFloat(SOP_PAINT_BG_IDX, 2, t); }

    fpreal              SOFTEDGE(fpreal t) override
                            { return evalFloat(SOP_PAINT_SOFTEDGE_IDX, 0, t); }
    void                KERNEL(UT_String &str, fpreal t) override 
                            { evalString(str, SOP_PAINT_KERNEL_IDX, 0, t); }
    int                 UPTYPE(fpreal t) override
                            { return evalInt(SOP_PAINT_UPTYPE_IDX, 0, t); }
    fpreal              UPX(fpreal t) override
                            { return evalFloat(SOP_PAINT_UPVECTOR_IDX, 0, t); }
    fpreal              UPY(fpreal t) override
                            { return evalFloat(SOP_PAINT_UPVECTOR_IDX, 1, t); }
    fpreal              UPZ(fpreal t) override
                            { return evalFloat(SOP_PAINT_UPVECTOR_IDX, 2, t); }

    fpreal              PAPERNOISE(fpreal t) override
                            { return evalFloat(SOP_PAINT_PAPER_IDX, 0, t); }
    fpreal              SPLATTER(fpreal t) override
                            { return evalFloat(SOP_PAINT_SPLATTER_IDX, 0, t); }
    void                BITMAP(UT_String &str, fpreal t) override
                            { evalString(str, SOP_PAINT_BITMAP_IDX, 0, t); }
    int                 BITMAPCHAN(fpreal t) override
                            { return evalInt(SOP_PAINT_BITMAPCHAN_IDX, 0, t); }
    fpreal              ANGLE(fpreal t) override
                            { return evalFloat(SOP_PAINT_ANGLE_IDX,  0, t); }
    fpreal              SQUASH(fpreal t) override
                            { return evalFloat(SOP_PAINT_SQUASH_IDX, 0, t); }
    int                 DOSTAMPING() override
                            { return evalInt(SOP_PAINT_STAMP_IDX,    0, 0); }
    int                 WRITEALPHA() override
                            { return evalInt(SOP_PAINT_WRITEALPHA_IDX, 0, 0); }

    int                 OVERRIDECD() override
                            { return evalInt(SOP_PAINT_OVERRIDECD_IDX, 0, 0); }
    void                CDNAME(UT_String &str, fpreal t) override
                            { evalString(str, SOP_PAINT_CDNAME_IDX, 0, t); }
    int                 OVERRIDEALPHA() override
                            { return evalInt(SOP_PAINT_OVERRIDEALPHA_IDX,0,0); }
    void                ALPHANAME(UT_String &str, fpreal t) override
                            { evalString(str, SOP_PAINT_ALPHANAME_IDX, 0,t); }
    int                 OVERRIDENML() override { return 0; }
    void                NMLNAME(UT_String & /*str*/, fpreal /*t*/) override {}

    fpreal              SYMMETRYDIRX(fpreal t) override 
                            { return evalFloat(SOP_PAINT_SYMAXIS_IDX, 0, t); }
    fpreal              SYMMETRYDIRY(fpreal t) override 
                            { return evalFloat(SOP_PAINT_SYMAXIS_IDX, 1, t); }
    fpreal              SYMMETRYDIRZ(fpreal t) override 
                            { return evalFloat(SOP_PAINT_SYMAXIS_IDX, 2, t); }
    fpreal              SYMMETRYORIGX(fpreal t) override 
                            { return evalFloat(SOP_PAINT_SYMORIG_IDX, 0, t); }
    fpreal              SYMMETRYORIGY(fpreal t) override 
                            { return evalFloat(SOP_PAINT_SYMORIG_IDX, 1, t); }
    fpreal              SYMMETRYORIGZ(fpreal t) override 
                            { return evalFloat(SOP_PAINT_SYMORIG_IDX, 2, t); }
    int                 DOREFLECTION() override 
                            { return evalInt(SOP_PAINT_DOREFLECT_IDX,0, 0); }
    int                 DOROTATION() override 
                            { return evalInt(SOP_PAINT_DOROTATION_IDX,0, 0); }
    int                 SYMMETRYROT(fpreal t) override 
                            { return evalInt(SOP_PAINT_SYMROT_IDX,0, t); }
    fpreal              SYMMETRYDIST(fpreal t) override 
                            { return evalFloat(SOP_PAINT_SYMDIST_IDX,0, t); }

    int                 DOUVREFLECTION() override
                            { return evalInt(SOP_PAINT_DOUVREFLECT_IDX, 0, 0); }
    fpreal              SYMMETRYUVORIGU(fpreal t) override
                            { return evalFloat(SOP_PAINT_SYMUVORIG_IDX, 0, t); }
    fpreal              SYMMETRYUVORIGV(fpreal t) override
                            { return evalFloat(SOP_PAINT_SYMUVORIG_IDX, 1, t); }
    fpreal              SYMMETRYUVANGLE(fpreal t) override
                            { return evalFloat(SOP_PAINT_SYMUVANGLE_IDX, 0, t);}

    int                 ADDATTRIB() override
                            { return evalInt(SOP_PAINT_ADDATTRIB_IDX, 0, 0); }
    int                 VISUALIZE() override
                            { return myForceVisualize ||
                                    evalInt(SOP_PAINT_VISUALIZE_IDX, 0, 0); }
    fpreal              VISLOW(fpreal t) override
                            { return evalFloat(SOP_PAINT_VISRANGE_IDX, 0, t); }
    fpreal              VISHIGH(fpreal t) override
                            { return evalFloat(SOP_PAINT_VISRANGE_IDX, 1, t); }
    int                 VISMODE() override
                            { return evalInt(SOP_PAINT_VISMODE_IDX, 0, 0); }

    int                 USECONNECTIVITY() override
                            { return evalInt(SOP_PAINT_USECONNECTIVITY_IDX, 0, 0); }
    int                 USENORMALS() override
                            { return evalInt(SOP_PAINT_USENORMALS_IDX, 0, 0); }
    int                 USEDEPTH() override
                            { return evalInt(SOP_PAINT_USEDEPTH_IDX, 0, 0); }
    fpreal              DEPTH(fpreal t) override
                            { return evalFloat(SOP_PAINT_DEPTH_IDX, 0, t); }
    fpreal              HEIGHT(fpreal t) override
                            { return evalFloat(SOP_PAINT_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.
    bool                hasStrokeChanged(fpreal t) override;
    bool                hasStyleChanged(fpreal t) override;

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

    bool                hasVisrangeChanged(fpreal t) override;
};

#endif