GU_Feather.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_Feather_h__
#define __GU_Feather_h__

#include "GU_API.h"
#include "GU_Detail.h"
#include "GU_GroomUtils.h"
#include "GU_PrimPoly.h"

#include <GA/GA_Handle.h>
#include <GA/GA_Names.h>
#include <GEO/GEO_PrimPoly.h>
#include <GU/GU_SubDivCurve.h>
#include <SYS/SYS_Math.h>
#include <numeric>
#include <type_traits>
#include <iostream>
#include <chrono>

class GU_FeatherROhandle;
class GU_FeatherTemplateSet;
class GU_FeatherTemplateInterpolate;

template<typename T>
class GU_API GU_FeatherBarbValueInfo
{
    template<class V = T>
    using is_int = std::is_integral<V>;

    template<class V = T>
    using is_flt = std::is_floating_point<V>;

public:
    template<class V = T>
    static constexpr
    typename std::enable_if<is_int<V>::value || is_flt<V>::value, int>::type
    tupleSize()
    {
        return 1;
    }

    template<class V = T>
    static constexpr
    typename std::enable_if<!(is_int<V>::value || is_flt<V>::value), int>::type
    tupleSize()
    {
        return V::tuple_size;
    }

};

template<typename ValueType>
class GU_API GU_FeatherBarbROHandle
{
public:
    typedef ValueType value_type;

    GU_FeatherBarbROHandle()
    {}

    GU_FeatherBarbROHandle(
        const GU_Detail &gdp,
        GA_ROHandleT<ValueType> &pos,
        GA_ROHandleQ &orient,
        const UT_StringRef &name)
    : myDetail(SYSconst_cast(&gdp))
    , myPos(pos)
    , myOrient(orient)
    {
        GA_Attribute *attrib = findAttribByName(name);
        if (attrib != nullptr)
            setAttrib(*attrib);
    };

    GU_FeatherBarbROHandle(
        const GU_Detail &gdp,
        const UT_StringRef &name)
    : myDetail(SYSconst_cast(&gdp))
    {
        GA_Attribute *attrib = findAttribByName(name);
        if (attrib != nullptr)
            setAttrib(*attrib);
    };

    GU_FeatherBarbROHandle(
        const GU_Detail &gdp,
        const GA_Attribute &attrib)
    : myDetail(SYSconst_cast(&gdp))
    {
        setAttrib(SYSconst_cast(attrib));
    };

    void
    bind(
        const GU_Detail *gdp,
        const GA_Attribute *attrib)
    {
        myDetail = SYSconst_cast(gdp);

        if (attrib)
            setAttrib(*SYSconst_cast(attrib));
    }

    bool
    isValid() const
    {
        return myAttrib != nullptr;
    }

    GA_Attribute*
    getAttribute()
    {
        return myAttrib;
    }

    const GA_Attribute*
    getAttribute() const
    {
        return myAttrib;
    }

    static int valueTupleSize()
    {
        return GU_FeatherBarbValueInfo<ValueType>::tupleSize();
    }

    int numBarbPoints() const
    {
        int value_tuple_size = GU_FeatherBarbValueInfo<ValueType>::tupleSize();

        if (value_tuple_size == 0)
            return 0;

        return myTupleSize / value_tuple_size;
    }

    // get for integral/float types
    template<class V = ValueType>
    SYS_FORCE_INLINE
    typename std::enable_if<std::is_integral<V>::value || std::is_floating_point<V>::value, void>::type
    get(GA_Offset offset, UT_Array<ValueType> &array) const
    {
        array.bumpSize(numBarbPoints());
        V *data = reinterpret_cast<V*>(array.data());
        myTuple->get(myAttrib, offset, data, myTupleSize);
    }

    // get for vector types
    template<class V = ValueType>
    SYS_FORCE_INLINE
    typename std::enable_if<!std::is_integral<V>::value && !std::is_floating_point<V>::value, void>::type
    get(GA_Offset offset, UT_Array<ValueType> &array) const
    {
        using ScalarType = typename ValueType::value_type;
        array.bumpSize(numBarbPoints());
        ScalarType *data = reinterpret_cast<ScalarType*>(array.data());
        myTuple->get(myAttrib, offset, data, myTupleSize);
    }

    template<typename T>
    SYS_FORCE_INLINE
    void
    xformToObject(
        GA_Offset ptoff,
        UT_Array<UT_Vector3T<T>> &array) const
    {
        UT_Vector3 pos = myPos.get(ptoff);
        UT_Quaternion orient = myOrient.get(ptoff);

        for (UT_Vector3T<T> &barb : array)
        {
            barb = orient.rotate(barb);
            barb += pos;
        }
    }

    template<typename T>
    SYS_FORCE_INLINE
    void
    xformToObjectNonZero(
        GA_Offset ptoff,
        UT_Array<UT_Vector3T<T>> &array) const
    {
        UT_Vector3 pos = myPos.get(ptoff);
        UT_Quaternion orient = myOrient.get(ptoff);

        for (UT_Vector3T<T> &barb : array)
        {
            if (barb.isZero())
                continue;
            barb = orient.rotate(barb);
            barb += pos;
        }
    }

    template<typename T>
    SYS_FORCE_INLINE
    void
    xformToLocal(
        GA_Offset ptoff,
        UT_Array<UT_Vector3T<T>> &array) const
    {
        UT_Vector3 pos = myPos.get(ptoff);
        UT_Quaternion orient = myOrient.get(ptoff);

        for (UT_Vector3T<T> &barb : array)
        {
            barb -= pos;
            barb = orient.rotateInverse(barb);
        }
    }

    template<typename T>
    SYS_FORCE_INLINE
    void
    xformToLocalNonZero(
        GA_Offset ptoff,
        UT_Array<UT_Vector3T<T>> &array) const
    {
        UT_Vector3 pos = myPos.get(ptoff);
        UT_Quaternion orient = myOrient.get(ptoff);

        for (UT_Vector3T<T> &barb : array)
        {
            if (barb.isZero())
                continue;
            barb -= pos;
            barb = orient.rotateInverse(barb);
        }
    }

    const UT_Quaternion
    getOrient(GA_Offset offset) const
    {
        return myOrient.get(offset);
    }

    SYS_FORCE_INLINE
    fpreal
    boundingRadius(GA_Offset ptoff) const
    {
        if (myTupleSize < 3)
            return 0.0;

        UT_Vector3 data;
        myTuple->get(myAttrib, ptoff, reinterpret_cast<fpreal32*>(data.data()), 3, myTupleSize-3);

        return data.length();
    }

    int
    tupleSize() const
    {
        return myTupleSize;
    }

    void
    bumpDataId() const
    {
        myAttrib->bumpDataId();
    }

protected:
    GU_Detail               *myDetail;
    GA_ROHandleT<ValueType>  myPos;
    GA_ROHandleQ             myOrient;

    GA_Attribute            *myAttrib = nullptr;
    const GA_AIFTuple       *myTuple = nullptr;
    int                      myTupleSize = 0;

private:
    GA_Attribute *findAttribByName(const UT_StringRef &name)
    {
        int tuple_size = GU_FeatherBarbValueInfo<ValueType>::tupleSize();

        return myDetail->findFloatTuple(
            GA_ATTRIB_POINT, name, tuple_size);
    }

    void setAttrib(GA_Attribute &attrib)
    {
        myAttrib = &attrib;
        myTuple = myAttrib->getAIFTuple();
        myTupleSize = myTuple->getTupleSize(myAttrib);

        UT_ASSERT(3 % GU_FeatherBarbValueInfo<ValueType>::tupleSize() == 0);
    }

};

template<typename ValueType>
class GU_API GU_FeatherBarbRWHandle : public GU_FeatherBarbROHandle<ValueType>
{
    using Base = GU_FeatherBarbROHandle<ValueType>;
public:
    GU_FeatherBarbRWHandle()
    : Base()
    {}

    GU_FeatherBarbRWHandle(
        GU_Detail &gdp,
        GA_ROHandleT<ValueType> &pos,
        GA_ROHandleQ &orient,
        const UT_StringRef &name)
    : Base(gdp, pos, orient, name)
    {};

    GU_FeatherBarbRWHandle(
        const GU_Detail &gdp,
        const UT_StringRef &name)
    : Base(gdp, name)
    {
    };

    GU_FeatherBarbRWHandle(
        const GU_Detail &gdp,
        const GA_Attribute &attrib)
    : Base(gdp, attrib)
    {
    };

    GA_Attribute *operator->() const
    {
        return myAttrib;
    }

    // vector set
    template<class V = ValueType>
    SYS_FORCE_INLINE
    typename std::enable_if<!std::is_integral<V>::value && !std::is_floating_point<V>::value, void>::type
    set(GA_Offset offset, const ValueType *array) const
    {
        using ScalarType = typename ValueType::value_type;
        const ScalarType *data = reinterpret_cast<const ScalarType*>(array);
        myTuple->set(myAttrib, offset, data, myTupleSize);
    }

    // vector set
    template<class V = ValueType>
    SYS_FORCE_INLINE
    typename std::enable_if<!std::is_integral<V>::value && !std::is_floating_point<V>::value, void>::type
    blend(GA_Offset offset, const ValueType *array, float alpha) const
    {
        using ScalarType = typename ValueType::value_type;
        const ScalarType *data = reinterpret_cast<const ScalarType*>(array);
        for (int i=0; i<myTupleSize; ++i)
        {
            ScalarType value;
            myTuple->get(myAttrib, offset, value, i);

            value = SYSlerp(value, data[i], alpha);
            myTuple->set(myAttrib, offset, value, i);
        }
    }

    // scalar set
    template<class V = ValueType>
    SYS_FORCE_INLINE
    typename std::enable_if<std::is_integral<V>::value || std::is_floating_point<V>::value, void>::type
    set(GA_Offset offset, const ValueType *array) const
    {
        const V *data = reinterpret_cast<const V*>(array);
        myTuple->set(myAttrib, offset, data, myTupleSize);
    }

private:
    using Base::myTupleSize;
    using Base::myTuple;
    using Base::myAttrib;
};

template<typename T>
class GU_FeatherBarbFlat
{
public:
    GU_FeatherBarbFlat()
    {
        setDimensions(0, 0);
    }

    GU_FeatherBarbFlat(int ptcount, int barbsegs)
    {
        setDimensions(ptcount, barbsegs);
    }

    void
    setDimensions(int ptcount, int barbsegs)
    {
        myBarbSegs = barbsegs;
        myData.setSize(ptcount * barbsegs);
    }

    void
    bumpDimensions(int ptcount, int barbsegs)
    {
        myBarbSegs = barbsegs;
        myData.bumpSize(ptcount * barbsegs);
    }

    SYS_FORCE_INLINE
    const T&
    get(int index, int segindex) const
    {
        return myData[flatIndex(index, segindex)];
    }

    SYS_FORCE_INLINE
    const T*
    getBarbPtr(int index) const
    {
        return &myData[flatIndex(index, 0)];
    }

    SYS_FORCE_INLINE
    void
    set(int index, int segindex, const T &value)
    {
        myData[flatIndex(index, segindex)] = value;
    }

    SYS_FORCE_INLINE
    void
    set(int index, const UT_Array<T> &value)
    {
        int segs = SYSmin(myBarbSegs, value.size());
        for (int seg=0; seg < segs; ++seg)
        {
            myData[flatIndex(index, seg)] = value[seg];
        }
    }

    SYS_FORCE_INLINE
    void
    add(int index, int segindex, const T &value)
    {
        myData[flatIndex(index, segindex)] += value;
    }

    void
    zero()
    {
        myData.zero();
    }

    void dump()
    {
        UTformat("flat barb data:\n");
        for (int i=0; i<myData.size()/myBarbSegs; ++i)
        {
            for (int j=0; j<myBarbSegs; ++j)
            {
                UTformat("{} ", get(i, j));
            }
            UTformat("\n");
        }
    }

private:
    SYS_FORCE_INLINE
    int
    flatIndex(int index, int segindex) const
    {
        return index * myBarbSegs + segindex;
    }

    int             myBarbSegs;
    UT_Array<T>     myData;
};

class GU_API GU_FeatherTemplateSet
{
public:
    using TemplateOffsetMap = UT_Map<UT_StringHolder, GA_Offset>;

    GU_FeatherTemplateSet(const GU_Detail &gdp)
    : myDetail(gdp)
    {

    }

    const GU_Detail&
    getDetail() const
    {
        return myDetail;
    }

    // stores curve & edge lengths for each primitive
    void storeLengths();

    const UT_FloatArray& getCurveLengths() const
    {
        // storeLengths() must have been run at this point.
        UT_ASSERT(myDetail.getNumPrimitives() == 0 || myCurveLengths.size() > 0);

        return myCurveLengths;
    }

    const UT_Array<UT_FloatArray>& getEdgeLengths() const
    {
        // storeLengths() must have been run at this point.
        UT_ASSERT(myDetail.getNumPrimitives() == 0 || myEdgeLengths.size() > 0);

        return myEdgeLengths;
    }

    // stores a map from template name to primitive offset
    void storeOffsetMap(
        GA_ROHandleS &templatenameattrib);

    const TemplateOffsetMap&
    getTemplateOffsetMap() const
    {
        // storeLengths() must have been run at this point.
        UT_ASSERT(myDetail.getNumPrimitives() == 0 || myTemplateOffsetMap.size() > 0);

        return myTemplateOffsetMap;
    }

    void
    storeFirstBarbAttrib();

    const GA_ROHandleI
    getFirstBarbAttrib() const
    {
        return myFirstBarbAttrib.get();
    }

private:

    const GU_Detail &myDetail;
    UT_Map<UT_StringHolder, GA_Offset> myTemplateOffsetMap;
    UT_FloatArray myCurveLengths;
    UT_Array<UT_FloatArray> myEdgeLengths;
    GA_AttributeUPtr myFirstBarbAttrib;
};

class GU_API GU_FeatherTemplateInterpolate
{
public:
    using TemplateOffsetMap = UT_Map<UT_StringHolder, GA_Offset>;

    struct TempData
    {
        UT_StringArray                              templatenames;
        UT_Int64Array                               templateindices;
    };

    GU_FeatherTemplateInterpolate(
        const GU_Detail             &gdp,
        const GU_Detail             &templategdp,
        const GU_FeatherTemplateSet &templateinterp,
        const UT_StringHolder       &indices_attrib_name,
        const UT_StringHolder       &weights_attrib_name)
    : myTemplateDetail(templategdp)
    , myTemplateSet(templateinterp)
    {
        myTemplateIdentifierAttrib =
            gdp.findStringArray(GA_ATTRIB_PRIMITIVE, indices_attrib_name);

        if (myTemplateIdentifierAttrib != nullptr)
        {
            myTemplateNamesArray = myTemplateIdentifierAttrib->getAIFSharedStringArray();
        }
        else
        {
            myTemplateIdentifierAttrib =
                gdp.findIntArray(GA_ATTRIB_PRIMITIVE, indices_attrib_name);

            if (myTemplateIdentifierAttrib != nullptr)
                myTemplateIndicesArray = myTemplateIdentifierAttrib->getAIFNumericArray();
        }

        myTemplateWeightsAttrib =
            gdp.findFloatArray(GA_ATTRIB_PRIMITIVE, weights_attrib_name);

        if (myTemplateWeightsAttrib != nullptr)
            myTemplateWeightArray =  myTemplateWeightsAttrib->getAIFNumericArray();
    }

    GU_FeatherTemplateInterpolate(
        const GU_Detail                     &gdp,
        const GU_FeatherTemplateSet &templateinterp,
        const GA_Attribute                  &templatenamesattrib,
        const GA_Attribute                  &templateweightattrib)
    : myTemplateDetail(gdp)
    , myTemplateSet(templateinterp)
    , myTemplateIdentifierAttrib(&templatenamesattrib)
    , myTemplateWeightsAttrib(&templateweightattrib)
    {
        myTemplateNamesArray = templatenamesattrib.getAIFSharedStringArray();
        myTemplateIndicesArray = templatenamesattrib.getAIFNumericArray();
        myTemplateWeightArray =  templateweightattrib.getAIFNumericArray();
    }

    bool isValid() const
    {
        return
            (myTemplateNamesArray != nullptr ||
             myTemplateIndicesArray != nullptr)
            && myTemplateWeightArray != nullptr;
    }

    bool hasTemplateNames() const
    {
        return myTemplateNamesArray != nullptr;
    }

    bool hasTemplateIndices() const
    {
        return myTemplateIndicesArray != nullptr;
    }

    const GU_Detail&
    getTemplateDetail() const
    {
        return myTemplateDetail;
    }

    void getNames(
        GA_Offset primoff,
        UT_StringArray &templatenames) const
    {
        myTemplateNamesArray->get(myTemplateIdentifierAttrib, primoff, templatenames);
    }

    void getIndices(
        GA_Offset primoff,
        UT_Int64Array &templateindices) const
    {
        myTemplateIndicesArray->get(myTemplateIdentifierAttrib, primoff, templateindices);
    }

    void getWeights(
        GA_Offset primoff,
        UT_FloatArray &templateweights) const
    {
        myTemplateWeightArray->get(myTemplateWeightsAttrib, primoff, templateweights);
    }

    void getTemplateOffsets(
        GA_OffsetArray &templateoffsets,
        const UT_StringArray &templatenames,
        GA_Offset primoff) const
    {
        templateoffsets.setSizeNoInit(templatenames.size());

        auto &templatemap = myTemplateSet.getTemplateOffsetMap();

        for (int i=0; i<templateoffsets.size(); ++i)
        {
            auto templateiter = templatemap.find(templatenames[i]);

            if (templateiter == templatemap.end())
                templateoffsets[i] = GA_INVALID_OFFSET;
            else
                templateoffsets[i] = templateiter->second;
        }
    }

    void getTemplateOffsets(
        GA_OffsetArray &templateoffsets,
        const UT_Int64Array &templateindices,
        GA_Offset primoff) const
    {
        templateoffsets.setSizeNoInit(templateindices.size());

        for (int i=0; i<templateindices.size(); ++i)
        {
            GA_Index index = templateindices[i];

            if (index >= 0 && index < myTemplateDetail.getNumPrimitives())
                templateoffsets[i] = myTemplateDetail.primitiveOffset(index);
            else
                templateoffsets[i] = GA_INVALID_OFFSET;
        }
    }

    void makeTemplateOffsetMap(
        UT_Map<UT_StringHolder, GA_Offset> &templatemap,
        const GU_Detail *templategdp,
        GA_ROHandleS &templatenameattrib)
    {
        UT_Vector3Array     temppositions;
        GA_ROHandleV3       tplposattrib(templategdp->getP());

        int num_templates = templategdp->getNumPrimitives();
        UT_FloatArray tpllengths(num_templates, num_templates);
        UT_Array<UT_FloatArray> tpledgelengths(num_templates, num_templates);

        templategdp->forEachPrimitive([&](GA_Offset primoff)
        {
            templatemap[templatenameattrib.get(primoff)] = primoff;
        });
    }

    void normalizeWeights(
        GA_OffsetArray &templateoffsets,
        UT_FloatArray &templateweights) const
    {
        float wsum(0.0);

        int templatecount =
            SYSmin(templateoffsets.size(), templateweights.size());

        for (int i=0; i<templatecount; ++i)
        {
            if (templateoffsets[i] != GA_INVALID_OFFSET)
                wsum += templateweights[i];
            else
                templateweights[i] = 0.0;
        }

        if (wsum == 0.0)
            return;

        float invwsum = SYSsaferecip(wsum);

        for (int i=0; i<templatecount; ++i)
            templateweights[i] *= invwsum;
    }

    void getTemplateOffsetsAndWeights(
        GA_Offset primoff,
        GA_OffsetArray &offsets,
        UT_FloatArray &weights,
        TempData &temp) const
    {
        if (hasTemplateNames())
        {
            getNames(
                primoff, temp.templatenames);

            getTemplateOffsets(
                offsets,
                temp.templatenames, primoff);
        }
        else if (hasTemplateIndices())
        {
            getIndices(
                primoff, temp.templateindices);

            getTemplateOffsets(
                offsets,
                temp.templateindices, primoff);
        }
        else
        {
            offsets.setSize(0);
            weights.setSize(0);
            return;
        }

        getWeights(primoff, weights);

        filterInvalid(offsets, weights);

        normalizeWeights(offsets, weights);
    }

    float
    computeBlendedCurveParam(
        int i,
        int vtxcount,
        GA_OffsetArray &templateoffsets,
        UT_FloatArray &templateweights,
        GA_ROHandleI &template_firstbarb_handle,
        int shaftsegs,
        fpreal curvelength,
        UT_FloatArray &curveedgelengths)
    {
        float u = float(i) / (vtxcount-1);
        float source_u(0.0);

        const GU_Detail &gdp = myTemplateSet.getDetail();

        auto &lengths = myTemplateSet.getCurveLengths();
        auto &edgelengths = myTemplateSet.getEdgeLengths();

        for (int j=0; j<templateoffsets.size(); ++j)
        {
            GA_Offset tploffset = templateoffsets[j];
            float w = templateweights[j];

            int tplfirstbarb = template_firstbarb_handle.get(tploffset);
            int tplvtxcount = gdp.getPrimitiveVertexCount(tploffset);

            float tmpu = u;
            if (i <= shaftsegs)
                tmpu = float(i) * tplfirstbarb / shaftsegs;
            else
                tmpu = (tplvtxcount-tplfirstbarb-1) * float(i - shaftsegs) / (vtxcount-shaftsegs-1) + tplfirstbarb;

            tmpu /= tplvtxcount - 1;

            GA_Index tplindex = gdp.primitiveIndex(templateoffsets[j]);
            tmpu = GU_GroomUtils::unitToUnitLengthDomain(
                lengths[tplindex], edgelengths[tplindex], tmpu);

            source_u += w * tmpu;
        }

        return GU_GroomUtils::unitLengthToUnitDomain(curvelength, curveedgelengths, source_u);
    }

private:
    void filterInvalid(
        GA_OffsetArray &offsets,
        UT_FloatArray &weights) const
    {
        int index = 0;
        for (int i=0; i<offsets.size(); ++i)
        {
            if (offsets[i] != GA_INVALID_OFFSET)
            {
                if (index != i)
                {
                    offsets[index] = offsets[i];
                    weights[index] = weights[i];
                }

                ++index;

            }
        }

        offsets.setSize(index);
        weights.setSize(index);
    }

    const GU_Detail                     &myTemplateDetail;
    const GU_FeatherTemplateSet         &myTemplateSet;
    const GA_Attribute                  *myTemplateIdentifierAttrib = nullptr;
    const GA_Attribute                  *myTemplateWeightsAttrib = nullptr;
    const GA_AIFSharedStringArray       *myTemplateNamesArray = nullptr;
    const GA_AIFNumericArray            *myTemplateIndicesArray = nullptr;
    const GA_AIFNumericArray            *myTemplateWeightArray = nullptr;
};

class GU_API GU_Feather
{
public:
    enum class BarbSide
    {
        NONE = 0,
        LEFT,
        RIGHT
    };

    struct AttribMap
    {
        AttribMap(
            const GU_Detail &from_detail,
            GU_Detail &detail,
            const UT_StringRef &name)
        : fromName(name)
        , toName(name)
        , from(from_detail, name)
        , to(detail, name)
        {}

        AttribMap(
            const GU_Detail &from_detail,
            GU_Detail &detail,
            const UT_StringRef &from_name,
            GA_Attribute  &to_attrib)
        : fromName(from_name)
        , toName(to_attrib.getName())
        , from(from_detail, from_name)
        , to(detail, to_attrib)
        {}

        AttribMap(
            const GU_Detail &from_detail,
            GU_Detail &detail,
            const GA_Attribute  &from_attrib,
            GA_Attribute  &to_attrib)
        : fromName(from_attrib.getName())
        , toName(to_attrib.getName())
        , from(from_detail, from_attrib)
        , to(detail, to_attrib)
        {}

        UT_StringHolder                      fromName;
        UT_StringHolder                      toName;
        GU_FeatherBarbROHandle<UT_Vector3>   from;
        GU_FeatherBarbRWHandle<UT_Vector3>   to;
    };

    static const UT_StringHolder BarbLAttrib;
    static const UT_StringHolder BarbRAttrib;
    static const UT_StringHolder BarbOrientAttrib;
    static const UT_StringHolder BarbUVLAttrib;
    static const UT_StringHolder BarbUVRAttrib;
    static const UT_StringHolder TemplateNamesAttrib;
    static const UT_StringHolder TemplateWeightsAttrib;

    static const UT_StringHolder SideAttrib;
    static const UT_StringHolder SideLeft;
    static const UT_StringHolder SideCenter;
    static const UT_StringHolder SideRight;;

    static const UT_StringArray FeatherAttribs;

    static const UT_StringArray FeatherAttribsLengthScaled;

    static const UT_StringHolder&
    getBarbSideString(BarbSide barbside)
    {
        if (barbside == BarbSide::LEFT)
            return SideLeft;
        else if (barbside == BarbSide::RIGHT)
            return SideRight;
        else
            return UT_StringHolder::theEmptyString;
    }

    static UT_StringHolder
    getBarbAttribName(const UT_StringRef &basename, BarbSide barbside)
    {
        UT_WorkBuffer buffer;
        buffer.format("{}_barb{}", basename, getBarbSideString(barbside));

        return UT_StringHolder(buffer);
    }

    static GA_Attribute*
    createBarbAttrib(
        GU_Detail &detail,
        const UT_StringRef &name,
        int value_tuplesize,
        int barbpts)
    {
        return detail.addFloatTuple(
            GA_ATTRIB_POINT,
            name,
            barbpts * value_tuplesize);
    }

    static GA_ATINumericUPtr
    createDetachedBarbAttrib(
        const GU_Detail &detail,
        GA_Storage storage,
        int value_tuplesize,
        int barbpts)
    {
        return detail.createDetachedTupleAttribute(
            GA_ATTRIB_POINT,
            storage,
            barbpts * value_tuplesize);
    }

    static void
    addFeatherAttribsToCurveSampler(
        GU_GroomCurveAttribSampler &sampler)
    {
        for (const char *attribname : GU_Feather::FeatherAttribsLengthScaled)
            sampler.addLengthScaledAttrib(attribname);

        for (const char *attribname : GU_Feather::FeatherAttribs)
            sampler.addAttrib(attribname);
    }

    static
    int
    findFirstBarbIndex(
        const GEO_PrimPoly &poly,
        const GU_FeatherBarbROHandle<UT_Vector3> &barbl,
        const GU_FeatherBarbROHandle<UT_Vector3> &barbr,
        UT_Vector3Array &tempbarbvals);

    static
    void
    findFirstBarbIndex(
        const GA_RWHandleI &indices,
        const GU_Detail &detail,
        const GU_FeatherBarbROHandle<UT_Vector3> &barbl,
        const GU_FeatherBarbROHandle<UT_Vector3> &barbr,
        const GA_PrimitiveGroup *group=nullptr);

    static void
    computeBarbTangents(
        const GU_Detail &detail,
        const GU_FeatherBarbROHandle<UT_Vector3> &barbl,
        const GU_FeatherBarbROHandle<UT_Vector3> &barbr,
        const GU_FeatherBarbRWHandle<UT_Vector3> &tangentl,
        const GU_FeatherBarbRWHandle<UT_Vector3> &tangentr,
        const GU_FeatherBarbRWHandle<UT_Vector3> &bitangentl,
        const GU_FeatherBarbRWHandle<UT_Vector3> &bitangentr,
        const GA_ROHandleI &firstbarb_handle);

    static void
    deltaDeform(
        GU_Detail &detail,
        const GU_Detail &rest_detail,
        const GU_Detail &anim_detail,
        int from_barbsegs,
        int to_barbsegs,
        const GA_ROHandleI &firstbarb_handle,
        const GA_ROHandleI &rest_firstbarb_handle,
        const GA_ROHandleI &anim_firstbarb_handle);

    static void
    populateBarbAttribMap(
        UT_Array<GU_Feather::AttribMap> &attribmaps,
        GU_Detail &gdp,
        const GU_Detail &sourcegdp,
        const UT_StringHolder &attribpattern);

    static void
    createDestBarbAttributes(
        UT_Array<GU_Feather::AttribMap> &attribmaps,
        GU_Detail &gdp);

    // Create barb attributes missing on gdp. If tuplesize is <= 0, match the
    // tuple size of source attributes, otherwise create all dest attribute
    // with the specified tuplesize
    static void
    createDestBarbAttributes(
        UT_Array<GU_Feather::AttribMap> &attribmaps,
        GU_Detail &gdp, int tuplesize);

    static void expandTemplateBarbAttribs(
        GU_Detail &gdp,
        const GA_PrimitiveGroup *group,
        const GU_Detail &sourcegdp,
        int shaft_base_segs,
        const GA_ROHandleI &shaft_base_segs_attrib);

    static void expandTemplateBarbAttribs(
        GU_Detail &gdp,
        const GA_PrimitiveGroup *group,
        const GU_Detail &sourcegdp,
        UT_Array<GU_Feather::AttribMap> &attribmaps,
        int shaft_base_segs,
        const GA_ROHandleI &shaft_base_segs_attrib);

    static void zeroBarbValues(
        GU_Detail &gdp,
        const GA_PrimitiveGroup *group);
};

class GU_API GU_FeatherBarbInterpolate
{
public:
    struct BarbInterpCoeffs
    {
        UT_Vector4iArray indices;
        UT_Vector4FArray coeffs;
    };

    struct ShaftData
    {
        GA_OffsetArray   ptOffs;
        int              firstBarbIndex;
    };

    struct BarbAttribInterpolateTemp
    {
        GU_FeatherBarbFlat<UT_Vector3>              from_v_values;
        UT_Array<GU_FeatherBarbFlat<UT_Vector3>>    attrib_outvalues;
        UT_Array<UT_Vector3>                        temp_values;

        ShaftData                                   shaft_from;
        ShaftData                                   shaft_to;

        UT_Vector4Array                             s_coeffs;
        UT_Vector4iArray                            s_indices;

        UT_Vector2Array                             s_coeffs_linear;
        UT_Vector2iArray                            s_indices_linear;

        GA_OffsetArray                              templateoffsets;
        UT_FloatArray                               templateweights;
        UT_ValArray<bool>                           templateflips;

        GU_FeatherTemplateInterpolate::TempData     interptemp;
    };

    template<typename WVEC, typename IVEC>
    static UT_Tuple<WVEC, IVEC> computeShaftPointCoeffs(
        int i,
        int to_ptcount,
        int from_ptcount);

    static void populateShaftData(
        const GEO_PrimPoly                  &poly,
        int                                  firstbarbindex,
        const GA_ROHandleI                  &firstindexhandle,
        ShaftData                           &shaftdata)
    {
        GA_Size vtxcount = poly.getFastVertexCount();

        if (firstindexhandle.isValid())
            shaftdata.firstBarbIndex = firstindexhandle.get(poly.getMapOffset());
        else
            shaftdata.firstBarbIndex = firstbarbindex;

        if (shaftdata.firstBarbIndex < 0)
            return;

        shaftdata.ptOffs.bumpSize(vtxcount-shaftdata.firstBarbIndex);
        for (int i=shaftdata.firstBarbIndex; i<vtxcount; ++i)
        {
            shaftdata.ptOffs[i-shaftdata.firstBarbIndex] = poly.getPointOffset(i);
        }

    }

    static void
    interpolateBarbAttribs(
        bool use_subd,
        const GU_Detail &from_detail,
        GU_Detail &detail,
        const GA_PrimitiveGroup *group,
        const UT_Array<GU_Feather::AttribMap> &attribmaps,
        int shaft_base_segs,
        const GA_ROHandleI &firstbarb_handle,
        const GA_ROHandleS &from_side,
        const GA_ROHandleS &side,
        const GA_ROHandleF &blendattrib,
        const GU_FeatherTemplateSet &templateset,
        const GU_FeatherTemplateInterpolate *templateinterp=nullptr);

    static void
    interpolateBarbAttribs(
        GA_Offset primoff,
        BarbAttribInterpolateTemp &temp,
        GA_OffsetArray &source_primoffs,
        UT_FloatArray &source_primweights,
        UT_ValArray<bool> &source_flips,
        UT_Array<BarbInterpCoeffs> &barb_coeffs,
        bool use_subd,
        const GU_Detail &from_detail,
        GU_Detail &detail,
        const UT_Array<GU_Feather::AttribMap> &attribmaps,
        int shaft_base_segs,
        float alpha,
        const GU_FeatherTemplateSet &templateset);

    // Interpolate shaft curves using cubic coefficients
    template<typename T>
    static void interpolateVSubD(
        UT_Array<T> &out_values,
        const GA_OffsetArray &from_ptoffs,
        const UT_Vector4Array &s_coeffs,
        const UT_Vector4iArray &s_indices,
        const GA_ROHandleT<T> &from_attrib);

    // Interpolates across barbs, keeping the barb segment count of the input.
    // Combined with interpolateV this allows for quad interpolation.
    //
    // Outputs barb values as a flat array. Indices of barb values in the array
    // are computed as
    //
    // ptindex * nbarbsegs + barbseg.
    //
    // 3 source barbs:          4 output barbs:
    //
    //  \     /                 \     /
    //   \   /                   \   /
    //    \ /                   \ \ / /
    //  \  V  /                  \ V /
    //   \ | /                  \ \|/ /
    //    \|/                    \ V /
    //  \  V  /                 \ \|/ /
    //   \ | /                   \ V /
    //    \|/                     \|/
    //     V                       V
    //
    //                          (number of barbs differs,
    //                           barb segment count unchanged)
    template<typename T, typename WVEC, typename IVEC>
    static void interpolateV(
        GU_FeatherBarbFlat<T>  &from_v_values,
        UT_Array<T>  &temp,
        const GA_OffsetArray &from_ptoffs,
        const UT_ValArray<WVEC> &s_coeffs,
        const UT_ValArray<IVEC> &s_indices,
        const GU_FeatherBarbROHandle<T> &from_attrib);


    // Interpolates barb values, barb segment count can be different on the
    // destination, number of barbs stays the same. Combined with
    // interpolateV this allows for quad interpolation.
    //
    // Expects a flat array of barb values as output by interpolateV as
    // input. Outputs barb values as a flat array.
    //
    // For both arrays, barb value indices are computed as
    //
    // (ptindex * nbarbsegs + barbseg)
    //
    // Example:
    //
    // source barbs with 4 segments
    //
    //  \     /                output barbs with 3 segments
    //   \   /
    //    \ /                   \   /
    //  \  V  /                  \ /
    //   \ | /                    V
    //    \|/                   \ | /
    //  \  V  /                  \|/
    //   \ | /                    V
    //    \|/                   \ | /
    //     V                     \|/
    //                            V
    //
    //                          (number of barbs unchanged,
    //                           barb segment count differs)
    template<typename T>
    static void interpolateUSubD(
        GU_FeatherBarbFlat<T> &attrib_outvalues,
        int to_ptcount,
        const GU_FeatherBarbFlat<T> &from_v_values,
        const BarbInterpCoeffs &barb_coeffs,
        float weight,
        bool flip);

    template<typename WVEC, typename IVEC>
    static void computeShaftCoeffs(
        UT_ValArray<WVEC> &s_coeffs,
        UT_ValArray<IVEC> &s_indices,
        const GEO_PrimPoly &poly,
        int to_firstbarbindex,
        int to_ptcount,
        int from_firstbarbpt,
        int from_ptcount);

    static void computeBarbInterpCoeffs(
        int from_barbpts,
        int to_barbpts,
        BarbInterpCoeffs &interpdata);

    static void computeBarbInterpCoeffs(
        const UT_Array<GU_Feather::AttribMap> &attribmaps,
        UT_Array<BarbInterpCoeffs> &barb_coeffs);

    template<typename T, typename WVEC, typename IVEC>
    static void interpolate(
        GU_FeatherBarbFlat<T> &attrib_outvalues,
        GU_FeatherBarbFlat<T>  &from_v_values,
        UT_Array<T>  &temp,
        const GA_OffsetArray &from_ptoffs,
        const UT_ValArray<WVEC> &s_coeffs,
        const UT_ValArray<IVEC> &s_indices,
        const GU_FeatherBarbROHandle<T> &from_attrib,
        int to_ptcount,
        const BarbInterpCoeffs &barb_coeffs,
        float weight,
        bool flip);

    template<typename T>
    static void setBarbs(
        const GU_FeatherBarbFlat<T> &attrib_values,
        const GA_OffsetArray &to_ptoffs,
        const GU_FeatherBarbRWHandle<T> &to_attrib);

    template<typename T>
    static void blendBarbs(
        const GU_FeatherBarbFlat<T> &attrib_values,
        const GA_OffsetArray &to_ptoffs,
        const GU_FeatherBarbRWHandle<T> &to_attrib,
        float alpha);
};

class GU_API GU_FeatherROhandle
{
public:
    GU_FeatherROhandle(
        const GU_Detail &gdp,
        const UT_StringRef &orientname)
    : myDetail(SYSconst_cast(gdp))
    , myPos(myDetail.getP())
    , myOrient(GU_GroomUtils::findNamedOrient(myDetail, orientname))
    , myBarbL(myDetail, myPos, myOrient, GU_Feather::BarbLAttrib)
    , myBarbR(myDetail, myPos, myOrient, GU_Feather::BarbRAttrib)
    {
    }

    SYS_FORCE_INLINE
    fpreal
    boundingRadius(GA_Offset primoff) const
    {
        GEO_PrimPoly poly(
                &myDetail, primoff, myDetail.getPrimitiveVertexList(primoff));

        int vtxcount(poly.getFastVertexCount());

        fpreal maxradius(0.0);

        UT_Vector3 lastpos;
        GA_Offset lastptoff;
        fpreal seglength;
        fpreal lastseglength;
        for (int i=0; i<vtxcount; ++i)
        {
            GA_Offset ptoff;
            UT_Vector3 pos;

            if (i < vtxcount)
            {
                GA_Offset ptoff = poly.getPointOffset(i);
                pos = myPos.get(ptoff);


                if (i > 0)
                    seglength = lastpos.distance(pos);


                //////////////
                fpreal radius = SYSmax(
                    myBarbL.boundingRadius(ptoff),
                    0.0);

                if (radius > maxradius)
                    maxradius = radius;
                //////////////
            }

            continue;

            if (i>0)
            {
                float addedrad = 0;


                if (i > 1 && i < vtxcount)
                    addedrad = SYSmax(seglength, lastseglength);
                else if (i==1)
                    addedrad = seglength;
                else if (i==vtxcount)
                    addedrad = lastseglength;

                fpreal radius = SYSmax(
                    myBarbL.boundingRadius(lastptoff) + addedrad,
                    myBarbL.boundingRadius(lastptoff) + addedrad);

                if (radius > maxradius)
                    maxradius = radius;
            }

            if (i < vtxcount)
            {
                lastptoff = ptoff;
                lastpos = pos;
                lastseglength = seglength;
            }
        }

        return maxradius;
    }

    const GU_FeatherBarbROHandle<UT_Vector3F>&
    barbL() const
    {
        return myBarbL;
    }

    const GU_FeatherBarbROHandle<UT_Vector3F>&
    barbR() const
    {
        return myBarbR;
    }

protected:
    GU_Detail       &myDetail;
    GA_RWHandleV3    myPos;
    GA_ROHandleQ     myOrient;
    GU_FeatherBarbRWHandle<UT_Vector3F>   myBarbL;
    GU_FeatherBarbRWHandle<UT_Vector3F>   myBarbR;
};

class GU_API GU_FeatherRWHandle : public GU_FeatherROhandle
{
public:
    GU_FeatherRWHandle(
        GU_Detail &gdp,
        const UT_StringRef &orientname)
    : GU_FeatherROhandle(gdp, orientname)
    {
    }

    const GU_FeatherBarbRWHandle<UT_Vector3F>&
    barbL() const
    {
        return myBarbL;
    }

    const GU_FeatherBarbRWHandle<UT_Vector3F>&
    barbR() const
    {
        return myBarbR;
    }

};

class GU_FeatherDerivatives
{
public:
    struct TempData
    {
        int                              myFirstIndex;
        int                              myVtxCount;
        GU_FeatherBarbFlat<UT_Vector3>   myBarbFlat;
        UT_Array<bool>                   myBarbFetched;
        UT_Array<UT_Vector3>             myTempVecs;
        GA_OffsetArray                   myPtOffs;
    };

    GU_FeatherDerivatives(
    const GU_FeatherBarbROHandle<UT_Vector3> &barb,
    const GU_FeatherBarbRWHandle<UT_Vector3> &tangent,
    const GU_FeatherBarbRWHandle<UT_Vector3> &bitangent)
    : myBarb(barb)
    , myTangent(tangent)
    , myBitangent(bitangent)
    {
    }

    void startPrim(
        const GU_Detail &detail,
        const GEO_PrimPoly &poly,
        int firstindex,
        TempData &tempdata);

    void computeForPoint(
        GA_Size i,
        TempData &tempdata);

private:
    const GU_FeatherBarbROHandle<UT_Vector3>    &myBarb;
    const GU_FeatherBarbRWHandle<UT_Vector3>    &myTangent;
    const GU_FeatherBarbRWHandle<UT_Vector3>    &myBitangent;

};

#endif