SOP_ParmOverride.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:
 *      Helper class for evaluating parms with override dropdown menus.
 */

#ifndef __SOP_ParmOverride_h__
#define __SOP_ParmOverride_h__

#include "GA/GA_AIFTuple.h"
#include "SOP_API.h"
#include "SOP_NodeVerb.h"
#include <FS/FS_Info.h>
#include <GU/GU_GroomUtils.h>
#include <GU/GU_AttribValueLookupTable.h>
#include <TIL/TIL_TextureMap.h>
#include <UT/UT_VoxelArray.h>
#include <GU/GU_Feather.h>
#include <type_traits>

class SOP_ParmOverride
{
public:
    enum class OverrideType
    {
        NONE = 0,
        CURVEATTRIB,
        CLUMPATTRIB,
        SKINATTRIB,
        TEXTURE,
        TEXTUREPRIM,
    };

    enum class UVMode
    {
        SKIN = 0,
        CURVE,
        FEATHER
    };

    enum class BarbMode
    {
        PERPOINT = 0,
        MAX
    };

    class CacheData
    {
    public:
        fpreal baseparmvalue;
        OverrideType overridetype;
        GA_DataId curvePid;
        GA_DataId curvetopoid;
        GA_DataId clumpPid;
        GA_DataId clumptopoid;
        GA_DataId skinPid;
        GA_DataId skintopoid;
        GA_DataId curveattribid;
        GA_DataId clumpattribid;
        GA_DataId skinattribid;
        GA_DataId uvattribid;
        GA_DataId texuniqueid;
        GA_DataId texmetacachecount;
        UT_StringHolder texturepath;
        bool doramp;
        GU_GroomFastRamp remapramp;
        bool dofit;
        UT_Vector2D inrange;
        UT_Vector2D outrange;

    };

    struct EvalTemp
    {
        float            length;
        UT_FloatArray    edgelengths;
    };

    template<typename T>
    class OverrideValue
    {
        friend SOP_ParmOverride;
    public:
        using BarbSide = GU_Feather::BarbSide;

        void setDims(
            exint shaftdim,
            exint barbdim)
        {
            if (barbdim > 2)
            {
                UT_ASSERT(barbdim % 2 == 0);
            }

            myNumPoints = shaftdim;
            myNumBarbPoints = barbdim;
            myData.setSize(shaftdim * barbdim);
        }

        void bumpDims(
            exint shaftdim,
            exint barbdim)
        {
            if (barbdim > 2)
            {
                UT_ASSERT(barbdim % 2 == 0);
            }

            myNumPoints = shaftdim;
            myNumBarbPoints = barbdim;
            myData.bumpSize(shaftdim * barbdim);
        }

        template<typename FIRSTOV>
        static
        void getMaxDim(
            exint &shaftdim,
            exint &barbdim,
            FIRSTOV first)
        {
            shaftdim = first.getShaftDim();
            barbdim = first.getBarbDim();
        }

        // Compute the maximum dimensions of some OverrideValues
        template<typename FIRSTOV, typename... OV>
        static
        void getMaxDim(
            exint &shaftdim,
            exint &barbdim,
            FIRSTOV first,
            OV... overvalues)
        {
            exint current_shaft, current_barb, rest_shaft, rest_barb;

            getMaxDim(current_shaft, current_barb, first);
            getMaxDim(rest_shaft, rest_barb, overvalues...);

            shaftdim = SYSmax(current_shaft, rest_shaft);
            barbdim = SYSmax(current_barb, rest_barb);
        }

        UT_ValArray<T>&
        getArray()
        {
            return myData;
        }

        SYS_FORCE_INLINE
        exint size() const
        {
            return myData.size();
        }

        SYS_FORCE_INLINE
        exint getShaftDim() const
        {
            return myNumPoints;
        }

        SYS_FORCE_INLINE
        exint getBarbDim() const
        {
            return myNumBarbPoints;
        }

        SYS_FORCE_INLINE
        T& operator()(exint i)
        {
            UT_ASSERT(i < myNumPoints * myNumBarbPoints);
            return myData[i];
        }

        // Address array directly, no bounds checking
        SYS_FORCE_INLINE
        T& operator()(exint point, exint barbpoint)
        {
            UT_ASSERT(point < myNumPoints);
            UT_ASSERT(barbpoint < myNumBarbPoints);
            return myData[myNumBarbPoints * point + barbpoint];
        }

        // elements by shaft/barb indices, with some additional logic for
        // safely accessing elements when dims are smaller than the actual
        // feather geometry. This is not actual bounds checking, just special
        // cases for when we only have one element for the shaft or one element
        // for barbs, or per barb side. More detail below.
        //
        // If the override has barbdim = 1, barbpoint is internally
        // set to 0, always accessing the one barb element, so callers
        // can just pass in the barb index safely, without checking dims.
        //
        // If barbdim == 2, each side has its own element (barbside left
        // accesses barb value 0, barbside right access barb value 1. barbpoint
        // is still set to 0 internally.
        //
        // If barbdim > 2, it should match left barb count + right barb count,
        // and no actual bounds checking is done.
        //
        //
        // If shaftdim is 1, point is internally set to 0, always accessing that
        // one element, so again, callers can safely access with the actual
        // shaft point index.
        //
        // If shaftdim > 1, shaftdim should equal number of shaft points on the
        // caller side, so no actual bounds checking is done.
        SYS_FORCE_INLINE
        T& operator()(
            exint point,
            BarbSide barbside,
            exint barbpoint)
        {
            return SYSconst_cast(get(
                point, barbside, barbpoint, myNumPoints, myNumBarbPoints));
        }

        SYS_FORCE_INLINE
        const T& operator()(
            exint point,
            BarbSide barbside,
            exint barbpoint) const
        {
            return get(
                point, barbside, barbpoint, myNumPoints, myNumBarbPoints);
        }

        SYS_FORCE_INLINE
        T& operator()(
            exint point,
            BarbSide barbside,
            exint barbpoint,
            exint shaftdim,
            exint barbdim)
        {
            return SYSconst_cast(get(
                point, barbside, barbpoint, shaftdim, barbdim));
        }

        SYS_FORCE_INLINE
        const T& operator()(
            exint point,
            BarbSide barbside,
            exint barbpoint,
            exint shaftdim,
            exint barbdim) const
        {
            return get(
                point, barbside, barbpoint, shaftdim, barbdim);
        }

        template<typename FN>
        void setEachElement(FN &&fn)
        {
            for (int i=0; i<myNumPoints; ++i)
            {
                for (int j=0; j<myNumBarbPoints; ++j)
                {
                    int center = myNumBarbPoints / 2;
                    auto barbside = j < center ? BarbSide::LEFT : BarbSide::RIGHT;
                    int barbpoint = barbside == BarbSide::LEFT
                        ? -j + center - 1
                        : j - center;

                    (*this)(i, barbside, barbpoint) = fn(i, barbside, barbpoint);
                }
            }
        }

        typename UT_ValArray<T>::iterator begin() { return typename UT_ValArray<T>::iterator(myData.begin()); }
        typename UT_ValArray<T>::iterator end() { return typename UT_ValArray<T>::iterator(myData.end()); }
    private:
        SYS_FORCE_INLINE
        const T& get(
            exint point,
            BarbSide barbside,
            exint barbpoint,
            exint shaftdim,
            exint barbdim) const
        {
            if (shaftdim == 1)
            {
                point = 0;
            }
            else
            {
                UT_ASSERT(point < shaftdim);
            }

            if (barbdim == 1)
            {
                return myData[point];
            }
            else if (barbdim == 2)
            {
                return myData[barbdim * point + int(barbside) - 1];
            }
            else
            {
                UT_ASSERT(barbpoint < barbdim/2);
                int offset = barbdim / 2;
                offset += barbside == BarbSide::LEFT ? -1 - barbpoint : barbpoint;

                UT_ASSERT(offset >= 0 && offset < myData.size());
                return myData[barbdim * point + offset];
            }
        }

        UT_ValArray<T>    myData;
        exint             myNumPoints = 1;
        exint             myNumBarbPoints = 1;
    };

    using OverrideValueF = OverrideValue<float>;
    using OverrideValueV3 = OverrideValue<UT_Vector3>;
    using OverrideValueQ = OverrideValue<UT_Quaternion>;

    SOP_ParmOverride(
            const SOP_NodeVerb::CookParms &cookparms,
            const SOP_NodeParms &parms,
            const UT_StringHolder &baseparmname,
            const GU_Detail *gdp,
            const GU_Detail *clumpgdp,
            const GU_Detail *skingdp,
            const GU_Detail *texprimgdp,
            const GA_ROHandleV3 &uvattrib,
            const UT_ValArray<OverrideType> &overridetypes);

    SOP_ParmOverride(
            const SOP_NodeVerb::CookParms &cookparms,
            const SOP_NodeParms &parms,
            const UT_StringHolder &baseparmname,
            const GU_Detail *gdp,
            const GU_Detail *clumpgdp,
            const GU_Detail *skingdp,
            const GU_Detail *texprimgdp,
            const GA_ROHandleV3 &uvattrib,
            const GA_ROHandleV3 &curveuvattrib,
            const UT_ValArray<OverrideType> &overridetypes,
            const GA_Attribute *barbl,
            const GA_Attribute *barbr,
            const GA_Attribute *barbuvl,
            const GA_Attribute *barbuvr);

    void setBarbPromotionMode(BarbMode mode)
    {
        myBarbMode = mode;
    }

    OverrideType overrideType() const
    {
        return myOverrideType;
    }

    fpreal baseValue() const
    {
        return myBaseParmValue;
    }

    // eval curve, clump, skin and texture
    void eval(
            UT_FloatArray                       &out,
            const GA_AttributeOwner              target,
            const GA_Offset                      skinprimoff,
            const GA_OffsetArray                &skinvertoffsets,
            const UT_FloatArray                 &skinvertweights,
            const UT_Vector3                    &uv,
            const GA_Offset                      curveprimoff,
            const GA_OffsetListRef              &curvevertoffsets,
            const GA_Offset                      clumpprimoff,
            const UT_ValArray<GA_OffsetArray>    &clumpvertoffsets,
            const UT_ValArray<UT_FloatArray>     &clumpvertweights)
    {
        eval(
            out,
            target,
            skinprimoff,
            &skinvertoffsets,
            &skinvertweights,
            uv,
            curveprimoff,
            &curvevertoffsets,
            clumpprimoff,
            &clumpvertoffsets,
            &clumpvertweights);
    }

    // eval curve, skin and texture
    void eval(
            UT_FloatArray                   &out,
            const GA_AttributeOwner          target,
            const GA_Offset                  skinprimoff,
            const GA_OffsetArray            &skinvertoffsets,
            const UT_FloatArray             &skinvertweights,
            const UT_Vector3                &uv,
            const GA_Offset                  curveprimoff,
            const GA_OffsetListRef          &curvevertoffsets)
    {
        eval(
            out,
            target,
            skinprimoff,
            &skinvertoffsets,
            &skinvertweights,
            uv,
            curveprimoff,
            &curvevertoffsets,
            GA_INVALID_OFFSET, // no clump offset
            nullptr, // no clump vert arrays
            nullptr);
    }

    // eval curve, skin and texture with uv span
    void eval(
            OverrideValue<float>            &out,
            EvalTemp                        &temp,
            const GA_AttributeOwner          target,
            const GA_Offset                  skinprimoff,
            const GA_OffsetArray            &skinvertoffsets,
            const UT_FloatArray             &skinvertweights,
            const UT_Vector3                &uv,
            const GA_Offset                  curveprimoff,
            const GA_OffsetListRef          &curvevertoffsets)
    {
        eval(
            out,
            temp,
            target,
            skinprimoff,
            &skinvertoffsets,
            &skinvertweights,
            uv,
            curveprimoff,
            &curvevertoffsets,
            GA_INVALID_OFFSET, // no clump offset
            nullptr, // no clump vert arrays
            nullptr);
    }

    fpreal evalSkin(
            const GA_Offset                  skinprimoff,
            const GA_OffsetArray            &skinvertoffsets,
            const UT_FloatArray             &skinvertweights,
            const UT_Vector3                &uv);

    fpreal evalSkinPoint(
            const GA_Offset                  skinptoff);

    bool evaluatesToSingleValue(
            GA_AttributeOwner target) const;

    float postProcessVarying(float value) const;

    bool needSkin() const;

    bool needTexPrim() const;

    bool needUV() const;

    const GA_Attribute* getRequiredAttrib() const;

    bool hasChanged(const CacheData *cache) const;

    const UT_StringHolder&
    getBaseName() const
    {
        return myBaseParmName;
    }

    UVMode getUVMode() const
    {
        return myUVMode;
    }

    bool
    updateOverrideCache(
            UT_UniquePtr<SOP_ParmOverride::CacheData> &cachedata) const
    {
        if (!cachedata ||
                hasChanged(cachedata.get()))
        {
            cachedata.reset(getCacheData());
            return true;
        }
        return false;
    }

private:
    typedef UT_Tuple<int, int> UdimCoord;
    struct MyHashCompare {
        static size_t hash( const UdimCoord& x ) {
            int xhash = SYSwang_inthash(std::get<0>(x));
            return SYSwang_inthash(xhash + std::get<1>(x));
        }
        //! True if strings are equal
        static bool equal( const UdimCoord& x, const UdimCoord& y ) {
            return x==y;
        }
    };
    typedef UT_ConcurrentHashMap<UdimCoord, UT_UniquePtr<TIL_TextureMap>, MyHashCompare> TexPathMap;

    // This eval() accepts pointers to the various offset arrays,
    // so the public functions, which accept references, can pass nullptrs
    // for unused arrays.
    void eval(
            OverrideValue<float>                &out,
            EvalTemp                            &temp,
            const GA_AttributeOwner              target,
            const GA_Offset                      skinprimoff,
            const GA_OffsetArray                *skinvertoffsets,
            const UT_FloatArray                 *skinvertweights,
            const UT_Vector3                    &uv,
            const GA_Offset                      curveprimoff,
            const GA_OffsetListRef              *curvevertoffsets,
            const GA_Offset                      clumpprimoff,
            const UT_ValArray<GA_OffsetArray>   *clumpvertoffsets,
            const UT_ValArray<UT_FloatArray>    *clumpvertweights);

    void eval(
            UT_FloatArray                       &out,
            const GA_AttributeOwner              target,
            const GA_Offset                      skinprimoff,
            const GA_OffsetArray                *skinvertoffsets,
            const UT_FloatArray                 *skinvertweights,
            const UT_Vector3                    &uv,
            const GA_Offset                      curveprimoff,
            const GA_OffsetListRef              *curvevertoffsets,
            const GA_Offset                      clumpprimoff,
            const UT_ValArray<GA_OffsetArray>   *clumpvertoffsets,
            const UT_ValArray<UT_FloatArray>    *clumpvertweights)
    {
        OverrideValue<float> temp_out;
        EvalTemp             temp;

        eval(
            temp_out,
            temp,
            target,
            skinprimoff,
            skinvertoffsets,
            skinvertweights,
            uv,
            curveprimoff,
            curvevertoffsets,
            clumpprimoff,
            clumpvertoffsets,
            clumpvertweights);

        out.swap(temp_out.getArray());
    }

    template<typename LOOKUPFN>
    void lookupTexture(
        OverrideValue<float> &out,
        GA_Offset curveprimoff,
        const UT_Vector3 &uv,
        const GA_OffsetListRef *curvevertoffsets,
        LOOKUPFN &&lookupfn);

    float lookupTexture(const UT_Vector3 &uv);

    float lookupTexturePrim(const UT_Vector3 &uv);

    static exint
    findParmIndex(
            const SOP_NodeParms &parms,
            const UT_StringHolder &parmname);

    CacheData *getCacheData() const;

    void check();

    const SOP_NodeVerb::CookParms       &myCookParms;
    const SOP_NodeParms                 &myParms;
    const UT_StringHolder               &myBaseParmName;
    const GU_Detail                     *myCurveGdp;
    const GU_Detail                     *myClumpGdp;
    const GU_Detail                     *mySkinGdp;
    const GU_Detail                     *myTexGdp;
    const GA_ROHandleV3                 &myUVAttrib;
    GA_ROHandleV3                        myCurveUVAttrib;
    GU_FeatherBarbROHandle<UT_Vector3>   myBarbLHandle;
    GU_FeatherBarbROHandle<UT_Vector3>   myBarbRHandle;
    GU_FeatherBarbROHandle<UT_Vector3>   myBarbUVLHandle;
    GU_FeatherBarbROHandle<UT_Vector3>   myBarbUVRHandle;
    exint                                myBaseParmIndex;
    SOP_NodeParms::ParmType              myBaseParmType;
    exint                                myOverrideParmIndex;
    exint                                myOptionsParmIndex;
    exint                                myCurveAttribParmIndex;
    exint                                myClumpAttribParmIndex;
    exint                                mySkinAttribParmIndex;
    exint                                myTextureParmIndex;
    exint                                myTexPrimParmIndex;
    exint                                myUVModeParmIndex;
    UT_StringHolder                      myTexPrimName;
    UT_VoxelArrayReadHandleF             myTexPrimReadHandle;
    exint                                myRampParmIndex;
    exint                                myBarbRampToggleIndex;
    exint                                myInRangeParmIndex;
    exint                                myOutRangeParmIndex;
    UVMode                               myUVMode = UVMode::SKIN;

    fpreal                               myBaseParmValue;
    OverrideType                         myOverrideType;
    UT_StringHolder                      myCurveAttribName;
    UT_StringHolder                      myClumpAttribName;
    UT_StringHolder                      mySkinAttribName;
    UT_StringHolder                      myTexturePath;
    bool                                 myTextureValid;
    const GA_Attribute                  *myCurveAttrib;
    const GA_AIFTuple                   *myCurveTuple;
    GA_ROHandleV3                        myCurvePAttrib;
    GA_ROHandleF                         myClumpAttrib;
    GA_ROHandleF                         mySkinAttrib;
    GA_ROHandleS                         myTexPrimNameAttrib;
    UT_UniquePtr<TIL_TextureMap>         myTextureMap;
    TexPathMap                           myUdimMaps;
    UT_Lock                              myUdimLock;
    bool                                 myUseUdim = false;

    bool                                 myDoFit = false;
    bool                                 myDoRamp = false;

    GU_GroomFastRamp                     myRemapRamp;
    bool                                 myRemapRampMapToBarbs = false;

    UT_Vector2D                          myInRange = {0.0, 1.0};
    UT_Vector2D                          myOutRange = {0.0, 1.0};

    BarbMode                             myBarbMode = BarbMode::MAX;

    template<typename T>
    static T
    evalAttrib(
            const GA_AttributeOwner target,
            const GA_Attribute *attrib,
            const GA_AIFTuple *tuple,
            const GA_Offset &primoff,
            const GA_Offset &vertoff)
    {
        T value(1.0);

        if (!attrib || !tuple)
            return value;

        const auto &attribgdp = attrib->getDetail();

        GA_AttributeOwner owner = attrib->getOwner();
        GA_Offset offset(0);
        if (owner == GA_ATTRIB_VERTEX)
            offset = vertoff;
        else if (owner == GA_ATTRIB_POINT)
            offset = attribgdp.vertexPoint(vertoff);
        else if (owner == GA_ATTRIB_PRIMITIVE)
            offset = primoff;

        if constexpr (std::is_integral_v<T> || std::is_floating_point_v<T>)
        {
            tuple->get(attrib, offset, value);
        }
        else
        {
            tuple->get(attrib, offset, value.data(), T::tuple_size, 0);
        }

        return value;
    }
};

#endif