SOP_UVBrush.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 UVBrush SOP, which works in conjunction with the
 *           UVBrush State and the GDT classes.
 *
 */

#ifndef __SOP_UVBrush_h__
#define __SOP_UVBrush_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_UVBRUSH_GRP_IDX = SOP_GDT_GRP_IDX,

    SOP_UVBRUSH_UVATTRIB_IDX,

    SOP_UVBRUSH_SWITCHER_IDX,

#define SOP_UVBRUSH_NUM_DEFORM_PARMS    (4)
    SOP_UVBRUSH_FOREBACK_SWITCHER_IDX,
    SOP_UVBRUSH_FS_IDX,
    SOP_UVBRUSH_BS_IDX,
    SOP_UVBRUSH_FLOODAPPLY_IDX,
    SOP_UVBRUSH_OP_IDX,
    SOP_UVBRUSH_CLEARALL_IDX,

#define SOP_UVBRUSH_NUM_NIB_PARMS (18)
    SOP_UVBRUSH_SHAPE_IDX,
    SOP_UVBRUSH_BITMAP_IDX,
    SOP_UVBRUSH_BITMAPCHAN_IDX,
    SOP_UVBRUSH_RAD_IDX,
    SOP_UVBRUSH_UVRAD_IDX,
    SOP_UVBRUSH_RADPRESSURE_IDX,
    SOP_UVBRUSH_USEDEPTH_IDX,
    SOP_UVBRUSH_DEPTH_IDX,
    SOP_UVBRUSH_ANGLE_IDX,
    SOP_UVBRUSH_SQUASH_IDX,
    SOP_UVBRUSH_OPAC_IDX,
    SOP_UVBRUSH_OPACPRESSURE_IDX,
    SOP_UVBRUSH_SPLATTER_IDX,
    SOP_UVBRUSH_PAPER_IDX,
    SOP_UVBRUSH_SOFTEDGE_IDX,
    SOP_UVBRUSH_KERNEL_IDX,
    SOP_UVBRUSH_UPTYPE_IDX,
    SOP_UVBRUSH_UPVECTOR_IDX,

#define SOP_UVBRUSH_NUM_SYM_PARMS (9)
    SOP_UVBRUSH_DOREFLECT_IDX,
    SOP_UVBRUSH_DOROTATION_IDX,
    SOP_UVBRUSH_SYMAXIS_IDX,
    SOP_UVBRUSH_SYMORIG_IDX,
    SOP_UVBRUSH_SYMROT_IDX,
    SOP_UVBRUSH_SYMDIST_IDX,
    SOP_UVBRUSH_DOUVREFLECT_IDX,
    SOP_UVBRUSH_SYMUVORIG_IDX,
    SOP_UVBRUSH_SYMUVANGLE_IDX,

#define SOP_UVBRUSH_NUM_RAY_PARMS       (11)
    SOP_UVBRUSH_PROJTYPE_IDX,
    SOP_UVBRUSH_USECONNECTIVITY_IDX,
    SOP_UVBRUSH_USENORMALS_IDX,
    SOP_UVBRUSH_REALTIME_IDX,
    SOP_UVBRUSH_RAY_ORIENT_IDX,
    SOP_UVBRUSH_RAY_HITPOS_IDX,
    SOP_UVBRUSH_RAY_HITPRIM_IDX,
    SOP_UVBRUSH_RAY_HITUVW_IDX,
    SOP_UVBRUSH_RAY_HITPRESSURE_IDX,
    SOP_UVBRUSH_RAY_HITPT_IDX,
    SOP_UVBRUSH_RAY_EVENT_IDX
};

class SOP_API SOP_UVBrush : public SOP_BrushBase
{
public:
             SOP_UVBrush(OP_Network *net, const char *name, OP_Operator *entry);
            ~SOP_UVBrush() 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 ) override
                 {
                 }
    void         setRayOrigin(const UT_Vector3 &orig, fpreal t) override
                 {
                     setFloat(SOP_UVBRUSH_RAY_HITPOS_IDX, 0, t, orig.x());
                     setFloat(SOP_UVBRUSH_RAY_HITPOS_IDX, 1, t, orig.y());
                     setFloat(SOP_UVBRUSH_RAY_HITPOS_IDX, 2, t, orig.z());
                 }
    void         setRayOrientation(const UT_Vector3 &orient, fpreal t) override
                 {
                     setFloat(SOP_UVBRUSH_RAY_ORIENT_IDX, 0, t, orient.x());
                     setFloat(SOP_UVBRUSH_RAY_ORIENT_IDX, 1, t, orient.y());
                     setFloat(SOP_UVBRUSH_RAY_ORIENT_IDX, 2, t, orient.z());
                 }
    void         setHitPrimitive(int primidx, fpreal t) override
                 {
                     setInt(SOP_UVBRUSH_RAY_HITPRIM_IDX, 0, t, primidx);
                 }
    void         setHitPoint(int pt, fpreal t) override
                 {
                     setInt(SOP_UVBRUSH_RAY_HITPT_IDX, 0, t, pt);
                 }
    void         setHitUVW(fpreal u, fpreal v, fpreal w, fpreal t) override
                 {
                     setFloat(SOP_UVBRUSH_RAY_HITUVW_IDX, 0, t, u);
                     setFloat(SOP_UVBRUSH_RAY_HITUVW_IDX, 1, t, v);
                     setFloat(SOP_UVBRUSH_RAY_HITUVW_IDX, 2, t, w);
                 }
    void         setHitPressure(fpreal p, fpreal t) override
                 {
                     setFloat(SOP_UVBRUSH_RAY_HITPRESSURE_IDX, 0, t, p);
                 }   
    void         setRadius(fpreal r, fpreal t) override
                 {
                     setFloat(SOP_UVBRUSH_RAD_IDX, 0, t, r);
                 }
    void         setUVRadius(fpreal r, fpreal t) override
                 {
                     setFloat(SOP_UVBRUSH_UVRAD_IDX, 0, t, r);
                 }
    void         setBrushEvent(SOP_BrushEvent event) override
                 {
                     setInt(SOP_UVBRUSH_RAY_EVENT_IDX, 0, 0, int(event));
                 }
    void         setBrushOp(SOP_BrushOp op) override
                 {
                     int iop;
                     switch (op)
                     {
                         case SOP_BRUSHOP_SCALETEXTURE: iop = 1; break;
                         case SOP_BRUSHOP_SMOOTHTEXTURE:        iop = 2; break;
                         case SOP_BRUSHOP_ERASE:        iop = 3; break;
                         case SOP_BRUSHOP_DRAGTEXTURE:
                         default:                       iop = 0; break;
                     }
                     setInt(SOP_UVBRUSH_OP_IDX, 0, 0, iop);
                 }
    void         setBrushShape(SOP_BrushShape shape) override
                 {
                     setInt(SOP_UVBRUSH_SHAPE_IDX, 0, 0, int(shape));
                 }
    void         setProjectionType(int projtype) override
                 {
                     setInt(SOP_UVBRUSH_PROJTYPE_IDX, 0, 0, projtype);
                 }
    void         useForegroundColor() override
                 {
                     setInt(SOP_UVBRUSH_FOREBACK_SWITCHER_IDX, 0, 0, 0);
                 }
    void         useBackgroundColor() override
                 {
                     setInt(SOP_UVBRUSH_FOREBACK_SWITCHER_IDX, 0, 0, 1);
                 }

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

    void         getDescriptiveParmName(UT_String &name) const override
    {
        name = "uvattrib";
    }

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

protected:
    void                doErase() override;
    void                addEraseAttributes(GU_Brush &brush) override;

public:
    int                 altersGeometry() const override { return 0; }
    int                 altersColor() const override { return 0; }
    fpreal              RAWRADIUS(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_RAD_IDX, 0, t); }
    fpreal              RAWUVRADIUS(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_UVRAD_IDX, 0, t); }
    fpreal              RADIUSPRESSURE(fpreal t) override
                        { return evalFloat(SOP_UVBRUSH_RADPRESSURE_IDX, 0, t); }
    fpreal              RAWOPACITY(fpreal t) override
                            {return evalFloat(SOP_UVBRUSH_OPAC_IDX, 0, t) ; }
    fpreal              OPACITYPRESSURE(fpreal t) override
                        {return evalFloat(SOP_UVBRUSH_OPACPRESSURE_IDX, 0, t) ; }

    SOP_BrushOp         OP() override 
                        { 
                            switch (evalInt(SOP_UVBRUSH_OP_IDX, 0, 0))
                            {
                                case 0: return SOP_BRUSHOP_DRAGTEXTURE;
                                case 1: return SOP_BRUSHOP_SCALETEXTURE;
                                case 2: return SOP_BRUSHOP_SMOOTHTEXTURE;
                                case 3: default: return SOP_BRUSHOP_ERASE;
                            }
                        }

    int                 ACCUMSTENCIL() override 
                            { return 0;}
    int                 PROJECTIONTYPE() override
                            { return evalInt(SOP_UVBRUSH_PROJTYPE_IDX, 0, 0); }
    int                 REALTIME() override
                            { return evalInt(SOP_UVBRUSH_REALTIME_IDX, 0, 0); }
    int                 SHAPE(fpreal t) override
                            { return evalInt(SOP_UVBRUSH_SHAPE_IDX,  0, t); }

protected:
    int                 MERGEMODE() override
                            { return 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_UVBRUSH_RAY_ORIENT_IDX,0,t); }
    fpreal              RAYORIENTY(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_RAY_ORIENT_IDX,1,t); }
    fpreal              RAYORIENTZ(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_RAY_ORIENT_IDX,2,t); }
    fpreal              RAYHITX(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_RAY_HITPOS_IDX,0,t); }
    fpreal              RAYHITY(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_RAY_HITPOS_IDX,1,t); }
    fpreal              RAYHITZ(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_RAY_HITPOS_IDX,2,t); }
    fpreal              RAYHITU(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_RAY_HITUVW_IDX, 0,t); }
    fpreal              RAYHITV(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_RAY_HITUVW_IDX, 1,t); }
    fpreal              RAYHITW(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_RAY_HITUVW_IDX, 2,t); }
    fpreal              RAYHITPRESSURE(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_RAY_HITPRESSURE_IDX, 0, t); }
    int                 PRIMHIT(fpreal t) override
                            { return evalInt(SOP_UVBRUSH_RAY_HITPRIM_IDX, 0,t); }
    int                 PTHIT(fpreal t) override
                            { return evalInt(SOP_UVBRUSH_RAY_HITPT_IDX, 0, t); }
    int                 EVENT() override
                            { return evalInt(SOP_UVBRUSH_RAY_EVENT_IDX,   0,0); }
    bool                USE_FOREGROUND() override
                            { return evalInt(SOP_UVBRUSH_FOREBACK_SWITCHER_IDX,
                                                                  0, 0) == 0; }

    fpreal              FGR(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_FS_IDX,      0, t); }
    fpreal              FGG(fpreal  ) override
                            { return 0; }
    fpreal              FGB(fpreal  ) override
                            { return 0; }
    fpreal              BGR(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_BS_IDX,      0, t); }
    fpreal              BGG(fpreal  ) override
                            { return 0; }
    fpreal              BGB(fpreal  ) override
                            { return 0; }

    fpreal              SOFTEDGE(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_SOFTEDGE_IDX, 0, t); }
    void                KERNEL(UT_String &str, fpreal t) override 
                            { evalString(str, SOP_UVBRUSH_KERNEL_IDX, 0, t); }
    int                 UPTYPE(fpreal t) override
                            { return evalInt(SOP_UVBRUSH_UPTYPE_IDX, 0, t); }
    fpreal              UPX(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_UPVECTOR_IDX, 0, t); }
    fpreal              UPY(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_UPVECTOR_IDX, 1, t); }
    fpreal              UPZ(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_UPVECTOR_IDX, 2, t); }

    fpreal              PAPERNOISE(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_PAPER_IDX, 0, t); }
    fpreal              SPLATTER(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_SPLATTER_IDX, 0, t); }
    void                BITMAP(UT_String &str, fpreal t) override
                            { evalString(str, SOP_UVBRUSH_BITMAP_IDX, 0, t); }
    int                 BITMAPCHAN(fpreal t) override
                            { return evalInt(SOP_UVBRUSH_BITMAPCHAN_IDX, 0, t); }
    fpreal              ANGLE(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_ANGLE_IDX,  0, t); }
    fpreal              SQUASH(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_SQUASH_IDX, 0, t); }
    int                 DOSTAMPING() override { return 0; }
    int                 WRITEALPHA() override { return 0; }

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

    fpreal              SYMMETRYDIRX(fpreal t) override 
                            { return evalFloat(SOP_UVBRUSH_SYMAXIS_IDX, 0, t); }
    fpreal              SYMMETRYDIRY(fpreal t) override 
                            { return evalFloat(SOP_UVBRUSH_SYMAXIS_IDX, 1, t); }
    fpreal              SYMMETRYDIRZ(fpreal t) override 
                            { return evalFloat(SOP_UVBRUSH_SYMAXIS_IDX, 2, t); }
    fpreal              SYMMETRYORIGX(fpreal t) override 
                            { return evalFloat(SOP_UVBRUSH_SYMORIG_IDX, 0, t); }
    fpreal              SYMMETRYORIGY(fpreal t) override 
                            { return evalFloat(SOP_UVBRUSH_SYMORIG_IDX, 1, t); }
    fpreal              SYMMETRYORIGZ(fpreal t) override 
                            { return evalFloat(SOP_UVBRUSH_SYMORIG_IDX, 2, t); }
    int                 DOREFLECTION() override 
                            { return evalInt(SOP_UVBRUSH_DOREFLECT_IDX,0, 0); }
    int                 DOROTATION() override 
                            { return evalInt(SOP_UVBRUSH_DOROTATION_IDX,0, 0); }
    int                 SYMMETRYROT(fpreal t) override 
                            { return evalInt(SOP_UVBRUSH_SYMROT_IDX,0, t); }
    fpreal              SYMMETRYDIST(fpreal t) override 
                            { return evalFloat(SOP_UVBRUSH_SYMDIST_IDX,0, t); }

    int                 DOUVREFLECTION() override
                            { return evalInt(SOP_UVBRUSH_DOUVREFLECT_IDX, 0, 0); }
    fpreal              SYMMETRYUVORIGU(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_SYMUVORIG_IDX, 0, t); }
    fpreal              SYMMETRYUVORIGV(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_SYMUVORIG_IDX, 1, t); }
    fpreal              SYMMETRYUVANGLE(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_SYMUVANGLE_IDX, 0, t);}

    int                 ADDATTRIB() override { return 0; }
    void                UVATTRIB(UT_String &uvattribname, fpreal t) override
                            { evalString(uvattribname, "uvattrib", 0, t); }
    int                 VISUALIZE() override { return 0; }
    fpreal              VISLOW(fpreal) override { return 0; }
    fpreal              VISHIGH(fpreal) override { return 1; }
    int                 VISMODE() override { return 0; }

    int                 USECONNECTIVITY() override
                            { return evalInt(SOP_UVBRUSH_USECONNECTIVITY_IDX, 0, 0); }
    int                 USENORMALS() override
                            { return evalInt(SOP_UVBRUSH_USENORMALS_IDX, 0, 0); }
    int                 USEDEPTH() override
                            { return evalInt(SOP_UVBRUSH_USEDEPTH_IDX, 0, 0); }
    fpreal              DEPTH(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_DEPTH_IDX, 0, t); }
    fpreal              HEIGHT(fpreal t) override
                            { return evalFloat(SOP_UVBRUSH_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