GU_GroomUtils.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:        GU Library (C++)
 *
 */

#ifndef __GU_GroomUtils_h__
#define __GU_GroomUtils_h__

#include "GU_API.h"
#include "GU_Detail.h"
#include "GU_RayIntersect.h"
#include "GU_PolyFrame.h"
#include "GU_SurfaceDeform.h"

#include <GA/GA_Attribute.h>
#include <GA/GA_AttributeRefMap.h>
#include <GA/GA_Handle.h>
#include <GA/GA_SplittableRange.h>
#include <GA/GA_Types.h>
#include <GEO/GEO_Interpolate.h>
#include <GEO/GEO_PointTree.h>
#include <GEO/GEO_PrimPoly.h>
#include <UT/UT_ErrorLog.h>
#include <UT/UT_LineTree.h>
#include <UT/UT_Set.h>
#include <UT/UT_Tuple.h>
#include <UT/UT_Tracing.h>

#include <functional>
#include <numeric>
#include <type_traits>

class GU_API GU_GroomUtils
{
public:
    static GA_Attribute*
    findOrCreateFloatAttribute(
        GU_Detail &gdp,
        const GA_AttributeOwner owner,
        const UT_StringRef &name,
        const exint tsize,
        const GA_Defaults &defaults = GA_Defaults(0.0),
        GA_Storage storage = GA_STORE_REAL32);

    static GA_Attribute*
    findOrCreateIntAttribute(
        GU_Detail &gdp,
        const GA_AttributeOwner owner,
        const UT_StringRef &name,
        const exint tsize,
        const GA_Defaults &defaults = GA_Defaults(0),
        GA_Storage storage = GA_STORE_INT32);

    static GA_Attribute*
    findOrCreateStringAttribute(
        GU_Detail &gdp,
        const GA_AttributeOwner owner,
        const UT_StringRef &name);

    static GA_Attribute*
    findOrCreateStringArrayAttribute(
        GU_Detail &gdp,
        GA_AttributeOwner owner,
        const UT_StringRef &name,
        int tsize)
    {
        GA_Attribute *attrib = gdp.findStringArray(owner, name);

        if (!attrib)
            attrib = gdp.addStringArray(owner, name, tsize);

        return attrib;
    }

    static GA_Attribute*
    findOrCreateIntArrayAttribute(
        GU_Detail &gdp,
        GA_AttributeOwner owner,
        const UT_StringRef &name,
        int tsize,
        GA_Storage storage = GA_STORE_INT32)
    {
        GA_Attribute *attrib = gdp.findIntArray(owner, name);

        if (!attrib)
            attrib = gdp.addIntArray(owner, name, tsize);

        return attrib;
    }

    static GA_Attribute*
    findOrCreateFloatArrayAttribute(
        GU_Detail &gdp,
        GA_AttributeOwner owner,
        const UT_StringRef &name,
        int tsize,
        GA_Storage storage = GA_STORE_REAL32)
    {
        GA_Attribute *attrib = gdp.findFloatArray(owner, name);

        if (!attrib)
            attrib = gdp.addFloatArray(owner, name, tsize);

        return attrib;
    }

    static GA_Attribute*
    findNamedOrient(GU_Detail &gdp, const UT_StringRef &name);

    static const GA_Attribute*
    findNamedOrient(const GU_Detail &gdp, const UT_StringRef &name);

    static GA_Attribute*
    findOrCreateNamedOrient(GU_Detail &gdp, const UT_StringRef &name);

    static void getPrimPointPositions(
        UT_Vector3Array &positions,
        GA_Offset primoff,
        const GU_Detail &gdp,
        const GA_ROHandleV3 &pos_handle);
    

    static void setPrimPointPositions(
        UT_Vector3Array &positions,
        GA_Offset primoff,
        const GU_Detail &gdp,
        const GA_RWHandleV3 &pos_handle);

    static fpreal calcPerimeter(UT_Vector3Array &pos);

    static float unitLengthToUnitDomain(
            const UT_Vector3Array &pos,
            float perimeter,
            const UT_FloatArray &edgelengths,
            float ulength);

    static float unitToUnitLengthDomain(
            float perimeter,
            const UT_FloatArray &edgelengths,
            float uparm);

    static float unitLengthToUnitDomain(
            fpreal perimeter,
            const UT_FloatArray &edgelengths,
            float ulength);

    static float
    openCurveUnitToReal(int n, float u_unit)
    {
        if (n <= 0 || !u_unit) return 0.0f;

        if      (u_unit < 0.0f)     u_unit = 0.0f;
        else if (u_unit > 1.0f)     u_unit = 1.0f;

        return u_unit * float(n-1);
    }

    static UT_Tuple<UT_Vector2, UT_Vector2i>
    openCurvePointWeights(int n, fpreal u)
    {
        if (n == 0)
        {
            return { {0.0f, 0.0f}, {-1, -1} };
        }

        if (n == 1)
        {
            return { {1.0f, 0.0f}, {0, -1} };
        }

        u = openCurveUnitToReal(n, u); // Also checks out of bounds etc.

        int vcrt, vseq;
        float rem = GEO_Face::getIndices(u, vcrt, vseq, n-1, false /*ifclosed*/);

        if (rem == 0 || vcrt == vseq) {
            return { {1.0f, 0.0f}, {vcrt, -1} };
        }

        return {
            {1.0f-rem, rem},
            {vcrt, vseq}
        };
    }

    template<typename T>
    static T
    interpAttrib(
            const GA_ROHandleT<T> &attrib,
            const GA_Offset &primoff,
            const GA_OffsetArray &vertoffsets,
            const UT_FloatArray &vertweights,
            const T defaultvalue=T(0.0f));

    static fpreal
    computeLength(
        const UT_Vector3Array &positions);

    static fpreal
    computeEdgeLengths(
        const UT_Vector3Array &positions,
        UT_FloatArray &edgelengths);

    static fpreal
    computeEdgeLengths(
        const GU_Detail &gdp,
        const GA_ROHandleV3 &P,
        GA_Offset primoff,
        UT_FloatArray &edgelengths);

    static void
    vertexToPointOffsets(
        GA_OffsetArray &offsets,
        const GU_Detail &gdp)
    {
        for (int i=0; i<offsets.size(); ++i)
            offsets[i] = gdp.vertexPoint(offsets[i]);
    }

    // stores all quats of influencing guides for each point and attribute
    // in a linear array. Guides are the smallest dimension, so all the guides
    // for a point and attribute are in a continuous block of memory, ready
    // to be used with UT_Quaternion::interpolate().
    class QuatInterpTempStorage
    {
    public:
        SYS_FORCE_INLINE
        void setDim(int pointcount, int attribcount, int guidecount)
        {
            myPointCount = pointcount;
            myAttribCount = attribcount;
            myGuideCount = guidecount;
            myQuats.setSize(attribcount * pointcount * guidecount);
        };

        SYS_FORCE_INLINE
        int getLinearIndex(int pointindex, int attribindex, int guideindex)
        {
            int index = pointindex * (myAttribCount * myGuideCount)
                + attribindex * myGuideCount
                + guideindex;

            return index;
        }

        SYS_FORCE_INLINE
        const UT_QuaternionF&
        getValue(int pointindex, int attribindex, int guideindex)
        {
            int index = getLinearIndex(pointindex, attribindex, guideindex);

            return myQuats[index];
        }

        SYS_FORCE_INLINE
        void
        setValue(int pointindex, int attribindex, int guideindex, UT_QuaternionF &quat)
        {
            int index = getLinearIndex(pointindex, attribindex, guideindex);

            myQuats[index] = quat;
        }

        SYS_FORCE_INLINE
        const UT_QuaternionFArray&
        getData()
        {
            return myQuats;
        }

    private:
        int                 myPointCount = 0;
        int                 myAttribCount = 0;
        int                 myGuideCount = 0;

        UT_QuaternionFArray myQuats;
    };

    // positions must have size == vtxcount and initialized to 0.
    static void
    addWeightedGuide(
        const GU_Detail             &guidegdp,
        const GEO_PrimPoly * const   guideprim,
        const GA_Offset              guideprimoff,
        const int                    guideindex,
        const float                  guideweight,
        const GA_ROHandleF          &guidetightnessattrib,
        const GA_ROHandleV3         &guidetangentattrib,
        const GA_ROHandleV3         &guidenormalattrib,
        const GA_ROHandleV3         &guidePattrib,
        const GA_AttributeRefMap    &guidepointlinattribmap,
        const GA_AttributeRefMap    &guidepointquatattribmap,

        // settings
        const bool                   extrude,
        const bool                   setpos,
        const bool                   uniformguidesegments,
        const GA_Size                vtxcount,
        const UT_Vector3             rootpos,
        const GA_OffsetListRef      &vtxlist,
        // temp storage
        UT_FloatArray               &glengths,
        GA_OffsetArray              &guidevertoffsets,
        UT_FloatArray               &guidevertweights,
        // output
        UT_Array<UT_Vector3>        &positions,
        UT_ValArray<GA_WeightedSum> &pointsums,
        QuatInterpTempStorage       &quattemp,
        const UT_Matrix3            *guidetoposrot = nullptr);

    static void
    removeNonGuidesFromGroup(
        GA_PrimitiveGroup &guidegroup,
        GU_Detail &gdp);

    static void
    removeHiddenPrimitivesFromGroup(
        GA_PrimitiveGroup &guidegroup,
        GU_Detail &gdp);

    static void
    setGuideGroupMembers(
        GA_PrimitiveGroup &guidegroup,
        const GA_ElementGroup *ingroup,
        const GA_ElementGroup *inmirrorgroup,
        const GA_PrimitiveGroup *templategroup,
        GU_Detail &gdp);

    enum class SetLengthMode
    {
        SET = 0,
        MULTIPLY,
        ADD,
        SUBTRACT,
        SETMIN,
        SETMAX
    };

    static fpreal
    computeNewLength(
        fpreal prevlength,
        SetLengthMode mode,
        fpreal value)
    {
        if (mode == SetLengthMode::SETMIN)
        {
            return SYSmin(prevlength, value);
        }
        else if (mode == SetLengthMode::SETMAX)
        {
            return SYSmax(prevlength, value);
        }
        else if (mode == SetLengthMode::ADD)
        {
            return (prevlength+value);
        }
        else if (mode == SetLengthMode::SUBTRACT)
        {
            return (prevlength-value);
        }
        else if (mode == SetLengthMode::SET)
        {
            return value;
        }

        return value;
    }

    static void
    scaleCurve(
        GU_Detail &gdp,
        const GA_RWHandleV3 &Pattrib,
        GA_Offset primoff,
        GA_OffsetListRef &curvevertoffs,
        float factor);

    static void
    setCurveLength(
        GU_Detail &gdp,
        const GA_RWHandleV3 &Pattrib,
        GA_Offset primoff,
        fpreal prevlength,
        fpreal newlength,
        GA_OffsetListRef &curvevertoffs,
        UT_FloatArray &tempu,
        UT_Vector3Array &temppos);

    static void
    setCurveLength(
        UT_Vector3Array &positions,
        fpreal prevlength,
        fpreal newlength,
        UT_FloatArray &tempu,
        UT_Vector3Array &temppos);

    static float
    circlePackRootPoints(
        const GU_Detail &gdp,
        const GA_ROHandleV3 &restPattrib,
        UT_IntArray &indices,
        UT_FloatArray &sqdists,
        const GA_Offset * const offsets,
        exint numcurves,
        const UT_Vector3 &clumproot,
        const UT_Matrix3 &clumprot,
        const GA_RWHandleV2 &bundleposattrib);

    // copy of vex intrinsic in $SHS/vex/intrinsics/opmath.vfl
    static UT_Vector3
    slideFrame(
        const UT_Vector3 x0,
        const UT_Vector3 t0,
        const UT_Vector3 n0,
        const UT_Vector3 x1,
        const UT_Vector3 t1);

    static UT_Matrix3
    computeTangentFrame(
        const UT_Vector3 &tangent,
        const UT_Vector3 &normal);

    static void
    computeTangentFrames(
        UT_ValArray<UT_Matrix3> &frames,
        const UT_Vector3Array &positions,
        const UT_Vector3 &roottangent,
        const UT_Vector3 &rootnormal);

    SYS_FORCE_INLINE
    static GA_Offset
    primVertexOffset(const GU_Detail &gdp, GA_Offset primoff, GA_Size index=0)
    {
        return gdp.getPrimitiveVertexOffset(primoff, index);
    }

    SYS_FORCE_INLINE
    static GA_Offset
    primPointOffset(const GU_Detail &gdp, GA_Offset primoff, GA_Size index=0)
    {
        GA_Offset firstvtxoff(primVertexOffset(gdp, primoff, index));
        return gdp.vertexPoint(firstvtxoff);
    }

    static void setPagesConstant(GA_RWHandleF attribhandle, float value)
    {
        GA_Offset size = attribhandle->getIndexMap().offsetSize();

        UT_PageNum numpages(attribhandle->getData().numPages(size));

        for(GA_PageNum pagenum(0); pagenum < numpages; ++pagenum)
            attribhandle.setPageConstant(pagenum, &value);
    }

    static bool
    checkSkinPrimIndices(
        const GA_ROHandleI &skinprimattrib,
        const GU_Detail &skingdp,
        const GA_ElementGroup *group = nullptr)
    {
        UT_ASSERT(!group || skinprimattrib->getOwner() == group->getOwner());

        auto &constgdp = skinprimattrib.getAttribute()->getDetail();
        bool skinprimfail = false;
        GA_Range range = skinprimattrib->getOwner() == GA_ATTRIB_POINT
            ? constgdp.getPointRange(dynamic_cast<const GA_PointGroup*>(group))
            : constgdp.getPrimitiveRange(dynamic_cast<const GA_PrimitiveGroup*>(group));
        UTparallelFor(GA_SplittableRange(range),
        [&](const GA_SplittableRange &r)
        {
            GA_Offset startoff;
            GA_Offset endoff;

            for (GA_Iterator ptit(r); ptit.blockAdvance(startoff, endoff); )
            {
                if (skinprimfail)
                    return;

                for (GA_Offset off = startoff; off < endoff; ++off)
                {
                    GA_Index skinprimindex = skinprimattrib.get(off);
                    if (skinprimindex < 0 ||
                        skinprimindex >= skingdp.getNumPrimitives())
                    {
                        skinprimfail = true;
                        return;
                    }
                }
            }
        });

        return !skinprimfail;
    }

    static UT_Tuple<GA_Attribute*, GA_Attribute*>
    createNameAndWeightArrayAttributes(
        GU_Detail &gdp,
        GA_AttributeOwner owner,
        const UT_StringHolder &name_attrib_name,
        const UT_StringHolder &weight_attrib_name)
    {
        GA_Attribute* keyattrib = findOrCreateStringArrayAttribute(
            gdp, owner, name_attrib_name, 1);

        GA_Attribute* weightattrib = findOrCreateFloatArrayAttribute(
            gdp, owner, weight_attrib_name, 1);

        return UTmakeTuple(keyattrib, weightattrib);
    }

    static UT_Tuple<GA_Attribute*, GA_Attribute*>
    createIndexAndWeightArrayAttributes(
        GU_Detail &gdp,
        GA_AttributeOwner owner,
        const UT_StringHolder &name_attrib_name,
        const UT_StringHolder &weight_attrib_name)
    {
        GA_Attribute* keyattrib = findOrCreateIntArrayAttribute(
            gdp, owner, name_attrib_name, 1);

        GA_Attribute* weightattrib = findOrCreateFloatArrayAttribute(
            gdp, owner, weight_attrib_name, 1);

        return UTmakeTuple(keyattrib, weightattrib);
    }

};

class GU_API GU_GroomPartingLineAttribs
{
public:
    GU_GroomPartingLineAttribs(
        const GU_Detail &gdp,
        const GA_Attribute *restattrib);

    void findAttribs(const GU_Detail &gdp);

    bool attribMissing()
    {
        return myAttribMissing;
    }

    const UT_StringHolder &attribMissingWarning()
    {
        return myAttribMissingWarning;
    }

    GA_ROHandleV3            rest;
    GA_ROHandleF             radius;
    GA_ROHandleF             strength;
    GA_ROHandleV3            normal;

private:
    bool myAttribMissing = false;

    static const UT_StringHolder myAttribMissingWarning;
};

using gu_PartingLineAttribsUPtr = UT_UniquePtr<GU_GroomPartingLineAttribs>;

class GU_API GU_GroomInterpCoords
{
public:
    GA_OffsetArray                       offsets;
    UT_FloatArray                        weights;
};

class GU_API GU_GroomSkinIntersect
{
public:
    GU_GroomSkinIntersect(
        const GU_RayIntersect &rayintersect)
    : myRayIntersect(rayintersect)
    , mySkinGdp(*rayintersect.detail())
    , mySkinP(mySkinGdp.getP())
    {}

    GU_GroomSkinIntersect(
        const GU_RayIntersect &rayintersect,
        const GA_Attribute &normal)
    : myRayIntersect(rayintersect)
    , mySkinGdp(*rayintersect.detail())
    , mySkinP(mySkinGdp.getP())
    , mySkinN(&normal)
    {}

    SYS_FORCE_INLINE
    const GU_Detail&
    detail()
    {
        return mySkinGdp;
    }

    const GU_RayIntersect& rayIntersect()
    {
        return myRayIntersect;
    }

    SYS_FORCE_INLINE
    bool
    closestPointInfo(
        const UT_Vector3 &pos,
        GU_MinInfo &mininfo) const
    {
        int hitcount = myRayIntersect.minimumPoint(pos, mininfo);

        // If nothing hit within radius (unlikely), fall back to infinite radius
        if (hitcount == 0)
        {
            mininfo = GU_MinInfo(FLT_MAX, 0, true);
            hitcount = myRayIntersect.minimumPoint(pos, mininfo);
        }

        return hitcount > 0;
    }

    SYS_FORCE_INLINE
    bool hitPointInfo(UT_Vector3 pos, UT_Vector3 dir, GU_RayInfo &info)
    {
        int hits = myRayIntersect.sendRay(pos, dir, info);

        return hits > 0;
    }

    SYS_FORCE_INLINE
    static void
    computeVertWeights(
        const GU_MinInfo &mininfo,
        GU_GroomInterpCoords &interpcoords)
    {
        mininfo.prim->computeInteriorPointWeights(
                interpcoords.offsets, interpcoords.weights,
                mininfo.u1,
                mininfo.v1,
                0.0f);
    }

    SYS_FORCE_INLINE
    static void
    computeVertWeights(
        const GU_RayInfo &hitinfo,
        GU_GroomInterpCoords &interpcoords)
    {
        hitinfo.myPrim->computeInteriorPointWeights(
                interpcoords.offsets, interpcoords.weights,
                hitinfo.myU,
                hitinfo.myV,
                0.0f);
    }

    template<typename T>
    T
    interpAttrib(
        const GA_ROHandleT<T> &attrib,
        const GU_GroomInterpCoords &interpcoords) const
    {
        return GU_GroomUtils::interpAttrib(
                attrib, GA_INVALID_OFFSET,
                interpcoords.offsets, interpcoords.weights);
    }

    SYS_FORCE_INLINE
    UT_Vector3
    interpP(
        const GU_GroomInterpCoords &interpcoords) const
    {
        return interpAttrib(mySkinP, interpcoords);
    }

    SYS_FORCE_INLINE
    UT_Vector3
    interpN(
        const GU_GroomInterpCoords &interpcoords) const
    {
        UT_ASSERT(mySkinN.isValid());
        UT_Vector3 normal = interpAttrib(mySkinN, interpcoords);

        normal.normalize();

        return normal;
    }

    SYS_FORCE_INLINE
    bool
    closestPos(
        UT_Vector3 &pos,
        GU_MinInfo &mininfo,
        GU_GroomInterpCoords &interpcoords)
    {
        if (!closestPointInfo(pos, mininfo))
            return false;

        computeVertWeights(mininfo, interpcoords);

        pos = interpAttrib(mySkinP, interpcoords);

        return true;
    }

private:
    const GU_RayIntersect               &myRayIntersect;
    const GU_Detail                     &mySkinGdp;
    const GA_ROHandleV3                  mySkinP;
    const GA_ROHandleV3                  mySkinN;
};

class GU_API GU_GroomPartingLineLookup
{
public:
    struct PerThreadData
    {
        void setArraySize(unsigned int size)
        {
            lines.setSize(size);
            dist2s.setSize(size);
        }

        UT_IntArray              lines;
        UT_FloatArray            dist2s;

        GU_GroomInterpCoords     interpcoords;
    };

    GU_GroomPartingLineLookup(unsigned int maxpartlines)
    : myMaxPartLines(maxpartlines)
    {}

    GU_GroomPartingLineLookup(
        unsigned int maxpartlines,
        GU_GroomSkinIntersect *skinintersect)
    : myMaxPartLines(maxpartlines)
    {}

    static const GA_PrimitiveGroup*
    findGroup(const GU_Detail &gdp)
    {
        return gdp.findPrimitiveGroup("partinglines");
    }

    static GA_PrimitiveGroup&
    findOrCreateGroup(GU_Detail &gdp)
    {
        GA_PrimitiveGroup *group = gdp.findPrimitiveGroup("partinglines");

        if (group)
            return *group;

        return *gdp.newPrimitiveGroup("partinglines");
    }

    static GA_PrimitiveGroup*
    findGroup(GU_Detail &gdp)
    {
        return gdp.findPrimitiveGroup("partinglines");
    }

    void
    setLines(
        const GU_Detail &gdp,
        const GA_ROHandleV3 &restattrib,
        const GA_PrimitiveGroup &partlinesgroup);

    float
    computePartingWeight(
        const UT_Vector3 &posA,
        const UT_Vector3 &posB,
        const GU_GroomPartingLineAttribs &attribs,
        PerThreadData &threadvalues,
        const GU_GroomSkinIntersect *skinintersect = nullptr) const;

    GA_Offset getLineOffset1(int id) const
    {
        return myLineOffsets(2 * id);
    }

    GA_Offset getLineOffset2(int id) const
    {
        return myLineOffsets(2 * id + 1);
    }

    int64 getMemoryUsage(bool inclusive) const
    {
        int64 size(inclusive ? sizeof(*this) : 0);

        size += myLineOffsets.getMemoryUsage(true);

        return size;
    }

private:
    int addLine(const GA_Offset ptoff1, const UT_Vector3 &pt1,
                const GA_Offset ptoff2, const UT_Vector3 &pt2);

    const unsigned int           myMaxPartLines;
    UT_LineTree                  myLineTree;
    GA_OffsetArray               myLineOffsets;
};

class GU_API GU_GroomCurveAttribSampler
{
public:
    GU_GroomCurveAttribSampler(
        GU_Detail &dstgdp,
        const GU_Detail *srcgdp = nullptr)
    : myDstGdp(dstgdp)
    , mySrcGdp(srcgdp != nullptr ? *srcgdp : dstgdp)
    , myAttribMap(myDstGdp, &mySrcGdp)
    , myLengthScaledAttribMap(myDstGdp, &mySrcGdp)
    {
    }

    void
    addAttrib(const UT_StringRef &name)
    {
        addAttribToMap(myAttribMap, name);
    }

    void
    addLengthScaledAttrib(const UT_StringRef &name)
    {
        addAttribToMap(myLengthScaledAttribMap, name);
    }

    void
    sampleAttribs(
        const GEO_PrimPoly &dstpoly,
        const GEO_PrimPoly &srcpoly,
        float blend);

    void
    sampleAttribs(
        const GEO_PrimPoly &dstprimpoly,
        GA_Offset sourceprimoff,
        float blend)
    {
        const GEO_Primitive *srcgeoprim = mySrcGdp.getGEOPrimitive(
                                                        sourceprimoff);
        const GEO_PrimPoly  *srcpoly(nullptr);

        // We only do polygons
        if (srcgeoprim->getTypeId() == GEO_PRIMPOLY)
        {
            srcpoly = static_cast<const GEO_PrimPoly *>(srcgeoprim);

            sampleAttribs(dstprimpoly, *srcpoly, blend);
        }
    }

private:
    void
    addAttribToMap(GA_AttributeRefMap &map, const char *attribname);

    GU_Detail &myDstGdp;
    const GU_Detail &mySrcGdp;

    GA_AttributeRefMap      myAttribMap;
    GA_AttributeRefMap      myLengthScaledAttribMap;
};

// A tree that can be built using an arbitrary prim or point attribute as the
// point position. When using a prim attribute, this allows direct lookup of
// curve primitives.
class GU_API GU_GroomCurveTree : public GEO_PointTreeGAOffset
{
public:
    /// Rebuilds the tree with the given detail and primitive group,
    /// This creates a point per primitive using the primitive attribute of the
    /// specified name as the point position.
    /// if primgroup is NULL then all primitives are used.
    void
    build(
        const GEO_Detail *gdp,
        const GA_PrimitiveGroup *primgroup,
        const char *attrib,
        bool enable_multithreading=true);

    // Methods that must delegate to base class due to overloads
    void build(
        const GEO_Detail *gdp,
        const GA_PointGroup *ptgroup,
        bool enable_multithreading=true)
    {
        GEO_PointTreeGAOffset::build(gdp, ptgroup, enable_multithreading);
    }

    void build(
        const GEO_Detail *gdp,
        const GA_PointGroup *ptgroup,
        const char *attrib,
        bool enable_multithreading=true)
    {
        GEO_PointTreeGAOffset::build(gdp, ptgroup, attrib, enable_multithreading);
    }
};

class GU_API GU_GroomFastRamp
{
public:
    GU_GroomFastRamp(int numsamples=1000)
    : myNumSamples(numsamples)
    {}

    bool operator==(const GU_GroomFastRamp& ramp) const
    {
        return mySamples == ramp.mySamples
            && myNumSamples == ramp.myNumSamples
            && myIsConstant == ramp.myIsConstant;
    }

    bool operator!=(const GU_GroomFastRamp& ramp) const
    {
        return !(*this == ramp);
    }

    bool update(const UT_Ramp *widthramp);

    void update(const UT_FloatArray &values);

    SYS_FORCE_INLINE
    bool isConstant() { return myIsConstant; }

    SYS_FORCE_INLINE
    float lookup(float u) const
    {
        float us = u * (mySamples.size()-1);
        int indexA = SYSclamp(exint(us), exint(0), mySamples.size()-1);
        if (indexA == mySamples.size()-1)
            return mySamples(indexA);
        int indexB = indexA + 1;
        return SYSlerp(mySamples(indexA), mySamples(indexB), us - indexA);
    }

    SYS_FORCE_INLINE
    float lookupNearest(float u) const
    {
        int index = SYSclamp(
            exint(u * (mySamples.size()-1) + 0.5),
            exint(0),
            mySamples.size()-1);
        return mySamples(index);
    }

    const UT_FloatArray &samples() const;

private:
    UT_FloatArray    mySamples;
    int              myNumSamples;
    bool             myIsConstant = false;
};

class GU_API GU_GroomSourceAttribList
{
public:
    GU_GroomSourceAttribList(
        GU_Detail *dest,
        const GU_Detail *source,
        const GA_AttributeOwner destowner)
    : dest(dest)
    , source(source)
    , destowner(destowner)
    {}

    using AttribMatchTuple = std::pair<GA_AttributeOwner, UT_StringHolder>;

    void addSourceAttribs(
        const GA_AttributeOwner sourceowner,
        const char *matchpattern,
        UT_Set<AttribMatchTuple> &alreadymapped,
        const GA_AttributeFilter *filter=nullptr);

    enum AttribChange
    {
        NONE,
        DATA,
        STORAGE
    };

    class CacheData
    {
    private:
        UT_ValArray<int> targetindices;
        UT_ValArray<GA_AttributeOwner> owners;
        UT_ValArray<UT_StringHolder> names;
        UT_ValArray<int> typeids;
        UT_ValArray<int> tuplesizes;
        UT_ValArray<GA_DataId> dataids;

        friend GU_GroomSourceAttribList;

    };

    void mapAndCreateAttribs(
        GA_AttributeRefMap &map) const
    {
        mapAndCreateAttribs(map, nullptr);
    }


    void mapAndCreateAttrib(
        GA_AttributeRefMap &map,
        const UT_ValArray<AttribChange> *changes,
        int index) const;

    // Creates or updates attributes as required by the changes array
    //
    // Attributes that need their data copied are added to map.
    void mapAndCreateAttribs(
        GA_AttributeRefMap &map,
        const UT_ValArray<AttribChange> *changes) const
    {
        for (int i = 0; i < sourceattribs.size(); ++i)
            mapAndCreateAttrib(map, changes, i);
    }

    // Creates or updates attributes as required by the changes array
    //
    // Attributes that need their data copied are added to map.
    void mapAndCreateAttribs(
        GA_AttributeRefMap &map,
        const UT_ValArray<AttribChange> *changes,
        const std::function<bool(const GA_Attribute &)>& filter ) const
    {
        for (int i = 0; i < sourceattribs.size(); ++i)
            if (filter(*sourceattribs[i]))
                mapAndCreateAttrib(map, changes, i);
    }

    void
    mapAndCreateRealAttribs(
            GA_AttributeRefMap &map,
            const UT_ValArray<AttribChange> *changes) const
    {
        static auto &&theFilter = [](const GA_Attribute &attrib)
        {
            return attrib.getStorageClass() == GA_STORECLASS_REAL;
        };

        mapAndCreateAttribs(map, changes, theFilter);
    }

    void
    mapAndCreateNonRealAttribs(
            GA_AttributeRefMap &map,
            const UT_ValArray<AttribChange> *changes) const
    {
        static auto &&theFilter = [](const GA_Attribute &attrib)
        {
            return attrib.getStorageClass() != GA_STORECLASS_REAL;
        };

        mapAndCreateAttribs(map, changes, theFilter);
    }

    bool updateCache(
            UT_UniquePtr<CacheData> &cachedata,
            UT_ValArray<AttribChange> &changes) const;

private:
    CacheData* getCacheData() const;

    const GU_Detail *source;
    UT_ValArray<const GA_Attribute*> sourceattribs;
    GU_Detail *dest;
    const GA_AttributeOwner destowner;
};

class GU_ROWeightArrayPairHandle
{
public:
    GU_ROWeightArrayPairHandle() = default;

    GU_ROWeightArrayPairHandle(
        const GEO_Detail &detail,
        GA_AttributeOwner attrib_owner,
        const UT_StringHolder &key_attrib_name,
        const UT_StringHolder &weight_attrib_name)
    {
        bind(detail, attrib_owner, key_attrib_name, weight_attrib_name);
    }

    bool bind(
        const GEO_Detail &detail,
        GA_AttributeOwner attrib_owner,
        const UT_StringHolder &key_attrib_name,
        const UT_StringHolder &weight_attrib_name)
    {
        return bindImpl(SYSconst_cast(detail), attrib_owner, key_attrib_name, weight_attrib_name);
    }

    void bind(
        const GA_Attribute *key_attrib,
        const GA_Attribute *weight_attrib)
    {
        bindImpl(SYSconst_cast(key_attrib), SYSconst_cast(weight_attrib));

        setAIFArrays();
    }

    bool
    isValid() const
    {
        return myKeyAttrib && myWeightAttrib;
    }

    const GA_Attribute *
    keyAttrib() const
    {
        return myKeyAttrib;
    }

    const GA_Attribute *
    weightAttrib() const
    {
        return myWeightAttrib;
    }

    const GA_AIFNumericArray*
    indexArray() const
    {
        return myIndexArray;
    }

    const GA_AIFSharedStringArray*
    nameArray() const
    {
        return myNameArray;
    }

    const GA_AIFNumericArray*
    weightArray() const
    {
        return myWeightArray;
    }

    void setAIFArrays()
    {
        myIndexArray = myKeyAttrib
            ? myKeyAttrib->getAIFNumericArray()
            : nullptr;
        myNameArray = myKeyAttrib
            ? myKeyAttrib->getAIFSharedStringArray()
            : nullptr;

        myWeightArray = myWeightAttrib
            ? myWeightAttrib->getAIFNumericArray()
            : nullptr;
    }

protected:
    bool bindImpl(
        GEO_Detail &detail,
        GA_AttributeOwner attrib_owner,
        const UT_StringHolder &key_attrib_name,
        const UT_StringHolder &weight_attrib_name)
    {
        GA_Attribute *weight_attrib, *key_attrib;

        weight_attrib =
            SYSconst_cast(detail.findFloatArray(attrib_owner, weight_attrib_name));
        key_attrib =
            SYSconst_cast(detail.findStringArray(attrib_owner, key_attrib_name));

        if (!key_attrib)
        {
            key_attrib =
                SYSconst_cast(detail.findIntArray( attrib_owner, key_attrib_name));
        }

        if (!key_attrib || !weight_attrib)
            return false;

        myWeightAttrib = weight_attrib;
        myKeyAttrib = key_attrib;
        setAIFArrays();

        return true;
    }

    void bindImpl(
        GA_Attribute *key_attrib,
        GA_Attribute *weight_attrib)
    {
        myKeyAttrib = key_attrib;
        myWeightAttrib = weight_attrib;

        setAIFArrays();
    }

    const GA_AIFNumericArray        *myIndexArray = nullptr;
    const GA_AIFSharedStringArray   *myNameArray = nullptr;
    const GA_AIFNumericArray        *myWeightArray = nullptr;

    GA_Attribute                    *myKeyAttrib = nullptr;
    GA_Attribute                    *myWeightAttrib = nullptr;
};

class GU_RWWeightArrayPairHandle : public GU_ROWeightArrayPairHandle
{
public:
    GU_RWWeightArrayPairHandle() = default;

    GU_RWWeightArrayPairHandle(
        GEO_Detail &detail,
        GA_AttributeOwner attrib_owner,
        const UT_StringHolder &key_attrib_name,
        const UT_StringHolder &weight_attrib_name)
    {
        bind(detail, attrib_owner, key_attrib_name, weight_attrib_name);
    }

    bool bind(
        GEO_Detail &detail,
        GA_AttributeOwner attrib_owner,
        const UT_StringHolder &key_attrib_name,
        const UT_StringHolder &weight_attrib_name)
    {
        return bindImpl(detail, attrib_owner, key_attrib_name, weight_attrib_name);
    }

    void bind(
        GA_Attribute *key_attrib,
        GA_Attribute *weight_attrib)
    {
        bindImpl(key_attrib, weight_attrib);
    }

    bool
    isValid() const
    {
        return myKeyAttrib && myWeightAttrib;
    }

    GA_Attribute *
    keyAttrib() const
    {
        return myKeyAttrib;
    }

    GA_Attribute *
    weightAttrib() const
    {
        return myWeightAttrib;
    }

    void set(
        GA_Offset primoff,
        const UT_StringArray &names,
        const UT_FloatArray &weights)
    {
        nameArray()->set(keyAttrib(), primoff, names);
        weightArray()->set(weightAttrib(), primoff, weights);
    }

    void bumpDataIds()
    {
        if (myKeyAttrib != nullptr)
            myKeyAttrib->bumpDataId();

        if (myWeightAttrib != nullptr)
            myWeightAttrib->bumpDataId();
    }
};

class GU_WeightArrayInterpolate
{
public:
    struct TempData
    {
        UT_StringArray                   outnames;
        UT_ValArray<GA_Size>             outindices;
        UT_FloatArray                    outweights;

        UT_Map<UT_StringHolder, float>   tempnameset;
        UT_Map<GA_Size, float>           tempindexset;
    };

    GU_WeightArrayInterpolate(
        const GEO_Detail &weightgeo)
    : myWeightGeo(weightgeo)
    {
    }

    GU_WeightArrayInterpolate(
        const GEO_Detail &weightgeo,
        GA_AttributeOwner attrib_owner,
        const UT_StringRef &key_attrib_name,
        const UT_StringRef &weight_attrib_name)
    : myWeightGeo(weightgeo)
    {
        myInputAttribs.bind(
            myWeightGeo,
            attrib_owner,
            key_attrib_name,
            weight_attrib_name);
    }

    GU_WeightArrayInterpolate(
        const GEO_Detail &weightgeo,
        const GA_Attribute &keyattrib,
        const GA_Attribute &weightattrib)
    : myWeightGeo(weightgeo)
    {
        myInputAttribs.bind(
            &keyattrib,
            &weightattrib);
    }

    bool bindInputAttribs(
        GA_AttributeOwner attrib_owner,
        const UT_StringRef &key_attrib_name,
        const UT_StringRef &weight_attrib_name)
    {
        return myInputAttribs.bind(
            myWeightGeo,
            attrib_owner,
            key_attrib_name,
            weight_attrib_name);
    }

    bool
    isValid() const
    {
        return myInputAttribs.keyAttrib() && myInputAttribs.weightAttrib();
    }

    const GA_Attribute *
    keyAttrib() const
    {
        return myInputAttribs.keyAttrib();
    }

    const GA_Attribute *
    weightAttrib() const
    {
        return myInputAttribs.weightAttrib();
    }

    const GU_ROWeightArrayPairHandle&
    getWeightArrayPairHandle() const
    {
        return myInputAttribs;
    }

    void
    createOutputAttribs(
        GU_Detail &gdp,
        GA_AttributeOwner owner)
    {
        bool key_is_string = false;

        if (!isValid())
            return;

        const UT_StringHolder key_name = keyAttrib()->getName();
        const UT_StringHolder weight_name = weightAttrib()->getName();

        key_is_string = keyAttrib()->getAIFSharedStringArray() != nullptr;

        GA_Attribute *keyattrib = nullptr;
        GA_Attribute *weightattrib = nullptr;

        if (key_is_string)
        {
            UTlhsTuple(keyattrib, weightattrib) =
                GU_GroomUtils::createNameAndWeightArrayAttributes(
                    gdp, owner, key_name, weight_name);
        }
        else
        {
            UTlhsTuple(keyattrib, weightattrib) =
                GU_GroomUtils::createIndexAndWeightArrayAttributes(
                    gdp, owner, key_name, weight_name);
        }

        myOutputAttribs.bind(keyattrib, weightattrib);
    }

    void interpolate(
        const GA_OffsetArray    &offsets,
        const UT_FloatArray     &weights,
        GA_Offset               &out_offset,
        TempData                &tempdata) const
    {
        bool success = false;
        if (myInputAttribs.nameArray() != nullptr)
        {
            interpolate(
                tempdata.outnames,
                tempdata.outweights,
                offsets,
                weights,
                tempdata.tempnameset);

            myOutputAttribs.nameArray()->set(
                myOutputAttribs.keyAttrib(), out_offset, tempdata.outnames);

            success = true;
        }
        else if (myInputAttribs.indexArray())
        {
            interpolate(
                tempdata.outindices,
                tempdata.outweights,
                offsets,
                weights,
                tempdata.tempindexset);

            myOutputAttribs.indexArray()->set(
                myOutputAttribs.keyAttrib(), out_offset, tempdata.outindices);

            success = true;
        }

        if (success)
        {
            myOutputAttribs.weightArray()->set(
                myOutputAttribs.weightAttrib(), out_offset, tempdata.outweights);
        }
    }

    template<typename C>
    void
    interpolate(
        C                       &out_keys,
        UT_Array<float>         &out_weights,
        const GA_OffsetArray    &offsets,
        const UT_FloatArray     &weights,
        UT_Map<typename C::value_type, float>        &blended_weights_set) const
    {
        UT_ASSERT(offsets.size() == weights.size());

        interpolate(
                out_keys,
                out_weights,
                offsets.data(),
                weights.data(),
                offsets.size(),
                blended_weights_set);
    }

    template<typename C>
    void
    interpolate(
        C                       &out_keys,
        UT_Array<float>         &out_weights,
        const GA_Offset         *offsets,
        const float             *weights,
        const int               weightcount,
        UT_Map<typename C::value_type, float>        &blended_weights_set) const
    {
        using T = typename C::value_type;

        blended_weights_set.clear();

        float pw_sum(0.0f);

        for (int i=0; i<weightcount; ++i)
        {
            GA_Offset offset = offsets[i];
            float pw = weights[i];

            if (pw < SYS_FTOLERANCE)
                continue;

            if constexpr(SYS_IsSame_v<C, UT_StringArray>)
                myInputAttribs.nameArray()->get(myInputAttribs.keyAttrib(), offset, out_keys);
            else
                myInputAttribs.indexArray()->get(myInputAttribs.keyAttrib(), offset, out_keys);

            myInputAttribs.weightArray()->get(myInputAttribs.weightAttrib(), offset, out_weights);

            int count = SYSmin(out_keys.size(), out_weights.size());

            for (int j=0; j<count; ++j)
            {
                T key = out_keys[j];
                float w = out_weights[j];

                blended_weights_set[key] =
                    blended_weights_set.get(key, 0.0f) + pw * w;
            }

            pw_sum += pw;
        }

        float inv_pw_sum = SYSsaferecip(pw_sum);

        out_keys.setSize(0);
        out_weights.setSize(0);
        for (auto &wpair : blended_weights_set)
        {
            out_keys.append(wpair.first);
            out_weights.append(inv_pw_sum * wpair.second);
        }
    }

    void
    interpolate(
        const GU_Detail &geo,
        const GA_Attribute &prim_attrib,
        const GA_Attribute &primuv_attrib,
        GA_Attribute &key_attrib,
        GA_Attribute &weight_attrib) const
    {
        const GA_AIFNumericArray *index_array = key_attrib.getAIFNumericArray();
        const GA_AIFNumericArray *weight_array = weight_attrib.getAIFNumericArray();

        const GA_Size num_weight_prims = myWeightGeo.getNumPrimitives();

        GA_ROHandleI prim_handle(&prim_attrib);
        GA_ROHandleV3 primuv_handle(&primuv_attrib);

        GA_Range elemrange;

        switch (prim_attrib.getOwner())
        {
            default: UT_ASSERT(0); SYS_FALLTHROUGH;
            case GA_ATTRIB_VERTEX: elemrange = geo.getVertexRange(); break;
            case GA_ATTRIB_POINT: elemrange = geo.getPointRange(); break;
            case GA_ATTRIB_PRIMITIVE: elemrange = geo.getPrimitiveRange(); break;
            case GA_ATTRIB_DETAIL: elemrange = geo.getGlobalRange(); break;
        }

        UTparallelFor(GA_SplittableRange(elemrange),
        [&](const GA_SplittableRange &r)
        {
            GA_Offset                startoff;
            GA_Offset                endoff;

            GA_OffsetArray           pt_offsets;
            UT_FloatArray            pt_weights;

            UT_ValArray<GA_Size>     indices;
            UT_ValArray<float>       weights;

            UT_Map<GA_Size, float>   temp_set;

            for (GA_Iterator ptit(r); ptit.blockAdvance(startoff, endoff); )
            {
                for (GA_Offset elemoff = startoff; elemoff < endoff; ++elemoff)
                {
                    GA_Index skinprimindex = prim_handle.get(elemoff);

                    if (skinprimindex < 0 || skinprimindex >= num_weight_prims)
                        continue;

                    GA_Offset primoff = myWeightGeo.primitiveOffset(skinprimindex);
                    UT_Vector3 primuv = primuv_handle.get(elemoff);

                    auto skinprim = myWeightGeo.getGEOPrimitive(primoff);
                    skinprim->computeInteriorPointWeights(
                            pt_offsets, pt_weights,
                            primuv.x(),
                            primuv.y(),
                            primuv.z());

                    if (myInputAttribs.weightAttrib()->getOwner() != GA_ATTRIB_VERTEX)
                        for (int i=0; i<pt_offsets.size(); ++i)
                            pt_offsets[i] = myWeightGeo.vertexPoint(pt_offsets[i]);

                    interpolate(
                        indices, weights,
                        pt_offsets, pt_weights,
                        temp_set);

                    index_array->set(&key_attrib, elemoff, indices);
                    weight_array->set(&weight_attrib, elemoff, weights);
                }
            }
        });
    }

private:
    const GEO_Detail            &myWeightGeo;

    GU_ROWeightArrayPairHandle   myInputAttribs;
    GU_RWWeightArrayPairHandle   myOutputAttribs;
};

struct
GU_SkinInterpolate
{
    enum class SkinGuideMode
    {
        MATCHBYGUIDEID = 0,
        WEIGHTARRAYS
    };

    struct CacheData
    {
    private:
        GA_DataId myTopoId = -2;
        GA_DataId myPrimlistId = -2;
        GA_DataId myGuidesArrayId = -2;
        GA_DataId myWeightsArrayId = -2;

        friend GU_SkinInterpolate;
    };

    GU_SkinInterpolate(
        const GU_Detail &guidegdp,
        const GU_Detail &interpgdp,
        const GA_ROHandleV3 &rootlookuppos,
        SkinGuideMode guidemode,
        const GA_ROHandleI &skinguidelookupattrib,
        const UT_StringHolder &guidesattrib,
        const UT_StringHolder &weightsattrib)
    : myGuideGdp(guidegdp)
    , myInterpGdp(interpgdp)
    , myWeightArrayInterp(
        guidemode == SkinGuideMode::WEIGHTARRAYS
            ? UTmakeUnique<GU_WeightArrayInterpolate>(
                myInterpGdp, GA_ATTRIB_POINT,
                guidesattrib, weightsattrib)
            : nullptr)
    , myRootLookupPos(rootlookuppos)
    , myRayIntersect(UTmakeUnique<GU_RayIntersect>(&interpgdp))
    , myGuideMode(guidemode)
    , mySkinGuideLookupAttrib(skinguidelookupattrib)
    {
    }

    bool isValid()
    {
        if (guideMode() == SkinGuideMode::WEIGHTARRAYS)
        {
            return myWeightArrayInterp->isValid();
        }

        return true;
    }

    bool checkGuides(
        const GA_PrimitiveGroup *guidegroup)
    {
        if (myGuideMode != SkinGuideMode::WEIGHTARRAYS)
            return true;

        UT_ValArray<GA_Size> indices;

        for (GA_Offset ptoff : myInterpGdp.getPointRange())
        {
            auto handle = myWeightArrayInterp->getWeightArrayPairHandle();
            handle.indexArray()->get(handle.keyAttrib(), ptoff, indices);

            for (GA_Size index : indices)
            {
                if (index < 0 || index >= myGuideGdp.getNumPrimitives())
                    return false;

                if (guidegroup != nullptr && !guidegroup->containsIndex(index))
                {
                    return false;
                }
            }
        }

        return true;
    }

    bool updateCache(CacheData &cache)
    {
        GA_DataId topoid = interpMesh().getTopology().getDataId();
        GA_DataId primlistid = interpMesh().getPrimitiveList().getDataId();

        GA_DataId guidesarrayid = GA_INVALID_DATAID;
        GA_DataId weightsarrayid = GA_INVALID_DATAID;

        if (guideMode() == SkinGuideMode::WEIGHTARRAYS
                && myWeightArrayInterp->isValid())
        {
            guidesarrayid = myWeightArrayInterp->keyAttrib()->getDataId();
            weightsarrayid = myWeightArrayInterp->weightAttrib()->getDataId();
        }

        if (topoid != cache.myTopoId ||
            primlistid != cache.myPrimlistId ||
            guidesarrayid != cache.myGuidesArrayId ||
            weightsarrayid != cache.myWeightsArrayId)
        {
            cache.myTopoId = topoid;
            cache.myPrimlistId = primlistid;
            cache.myGuidesArrayId = guidesarrayid;
            cache.myWeightsArrayId = weightsarrayid;
            return true;
        }

        return false;
    }

    SkinGuideMode guideMode() const
    {
        return myGuideMode;
    }

    const GU_Detail &interpMesh() const
    {
        return myInterpGdp;
    }

    void computePointWeights(
        GA_Offset sourceptoff,
        GU_MinInfo &mininfo,
        GA_OffsetArray &offsets,
        UT_FloatArray &weights) const
    {
        myRayIntersect->minimumPoint(
            myRootLookupPos.get(sourceptoff), mininfo);


        GA_Offset hitprim_offset = mininfo.prim.offset();
        auto skinprim = myInterpGdp.getGEOPrimitive(hitprim_offset);
        skinprim->computeInteriorPointWeights(
                offsets, weights,
                mininfo.u1, mininfo.v1,
                0.0f);

        GU_GroomUtils::vertexToPointOffsets(offsets, myInterpGdp);
    }

    // Populates guideoffsets and guideweights array using the method
    // specified by the guidemode argument to the constructor.
    void interpolate(
        GA_OffsetArray &guideoffsets,
        UT_FloatArray &guideweights,
        const GA_OffsetArray &skinoffsets,
        const UT_FloatArray &skinweights,
        UT_ValArray<GA_Size> &tempindices,
        UT_Map<GA_Size, float> &tempset) const
    {
        if (guideMode() == SkinGuideMode::WEIGHTARRAYS)
        {
            interpolateWeightArrays(
                guideoffsets,
                guideweights,
                skinoffsets,
                skinweights,
                tempindices,
                tempset);
        }
        else
        {
            interpolateGuides(
                guideoffsets,
                guideweights,
                skinoffsets,
                skinweights);
        }
    }

private:
    void interpolateWeightArrays(
        GA_OffsetArray &guideoffsets,
        UT_FloatArray &guideweights,
        const GA_OffsetArray &skinoffsets,
        const UT_FloatArray &skinweights,
        UT_ValArray<GA_Size> &tempindices,
        UT_Map<GA_Size, float> &tempset) const
    {
        myWeightArrayInterp->interpolate(
            tempindices,
            guideweights,
            skinoffsets,
            skinweights,
            tempset);

        guideoffsets.setCapacity(tempindices.size());
        guideoffsets.setSize(0);
        for (GA_Size index : tempindices)
        {
            guideoffsets.append(
                myGuideGdp.primitiveOffset(index));
        }
    }

    void interpolateGuides(
        GA_OffsetArray &guideoffsets,
        UT_FloatArray &guideweights,
        const GA_OffsetArray &skinoffsets,
        const UT_FloatArray &skinweights) const
    {
        guideoffsets.setSize(skinoffsets.size());
        guideweights.setSize(skinoffsets.size());

        for (GA_Size j = 0; j < skinoffsets.size(); ++j)
        {
            GA_Offset skinptoff = skinoffsets(j);
            GA_Index guideindex;

            if (mySkinGuideLookupAttrib.isValid())
            {
                guideindex = mySkinGuideLookupAttrib.get(skinptoff);

                if (guideindex == GA_INVALID_INDEX)
                {
                    guideoffsets.clear();
                    guideweights.clear();
                    break;
                }
            }
            else
            {
                guideindex = interpMesh().pointIndex(skinptoff);
            }

            GA_Offset guideprimoff = myGuideGdp.primitiveOffset(guideindex);

            guideoffsets(j) = guideprimoff;
            guideweights(j) = skinweights(j);
        }
    }

    const GU_Detail                         &myGuideGdp;
    const GU_Detail                         &myInterpGdp;
    UT_UniquePtr<GU_WeightArrayInterpolate>  myWeightArrayInterp;
    const GA_ROHandleV3                     &myRootLookupPos;
    UT_UniquePtr<GU_RayIntersect>            myRayIntersect;
    const SkinGuideMode                      myGuideMode;
    const GA_ROHandleI                      &mySkinGuideLookupAttrib;
};

#endif