SOP_BrushHairLen.h

Go to the documentation of this file.

/*
 * Copyright (c) 2024
 *      Side Effects Software Inc.  All rights reserved.
 *
 * Redistribution and use of Houdini Development Kit samples in source and
 * binary forms, with or without modification, are permitted provided that the
 * following conditions are met:
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. The name of Side Effects Software may not be used to endorse or
 *    promote products derived from this software without specific prior
 *    written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE `AS IS' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
 * NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *----------------------------------------------------------------------------
 */

#ifndef __SOP_BrushHairLen__
#define __SOP_BrushHairLen__

#include <SOP/SOP_Node.h>
#include <SOP/SOP_BrushBase.h>

namespace HDK_Sample {
class SOP_BrushHairLen : public SOP_BrushBase
{
public:
             SOP_BrushHairLen(OP_Network *net, const char *, OP_Operator *entry);
            ~SOP_BrushHairLen() override;

    static OP_Node      *myConstructor(OP_Network  *net, const char *name,
                                       OP_Operator *entry);
    static PRM_Template  myTemplateList[];

    /// This is the callback triggered when a BRUSHOP_CALLBACK is used:
    void                 brushOpCallback(
                            fpreal t,
                            GA_Offset pt,
                            const UT_Array<GA_Offset> *ptneighbour,
                            GA_Offset vtx,
                            const UT_Array<GA_Offset> *vtxneighbour,
                            float alpha,
                            GEO_Delta *delta,
                            const GU_Detail *gdp) override;

protected:
    OP_ERROR             cookMySop(OP_Context &context) override;

    /// These are the many & various methods used by BrushBase to
    /// determine the current brush status.  We can either hook them
    /// up to parameters (via evalFloat) or hard code them.  In this
    /// case we have hard coded most.

    /// Public methods needed by MSS:
public:
    /// Finds the geometry to do the intersection with.
    const GU_Detail    *getIsectGdp(fpreal t) override;
    
    /// If the action of the brush will change point positions,
    /// we should set this to 1.  We create geometry, but leave point
    /// positions untouched.
    int                 altersGeometry() const override
        { return 0; }
    /// We do attribute changes.
    int                 altersColor() const override
        { return 1; }
    /// This gets the current radius of the brush, unmodulated by the
    /// current pressure amount.
    fpreal              RAWRADIUS(fpreal t) override
        { return evalFloat("radius", 0, t); }
    /// This gets the raw radius for the UV space.
    fpreal              RAWUVRADIUS(fpreal t) override
        { return evalFloat("uvradius", 0, t); }
    /// This is how much the HITPRESSURE should affect the RADIUS.
    fpreal              RADIUSPRESSURE(fpreal /*t*/) override
        { return 1.0f; }
    /// The opacity, hardcoded to 1.0f, for a full replace
    fpreal              RAWOPACITY(fpreal /*t*/) override
        { return 1.0f; }
    fpreal              OPACITYPRESSURE(fpreal /*t*/) override
        { return 1.0f; }

    /// This is how far along the brush axis it will be able to paint.
    /// We tie it directly to the raidus here.
    fpreal              DEPTH(fpreal t) override
        { return evalFloat("radius", 0, t); }
    fpreal              HEIGHT(fpreal t) override
        { return evalFloat("radius", 0, t); }
    /// Whether to use depth clipping at all.
    int                 USEDEPTH() override
        { return 1; }
    /// Whether to not paint across unconnected seams.  We are using depth
    /// clipping in this tool, so have it off.
    int                 USECONNECTIVITY() override
        { return 0; }

    /// This needs to map our OP_Menu into SOP_BrushOp.  We leave this
    /// to the C code.
    SOP_BrushOp         OP() override;

    /// Whether accumulate stencil is currently on.  We keep it off.
    int                 ACCUMSTENCIL() override
        { return 0; }
    /// Projection Type 1 is orient to surface, 0 is to use it flat on.
    /// We hard code it to flat on.
    int                 PROJECTIONTYPE() override
        { return 0; }
    /// In realtime mode, all changes are applied immediately to the
    /// gdp, rather than being stored in the CurrentDelta during a brush
    /// stroke.  Some types of brushing require this behaviour implicitly.
    int                 REALTIME() override
        { return 1; }
    /// This returns a SOP_BrushShape.  We hardcode to circle.
    int                 SHAPE(fpreal /*t*/) override
        { return SOP_BRUSHSHAPE_CIRCLE; }

    /// Protected methods needed by SOP_BrushBase:
protected:
    /// This returns a GU_BrushMergeMode, defined in GU_Brush.h
    /// We just use the standard replace.
    int                 MERGEMODE() override
        { return GU_BRUSHMERGEMODE_REPLACE; }

    /// Not used:
    void                SCRIPT(UT_String & /*s*/, fpreal /*t*/) override
        { }
    
    /// These are used by deformation brush ops:
    int                 AXIS() override
        { return 0; }
    fpreal              USERX(fpreal /*t*/) override
        { return 0.0f; }
    fpreal              USERY(fpreal /*t*/) override
        { return 0.0f; }
    fpreal              USERZ(fpreal /*t*/) override
        { return 0.0f; }

    /// These query the current raystate.  We read off the cached values...
    fpreal              RAYORIENTX(fpreal /*t*/) override
        { return myRayOrient.x(); }
    fpreal              RAYORIENTY(fpreal /*t*/) override
        { return myRayOrient.y(); }
    fpreal              RAYORIENTZ(fpreal /*t*/) override
        { return myRayOrient.z(); }
    fpreal              RAYHITX(fpreal /*t*/) override
        { return myRayHit.x(); }
    fpreal              RAYHITY(fpreal /*t*/) override
        { return myRayHit.y(); }
    fpreal              RAYHITZ(fpreal /*t*/) override
        { return myRayHit.z(); }
    fpreal              RAYHITU(fpreal /*t*/) override
        { return myRayHitU; }
    fpreal              RAYHITV(fpreal /*t*/) override
        { return myRayHitV; }
    fpreal              RAYHITW(fpreal /*t*/) override
        { return myRayHitW; }
    fpreal              RAYHITPRESSURE(fpreal /*t*/) override
        { return myRayHitPressure; }
    int                 PRIMHIT(fpreal /*t*/) override
        { return myPrimHit; }
    int                 PTHIT(fpreal /*t*/) override
        { return myPtHit; }
    int                 EVENT() override
        { return myEvent; }

    /// These query the current "colours" of the brush...
    /// F is for foreground, B, for background.  Up to a 3 vector is
    /// possible in the order R, G, B.
    /// If USE_FOREGROUND is true, the F will be used, otherwise B.
    bool                USE_FOREGROUND() override
        { return myUseFore; }
    fpreal              FGR(fpreal t) override
        { return evalFloat("flen", 0, t); }
    fpreal              FGG(fpreal /*t*/) override
        { return 0.0f; }
    fpreal              FGB(fpreal /*t*/) override
        { return 0.0f; }
    fpreal              BGR(fpreal t) override
        { return evalFloat("blen", 0, t); }
    fpreal              BGG(fpreal /*t*/) override
        { return 0.0f; }
    fpreal              BGB(fpreal /*t*/) override
        { return 0.0f; }

    /// These control the shape of the nib.  We have hard coded
    /// most of them...
    /// What percentage of the radius to devote to the fall off curve.
    fpreal              SOFTEDGE(fpreal /*t*/) override
        { return 1.0f; }
    /// Which metaball kernel to use as the fall off curve.
    void                KERNEL(UT_String &str, fpreal /*t*/) override
        { str = "Elendt"; }
    /// How to determine the upvector, unnecessary with circular brushes.
    int                 UPTYPE(fpreal /*t*/) override
        { return 0; }
    fpreal              UPX(fpreal /*t*/) override
        { return 0.0f; }
    fpreal              UPY(fpreal /*t*/) override
        { return 0.0f; }
    fpreal              UPZ(fpreal /*t*/) override
        { return 0.0f; }

    /// Alpha noise in the paper space
    fpreal              PAPERNOISE(fpreal /*t*/) override
        { return 0.0f; }
    /// Alpha noise in the brush space
    fpreal              SPLATTER(fpreal /*t*/) override
        { return 0.0f; }
    /// Name of the bitmap to use if bitmap brush is on, which it isn't.
    void                BITMAP(UT_String & /*str*/, fpreal /*t*/) override
        { }
    /// Which channel of the bitmap brush should be used.
    int                 BITMAPCHAN(fpreal /*t*/) override
        { return 0; }
    /// More hard coded stuff directly from the Nib tab...
    fpreal              ANGLE(fpreal /*t*/) override
        { return 0.0f; }
    fpreal              SQUASH(fpreal /*t*/) override
        { return 1.0f; }
    int                 DOSTAMPING() override
        { return 0; }
    int                 WRITEALPHA() override
        { return 0; }
    /// We explicitly override these parameters as we want the brush
    /// to automatically edit our "hairlen" point attribute.
    int                 OVERRIDECD() override
        { return 1; }
    void                CDNAME(UT_String &str, fpreal /*t*/) override
        { str = "hairlen"; }
    /// As WRITEALPHA is off, this is irrelevant:
    int                 OVERRIDEALPHA() override
        { return 0; }
    void                ALPHANAME(UT_String & /*str*/, fpreal /*t*/) override
        { }
    /// For Comb style brushes, this preserves the normal length.
    int                 PRESERVENML() override
        { return 0; }
    /// For Comb style brushes this allows overriding the normal attribute.
    int                 OVERRIDENML() override
        { return 0; }
    void                NMLNAME(UT_String & /*str*/, fpreal /*t*/) override
        { }

    /// These methods are used to get the current symmetry operations
    /// that are enabled with the brush.  We don't use any of them here.
    int                 DOREFLECTION() override
        { return 0; }
    int                 DOROTATION() override
        { return 0; }
    fpreal              SYMMETRYDIRX(fpreal /*t*/) override
        { return 0.0f; }
    fpreal              SYMMETRYDIRY(fpreal /*t*/) override
        { return 0.0f; }
    fpreal              SYMMETRYDIRZ(fpreal /*t*/) override
        { return 0.0f; }
    fpreal              SYMMETRYORIGX(fpreal /*t*/) override
        { return 0.0f; }
    fpreal              SYMMETRYORIGY(fpreal /*t*/) override
        { return 0.0f; }
    fpreal              SYMMETRYORIGZ(fpreal /*t*/) override
        { return 0.0f; }
    int                 SYMMETRYROT(fpreal /*t*/) override
        { return 0; }
    fpreal              SYMMETRYDIST(fpreal /*t*/) override
        { return 0.0f; }

    /// This determines if the Cd or Normal should be auto-added.
    /// We have it off as we add it by hand in our cook.
    int                 ADDATTRIB() override
        { return 0; }
    /// This determines if visualization will occur.
    int                 VISUALIZE() override
        { return 0; }
    int                 VISTYPE() override
        { return 0; }
    fpreal              VISLOW(fpreal /*t*/) override
        { return 0.0f; }
    fpreal              VISHIGH(fpreal /*t*/) override
        { return 1.0f; }
    int                 VISMODE() override
        { return 0; }
    fpreal              ZEROWEIGHTCOLOR_R() override 
        { return 1.0f; }
    fpreal              ZEROWEIGHTCOLOR_G() override 
        { return 1.0f; }
    fpreal              ZEROWEIGHTCOLOR_B() override 
        { return 1.0f; }

    /// This is used by capture brushes to determine if they should
    /// normalize the weights.
    int                 NORMALIZEWEIGHT() override
        { return 0; }

    /// Should return true if this brush will affect capture regions.
    int                 USECAPTURE() override
        { return 0; }
    /// Returns the capture region to brush for such brushes.
    int                 CAPTUREIDX(fpreal /*t*/) override
        { return 0; }

    /// These determine if the relevant parameters have changed.  They are
    /// often used to determine when to invalidate internal caches.
    
    /// hasStrokeChanged should return true if any of the setHit* were called,
    /// as it will cause a new dab to be applied.
    bool                hasStrokeChanged(fpreal /*t*/) override
        { return myStrokeChanged; }
    /// This should return true if the style of the brush changed, specifically
    /// the foreground or background colours.  We test this trhough isParmDirty
    /// in the C code.
    bool                hasStyleChanged(fpreal t) override;
    /// This determines if the nib file changed.  We don't have a nib file.
    bool                hasNibFileChanged(fpreal /*t*/) override
        { return false; }
    /// This returns true if any nib parameters (such as shape, etc) have
    /// changed since the last cook.
    bool                hasNibLookChanged(fpreal /*t*/) override
        { return false; }
    /// This returns true if the type of accumulation mode changed.
    bool                hasAccumStencilChanged(fpreal /*t*/) override
        { return false; }
    /// This returns true if the capture index has changed.
    bool                hasCaptureIdxChanged(fpreal /*t*/) override
        { return false; }
    /// This return strue if the visualization range has changed.
    bool                hasVisrangeChanged(fpreal /*t*/) override
        { return false; }

    /// If this returns true, the selection will be cooked as the
    /// group.  We don't want that, so return false.
    bool                wantsCookSelection() const override
        { return false; }

    /// public methods used by MSS level to write to this level:
    /// The usual brush ops (such as Paint, etc) will set parameters
    /// with these values.  We just cache them locally here.
public:
    /// We are locking off accumulate stencil (ACCUMSTENCIL) so can
    /// ignore attempts to turn it on.
    void setAccumulateStencil(bool /*yesno*/) override {}
    void setRayOrigin(const UT_Vector3 &orig, fpreal /*t*/) override
        { myRayHit = orig; myStrokeChanged = true; forceRecook(); }
    void setRayOrientation(const UT_Vector3 &orient, fpreal /*t*/) override
        { myRayOrient = orient; myStrokeChanged = true; forceRecook(); }
    void setHitPrimitive(int primidx, fpreal /*t*/) override
        { myPrimHit = primidx; myStrokeChanged = true; forceRecook(); }
    void setHitPoint(int ptidx, fpreal /*t*/) override
        { myPtHit = ptidx; myStrokeChanged = true; forceRecook(); }
    void         setHitUVW(fpreal u, fpreal v, fpreal w, fpreal /*t*/) override
    {
        myRayHitU = u;
        myRayHitV = v;
        myRayHitW = w;
        myStrokeChanged = true;
        forceRecook();
    }
    void setHitPressure(fpreal pressure, fpreal /*t*/) override
        { myRayHitPressure = pressure; myStrokeChanged = true; forceRecook(); }
    void setBrushEvent(SOP_BrushEvent event) override
        { myEvent = event; myStrokeChanged = true; forceRecook(); }
    /// This one must map from SOP_BrushOp into our own op menu.
    /// Thus it is left to the C file.
    void setBrushOp(SOP_BrushOp op) override;
    /// As we are always returning CIRCLE for SHAPE(), we ignore
    /// requests to change the brush shape.
    void setBrushShape(SOP_BrushShape /*shape*/) override {}
    /// As we are locking projection type to not orient to surface,
    /// we can ignore these change requests (see PROJECTIONTYPE)
    void setProjectionType(int /*projtype*/) override {}
    void useForegroundColor() override
        { myUseFore = true; }
    void useBackgroundColor() override
        { myUseFore = false; }
    /// This is used by the eyedropper to write into the current colour
    /// field.
    void setCurrentColor(const UT_Vector3 &cd) override
        {
            setFloat(myUseFore ? "flen" : "blen", 0, 0, cd.x());
        }

    /// This is used to update the radii from the state:
    void setRadius(fpreal r, fpreal t) override
    {
        setFloat("radius", 0, t, r);
    }
    void setUVRadius(fpreal r, fpreal t) override
    {
        setFloat("uvradius", 0, t, r);
    }

protected:
    /// This method handles the erase callback relevant to this type
    /// of brush.
    void                doErase() override;

private:
    /// Here we cache the current ray hit values...
    UT_Vector3          myRayOrient, myRayHit;
    float               myRayHitU, myRayHitV, myRayHitW;
    float               myRayHitPressure;
    int                 myPrimHit;
    int                 myPtHit;
    int                 myEvent;
    bool                myUseFore;
    bool                myStrokeChanged;


    /// These are cached for the brushop callback to know the attribute
    /// indices.
    bool                myHairlenFound;
    GA_RWHandleF        myHairlenHandle;
    fpreal              myTime;
};
} // End HDK_Sample namespace

#endif