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

#ifndef __SOP_Comb_h__
#define __SOP_Comb_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_COMB_GRP_IDX = SOP_GDT_GRP_IDX,

    SOP_COMB_SWITCHER_IDX,

#define SOP_COMB_NUM_DEFORM_PARMS       (6)
    SOP_COMB_LIFT_IDX,
    SOP_COMB_PRESERVENML_IDX,
    SOP_COMB_OVRNML_IDX,
    SOP_COMB_NMLNAME_IDX,
    SOP_COMB_CLEARALL_IDX,
    SOP_COMB_OP_IDX,

#define SOP_COMB_NUM_NIB_PARMS (18)
    SOP_COMB_SHAPE_IDX,
    SOP_COMB_BITMAP_IDX,
    SOP_COMB_BITMAPCHAN_IDX,
    SOP_COMB_RAD_IDX,
    SOP_COMB_UVRAD_IDX,
    SOP_COMB_RADPRESSURE_IDX,
    SOP_COMB_USEDEPTH_IDX,
    SOP_COMB_DEPTH_IDX,
    SOP_COMB_ANGLE_IDX,
    SOP_COMB_SQUASH_IDX,
    SOP_COMB_OPAC_IDX,
    SOP_COMB_OPACPRESSURE_IDX,
    SOP_COMB_SPLATTER_IDX,
    SOP_COMB_PAPER_IDX,
    SOP_COMB_SOFTEDGE_IDX,
    SOP_COMB_KERNEL_IDX,
    SOP_COMB_UPTYPE_IDX,
    SOP_COMB_UPVECTOR_IDX,

#define SOP_COMB_NUM_SYM_PARMS (9)
    SOP_COMB_DOREFLECT_IDX,
    SOP_COMB_DOROTATION_IDX,
    SOP_COMB_SYMAXIS_IDX,
    SOP_COMB_SYMORIG_IDX,
    SOP_COMB_SYMROT_IDX,
    SOP_COMB_SYMDIST_IDX,
    SOP_COMB_DOUVREFLECT_IDX,
    SOP_COMB_SYMUVORIG_IDX,
    SOP_COMB_SYMUVANGLE_IDX,

#define SOP_COMB_NUM_RAY_PARMS  (11)
    SOP_COMB_PROJTYPE_IDX,
    SOP_COMB_USECONNECTIVITY_IDX,
    SOP_COMB_USENORMALS_IDX,
    SOP_COMB_REALTIME_IDX,
    SOP_COMB_RAY_ORIENT_IDX,
    SOP_COMB_RAY_HITPOS_IDX,
    SOP_COMB_RAY_HITPRIM_IDX,
    SOP_COMB_RAY_HITUVW_IDX,
    SOP_COMB_RAY_HITPRESSURE_IDX,
    SOP_COMB_RAY_HITPT_IDX,
    SOP_COMB_RAY_EVENT_IDX
};

class SOP_API SOP_Comb : public SOP_BrushBase
{
public:
             SOP_Comb(OP_Network *net, const char *name, OP_Operator *entry);
            ~SOP_Comb() 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_COMB_RAY_HITPOS_IDX, 0, t, orig.x());
                     setFloat(SOP_COMB_RAY_HITPOS_IDX, 1, t, orig.y());
                     setFloat(SOP_COMB_RAY_HITPOS_IDX, 2, t, orig.z());
                 }
    void         setRayOrientation(const UT_Vector3 &orient, fpreal t) override
                 {
                     setFloat(SOP_COMB_RAY_ORIENT_IDX, 0, t, orient.x());
                     setFloat(SOP_COMB_RAY_ORIENT_IDX, 1, t, orient.y());
                     setFloat(SOP_COMB_RAY_ORIENT_IDX, 2, t, orient.z());
                 }
    void         setHitPrimitive(int primidx, fpreal t) override
                 {
                     setInt(SOP_COMB_RAY_HITPRIM_IDX, 0, t, primidx);
                 }
    void         setRadius(fpreal r, fpreal t) override
                 {
                     setFloat(SOP_COMB_RAD_IDX, 0, t, r);
                 }
    void         setUVRadius(fpreal r, fpreal t) override
                 {
                     setFloat(SOP_COMB_UVRAD_IDX, 0, t, r);
                 }
    void         setHitPoint(int pt, fpreal t) override
                 {
                     setInt(SOP_COMB_RAY_HITPT_IDX, 0, t, pt);
                 }
    void         setHitUVW(fpreal u, fpreal v, fpreal w, fpreal t) override
                 {
                     setFloat(SOP_COMB_RAY_HITUVW_IDX, 0, t, u);
                     setFloat(SOP_COMB_RAY_HITUVW_IDX, 1, t, v);
                     setFloat(SOP_COMB_RAY_HITUVW_IDX, 2, t, w);
                 }
    void         setHitPressure(fpreal p, fpreal t) override
                 {
                     setFloat(SOP_COMB_RAY_HITPRESSURE_IDX, 0, t, p);
                 }
    void         setBrushEvent(SOP_BrushEvent event) override
                 {
                     setInt(SOP_COMB_RAY_EVENT_IDX, 0, 0, int(event));
                 }
    void         setBrushOp(SOP_BrushOp op) override
                 {
                     int iop;
                     switch (op)
                     {
                         default:
                         case SOP_BRUSHOP_COMB:         iop = 0; break;
                         case SOP_BRUSHOP_SMOOTHNORMAL: iop = 1; break;
                         case SOP_BRUSHOP_ERASE:        iop = 2; break;
                         case SOP_BRUSHOP_LIFT:         iop = 3; break;
                         case SOP_BRUSHOP_ROTATE:       iop = 4; break;
                     }
                     setInt(SOP_COMB_OP_IDX, 0, 0, iop);
                 }
    void         setBrushShape(SOP_BrushShape shape) override
                 {
                     setInt(SOP_COMB_SHAPE_IDX, 0, 0, int(shape));
                 }
    void         setProjectionType(int projtype) override
                 {
                     setInt(SOP_COMB_PROJTYPE_IDX, 0, 0, projtype);
                 }
    void         useForegroundColor() override
                 {
                 }
    void         useBackgroundColor() override
                 {
                 }

    int                 altersGeometry() const override { return 0; }
    int                 altersColor() const override { return 0; }
    fpreal              RAWRADIUS(fpreal t) override
                            { return evalFloat(SOP_COMB_RAD_IDX, 0, t); }
    fpreal              RAWUVRADIUS(fpreal t) override
                            { return evalFloat(SOP_COMB_UVRAD_IDX, 0, t); }
    fpreal              RADIUSPRESSURE(fpreal t) override
                        { return evalFloat(SOP_COMB_RADPRESSURE_IDX, 0, t); }
    fpreal              RAWOPACITY(fpreal t) override
                            {return evalFloat(SOP_COMB_OPAC_IDX, 0, t); }
    fpreal              OPACITYPRESSURE(fpreal t) override
                        {return evalFloat(SOP_COMB_OPACPRESSURE_IDX, 0, t) ; }

    SOP_BrushOp         OP() override
                        { 
                            switch (evalInt(SOP_COMB_OP_IDX, 0, 0))
                            {
                                default:
                                case 0: return SOP_BRUSHOP_COMB;
                                case 1: return SOP_BRUSHOP_SMOOTHNORMAL;
                                case 2: return SOP_BRUSHOP_ERASE;
                                case 3: return SOP_BRUSHOP_LIFT;
                                case 4: return SOP_BRUSHOP_ROTATE;
                            }
                        }
    int                 ACCUMSTENCIL() override { return 0; }
    int                 PROJECTIONTYPE() override
                            { return evalInt(SOP_COMB_PROJTYPE_IDX, 0, 0); }
    int                 REALTIME() override
                            { return evalInt(SOP_COMB_REALTIME_IDX, 0, 0); }
    int                 SHAPE(fpreal t) override
                            { return evalInt(SOP_COMB_SHAPE_IDX, 0, t); }
    int                 OVERRIDENML() override  
                            { return evalInt(SOP_COMB_OVRNML_IDX, 0, 0); }
    void                NMLNAME(UT_String &str, fpreal t) override
                            { evalString(str, SOP_COMB_NMLNAME_IDX, 0, t); }

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


    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_COMB_RAY_ORIENT_IDX, 0, t); }
    fpreal              RAYORIENTY(fpreal t) override
                            { return evalFloat(SOP_COMB_RAY_ORIENT_IDX, 1, t); }
    fpreal              RAYORIENTZ(fpreal t) override
                            { return evalFloat(SOP_COMB_RAY_ORIENT_IDX, 2, t); }
    fpreal              RAYHITX(fpreal t) override
                            { return evalFloat(SOP_COMB_RAY_HITPOS_IDX, 0, t); }
    fpreal              RAYHITY(fpreal t) override
                            { return evalFloat(SOP_COMB_RAY_HITPOS_IDX, 1, t); }
    fpreal              RAYHITZ(fpreal t) override
                            { return evalFloat(SOP_COMB_RAY_HITPOS_IDX, 2, t); }
    fpreal              RAYHITU(fpreal t) override
                            { return evalFloat(SOP_COMB_RAY_HITUVW_IDX,  0, t); }
    fpreal              RAYHITV(fpreal t) override
                            { return evalFloat(SOP_COMB_RAY_HITUVW_IDX,  1, t); }
    fpreal              RAYHITW(fpreal t) override
                            { return evalFloat(SOP_COMB_RAY_HITUVW_IDX,  2, t); }
    fpreal              RAYHITPRESSURE(fpreal t) override
                            { return evalFloat(SOP_COMB_RAY_HITPRESSURE_IDX, 0, t); }
    int                 PRIMHIT(fpreal t) override
                            { return   evalInt(SOP_COMB_RAY_HITPRIM_IDX,0, t); }
    int                 PTHIT(fpreal t) override
                            { return evalInt(SOP_COMB_RAY_HITPT_IDX, 0, t); }
    int                 EVENT() override
                            { return   evalInt(SOP_COMB_RAY_EVENT_IDX,  0, 0); }
    bool                USE_FOREGROUND() override
                            { return 1; }

    // We return the lift as our first entry of the foreground colour.
    fpreal              FGR(fpreal t) override
                        { return evalFloat(SOP_COMB_LIFT_IDX, 0, t); }
    fpreal              FGG(fpreal) override   { return 0.0; }
    fpreal              FGB(fpreal) override   { return 0.0; }
    fpreal              BGR(fpreal) override   { return 0.0; }
    fpreal              BGG(fpreal) override   { return 0.0; }
    fpreal              BGB(fpreal) override   { return 0.0; }

    fpreal              SOFTEDGE(fpreal t) override
                            { return evalFloat(SOP_COMB_SOFTEDGE_IDX, 0, t); }
    void                KERNEL(UT_String &str, fpreal t) override 
                            { evalString(str, SOP_COMB_KERNEL_IDX, 0, t); }
    int                 UPTYPE(fpreal t) override
                            { return evalInt(SOP_COMB_UPTYPE_IDX, 0, t); }
    fpreal              UPX(fpreal t) override
                            { return evalFloat(SOP_COMB_UPVECTOR_IDX, 0, t); }
    fpreal              UPY(fpreal t) override
                            { return evalFloat(SOP_COMB_UPVECTOR_IDX, 1, t); }
    fpreal              UPZ(fpreal t) override
                            { return evalFloat(SOP_COMB_UPVECTOR_IDX, 2, t); }

    fpreal              PAPERNOISE(fpreal t) override
                            { return evalFloat(SOP_COMB_PAPER_IDX, 0, t); }
    fpreal              SPLATTER(fpreal t) override
                            { return evalFloat(SOP_COMB_SPLATTER_IDX, 0, t); }
    void                BITMAP(UT_String &str, fpreal t) override
                            { evalString(str, SOP_COMB_BITMAP_IDX, 0, t); }
    int                 BITMAPCHAN(fpreal t) override
                            { return evalInt(SOP_COMB_BITMAPCHAN_IDX, 0, t); }
    fpreal              ANGLE(fpreal t) override
                            { return evalFloat(SOP_COMB_ANGLE_IDX,  0, t); }
    fpreal              SQUASH(fpreal t) override
                            { return evalFloat(SOP_COMB_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                 ADDATTRIB() override                    { return 1; }
    int                 PRESERVENML() override
                            { return evalInt(SOP_COMB_PRESERVENML_IDX, 0, 0); }
    fpreal              SYMMETRYDIRX(fpreal t) override 
                            { return evalFloat(SOP_COMB_SYMAXIS_IDX, 0, t); }
    fpreal              SYMMETRYDIRY(fpreal t) override 
                            { return evalFloat(SOP_COMB_SYMAXIS_IDX, 1, t); }
    fpreal              SYMMETRYDIRZ(fpreal t) override 
                            { return evalFloat(SOP_COMB_SYMAXIS_IDX, 2, t); }
    fpreal              SYMMETRYORIGX(fpreal t) override 
                            { return evalFloat(SOP_COMB_SYMORIG_IDX, 0, t); }
    fpreal              SYMMETRYORIGY(fpreal t) override 
                            { return evalFloat(SOP_COMB_SYMORIG_IDX, 1, t); }
    fpreal              SYMMETRYORIGZ(fpreal t) override 
                            { return evalFloat(SOP_COMB_SYMORIG_IDX, 2, t); }
    int                 DOREFLECTION() override 
                            { return evalInt(SOP_COMB_DOREFLECT_IDX,0, 0); }
    int                 DOROTATION() override 
                            { return evalInt(SOP_COMB_DOROTATION_IDX,0, 0); }
    int                 SYMMETRYROT(fpreal t) override 
                            { return evalInt(SOP_COMB_SYMROT_IDX,0, t); }
    fpreal              SYMMETRYDIST(fpreal t) override 
                            { return evalFloat(SOP_COMB_SYMDIST_IDX,0, t); }

    int                 DOUVREFLECTION() override
                            { return evalInt(SOP_COMB_DOUVREFLECT_IDX, 0, 0); }
    fpreal              SYMMETRYUVORIGU(fpreal t) override
                            { return evalFloat(SOP_COMB_SYMUVORIG_IDX, 0, t); }
    fpreal              SYMMETRYUVORIGV(fpreal t) override
                            { return evalFloat(SOP_COMB_SYMUVORIG_IDX, 1, t); }
    fpreal              SYMMETRYUVANGLE(fpreal t) override
                            { return evalFloat(SOP_COMB_SYMUVANGLE_IDX, 0, t);}

    int                 USECONNECTIVITY() override
                            { return evalInt(SOP_COMB_USECONNECTIVITY_IDX, 0, 0); }
    int                 USENORMALS() override
                            { return evalInt(SOP_COMB_USENORMALS_IDX, 0, 0); }
    int                 USEDEPTH() override
                            { return evalInt(SOP_COMB_USEDEPTH_IDX, 0, 0); }
    fpreal              DEPTH(fpreal t) override
                            { return evalFloat(SOP_COMB_DEPTH_IDX, 0, t); }
    fpreal              HEIGHT(fpreal t) override
                            { return evalFloat(SOP_COMB_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;

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

};

#endif