SOP_SweepHDK.C

Go to the documentation of this file.

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

// A .proto.h file is an automatically generated header file based on theDsFile,
// below, to provide SOP_SweepHDKParms, an easy way to access parameter
// values from SOP_SweepHDKVerb::cook with the correct type, and
// SOP_SweepHDKEnums, a namespace containing enum types for any ordinal
// menu parameters.
#include "SOP_SweepHDK.proto.h"

#include "GU_Grid.h"
#include "GU_GridImpl.h"

#include "../SOP_OrientAlongCurve/GU_CurveFrame.h"
#include "../SOP_CopyToPoints/GEO_BuildPrimitives.h"
#include "../SOP_CopyToPoints/GU_Copy2.h"

#include <SOP/SOP_Node.h>
#include <SOP/SOP_NodeVerb.h>
#include <GU/GU_Detail.h>
#include <GOP/GOP_Manager.h>
#include <GEO/GEO_Curve.h>
#include <GEO/GEO_Hull.h>
#include <GEO/GEO_ParallelWiringUtil.h>
#include <GEO/GEO_PrimPoly.h>
#include <GEO/GEO_PrimPolySoup.h>
#include <GEO/GEO_TPSurf.h>
#include <GA/GA_AttributeFilter.h>
#include <GA/GA_AttributeInstanceMatrix.h>
#include <GA/GA_BezBasis.h>
#include <GA/GA_DataBitArray.h>
#include <GA/GA_Handle.h>
#include <GA/GA_Iterator.h>
#include <GA/GA_Names.h>
#include <GA/GA_NUBBasis.h>
#include <GA/GA_OffsetList.h>
#include <GA/GA_PolyCounts.h>
#include <GA/GA_SplittableRange.h>
#include <GA/GA_Types.h>
#include <OP/OP_AutoLockInputs.h>
#include <OP/OP_Operator.h>
#include <OP/OP_OperatorTable.h>
#include <PRM/PRM_TemplateBuilder.h>
#include <UT/UT_BitArray.h>
#include <UT/UT_BoundingCircle.h>
#include <UT/UT_DSOVersion.h>
#include <UT/UT_Interrupt.h>
#include <UT/UT_PageArray.h>
#include <UT/UT_PageArrayImpl.h>
#include <UT/UT_ParallelUtil.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_Vector3.h>
#include <SYS/SYS_Math.h>

#include <algorithm> // For std::make_heap, push_heap, pop_heap

using namespace UT::Literal;

namespace HDK_Sample {

//******************************************************************************
//*                 Setup                                                      *
//******************************************************************************

constexpr static int theUComponent = 0;
constexpr static int theVComponent = 1;

constexpr static int theCurveInput = 0;
constexpr static int theCrossSectionInput = 1;

namespace {
struct CrossSectionAttribMatchData
{
    /// Handle for reading int64 attribute on curve input.
    /// If valid, it could be a point, vertex, primitive, or detail attribute.
    /// If invalid, myCurveStrAttrib might be valid.
    GA_ROHandleID myCurveIntAttrib;

    /// Handle for reading string attribute on curve input.
    /// If valid, it could be a point, vertex, primitive, or detail attribute.
    /// This can only be valid if myCurveIntAttrib is invalid.
    GA_ROHandleS myCurveStrAttrib;

    /// Map from integer to primitive offset in the cross section input.
    /// This won't be used at the same time as myStrToPrimOff.
    /// NOTE: UT::ArrayMap<exint,...> doesn't support 0x8000000000000000LL
    ///       as a key, which is probably safe to exclude.
    ///       If you need a map without any excluded values, UT_Map works.
    UT::ArrayMap<exint, GA_Offset> myIntToPrimOff;

    /// Map from string to primitive offset in the cross section input.
    /// This won't be used at the same time as myIntToPrimOff.
    /// NOTE: UT_ArrayStringMap doesn't support "" as a key, so any
    ///       primitives with name "" won't be matched, which is probably
    ///       what'd be expected anyway.
    ///       If you need a map without any excluded values, UT_Map works.
    UT_ArrayStringMap<GA_Offset> myStrToPrimOff;

    /// This is just a cache of the owner of myCurveIntAttrib or
    /// myCurveStrAttrib, whichever is valid, or GA_ATTRIB_INVALID if
    /// neither is valid.
    GA_AttributeOwner myCurveAttribOwner = GA_ATTRIB_INVALID;

    /// If myCurveIntAttrib is valid and the cross section geometry doesn't
    /// have a matching attribute, it will use the primitive index, instead
    /// of a map.
    bool myIsUsingMap = false;
};


struct sop_SweepGrid
{
    sop_SweepGrid()
        : mySingleCrossSection(true)
    {}
    ~sop_SweepGrid()
    {
        if (!mySingleCrossSection)
            delete myCrossSectionPrimOffs;
    }

    // Copy constructor, for handling myCrossSectionPrimOffs union.
    sop_SweepGrid(const sop_SweepGrid &that)
        : myStartPtOff(that.myStartPtOff)
        , myStartPrimOff(that.myStartPrimOff)
        , myStartVtxOff(that.myStartVtxOff)
        , myCurveNEdges(that.myCurveNEdges)
        , myCrossSectionNEdges(that.myCrossSectionNEdges)
        , myCurvePrimOff(that.myCurvePrimOff)
        , myCurveClosed(that.myCurveClosed)
        , myCurveUnrolled(that.myCurveUnrolled)
        , myCrossSectionClosed(that.myCrossSectionClosed)
        , myCrossSectionUnrolled(that.myCrossSectionUnrolled)
        , mySingleCrossSection(that.mySingleCrossSection)
        , myAllEqualNEdges(that.myAllEqualNEdges)
        , myUEndPoles(that.myUEndPoles)
        , myVEndPoles(that.myVEndPoles)
        , myHasPolygonCaps(that.myHasPolygonCaps)
        , myPrimitiveType(that.myPrimitiveType)
        , myBasisOrderCurve(that.myBasisOrderCurve)
        , myBasisOrderCrossSection(that.myBasisOrderCrossSection)
    {
        if (that.mySingleCrossSection)
            myCrossSectionPrimOff = that.myCrossSectionPrimOff;
        else
            myCrossSectionPrimOffs = new GA_OffsetList(*that.myCrossSectionPrimOffs);
    }

    // Move constructor, for handling myCrossSectionPrimOffs union.
    sop_SweepGrid(sop_SweepGrid &&that)
        : myStartPtOff(that.myStartPtOff)
        , myStartPrimOff(that.myStartPrimOff)
        , myStartVtxOff(that.myStartVtxOff)
        , myCurveNEdges(that.myCurveNEdges)
        , myCrossSectionNEdges(that.myCrossSectionNEdges)
        , myCurvePrimOff(that.myCurvePrimOff)
        , myCurveClosed(that.myCurveClosed)
        , myCurveUnrolled(that.myCurveUnrolled)
        , myCrossSectionClosed(that.myCrossSectionClosed)
        , myCrossSectionUnrolled(that.myCrossSectionUnrolled)
        , mySingleCrossSection(that.mySingleCrossSection)
        , myAllEqualNEdges(that.myAllEqualNEdges)
        , myUEndPoles(that.myUEndPoles)
        , myVEndPoles(that.myVEndPoles)
        , myHasPolygonCaps(that.myHasPolygonCaps)
        , myPrimitiveType(that.myPrimitiveType)
        , myBasisOrderCurve(that.myBasisOrderCurve)
        , myBasisOrderCrossSection(that.myBasisOrderCrossSection)
    {
        if (that.mySingleCrossSection)
            myCrossSectionPrimOff = that.myCrossSectionPrimOff;
        else
        {
            myCrossSectionPrimOffs = that.myCrossSectionPrimOffs;
            that.mySingleCrossSection = true;
        }
    }

    // Copy assignment operator, for handling myCrossSectionPrimOffs union.
    sop_SweepGrid &operator=(const sop_SweepGrid &that)
    {
        if (this == &that)
            return *this;

        myStartPtOff = that.myStartPtOff;
        myStartPrimOff = that.myStartPrimOff;
        myStartVtxOff = that.myStartVtxOff;
        myCurveNEdges = that.myCurveNEdges;
        myCrossSectionNEdges = that.myCrossSectionNEdges;
        myCurvePrimOff = that.myCurvePrimOff;
        if (!mySingleCrossSection)
            delete myCrossSectionPrimOffs;
        if (that.mySingleCrossSection)
            myCrossSectionPrimOff = that.myCrossSectionPrimOff;
        else
            myCrossSectionPrimOffs = new GA_OffsetList(*that.myCrossSectionPrimOffs);
        myCurveClosed = that.myCurveClosed;
        myCurveUnrolled = that.myCurveUnrolled;
        myCrossSectionClosed = that.myCrossSectionClosed;
        myCrossSectionUnrolled = that.myCrossSectionUnrolled;
        mySingleCrossSection = that.mySingleCrossSection;
        myAllEqualNEdges = that.myAllEqualNEdges;
        myUEndPoles = that.myUEndPoles;
        myVEndPoles = that.myVEndPoles;
        myHasPolygonCaps = that.myHasPolygonCaps;
        myPrimitiveType = that.myPrimitiveType;
        myBasisOrderCurve = that.myBasisOrderCurve;
        myBasisOrderCrossSection = that.myBasisOrderCrossSection;
        return *this;
    }

    // Move assignment operator, for handling myCrossSectionPrimOffs union.
    sop_SweepGrid &operator=(sop_SweepGrid &&that)
    {
        if (this == &that)
            return *this;

        myStartPtOff = that.myStartPtOff;
        myStartPrimOff = that.myStartPrimOff;
        myStartVtxOff = that.myStartVtxOff;
        myCurveNEdges = that.myCurveNEdges;
        myCrossSectionNEdges = that.myCrossSectionNEdges;
        myCurvePrimOff = that.myCurvePrimOff;
        if (!mySingleCrossSection)
            delete myCrossSectionPrimOffs;
        if (that.mySingleCrossSection)
            myCrossSectionPrimOff = that.myCrossSectionPrimOff;
        else
        {
            myCrossSectionPrimOffs = that.myCrossSectionPrimOffs;
            that.mySingleCrossSection = true;
        }
        myCurveClosed = that.myCurveClosed;
        myCurveUnrolled = that.myCurveUnrolled;
        myCrossSectionClosed = that.myCrossSectionClosed;
        myCrossSectionUnrolled = that.myCrossSectionUnrolled;
        mySingleCrossSection = that.mySingleCrossSection;
        myAllEqualNEdges = that.myAllEqualNEdges;
        myUEndPoles = that.myUEndPoles;
        myVEndPoles = that.myVEndPoles;
        myHasPolygonCaps = that.myHasPolygonCaps;
        myPrimitiveType = that.myPrimitiveType;
        myBasisOrderCurve = that.myBasisOrderCurve;
        myBasisOrderCrossSection = that.myBasisOrderCrossSection;
        return *this;
    }

    GA_Offset myStartPtOff;
    GA_Offset myStartPrimOff;
    GA_Offset myStartVtxOff;
    exint myCurveNEdges;
    exint myCrossSectionNEdges;
    GA_Offset myCurvePrimOff;
    union {
        /// NOTE: This is exint instead of GA_Offset just because unions need
        ///       all POD types, and GA_Offset isn't POD in strict types builds.
        exint myCrossSectionPrimOff;
        GA_OffsetList *myCrossSectionPrimOffs;
    };
    bool myCurveClosed:1;
    bool myCurveUnrolled:1;
    bool myCrossSectionClosed:1;
    bool myCrossSectionUnrolled:1;
    bool mySingleCrossSection:1;
    bool myAllEqualNEdges:1;
    bool myUEndPoles:1;
    bool myVEndPoles:1;
    bool myHasPolygonCaps:1;
    using PrimitiveType = GU_GridT<GA_Offset>::PrimitiveType;
    PrimitiveType myPrimitiveType;
    unsigned char myBasisOrderCurve:4;
    unsigned char myBasisOrderCrossSection:4;
};
}

class SOP_SweepHDKCache : public SOP_NodeCache, public GU_CopyToPointsCache
{
public:
    SOP_SweepHDKCache() : SOP_NodeCache(), GU_CopyToPointsCache(),
        myPrevCurvePrimListDataID(-1),
        myPrevCurveTopologyDataID(-1),
        myPrevOutputDetailID(-1),
        myPrevCopyOrder(SOP_SweepHDKEnums::CopyOrder::CYCLEVTX),
        myPrevSurfaceType(SOP_SweepHDKEnums::SurfaceType::POINTS),
        myPrevPrimType(SOP_SweepHDKEnums::PrimType::AUTO),
        myPrevSurfaceShape(SOP_SweepHDKEnums::SurfaceShape::INPUT),
        myPrevCols(-1),
        myPrevEndCapType(SOP_SweepHDKEnums::EndCapType::NONE),
        myPrevEndCapDivs(-1),
        myPrevCrossSectionPrimListDataID(-1),
        myPrevCrossSectionTopologyDataID(-1),
        myPrevUnrollClosedRowCol(false),
        myPrevCloseIfNoCurveInput(false),
        myPrevTriangularPoles(false),
        myPrevSwapRowCol(false),
        myPrevCrossSectCurveAttribDataId(-1),
        myPrevCrossSectPrimAttribDataId(-1)
    {}
    ~SOP_SweepHDKCache() override {}

    int64 myPrevOutputDetailID;
    int64 myPrevCurvePrimListDataID;
    int64 myPrevCurveTopologyDataID;
    GA_OffsetList myPrevCurveGroup;
    int64 myPrevCrossSectionPrimListDataID;
    int64 myPrevCrossSectionTopologyDataID;
    GA_OffsetList myPrevCrossSectionGroup;

    SOP_SweepHDKEnums::CopyOrder myPrevCopyOrder;
    SOP_SweepHDKEnums::SurfaceType myPrevSurfaceType;
    SOP_SweepHDKEnums::PrimType myPrevPrimType;
    /// We'll use NONE to represent using the cross section input.
    SOP_SweepHDKEnums::SurfaceShape myPrevSurfaceShape;
    int64 myPrevCols;
    SOP_SweepHDKEnums::EndCapType myPrevEndCapType;
    int64 myPrevEndCapDivs;
    bool myPrevUnrollClosedRowCol;
    bool myPrevCloseIfNoCurveInput;
    bool myPrevTriangularPoles;
    bool myPrevSwapRowCol;
    int64 myPrevCrossSectCurveAttribDataId;
    int64 myPrevCrossSectPrimAttribDataId;
    CrossSectionAttribMatchData myCrossSectionAttribMatchData;

    exint myNumGrids;
    UT_Array<sop_SweepGrid> myGrids;

    // These are indices into the transform arrays for the start of each grid.
    UT_UniquePtr<exint[]> myGridTransformStarts;
};

struct sop_SweepGridTransformWrapper
{
    sop_SweepGridTransformWrapper() {}

    void init(const SOP_SweepHDKCache &cache, exint gridi)
    {
        exint offset = cache.myGridTransformStarts[gridi];
        myTranslated = cache.myTransformTranslates3D ? (cache.myTransformTranslates3D.get() + offset) : nullptr;
        myMatrix3d = cache.myTransformMatrices3D ? (cache.myTransformMatrices3D.get() + offset) : nullptr;
        myInverse3d = cache.myTransformInverse3D ? (cache.myTransformInverse3D.get() + offset) : nullptr;
        myQuaterniond = cache.myTransformQuaternionsD ? (cache.myTransformQuaternionsD.get() + offset) : nullptr;
        myTranslatef = cache.myTransformTranslates3F ? (cache.myTransformTranslates3F.get() + offset) : nullptr;
        myMatrix3f = cache.myTransformMatrices3F ? (cache.myTransformMatrices3F.get() + offset) : nullptr;
        myInverse3f = cache.myTransformInverse3F ? (cache.myTransformInverse3F.get() + offset) : nullptr;
        myQuaternionf = cache.myTransformQuaternionsF ? (cache.myTransformQuaternionsF.get() + offset) : nullptr;
    }

    template<typename T>
    const UT_Vector3T<T> *getTranslates() const
    {
        SYS_STATIC_ASSERT((SYSisSame<T,double>()) || (SYSisSame<T,float>()));

        // NOTE: The reinterpret_cast's are just needed to get this to compile;
        //       the returned value should not change type.
        return SYSisSame<T,double>()
            ? reinterpret_cast<const UT_Vector3T<T> *>(myTranslated)
            : reinterpret_cast<const UT_Vector3T<T> *>(myTranslatef);
    }

    template<typename T>
    const UT_Matrix3T<T> *getInverse3s() const
    {
        SYS_STATIC_ASSERT((SYSisSame<T,double>()) || (SYSisSame<T,float>()));

        // NOTE: The reinterpret_cast's are just needed to get this to compile;
        //       the returned value should not change type.
        return SYSisSame<T,double>()
            ? reinterpret_cast<const UT_Matrix3T<T> *>(myInverse3d)
            : reinterpret_cast<const UT_Matrix3T<T> *>(myInverse3f);
    }

    template<typename T>
    const UT_Matrix3T<T> *getMatrix3s() const
    {
        SYS_STATIC_ASSERT((SYSisSame<T,double>()) || (SYSisSame<T,float>()));

        // NOTE: The reinterpret_cast's are just needed to get this to compile;
        //       the returned value should not change type.
        return SYSisSame<T,double>()
            ? reinterpret_cast<const UT_Matrix3T<T> *>(myMatrix3d)
            : reinterpret_cast<const UT_Matrix3T<T> *>(myMatrix3f);
    }

    template<typename T>
    const UT_QuaternionT<T> *getQuaternions() const
    {
        SYS_STATIC_ASSERT((SYSisSame<T,double>()) || (SYSisSame<T,float>()));

        // NOTE: The reinterpret_cast's are just needed to get this to compile;
        //       the returned value should not change type.
        return SYSisSame<T,double>()
            ? reinterpret_cast<const UT_QuaternionT<T> *>(myQuaterniond)
            : reinterpret_cast<const UT_QuaternionT<T> *>(myQuaternionf);
    }

    UT_Vector3D *myTranslated;
    UT_Matrix3D *myMatrix3d;
    UT_Matrix3D *myInverse3d;
    UT_QuaternionD *myQuaterniond;
    UT_Vector3F *myTranslatef;
    UT_Matrix3F *myMatrix3f;
    UT_Matrix3F *myInverse3f;
    UT_QuaternionF *myQuaternionf;
};


class SOP_SweepHDKVerb : public SOP_NodeVerb
{
public:
    SOP_NodeParms *allocParms() const override { return new SOP_SweepHDKParms(); }
    SOP_NodeCache *allocCache() const override { return new SOP_SweepHDKCache(); }
    UT_StringHolder name() const override { return theSOPTypeName; }

    CookMode cookMode(const SOP_NodeParms *parms) const override { return COOK_GENERIC; }

    void cook(const CookParms &cookparms) const override;

    /// This is the internal name of the SOP type.
    /// It isn't allowed to be the same as any other SOP's type name.
    static const UT_StringHolder theSOPTypeName;

    /// This static data member automatically registers
    /// this verb class at library load time.
    static const SOP_NodeVerb::Register<SOP_SweepHDKVerb> theVerb;

    /// This is the parameter interface string, below.
    static const char *const theDsFile;
};

// The static member variable definitions have to be outside the class definition.
// The declarations are inside the class.
const UT_StringHolder SOP_SweepHDKVerb::theSOPTypeName("hdk_sweep"_sh);
const SOP_NodeVerb::Register<SOP_SweepHDKVerb> SOP_SweepHDKVerb::theVerb;

/// This is the SOP class definition.
class SOP_SweepHDK : public SOP_Node
{
public:
    static PRM_Template *buildTemplates();

    static OP_Node *myConstructor(OP_Network *net, const char *name, OP_Operator *op)
    {
        return new SOP_SweepHDK(net, name, op);
    }

protected:
    const SOP_NodeVerb *cookVerb() const override;

    SOP_SweepHDK(OP_Network *net, const char *name, OP_Operator *op)
        : SOP_Node(net, name, op)
    {
        // All verb SOPs must manage data IDs, to track what's changed
        // from cook to cook.
        mySopFlags.setManagesDataIDs(true);
    }

    ~SOP_SweepHDK() override {}

    OP_ERROR cookInputGroups(OP_Context &context, int alone) override;

    /// Since this SOP implements a verb, cookMySop just delegates to the verb.
    OP_ERROR cookMySop(OP_Context &context) override
    {
        return cookMyselfAsVerb(context);
    }

    /// These are the labels that appear when hovering over the inputs.
    const char *inputLabel(unsigned idx) const override
    {
        switch (idx)
        {
            case 0:     return "Backbone Curves";
            case 1:     return "Cross Section(s)";
            default:    return "Invalid Source";
        }
    }

    /// This just indicates whether an input wire gets drawn with a dotted line
    /// in the network editor.  If something is usually copied directly
    /// into the output, a solid line (false) is used, but this SOP very often
    /// doesn't do that for either input.
    int isRefInput(unsigned i) const override
    {
        // First or second input both use dotted lines
        return (i == 0 || i == 1);
    }
};

PRM_Template *SOP_SweepHDK::buildTemplates()
{
    static PRM_TemplateBuilder templ("SOP_SweepHDK.C"_sh, SOP_SweepHDKVerb::theDsFile);
    if (templ.justBuilt())
    {
        templ.setChoiceListPtr("curvegroup", &SOP_Node::primGroupMenu);
        // FIXME: This needs to select primitive groups from input 1, not input 0!!!
        templ.setChoiceListPtr("crosssectiongroup", &SOP_Node::primGroupMenu);
    }
    return templ.templates();
}

const SOP_NodeVerb *SOP_SweepHDK::cookVerb() const
{
    return SOP_SweepHDKVerb::theVerb.get();
}

} // End of HDK_Sample namespace

/// newSopOperator is the hook that Houdini grabs from this dll
/// and invokes to register the SOP.  In this case, we add ourselves
/// to the specified operator table.
void newSopOperator(OP_OperatorTable *table)
{
    // NOTE: Even though this SOP requires at least one of the two
    //       inputs to be connected, if we specified the minimum number
    //       of sources as 1, the node would error out when providing only
    //       the second (cross section) input, which isn't what we want,
    //       so instead, we specify 0 as the minimum number of sources,
    //       and explicitly error in the cook function if neither input is
    //       present.
    table->addOperator(new OP_Operator(
        HDK_Sample::SOP_SweepHDKVerb::theSOPTypeName,   // Internal name
        "HDK Sweep",                                    // UI name
        HDK_Sample::SOP_SweepHDK::myConstructor,        // How to build the SOP
        HDK_Sample::SOP_SweepHDK::buildTemplates(),     // My parameters
        0,      // Min # of sources
        2,      // Max # of sources
        nullptr,// Custom local variables (none)
        0));    // No flags: not a generator, no merge input, not an output
}

namespace HDK_Sample {

OP_ERROR
SOP_SweepHDK::cookInputGroups(OP_Context &context, int alone)
{
    UT_ASSERT(alone);
    OP_AutoLockInputs inputs(this);
    if (inputs.lock(context) >= UT_ERROR_ABORT)
        return error();

    const GU_Detail *curve_input = inputGeo(theCurveInput);
    const GA_PrimitiveGroup *curve_group;
    OP_ERROR ret = cookInputPrimitiveGroups(context, curve_group, alone, true, 0, -1, true, false, GroupCreator(curve_input));
    if (ret >= UT_ERROR_ABORT)
        return ret;

    const GU_Detail *cross_section_input = inputGeo(theCrossSectionInput);
    const GA_PrimitiveGroup *cross_section_group;
    ret = cookInputPrimitiveGroups(context, cross_section_group, alone, true, 1, -1, true, false, GroupCreator(cross_section_input));
    return ret;
}

//******************************************************************************
//*                 Parameters                                                 *
//******************************************************************************

/// This is a multi-line raw string specifying the parameter interface for this SOP.
const char *const SOP_SweepHDKVerb::theDsFile = R"THEDSFILE(
{
    name        parameters
    parm {
        name    "curvegroup"
        cppname "CurveGroup"
        label   "Backbone Curve Group"
        type    string
        default { "" }
        parmtag { "script_action" "import soputils\nkwargs['geometrytype'] = (hou.geometryType.Primitives,)\nkwargs['inputindex'] = 0\nsoputils.selectGroupParm(kwargs)" }
        parmtag { "script_action_help" "Select geometry from an available viewport.\nShift-click to turn on Select Groups." }
        parmtag { "script_action_icon" "BUTTONS_reselect" }
    }
    parm {
        name    "crosssectiongroup"
        cppname "CrossSectionGroup"
        label   "Cross Section Group"
        type    string
        default { "" }
        parmtag { "script_action" "import soputils\nkwargs['geometrytype'] = (hou.geometryType.Primitives,)\nkwargs['inputindex'] = 1\nsoputils.selectGroupParm(kwargs)" }
        parmtag { "script_action_help" "Select geometry from an available viewport.\nShift-click to turn on Select Groups." }
        parmtag { "script_action_icon" "BUTTONS_reselect" }
    }
    parm {
        name    "sepparm"
        label   ""
        type    separator
        default { "" }
    }
    group {
        name    "surface_folder"
        label   "Surface"
        parm {
            name    "surfaceshape"
            cppname "SurfaceShape"
            label   "Surface Shape"
            type    ordinal
            default { "0" }     // Default to first entry in menu, "input"
            menu {
                "input"     "Second Input Cross Sections"
                "tube"      "Round Tube"
                "square"    "Square Tube"
                "ribbon"    "Ribbon"
            }
        }
        parm {
            name    "surfacetype"
            cppname "SurfaceType"
            label   "Surface Type"
            type    ordinal
            default { "5" }     // Default to menu entry "quads"
            menu {
                "points"    "Points"
                "rows"      "Rows"
                "cols"      "Columns"
                "rowcol"    "Rows and Columns"
                "tris"      "Triangles"
                "quads"     "Quadrilaterals"
                "alttris"   "Alternating Triangles"
                "revtris"   "Reverse Triangles"
            }
        }
        parm {
            name    "scale"
            label   "Scale Cross Sections"
            type    float
            default { "1" }
            range   { 0 4 }
            disablewhen "{ surfaceshape != input }"
            hidewhen    "{ surfaceshape != input }"
        }
        parm {
            name    "cols"
            label   "Columns"
            type    integer
            default { "8" }
            range   { 1! 24 }
            disablewhen "{ surfaceshape == input }"
            hidewhen    "{ surfaceshape == input }"
        }
        parm {
            name    "radius"
            label   "Radius"
            type    float
            default { "0.1" }
            range   { 0 1 }
            parmtag { "units" "m1" }
            disablewhen "{ surfaceshape != tube }"
            hidewhen    "{ surfaceshape != tube }"
        }
        parm {
            name    "width"
            label   "Width"
            type    float
            default { "0.2" }
            range   { 0 1 }
            parmtag { "units" "m1" }
            disablewhen "{ surfaceshape != ribbon surfaceshape != square }"
            hidewhen    "{ surfaceshape != ribbon surfaceshape != square }"
        }
        parm {
            name    "reversecrosssections"
            cppname "ReverseCrossSections"
            label   "Reverse Cross Sections"
            type    toggle
            default { "0" }
        }
        parm {
            name    "stretcharoundturns"
            cppname "StretchAroundTurns"
            label   "Stretch Around Turns"
            type    toggle
            default { "1" }
        }
        parm {
            name    "maxstretcharoundturns"
            cppname "MaxStretchAroundTurns"
            label   "Max Stretch"
            type    log
            default { "10" }
            range   { 1! 100 }
            disablewhen "{ stretcharoundturns == 0 }"
        }
        groupsimple {
            name    "endcaps_folder"
            label   "End Caps"
            parm {
                name    "endcaptype"
                cppname "EndCapType"
                label   "End Cap Type"
                type    ordinal
                default { "0" }     // Default to menu entry "none"
                menu {
                    "none"      "None"
                    "single"    "Single Polygon"
                    "grid"      "Grid"
                    "sidesingle" "Side Single Polygon"
                }
            }
            parm {
                name    "capdivs"
                cppname "CapDivs"
                label   "Cap Divisions"
                type    integer
                default { "3" }
                range   { 1! 10 }
                disablewhen "{ endcaptype == none } { endcaptype == single } { endcaptype == sidesingle }"
                hidewhen "{ endcaptype == none } { endcaptype == single } { endcaptype == sidesingle }"
                joinnext
            }
            parm {
                name    "triangularpoles"
                cppname "TriangularPoles"
                label   "Triangular Poles"
                type    toggle
                default { "0" }
                disablewhen "{ endcaptype == none } { endcaptype == single } { endcaptype == sidesingle }"
                hidewhen "{ endcaptype == none } { endcaptype == single } { endcaptype == sidesingle }"
            }
            parm {
                name    "capscale"
                cppname "CapScale"
                label   "End Cap Scale"
                type    float
                default { "1" }
                range   { 0 1 }
                disablewhen "{ endcaptype == none } { endcaptype == single } { endcaptype == sidesingle }"
                hidewhen "{ endcaptype == none } { endcaptype == single } { endcaptype == sidesingle }"
            }
            parm {
                name    "caproundness"
                cppname "CapRoundness"
                label   "End Cap Roundness"
                type    float
                default { "1" }
                range   { 0 1 }
                disablewhen "{ endcaptype == none } { endcaptype == single } { endcaptype == sidesingle }"
                hidewhen "{ endcaptype == none } { endcaptype == single } { endcaptype == sidesingle }"
            }
            parm {
                name    "addendcapsgroup"
                cppname "AddEndCapsGroup"
                label   "Add End Caps Group"
                type    toggle
                default { "0" }
                nolabel
                joinnext
            }
            parm {
                name    "endcapsgroup"
                cppname "EndCapsGroup"
                label   "End Caps Group"
                type    string
                default { "endcaps" }
                disablewhen "{ addendcapsgroup == 0 }"
            }
        }
        groupsimple {
            name    "scale_folder"
            label   "Scale"
            parm {
                name    "applyscale"
                cppname "ApplyScale"
                label   "Apply Scale Along Curve"
                type    toggle
                default { "0" }
            }
            parm {
                name    "scaleramp"
                cppname "ScaleRamp"
                label   "Scale Ramp"
                type    ramp_flt
                default { "2" }
                range   { 0! 10 }
                disablewhen "{ applyscale == 0 }"
                parmtag     { "rampfloatdefault" "1pos ( 0 ) 1value ( 1 ) 1interp ( linear ) 2pos ( 1 ) 2value ( 1 ) 2interp ( linear )" }
            }
        }
        groupsimple {
            name    "rotation_folder"
            label   "Rotation"
            parm {
                name    "rOrd"
                cppname "ROrd"
                label   "Rotate Order"
                type    ordinal
                // NOTE: The default rotation order X,Y,Z is semi-arbitrary, but Z
                //       should probably be last, since it always needs to twist
                //       around the curve tangent.  The X and Y rotations may have
                //       just been to reorient a cross-section before copying.
                default { "xyz" }
                menu {
                    "xyz"   "Pitch, Yaw, Roll"
                    "xzy"   "Pitch, Roll, Yaw"
                    "yxz"   "Yaw, Pitch, Roll"
                    "yzx"   "Yaw, Roll, Pitch"
                    "zxy"   "Roll, Pitch, Yaw"
                    "zyx"   "Roll, Yaw, Pitch"
                }
            }
            parm {
                name    "applyroll"
                cppname "ApplyRoll"
                label   "Apply Roll or Twist"
                type    toggle
                default { "1" }
            }
            parm {
                name    "roll"
                label   "Roll"
                type    float
                default { "0" }
                range   { -180 180 }
                hidewhen "{ applyroll == 0 }"
            }
            parm {
                name    "fulltwists"
                cppname "FullTwists"
                label   "Full Twists"
                type    integer
                default { "0" }
                range   { -10 10 }
                hidewhen "{ applyroll == 0 }"
            }
            parm {
                name    "incroll"
                cppname "IncRoll"
                label   "Partial Twist"
                type    float
                default { "0" }
                range   { -180 180 }
                hidewhen "{ applyroll == 0 }"
                joinnext
            }
            parm {
                name    "rollper"
                cppname "RollPer"
                label   "Twist Per"
                type    ordinal
                default { "4" }     // Default to "fulldistance" entry in menu
                menu {
                    "edge"          "Per Edge"
                    "distance"      "Per Unit Distance"
                    "attrib"        "Scale by Attribute"
                    "fulledges"     "Per Full Curve by Edges"
                    "fulldistance"  "Per Full Curve by Distance"
                }
                hidewhen "{ applyroll == 0 }"
            }
            parm {
                name    "rollattrib"
                cppname "RollAttrib"
                label   "Twist Ramp Attribute"
                type    string
                default { "roll" }
                disablewhen "{ applyroll == 0 } { applyroll == 1 rollper != attrib }"
                hidewhen    "{ applyroll == 0 } { applyroll == 1 rollper != attrib }"
            }
            parm {
                name    "sepparmroll"
                label   ""
                type    separator
                default { "" }
                hidewhen "{ applyroll == 0 }"
            }
            parm {
                name    "applyyaw"
                cppname "ApplyYaw"
                label   "Apply Yaw"
                type    toggle
                default { "0" }
            }
            parm {
                name    "yaw"
                label   "Yaw"
                type    float
                default { "0" }
                range   { -180 180 }
                hidewhen "{ applyyaw == 0 }"
            }
            parm {
                name    "incyaw"
                cppname "IncYaw"
                label   "Incremental Yaw"
                type    float
                default { "0" }
                range   { -180 180 }
                hidewhen "{ applyyaw == 0 }"
                joinnext
            }
            parm {
                name    "yawper"
                cppname "YawPer"
                label   "Yaw Per"
                type    ordinal
                default { "4" }     // Default to "fulldistance" entry in menu
                menu {
                    "edge"          "Per Edge"
                    "distance"      "Per Unit Distance"
                    "attrib"        "Scale By Attribute"
                    "fulledges"     "Per Full Curve by Edges"
                    "fulldistance"  "Per Full Curve by Distance"
                }
                hidewhen "{ applyyaw == 0 }"
            }
            parm {
                name    "yawattrib"
                cppname "YawAttrib"
                label   "Yaw Ramp Attribute"
                type    string
                default { "yaw" }
                disablewhen "{ applyyaw == 0 } { applyyaw == 1 yawper != attrib }"
                hidewhen    "{ applyyaw == 0 } { applyyaw == 1 yawper != attrib }"
            }
            parm {
                name    "sepparmyaw"
                label   ""
                type    separator
                default { "" }
                hidewhen "{ applyyaw == 0 }"
            }
            parm {
                name    "applypitch"
                cppname "ApplyPitch"
                label   "Apply Pitch"
                type    toggle
                default { "0" }
            }
            parm {
                name    "pitch"
                label   "Pitch"
                type    float
                default { "0" }
                range   { -180 180 }
                hidewhen "{ applypitch == 0 }"
            }
            parm {
                name    "incpitch"
                cppname "IncPitch"
                label   "Incremental Pitch"
                type    float
                default { "0" }
                range   { -180 180 }
                hidewhen "{ applypitch == 0 }"
                joinnext
            }
            parm {
                name    "pitchper"
                cppname "PitchPer"
                label   "Pitch Per"
                type    ordinal
                default { "4" }     // Default to "fulldistance" entry in menu
                menu {
                    "edge"          "Per Edge"
                    "distance"      "Per Unit Distance"
                    "attrib"        "Scale By Attribute"
                    "fulledges"     "Per Full Curve by Edges"
                    "fulldistance"  "Per Full Curve by Distance"
                }
                hidewhen "{ applypitch == 0 }"
            }
            parm {
                name    "pitchattrib"
                cppname "PitchAttrib"
                label   "Pitch Ramp Attribute"
                type    string
                default { "pitch" }
                disablewhen "{ applypitch == 0 } { applypitch == 1 pitchper != attrib }"
                hidewhen    "{ applypitch == 0 } { applypitch == 1 pitchper != attrib }"
            }
        }
    }
)THEDSFILE"
// ==== This is necessary because MSVC++ has a limit of 16380 character per
// ==== string literal
R"THEDSFILE(
    group {
        name    "construction_folder"
        label   "Construction"
        groupsimple {
            name    "cross_sections_folder"
            label   "Cross Sections"
            parm {
                name    "copyorder"
                cppname "CopyOrder"
                label   "Cross Section Order"
                type    ordinal
                default { "1" }     // Default to third entry in menu, "each"
                menu {
                    "all"   "All Cross Sections At Each Curve Vertex"
                    "each"  "Each Cross Section At All Curve Vertices"
                    "cyclevtx" "Cycle Through Cross Section Primitives per Vertex"
                    "cyclepr" "Cycle Through Cross Section Primitives per Curve"
                    "attrib" "Choose Cross Section Primitives by Attribute"
                }
                disablewhen "{ surfaceshape != input }"
            }
            parm {
                name    "crosssectionattrib"
                cppname "CrossSectionAttrib"
                label   "Cross Section Attribute"
                type    string
                default { "variant" }
                disablewhen "{ surfaceshape != input } { copyorder != attrib }"
                hidewhen    "{ surfaceshape != input } { copyorder != attrib }"
            }
            parm {
                name    "primtype"
                cppname "PrimType"
                label   "Primitive Type"
                type    ordinal
                default { "0" }     // Default to menu entry "auto"
                menu {
                    "auto"      "Automatic"
                    "poly"      "Polygons"
                    "mesh"      "Bilinear Mesh"
                    "nurbs"     "NURBS Surface"
                    "bezier"    "Bezier Surface"
                    "polysoup"  "Polygon Soup"
                }
                disablewhen "{ surfacetype == points }"
            }
            parm {
                name    "unrollclosedrowcol"
                cppname "UnrollClosedRowCol"
                label   "Ensure Unique Seam Vertices"
                type    toggle
                default { "0" }
                disablewhen "{ surfacetype == points }"
            }
            parm {
                name    "swaprowcol"
                cppname "SwapRowCol"
                label   "Swap Rows and Columns"
                type    toggle
                default { "0" }
            }
            parm {
                name    "closeifnocurveinput"
                cppname "CloseIfNoCurveInput"
                label   "Close Implicit Backbone Curve if No Curve Input"
                type    toggle
                default { "0" }
                disablewhen "{ surfacetype == points } { surfacetype == rows } { hasinput(0) != 0 }"
            }
            //parm {
            //    name    "segdivs"
            //    cppname "SegDivs"
            //    label   "Segment Divisions"
            //    type    integer
            //    default { "1" }
            //    range   { 1! 10 }
            //}
        }
        groupsimple {
            name    "up_folder"
            label   "Up Vectors"
            parm {
                name    "upvectortype"
                cppname "UpVectorType"
                label   "Target Up Vector"
                type    ordinal
                default { "0" } // Default to first entry in menu, "normal"
                menu {
                    "normal"    "Curve Normal"
                    "x"         "X Axis"
                    "y"         "Y Axis"
                    "z"         "Z Axis"
                    "attrib"    "Attribute"
                    "custom"    "Custom"
                }
                disablewhen "{ tangenttype == none }"
            }
            //parm {
            //    name    "usenormalup"
            //    cppname "UseNormalUp"
            //    label   "Use Curve Normal as Up Vector (When Valid)"
            //    type    toggle
            //    default { "1" }
            //    disablewhen "{ tangenttype == none }"
            //}
            parm {
                name    "upvectoratstart"
                cppname "UpVectorAtStart"
                label   "Target Up Vector at Start (else Average)"
                type    toggle
                default { "1" }
                disablewhen "{ tangenttype == none }"
            }
            parm {
                name    "useendupvector"
                cppname "UseEndUpVector"
                label   "Use Target End Up Vector"
                type    toggle
                default { "0" }
                disablewhen "{ tangenttype == none } { upvectoratstart == 0 }"
            }
            parm {
                name    "upvectorattrib"
                cppname "UpVectorAttrib"
                label   "Start Up Attribute"
                type    string
                default { "start_up" }
                disablewhen "{ tangenttype == none } { upvectortype != attrib }"
                hidewhen "{ tangenttype == none } { upvectortype != attrib }"
            }
            parm {
                name    "endupvectorattrib"
                cppname "EndUpVectorAttrib"
                label   "End Up Attribute"
                type    string
                default { "end_up" }
                disablewhen "{ tangenttype == none } { upvectortype != attrib } { useendupvector == 0 } { upvectoratstart == 0 }"
                hidewhen "{ tangenttype == none } { upvectortype != attrib } { useendupvector == 0 } { upvectoratstart == 0 }"
            }
            parm {
                name    "upvector"
                cppname "UpVector"
                label   "Start Up Vector"
                type    vector
                size    3
                default { "0" "1" "0" }
                disablewhen "{ tangenttype == none } { upvectortype != custom }"
                hidewhen "{ tangenttype == none } { upvectortype != custom }"
            }
            parm {
                name    "endupvector"
                cppname "EndUpVector"
                label   "End Up Vector"
                type    vector
                size    3
                default { "0" "1" "0" }
                disablewhen "{ tangenttype == none } { upvectortype != custom } { useendupvector == 0 } { upvectoratstart == 0 }"
                hidewhen "{ tangenttype == none } { upvectortype != custom } { useendupvector == 0 } { upvectoratstart == 0 }"
            }
        }
        groupsimple {
            name    "tangents_folder"
            label   "Tangents"
            parm {
                name    "tangenttype"
                cppname "TangentType"
                label   "Tangent Type"
                type    ordinal
                default { "0" } // Default to first entry in menu, "avgdir"
                menu {
                    "avgdir"    "Average of Edge Directions"
                    "diff"      "Central Difference"
                    "prev"      "Previous Edge"
                    "next"      "Next Edge"
                    "none"      "Z Axis (Ignore Curve)"
                }
            }
            parm {
                name    "continuousclosed"
                cppname "ContinuousClosed"
                label   "Make Closed Curve Orientations Continuous"
                type    toggle
                default { "1" }
                disablewhen "{ tangenttype == none }"
            }
            parm {
                name    "extrapolateendtangents"
                cppname "ExtrapolateEndTangents"
                label   "Extrapolate End Tangents"
                type    toggle
                default { "0" }
                disablewhen "{ tangenttype == none }"
            }
            parm {
                name    "transformbyattribs"
                cppname "TransformByAttribs"
                label   "Transform Using Curve Point Attributes"
                type    toggle
                default { "1" }
            }
        }
    }
)THEDSFILE"
// ==== This is necessary because MSVC++ has a limit of 16380 character per
// ==== string literal
R"THEDSFILE(
    group {
        name    "uvs_folder"
        label   "UVs and Attributes"
        groupsimple {
            name    "uv_folder"
            label   "UV Coordinates"
            parm {
                name    "computeuvs"
                cppname "ComputeUVs"
                label   "Compute UVs"
                type    toggle
                default { "0" }
            }
            parm {
                name    "overrideexistinguvs"
                cppname "OverrideExistingUVs"
                label   "Override Any Existing UVs"
                type    toggle
                default { "0" }
                disablewhen "{ computeuvs == 0 }"
            }
            parm {
                name    "lengthweighteduvs"
                cppname "LengthWeightedUVs"
                label   "Length-Weighted UVs"
                type    toggle
                default { "1" }
                disablewhen "{ computeuvs == 0 }"
            }
            parm {
                name    "normalizeu"
                cppname "NormalizeU"
                label   "Normalize Computed Us"
                type    toggle
                default { "1" }
                disablewhen "{ computeuvs == 0 } { lengthweighteduvs == 0 }"
            }
            parm {
                name    "normalizev"
                cppname "NormalizeV"
                label   "Normalize Computed Vs"
                type    toggle
                default { "0" }
                disablewhen "{ computeuvs == 0 } { lengthweighteduvs == 0 }"
            }
            parm {
                name    "flipu"
                cppname "FlipU"
                label   "Flip Computed Us"
                type    toggle
                default { "1" }
                disablewhen "{ computeuvs == 0 }"
            }
            groupcollapsible {
                name    "uvscale_folder"
                label   "UV Scale"
                grouptag { "group_type" "collapsible" }
                parmtag { "group_default" "0" }
                parm {
                    name    "uvscale"
                    cppname "UVScale"
                    label   "UV Scale"
                    type    float
                    size    2
                    default { "1" "1" }
                    disablewhen "{ computeuvs == 0 }"
                }
                parm {
                    name    "usemeshedgelengths"
                    cppname "UseMeshEdgeLengths"
                    label   "Use Mesh Edge Lengths Instead of Curve Edge Lengths"
                    type    toggle
                    default { "1" }
                    disablewhen "{ computeuvs == 0 } { lengthweighteduvs == 0 }"
                }
                parm {
                    name    "propscalepercurve"
                    cppname "PropScalePerCurve"
                    label   "Use Max Cross Section Length per Curve for Proportional Scale"
                    type    toggle
                    default { "1" }
                    disablewhen "{ computeuvs == 0 } { lengthweighteduvs == 0 } { normalizeu != 1 } { normalizev != 0 }"
                }
            }
            groupcollapsible {
                name    "uvseams_folder"
                label   "UV Seams"
                grouptag { "group_type" "collapsible" }
                parmtag { "group_default" "0" }
                parm {
                    name    "wrapu"
                    cppname "WrapU"
                    label   "Snap U to Nearest Tile Boundary"
                    type    toggle
                    default { "1" }
                    disablewhen "{ computeuvs == 0 } { lengthweighteduvs == 0 } { normalizeu == 1 }"
                }
                parm {
                    name    "wrapv"
                    cppname "WrapV"
                    label   "Snap V to Nearest Tile Boundary"
                    type    toggle
                    default { "1" }
                    disablewhen "{ computeuvs == 0 } { lengthweighteduvs == 0 } { normalizev == 1 }"
                }
            }
        }
        groupcollapsible {
            name    "attributes_folder"
            label   "Attributes"
            grouptag { "group_type" "collapsible" }
            parmtag { "group_default" "0" }
            groupsimple {
                name    "input_folder"
                label   "Input"
                parm {
                    name    "attribsfrombackbone"
                    cppname "AttribsFromBackbone"
                    label   "From Backbone Curves"
                    type    string
                    default { "* ^P ^N ^up ^pscale ^scale ^orient ^rot ^pivot ^trans ^transform" }
                }
                parm {
                    name    "attribsfromcrosssection"
                    cppname "AttribsFromCrossSection"
                    label   "From Cross Sections"
                    type    string
                    default { "*" }
                }
            }
            groupsimple {
                name    "output_folder"
                label   "Output"
                parm {
                    name    "addptrow"
                    cppname "AddPointRow"
                    label   "Add Point Row Attribute"
                    type    toggle
                    default { "0" }
                    nolabel
                    joinnext
                }
                parm {
                    name    "ptrowattrib"
                    cppname "PtRowAttrib"
                    label   "Point Row Attribute"
                    type    string
                    default { "ptrow" }
                    disablewhen "{ addptrow == 0 }"
                }
                parm {
                    name    "addptcol"
                    cppname "AddPointCol"
                    label   "Add Point Col Attribute"
                    type    toggle
                    default { "0" }
                    nolabel
                    joinnext
                }
                parm {
                    name    "ptcolattrib"
                    cppname "PtColAttrib"
                    label   "Point Col Attribute"
                    type    string
                    default { "ptcol" }
                    disablewhen "{ addptcol == 0 }"
                }
                parm {
                    name    "addprimrow"
                    cppname "AddPrimRow"
                    label   "Add Prim Row Attribute"
                    type    toggle
                    default { "0" }
                    nolabel
                    joinnext
                }
                parm {
                    name    "primrowattrib"
                    cppname "PrimRowAttrib"
                    label   "Prim Row Attribute"
                    type    string
                    default { "primrow" }
                    disablewhen "{ addprimrow == 0 }"
                }
                parm {
                    name    "addprimcol"
                    cppname "AddPrimCol"
                    label   "Add Prim Col Attribute"
                    type    toggle
                    default { "0" }
                    nolabel
                    joinnext
                }
                parm {
                    name    "primcolattrib"
                    cppname "PrimColAttrib"
                    label   "Prim Col Attribute"
                    type    string
                    default { "primcol" }
                    disablewhen "{ addprimcol == 0 }"
                }
                parm {
                    name    "addcrosssectionnum"
                    cppname "AddCrossSectionNum"
                    label   "Add Cross Section Num Attribute"
                    type    toggle
                    default { "0" }
                    nolabel
                    joinnext
                }
                parm {
                    name    "crosssectionnumattrib"
                    cppname "CrossSectionNumAttrib"
                    label   "Cross Section Num Attribute"
                    type    string
                    default { "crossnum" }
                    disablewhen "{ addcrosssectionnum == 0 }"
                }
                parm {
                    name    "addcurvenum"
                    cppname "AddCurveNum"
                    label   "Add Curve Num Attribute"
                    type    toggle
                    default { "0" }
                    nolabel
                    joinnext
                }
                parm {
                    name    "curvenumattrib"
                    cppname "CurveNumAttrib"
                    label   "Curve Num Attribute"
                    type    string
                    default { "curvenum" }
                    disablewhen "{ addcurvenum == 0 }"
                }
                // TODO: Add option to compute vertex normals with cusp angle.
            }
        }
    }
}
)THEDSFILE";

//******************************************************************************
//*                 Cooking                                                    *
//******************************************************************************

using namespace SOP_SweepHDKEnums;
using namespace GU_CurveFrame;

#if 0
/// This function takes edge lengths and a number of points to insert,
/// and determines the number of those points that should go in each edge
/// in order to minimize the maximum final interval length.
template<typename T>
static void
insertIntoIntervals(
    const T *const edge_lengths,
    const T total_length,
    const exint nedges,
    const exint ninsertions,
    exint *const ninsertions_per_edge)
{
    UT_ASSERT(nedges >= 1 && ninsertions >= 0);
    exint ninsertions_so_far = 0;
    for (exint i = 0; i < nedges; ++i)
    {
        T portion = (total_length > 0) ? (edge_lengths[i]/total_length) : (T(1)/T(nedges));
        // In exact arithmetic, the number of insertions in a given edge would
        // be at least floor(ninsertions*portion), but roundoff error could
        // cause problems, so subtract 1 to reduce the risk of the initial
        // number of insertions exceeding ninsertions.
        exint ki = SYSmax(exint(0), exint(SYSfloor(ninsertions*portion))-1);
        // Clamp it, just in case something weird happens.
        ki = SYSmin(ki, ninsertions-ninsertions_so_far);
        ninsertions_per_edge[i] = ki;
        ninsertions_so_far += ki;
    }
    if (ninsertions_so_far == ninsertions)
        return;

    struct IntervalComparator {
        IntervalComparator(const T *const edge_lengths, const exint *const ninsertions_per_edge) :
            myEdgeLengths(edge_lengths),
            myNInsertionsPerEdge(ninsertions_per_edge)
        {}
        bool operator()(const exint a, const exint b) const {
            // Compare the current lengths of the intervals along edge a vs those along edge b.
            // Multiply by both denomonators, instead of dividing, for better performance.
            const T nadb = myEdgeLengths[a]*(myNInsertionsPerEdge[b]+1);
            const T nbda = myEdgeLengths[b]*(myNInsertionsPerEdge[a]+1);

            // std::priority_queue is a max heap, and we want that, but the
            // comparator should act like std::less and return true if the
            // value for a is less than the value for b.
            // We also want a stable tie-breaker to avoid any problems with
            // different behaviour on different platforms.
            return nadb < nbda || (nadb == nbda && a < b);
        }
        const T *const myEdgeLengths;
        const exint *const myNInsertionsPerEdge;
    };
    IntervalComparator comparator(edge_lengths, ninsertions_per_edge);

    // Use n^2 approach for small nedges or small number of remaining
    // insertions, to avoid building a heap.
    if (nedges < 20 || (ninsertions-ninsertions_so_far) < 20) {
        do {
            exint edge_with_largest_intervals = 0;
            for (exint i = 1; i < nedges; ++i) {
                if (comparator(edge_with_largest_intervals, i)) {
                    edge_with_largest_intervals = i;
                }
            }
            ++ninsertions_per_edge[edge_with_largest_intervals];
            ++ninsertions_so_far;
        } while (ninsertions_so_far < ninsertions);

        return;
    }

    // Make a binary heap of edge indices such that the edge with
    // longest current intervals will be at the top.
    UT_Array<exint> heap;
    heap.setSizeNoInit(nedges);
    for (exint i = 0; i < nedges; ++i)
        heap(i) = i;
    exint *const heap_begin = heap.array();
    exint *const heap_end = heap_begin+nedges;
    std::make_heap(heap_begin, heap_end, comparator);

    while (true)
    {
        // Insert another point in the edge with the largest intervals.
        exint edge_with_largest_intervals = heap_begin[0];
        ++ninsertions_per_edge[edge_with_largest_intervals];
        ++ninsertions_so_far;
        if (ninsertions_so_far == ninsertions)
            return;

        // Update the heap
        std::pop_heap(heap_begin, heap_end, comparator);
        heap_end[-1] = edge_with_largest_intervals;
        std::push_heap(heap_begin, heap_end, comparator);
    }
}
#endif

static int
sopParmToPrimType(const SOP_SweepHDKEnums::PrimType sop_primtype)
{
    using PrimType = SOP_SweepHDKEnums::PrimType;
    switch (sop_primtype)
    {
        case PrimType::AUTO:    return GA_PRIMNONE;
        case PrimType::POLY:    return GA_PRIMPOLY;
        case PrimType::POLYSOUP:return GA_PRIMPOLYSOUP;
        case PrimType::MESH:    return GA_PRIMMESH;
        case PrimType::BEZIER:  return GA_PRIMBEZSURF;
        case PrimType::NURBS:   return GA_PRIMNURBSURF;
    }
    return GA_PRIMNONE;
}

static SYS_FORCE_INLINE exint
reverseVtx(exint i, exint n, bool closed)
{
    if (!closed)
        return (n-i-1);
    return (i==0) ? 0 : (n-i);
}

static void
computeCurveUVs(
    const GEO_Detail *detail,
    const GA_PrimitiveGroup *prim_group,
    const GA_RWHandleV3 &uv_attrib,
    bool by_length,
    bool reverse)
{
    // We're modifying this attribute, and it'll be in the output detail,
    // so we need to bump its data ID.
    uv_attrib->bumpDataId();

    // Because we're not parallelizing over vertex pages and we're writing
    // to a vertex attribute, we must harden all pages of the attribute in advance.
    uv_attrib->hardenAllPages();

    UT_AutoInterrupt interrupt("Computing curve UVs");
    if (interrupt.wasInterrupted())
        return;

    //const float fnprimitives = float(prim_group ? prim_group->entries() : detail->getNumPrimitives());

    // Loop over primitives in parallel, using a splittable range and a lambda functor.
    UTparallelFor(GA_SplittableRange(detail->getPrimitiveRange(prim_group)),
        [detail,&uv_attrib,&interrupt,by_length,reverse](const GA_SplittableRange &r)
    {
        // Inside the functor, we have a sub-range of primitives, so loop over that range.
        // We use blockAdvance, instead of !it.atEnd() and ++it, for less looping overhead.
        GA_Offset start; GA_Offset end;
        for (GA_Iterator it(r); it.blockAdvance(start,end); )
        {
            // We probably don't need to check for interruption on every curve,
            // (unless people put in a curve with millions of vertices), so we
            // can check it once for every contiguous block of up to GA_PAGE_SIZE
            // primitive offsets.
            if (interrupt.wasInterrupted())
                return;

            // Loop over all primitives in this contiguous block of offsets.
            for (GA_Offset primoff = start; primoff < end; ++primoff)
            {
                const GA_OffsetListRef vertices = detail->getPrimitiveVertexList(primoff);
                const GA_Size n = vertices.size();

                float v = 0;
                //if (separate_us)
                //    v = float(GA_Size(detail->primitiveIndex(primoff))) / fnprimitives;

                // Nothing to do if no vertices; special case if 1 vertex
                if (n <= 1)
                {
                    if (n == 1)
                        uv_attrib.set(vertices(0), UT_Vector3(0,v,0));
                    continue;
                }

                const bool closed = vertices.getExtraFlag();

                // Reversed closed polygons keep vertex 0 in the same place
                GA_Offset vtxoff0;
                if (!reverse || closed)
                    vtxoff0 = vertices(0);
                else
                    vtxoff0 = vertices(n-1);

                bool local_by_length = by_length;
                if (local_by_length)
                {
                    // First, compute the full length of the curve
                    float length = 0;
                    const UT_Vector3 pos0 = detail->getPos3(detail->vertexPoint(vtxoff0));
                    UT_Vector3 prev_pos = pos0;
                    for (GA_Size i = 1; i < n; ++i)
                    {
                        GA_Size vtxi = (!reverse) ? i : (n-i-!closed);
                        const UT_Vector3 cur_pos = detail->getPos3(detail->vertexPoint(vertices(vtxi)));
                        length += distance3d(prev_pos, cur_pos);
                        prev_pos = cur_pos;
                    }
                    if (closed)
                    {
                        // One last edge if closed
                        length += distance3d(prev_pos, pos0);
                    }
                    if (length == 0)
                    {
                        // Fall back to uniform weighting if total length is zero
                        local_by_length = false;
                    }
                    else
                    {
                        // Compute the u values as cur_length/length
                        uv_attrib.set(vtxoff0, UT_Vector3(0,v,0));
                        float cur_length = 0;
                        prev_pos = detail->getPos3(detail->vertexPoint(vtxoff0));
                        for (GA_Size i = 1; i < n; ++i)
                        {
                            GA_Size vtxi = (!reverse) ? i : (n-i-!closed);
                            GA_Offset vtxoff = vertices(vtxi);
                            const UT_Vector3 cur_pos = detail->getPos3(detail->vertexPoint(vtxoff));
                            cur_length += distance3d(prev_pos, cur_pos);
                            const float u = cur_length/length;
                            uv_attrib.set(vtxoff, UT_Vector3(u,v,0));
                            prev_pos = cur_pos;
                        }
                    }
                }
                if (!local_by_length)
                {
                    // Uniform uv step on each edge, so each u value is vertex/nedges
                    GA_Size nedges = closed ? n : (n-1);
                    uv_attrib.set(vtxoff0, UT_Vector3(0,v,0));
                    for (GA_Size i = 1; i < n; ++i)
                    {
                        GA_Size vtxi = (!reverse) ? i : (n-i-!closed);
                        const float u = i/float(nedges);
                        uv_attrib.set(vertices(vtxi), UT_Vector3(u,v,0));
                    }
                }

                // This is a silly way to do it, but to try to get UV wrapping
                // correct when reversing a closed cross section, the first U value
                // needs to be 1, instead of 0.  This is because of how code below
                // handles wrapping and closed cross sections from the cross section input.
                if (reverse && closed)
                {
                    uv_attrib.set(vtxoff0, UT_Vector3(1,v,0));
                }
            }
        }
    });
}

static GA_Offset lookupCrossSectionFromAttrib(
    const CrossSectionAttribMatchData *copy_order_attrib_data,
    GA_Offset curve_offset,
    const GEO_Detail *cross_section_input,
    const GA_PrimitiveGroup *cross_section_group)
{
    if (copy_order_attrib_data->myCurveIntAttrib.isValid())
    {
        // Integer attribute case
        const exint id = copy_order_attrib_data->myCurveIntAttrib.get(curve_offset);
        if (copy_order_attrib_data->myIsUsingMap) {
            // Using map (both inputs had integer attribute)
            if (UT::ArrayMap<exint,GA_Offset>::clearer_type::isClear(id)) {
                // No cross section, since invalid key for map type.
                return GA_INVALID_OFFSET;
            }
            auto &&it = copy_order_attrib_data->myIntToPrimOff.find(id);
            if (it == copy_order_attrib_data->myIntToPrimOff.end()) {
                // No cross section, since key not in map.
                return GA_INVALID_OFFSET;
            }
            return it->second;
        }
        if (id < 0 || id >= cross_section_input->getNumPrimitives()) {
            // No cross section, since primitive index out of range.
            return GA_INVALID_OFFSET;
        }
        const GA_Offset cross_section_primoff = cross_section_input->primitiveOffset(id);
        if (cross_section_group && !cross_section_group->contains(cross_section_primoff)) {
            // No cross section, since primitive not in group.
            return GA_INVALID_OFFSET;
        }
        return cross_section_primoff;
    }

    // String attribute case
    UT_ASSERT_P(copy_order_attrib_data->myCurveStrAttrib.isValid());
    UT_ASSERT_P(copy_order_attrib_data->myIsUsingMap);

    const UT_StringHolder &name = copy_order_attrib_data->myCurveStrAttrib.get(curve_offset);
    if (!name.isstring()) {
        // No cross section, since invalid key for map type.
        return GA_INVALID_OFFSET;
    }
    auto &&it = copy_order_attrib_data->myStrToPrimOff.find(name);
    if (it == copy_order_attrib_data->myStrToPrimOff.end()) {
        // No cross section, since key not in map.
        return GA_INVALID_OFFSET;
    }
    return it->second;
}

static int
updateAutoPrimType(
    const GEO_Detail *const cross_section_input,
    const GA_Offset cross_section_primoff,
    int &primitive_type,
    unsigned char &fallback_orderu,
    const GA_Basis **const pbasisu)
{
    UT_ASSERT_P(cross_section_input != nullptr);
    int primtype = cross_section_input->getPrimitiveTypeId(cross_section_primoff);
    // Only change if cross section is NURBS or Bezier curve.
    if (primtype != GA_PRIMNURBCURVE && primtype != GA_PRIMBEZCURVE)
        return primtype;

    // NURBS takes precedence, so don't modify if already NURBS
    if (primitive_type != GA_PRIMNURBSURF)
    {
        if (primtype == GA_PRIMNURBCURVE)
            primitive_type = GA_PRIMNURBSURF;
        else //if (primtype == GA_PRIMBEZCURVE)
            primitive_type = GA_PRIMBEZSURF;
    }

    const GEO_Curve *curve = UTverify_cast<const GEO_Curve *>(cross_section_input->getPrimitive(cross_section_primoff));
    UT_ASSERT_P(curve->getBasis() != nullptr);
    fallback_orderu = SYSmax(fallback_orderu, curve->getBasis()->getOrder());
    if (pbasisu != nullptr)
        *pbasisu = curve->getBasis();

    return primtype;
}

static bool
computeCombinedCrossSectionProperties(
    const GEO_Detail *const cross_section_input,
    const GA_PrimitiveGroup *const cross_section_group,
    GA_Iterator &cross_section_it,
    exint num_cross_sections,
    exint &cross_section_nedges,
    bool &cross_section_closed,
    bool &cross_section_unrolled,
    bool &varying_nedges,
    GA_OffsetList &cross_section_primoffs,
    const bool is_primtype_auto,
    int &primitive_type,
    unsigned char &fallback_orderu,
    const GA_Basis **const pbasisu)
{
    if (num_cross_sections == 0)
        return false;

    UT_ASSERT(cross_section_it.isValid());
    UT_ASSERT(!cross_section_it.atEnd());

    // If the final values of closed, unrolled, or primtype differ from
    // the values for the U basis, the U basis must be thrown out.
    bool basis_cross_section_closed;
    bool basis_cross_section_unrolled;
    int basis_primtype;

    cross_section_nedges = -1;
    varying_nedges = false;
    //bool varying_cross_section_topology = false;
    for (exint cross_sectioni = 0; cross_sectioni < num_cross_sections; ++cross_sectioni)
    {
        GA_Offset cross_section_primoff = *cross_section_it;
        ++cross_section_it;
        if (cross_section_it.atEnd())
        {
            // Wrap around the cross sections
            cross_section_it.rewind();
            UT_ASSERT(!cross_section_it.atEnd());
        }

        cross_section_primoffs.append(cross_section_primoff);
        const GA_OffsetListRef cross_section_vertices = cross_section_input->getPrimitiveVertexList(cross_section_primoff);
        exint local_cross_section_nedges;
        bool local_cross_section_closed;
        bool local_cross_section_unrolled;
        bool nonempty = getPolyProperties(cross_section_input, cross_section_vertices, local_cross_section_nedges, local_cross_section_closed, local_cross_section_unrolled);

        // If any cross section has no vertices, don't generate this grid at all.
        if (!nonempty)
            return false;

        if (cross_section_nedges == -1)
        {
            // First iteration, so copy value.
            cross_section_closed = local_cross_section_closed;
            cross_section_unrolled = local_cross_section_unrolled;
        }
        else if (!local_cross_section_closed)
        {
            //varying_cross_section_topology |= cross_section_closed || cross_section_unrolled;
            // If any cross section is open, we go with open.
            cross_section_closed = false;
            cross_section_unrolled = false;
        }
        else if (local_cross_section_unrolled && cross_section_closed && !cross_section_unrolled)
        {
            // If we're closed and not yet unrolled and we encounter
            // an unrolled cross section, go with unrolled.
            cross_section_unrolled = true;
            //varying_cross_section_topology = true;
        }

        // Independent of that, we choose the number of edges to be the max number of edges.
        bool local_varying_nedges = (cross_section_nedges != -1 && local_cross_section_nedges != cross_section_nedges);
        //varying_cross_section_topology |= local_varying_nedges;
        varying_nedges |= local_varying_nedges;

        int local_primtype;
        if (is_primtype_auto)
        {
            local_primtype = updateAutoPrimType(cross_section_input, cross_section_primoff, primitive_type, fallback_orderu, nullptr);
        }

        // Pick the maximum cross_section_nedges.
        if (local_cross_section_nedges > cross_section_nedges)
        {
            cross_section_nedges = local_cross_section_nedges;

            if (is_primtype_auto && pbasisu != nullptr)
            {
                // Choose the basis with the maximum nedges, since it's the most likely to be valid.
                if (local_primtype == GA_PRIMNURBCURVE || local_primtype == GA_PRIMBEZCURVE)
                {
                    basis_primtype = (local_primtype == GA_PRIMNURBCURVE) ? GA_PRIMNURBSURF : GA_PRIMBEZSURF;
                    basis_cross_section_closed = local_cross_section_closed;
                    basis_cross_section_unrolled = local_cross_section_unrolled;

                    const GEO_Curve *curve = UTverify_cast<const GEO_Curve*>(cross_section_input->getPrimitive(cross_section_primoff));
                    UT_ASSERT_P(curve->getBasis() != nullptr);
                    *pbasisu = curve->getBasis();
                }
                else
                {
                    // Not a NURBS or Bezier curve, so clear the basis.
                    *pbasisu = nullptr;
                }
            }
        }
    }

    if (pbasisu != nullptr && *pbasisu != nullptr)
    {
        // NOTE: This basis not be valid with the final
        //       cross_section_closed or cross_section_unrolled or primitive_type,
        //       so clear it if it's not valid.
        if (basis_primtype != primitive_type ||
            basis_cross_section_closed != cross_section_closed ||
            basis_cross_section_unrolled != cross_section_unrolled)
        {
            *pbasisu = nullptr;
        }
    }

    UT_ASSERT(cross_section_primoffs.size() > 0);

    return true;
}

// This is primarily the same as computeCombinedCrossSectionProperties,
// except selecting cross sections using copy_order_attrib_data,
// instead of getting sequential ones with a GA_Iterator.
static bool
computeCombinedCrossSectionPropertiesAttrib(
    const GEO_Detail *const cross_section_input,
    const GA_PrimitiveGroup *const cross_section_group,
    const GEO_Detail *const curve_input,
    const GA_OffsetListRef &curve_vertices,
    const CrossSectionAttribMatchData *const copy_order_attrib_data,
    exint &cross_section_nedges,
    bool &cross_section_closed,
    bool &cross_section_unrolled,
    bool &varying_nedges,
    GA_OffsetList &cross_section_primoffs,
    const bool is_primtype_auto,
    int &primitive_type,
    unsigned char &fallback_orderu,
    const GA_Basis **const pbasisu)
{
    exint num_vertices = curve_vertices.size();
    if (num_vertices == 0)
        return false;

    const GA_AttributeOwner curve_owner = copy_order_attrib_data->myCurveAttribOwner;
    UT_ASSERT(curve_owner == GA_ATTRIB_POINT || curve_owner == GA_ATTRIB_VERTEX);

    // If the final values of closed, unrolled, or primtype differ from
    // the values for the U basis, the U basis must be thrown out.
    bool basis_cross_section_closed;
    bool basis_cross_section_unrolled;
    int basis_primtype;

    cross_section_nedges = -1;
    varying_nedges = false;
    //bool varying_cross_section_topology = false;
    for (exint vtxi = 0; vtxi < num_vertices; ++vtxi)
    {
        GA_Offset curve_offset = curve_vertices[vtxi];
        if (curve_owner == GA_ATTRIB_POINT)
            curve_offset = curve_input->vertexPoint(curve_offset);
        GA_Offset cross_section_primoff = lookupCrossSectionFromAttrib(copy_order_attrib_data, curve_offset, cross_section_input, cross_section_group);

        // If any cross sections don't work out, give up on the grid,
        // for simplicity when copying curve attributes later.
        if (!GAisValid(cross_section_primoff))
            return false;

        cross_section_primoffs.append(cross_section_primoff);
        const GA_OffsetListRef cross_section_vertices = cross_section_input->getPrimitiveVertexList(cross_section_primoff);
        exint local_cross_section_nedges;
        bool local_cross_section_closed;
        bool local_cross_section_unrolled;
        bool nonempty = getPolyProperties(cross_section_input, cross_section_vertices, local_cross_section_nedges, local_cross_section_closed, local_cross_section_unrolled);

        // If any cross section has no vertices, don't generate this grid at all.
        if (!nonempty)
            return false;

        if (cross_section_nedges == -1)
        {
            // First iteration, so copy value.
            cross_section_closed = local_cross_section_closed;
            cross_section_unrolled = local_cross_section_unrolled;
        }
        else if (!local_cross_section_closed)
        {
            //varying_cross_section_topology |= cross_section_closed || cross_section_unrolled;
            // If any cross section is open, we go with open.
            cross_section_closed = false;
            cross_section_unrolled = false;
        }
        else if (local_cross_section_unrolled && cross_section_closed && !cross_section_unrolled)
        {
            // If we're closed and not yet unrolled and we encounter
            // an unrolled cross section, go with unrolled.
            cross_section_unrolled = true;
            //varying_cross_section_topology = true;
        }

        // Independent of that, we choose the number of edges to be the max number of edges.
        bool local_varying_nedges = (cross_section_nedges != -1 && local_cross_section_nedges != cross_section_nedges);
        //varying_cross_section_topology |= local_varying_nedges;
        varying_nedges |= local_varying_nedges;

        int local_primtype;
        if (is_primtype_auto)
        {
            local_primtype = updateAutoPrimType(cross_section_input, cross_section_primoff, primitive_type, fallback_orderu, nullptr);
        }

        // Pick the maximum cross_section_nedges.
        if (local_cross_section_nedges > cross_section_nedges)
        {
            cross_section_nedges = local_cross_section_nedges;

            if (is_primtype_auto && pbasisu != nullptr)
            {
                // Choose the basis with the maximum nedges, since it's the most likely to be valid.
                if (local_primtype == GA_PRIMNURBCURVE || local_primtype == GA_PRIMBEZCURVE)
                {
                    basis_primtype = (local_primtype == GA_PRIMNURBCURVE) ? GA_PRIMNURBSURF : GA_PRIMBEZSURF;
                    basis_cross_section_closed = local_cross_section_closed;
                    basis_cross_section_unrolled = local_cross_section_unrolled;

                    const GEO_Curve *curve = UTverify_cast<const GEO_Curve*>(cross_section_input->getPrimitive(cross_section_primoff));
                    UT_ASSERT_P(curve->getBasis() != nullptr);
                    *pbasisu = curve->getBasis();
                }
                else
                {
                    // Not a NURBS or Bezier curve, so clear the basis.
                    *pbasisu = nullptr;
                }
            }
        }
    }

    if (pbasisu != nullptr && *pbasisu != nullptr)
    {
        // NOTE: This basis not be valid with the final
        //       cross_section_closed or cross_section_unrolled or primitive_type,
        //       so clear it if it's not valid.
        if (basis_primtype != primitive_type ||
            basis_cross_section_closed != cross_section_closed ||
            basis_cross_section_unrolled != cross_section_unrolled)
        {
            *pbasisu = nullptr;
        }
    }

    UT_ASSERT(cross_section_primoffs.size() > 0);

    return true;
}

static void
initPrimType(
    const bool output_points_only,
    const bool is_primtype_auto,
    int &primitive_type,
    unsigned char &fallback_orderv,
    const GA_Basis **const pbasisv,
    const GEO_Detail *const curve_input,
    const GA_Offset curve_primoff)
{
    // When using automatic primitive type mode, we take the highest order NURBS,
    // or if the cross section with the most edges is Bezier, Bezier of that order;
    // 0 indicates that we haven't encountered any NURBS or Bezier curves yet.
    // NOTE: If primitive_type becomes GA_PRIMNURBSURF or GA_PRIMBEZSURF below,
    //       fallback_orderv should be set to something between 2 and GA_MAXORDER.
    fallback_orderv = 0;
    if (!is_primtype_auto)
        return;

    // Default guess is polygon
    primitive_type = GA_PRIMPOLY;
    if (curve_input == nullptr)
    {
        // If no curve, and cross sections end up having NURBS or Bezier,
        // default to order 4, instead of assuming implicit curve should be a polygon (order 2).
        fallback_orderv = 4;
        if (pbasisv)
            *pbasisv = nullptr;
        return;
    }

    const int curve_primtype = curve_input->getPrimitiveTypeId(curve_primoff);
    bool is_curve = false;
    if (curve_primtype == GA_PRIMBEZCURVE)
    {
        // If curve primitive is a Bezier curve, default guess is Bezier surface.
        primitive_type = GA_PRIMBEZSURF;
        is_curve = true;
    }
    else if (curve_primtype == GA_PRIMNURBCURVE)
    {
        // If curve primitive is a NURBS curve, always use NURBS surface
        // primitive if automatic mode.
        primitive_type = GA_PRIMNURBSURF;
        is_curve = true;
    }
    if (is_curve)
    {
        const GEO_Curve *const curve = UTverify_cast<const GEO_Curve *>(curve_input->getPrimitive(curve_primoff));
        if (pbasisv)
            *pbasisv = curve->getBasis();
        UT_ASSERT_P(curve->getBasis());
        fallback_orderv = curve->getBasis()->getOrder();
    }
}

// This fills in grid_info based on the input data.
// This function does *not* handle the copy cases; it only handles the grid cases.
// It returns false if the grid is invalid; the caller should not rely on grid_info or num_points in that case.
// NOTE: It does *not* fill in grid_info.myStartPtOff, grid_info.myStartVtxOff, or grid_info.myStartPrimOff.
static bool
computeSingleGridSetup(
    // Cross section parameters
    const GEO_Detail *const cross_section_input,
    const GA_PrimitiveGroup *const cross_section_group,
    const bool single_cross_section,
    GA_Iterator &cross_section_it,
    GA_Offset single_cross_section_primoff,
    exint cross_section_nedges,
    bool cross_section_closed,
    bool cross_section_unrolled,
    const CopyOrder copy_order,
    const CrossSectionAttribMatchData *const copy_order_attrib_data,
    bool varying_nedges_all_case,
    const GA_OffsetList *cross_section_primoffs_all_case,

    // Backbone curve parameters
    const GEO_Detail *const curve_input,
    const GA_Offset curve_primoff,
    const bool closed_if_no_curve_input,

    // Surface parameters
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool unroll_closed_row_col,
    const bool is_primtype_auto,
    int primitive_type,
    unsigned char fallback_orderu,
    unsigned char fallback_orderv,
    const GA_Basis **const pbasisu,
    EndCapType end_cap_type,
    exint cap_divisions,

    // Output parameters
    sop_SweepGrid &grid_info,
    exint &num_points)
{
    const bool has_col_surface_type =
        surface_type == GEO_PATCH_COLS ||
        surface_type == GEO_PATCH_ROWCOL;
    const bool has_row_surface_type =
        surface_type == GEO_PATCH_ROWS ||
        surface_type == GEO_PATCH_ROWCOL;
    const bool has_rowcol_surface_type =
        has_col_surface_type || has_row_surface_type;

    const bool is_polygon_type = (!output_points_only && primitive_type == GA_PRIMPOLY);
    const bool could_add_row_seam_vertex = (has_col_surface_type || !is_polygon_type) && unroll_closed_row_col;
    const bool could_add_col_seam_vertex = (has_row_surface_type || !is_polygon_type) && unroll_closed_row_col;

    if (curve_input == nullptr)
    {
        // Just input cross sections, no input curves, so only this one grid.
        UT_ASSERT(cross_section_input != nullptr);
        grid_info.myCurvePrimOff = GA_INVALID_OFFSET;
        grid_info.myCurveClosed = closed_if_no_curve_input;
        grid_info.myCurveUnrolled = (grid_info.myCurveClosed && could_add_row_seam_vertex);
        exint num_cross_sections = (cross_section_group ? cross_section_group->entries() : cross_section_input->getNumPrimitives());
        grid_info.myCurveNEdges = num_cross_sections - !grid_info.myCurveClosed;

        bool varying_nedges;
        GA_OffsetList cross_section_primoffs;
        bool is_valid_grid = computeCombinedCrossSectionProperties(
            cross_section_input,
            cross_section_group,
            cross_section_it,
            num_cross_sections,
            cross_section_nedges,
            cross_section_closed,
            cross_section_unrolled,
            varying_nedges,
            cross_section_primoffs,
            is_primtype_auto,
            primitive_type,
            fallback_orderu,
            pbasisu);

        if (!is_valid_grid)
            return false;

        grid_info.myCrossSectionNEdges = cross_section_nedges;
        grid_info.myCrossSectionClosed = cross_section_closed;
        grid_info.myCrossSectionUnrolled = cross_section_unrolled || (cross_section_closed && could_add_col_seam_vertex);
        grid_info.myAllEqualNEdges = !varying_nedges;
        grid_info.mySingleCrossSection = (cross_section_primoffs.size() == 1);
        if (grid_info.mySingleCrossSection)
            grid_info.myCrossSectionPrimOff = cross_section_primoffs(0);
        else
            grid_info.myCrossSectionPrimOffs = new GA_OffsetList(std::move(cross_section_primoffs));
    }
    else
    {
        // Input curve
        grid_info.myCurvePrimOff = curve_primoff;

        exint curve_nedges;
        bool curve_closed;
        bool curve_unrolled;
        const GA_OffsetListRef curve_vertices = curve_input->getPrimitiveVertexList(curve_primoff);
        bool nonempty = getPolyProperties(curve_input, curve_vertices, curve_nedges, curve_closed, curve_unrolled);

        // Skip curves with no vertices
        if (!nonempty)
            return false;

        grid_info.myCurveClosed = curve_closed;
        grid_info.myCurveUnrolled = curve_unrolled || (curve_closed && could_add_row_seam_vertex);
        grid_info.myCurveNEdges = curve_nedges;

        if (single_cross_section)
        {
            UT_ASSERT_MSG(copy_order != CopyOrder::ATTRIB, "This branch doesn't handle the possibility of invalid cross section selection in attribute.");
            grid_info.myCrossSectionNEdges = cross_section_nedges;
            grid_info.myCrossSectionClosed = cross_section_closed;
            grid_info.myCrossSectionUnrolled = cross_section_unrolled || (cross_section_closed && could_add_col_seam_vertex);
            grid_info.myAllEqualNEdges = true;
            grid_info.mySingleCrossSection = true;
            grid_info.myCrossSectionPrimOff = single_cross_section_primoff;
        }
        else
        {
            UT_ASSERT_MSG(copy_order == CopyOrder::CYCLEVTX || copy_order == CopyOrder::ALL || copy_order == CopyOrder::ATTRIB,
                "Other cases should have resolved to single cross section grids.");

            bool varying_nedges = varying_nedges_all_case;
            GA_OffsetList cross_section_primoffs;
            if (copy_order == CopyOrder::CYCLEVTX)
            {
                exint num_cross_sections = curve_nedges + !curve_closed;
                bool is_valid_grid = computeCombinedCrossSectionProperties(
                    cross_section_input,
                    cross_section_group,
                    cross_section_it,
                    num_cross_sections,
                    cross_section_nedges,
                    cross_section_closed,
                    cross_section_unrolled,
                    varying_nedges,
                    cross_section_primoffs,
                    is_primtype_auto,
                    primitive_type,
                    fallback_orderu,
                    pbasisu);

                if (!is_valid_grid)
                    return false;
            }
            else if (copy_order == CopyOrder::ATTRIB)
            {
                bool is_valid_grid = computeCombinedCrossSectionPropertiesAttrib(
                    cross_section_input,
                    cross_section_group,
                    curve_input,
                    curve_vertices,
                    copy_order_attrib_data,
                    cross_section_nedges,
                    cross_section_closed,
                    cross_section_unrolled,
                    varying_nedges,
                    cross_section_primoffs,
                    is_primtype_auto,
                    primitive_type,
                    fallback_orderu,
                    pbasisu);

                if (!is_valid_grid)
                    return false;
            }

            grid_info.myCrossSectionNEdges = cross_section_nedges;
            grid_info.myCrossSectionClosed = cross_section_closed;
            grid_info.myCrossSectionUnrolled = cross_section_unrolled || (cross_section_closed && could_add_col_seam_vertex);
            grid_info.myAllEqualNEdges = !varying_nedges;
            grid_info.mySingleCrossSection = false;
            if (copy_order == CopyOrder::ALL)
            {
                exint ncopies = grid_info.myCurveNEdges + !grid_info.myCurveClosed;
                grid_info.myCurveNEdges = (ncopies * cross_section_primoffs_all_case->size()) - !grid_info.myCurveClosed;
                grid_info.myCrossSectionPrimOffs = new GA_OffsetList();
                for (exint copyi = 0; copyi < ncopies; ++copyi)
                {
                    grid_info.myCrossSectionPrimOffs->append(*cross_section_primoffs_all_case);
                }
            }
            else
            {
                grid_info.myCrossSectionPrimOffs = new GA_OffsetList(std::move(cross_section_primoffs));
            }
        }
    }

    grid_info.myHasPolygonCaps =
        !output_points_only &&
        (
            (end_cap_type == EndCapType::SINGLE &&
                (!grid_info.myCurveClosed && grid_info.myCrossSectionClosed && grid_info.myCrossSectionNEdges > 1)) ||
            (end_cap_type == EndCapType::SIDESINGLE &&
                (!grid_info.myCrossSectionClosed && grid_info.myCurveClosed && grid_info.myCurveNEdges > 1))
        ) &&
        !has_rowcol_surface_type;

    // FIXME: Because we haven't sorted out how to represent transforms for U end caps yet, disable them for now!!!
    grid_info.myUEndPoles = false;
#if 0
    grid_info.myUEndPoles =
        !output_points_only &&
        (end_cap_type != EndCapType::NONE && end_cap_type != EndCapType::SINGLE && end_cap_type != EndCapType::SIDESINGLE) &&
        (!grid_info.myCrossSectionClosed && grid_info.myCurveClosed) &&
        cap_divisions > 0;
#endif

    // NOTE: Even non-closed cross sections can yield end "caps", so that
    //       it's possible to do rounded and pointed ends on ribbons.
    //       Even the flat case can be useful if the end cross section is not a straight line.
    grid_info.myVEndPoles =
        !output_points_only &&
        (end_cap_type != EndCapType::NONE && end_cap_type != EndCapType::SINGLE && end_cap_type != EndCapType::SIDESINGLE) &&
        (!grid_info.myCurveClosed) &&
        cap_divisions > 0;

    if (grid_info.myUEndPoles)
    {
        // Add in the divisions for the first and last col cap
        grid_info.myCrossSectionNEdges += 2*cap_divisions;

        // The first and last columns are collapsed to single points.
        UT_ASSERT(grid_info.myCurveNEdges >= 1);
    }
    else if (grid_info.myVEndPoles)
    {
        // Add in the divisions for the first and last row cap
        grid_info.myCurveNEdges += 2*cap_divisions;

        if (!grid_info.mySingleCrossSection)
        {
            // Add duplicates of first and last cross section primoffs for simplicity later.
            GA_OffsetList new_cross_section_primoffs;
            GA_OffsetList &primoffs = *grid_info.myCrossSectionPrimOffs;
            for (exint i = 0; i < cap_divisions; ++i)
                new_cross_section_primoffs.append(primoffs(0));
            new_cross_section_primoffs.append(primoffs);
            for (exint i = 0; i < cap_divisions; ++i)
                new_cross_section_primoffs.append(primoffs.last());
            primoffs = std::move(new_cross_section_primoffs);
        }

        // The first and last rows are collapsed to single points.
        UT_ASSERT(grid_info.myCrossSectionNEdges >= 1);
    }

    using PrimitiveType = sop_SweepGrid::PrimitiveType;
    grid_info.myPrimitiveType = PrimitiveType::POINTS;
    if (!output_points_only)
    {
        grid_info.myPrimitiveType = PrimitiveType::POLYGON;
        if (primitive_type == GA_PRIMPOLYSOUP)
            grid_info.myPrimitiveType = PrimitiveType::POLYSOUP;
        else if (primitive_type == GA_PRIMMESH)
            grid_info.myPrimitiveType = PrimitiveType::MESH;
        else if (primitive_type == GA_PRIMNURBSURF)
            grid_info.myPrimitiveType = PrimitiveType::NURBS;
        else if (primitive_type == GA_PRIMBEZSURF)
            grid_info.myPrimitiveType = PrimitiveType::BEZIER;

        // Fall back to polygon if number of rows or cols is too small.
        // TODO: Consider supporting outputting a single NURBS/Bezier curve.
        if (grid_info.myPrimitiveType != PrimitiveType::POLYGON &&
            (grid_info.myCurveNEdges <= 0 || grid_info.myCrossSectionNEdges <= 0))
        {
            grid_info.myPrimitiveType = PrimitiveType::POLYGON;
        }
    }
    if (grid_info.myPrimitiveType == PrimitiveType::NURBS)
    {
        if (fallback_orderv == 0)
        {
            // Either not auto, or curve was polygon but one of the cross sections was NURBS/Bezier.
            // Use order 2 if auto, since that's the closest match to polygon,
            // but use order 4 if not auto, since the user specifically chose NURBS.
            fallback_orderv = (is_primtype_auto && curve_input != nullptr) ? 2 : 4;
        }
        exint curve_nvertices = grid_info.myCurveNEdges + (!grid_info.myCurveClosed || grid_info.myCurveUnrolled);
        if (curve_nvertices < fallback_orderv)
        {
            // Too few vertices for fallback_orderv
            // Clamp just in case we made a mistake elsewhere with a closed 1-vertex curve having 1 edge.
            fallback_orderv = SYSclamp(int(curve_nvertices), 2, 3);
        }
        if (fallback_orderu == 0)
        {
            // Either not auto, or curve was NURBS but all of the cross sections were polygon.
            fallback_orderu = (is_primtype_auto && cross_section_input != nullptr) ? 2 : 4;
        }
        exint cross_section_nvertices = grid_info.myCrossSectionNEdges + (!grid_info.myCrossSectionClosed || grid_info.myCrossSectionUnrolled);
        if (cross_section_nvertices < fallback_orderu)
        {
            // Too few vertices for fallback_orderu
            // Clamp just in case we made a mistake elsewhere with a closed 1-vertex curve having 1 edge.
            fallback_orderu = SYSclamp(int(cross_section_nvertices), 2, 3);
        }
    }
    else if (grid_info.myPrimitiveType == PrimitiveType::BEZIER)
    {
        if (fallback_orderv == 0)
        {
            // Either not auto, or curve was polygon but one of the cross sections was Bezier.
            // Use order 2 if auto, since that's the closest match to polygon,
            // but use order 4 if not auto, since the user specifically chose Bezier.
            fallback_orderv = is_primtype_auto ? 2 : 4;
        }
        if (grid_info.myCurveNEdges % (fallback_orderv-1) != 0)
        {
            // Fall back to order 2, since number of edges isn't correct.
            fallback_orderv = 2;
        }
        if (fallback_orderu == 0)
        {
            // Either not auto, or curve was Bezier but all of the cross sections were polygon.
            fallback_orderu = is_primtype_auto ? 2 : 4;
        }
        if (grid_info.myCrossSectionNEdges % (fallback_orderu-1) != 0)
        {
            // Fall back to order 2, since number of edges isn't correct.
            fallback_orderu = 2;
        }
    }
    grid_info.myBasisOrderCrossSection = fallback_orderu;
    grid_info.myBasisOrderCurve = fallback_orderv;

    // Number of points, taking into account rows/cols that are collapsed into single points.
    num_points = (grid_info.myCurveNEdges + !grid_info.myCurveClosed - 2*exint(grid_info.myVEndPoles))
        * (grid_info.myCrossSectionNEdges + !grid_info.myCrossSectionClosed - 2*exint(grid_info.myUEndPoles))
        + 2*exint(grid_info.myVEndPoles) + 2*exint(grid_info.myUEndPoles);

    return true;
}

template<typename T>
static void
initGUGrid(
    const sop_SweepGrid &grid_info,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const bool swap_row_col,
    const T grid_start_ptnum,

    GU_GridT<T> &grid)
{
    grid.myTriangularPoles = triangular_poles;
    // TODO: Add support to GU_GridT for separate unrolled rows vs. unrolled cols.
    grid.myUnrollCurves = grid_info.myCurveUnrolled || grid_info.myCrossSectionUnrolled;
    grid.mySurfaceType = surface_type;
    using PrimitiveType = typename GU_GridT<T>::PrimitiveType;
    bool is_single_grid_prim = false;
    if (output_points_only)
        grid.myPrimitiveType = PrimitiveType::POINTS;
    else
    {
        grid.myPrimitiveType = PrimitiveType(int(grid_info.myPrimitiveType));
        is_single_grid_prim = (grid.myPrimitiveType != PrimitiveType::POLYGON);
    }

    grid.myFirstColIfNotWrapped = true;
    grid.myLastColIfNotWrapped = true;
    grid.myFirstRowIfNotWrapped = true;
    grid.myLastRowIfNotWrapped = true;
    grid.myCurvesIfBasisRowCol = true;

    const exint nedgerows = swap_row_col ? grid_info.myCrossSectionNEdges : grid_info.myCurveNEdges;
    const exint nedgecols = swap_row_col ? grid_info.myCurveNEdges : grid_info.myCrossSectionNEdges;
    bool vclosed = swap_row_col ? grid_info.myCrossSectionClosed : grid_info.myCurveClosed;
    bool uclosed = swap_row_col ? grid_info.myCurveClosed : grid_info.myCrossSectionClosed;
    bool uendpoles = swap_row_col ? grid_info.myVEndPoles : grid_info.myUEndPoles;
    bool vendpoles = swap_row_col ? grid_info.myUEndPoles : grid_info.myVEndPoles;
    if (is_single_grid_prim)
    {
        const exint nvtxrows = nedgerows + (!vclosed || grid.myUnrollCurves);
        const exint nvtxcols = nedgecols + (!uclosed || grid.myUnrollCurves);
        if (nvtxrows < 2 || nvtxcols < 2)
        {
            is_single_grid_prim = false;
            grid.myPrimitiveType = PrimitiveType::POLYGON;
        }
        else
        {
            unsigned char orderv = swap_row_col ? grid_info.myBasisOrderCrossSection : grid_info.myBasisOrderCurve;
            unsigned char orderu = swap_row_col ? grid_info.myBasisOrderCurve : grid_info.myBasisOrderCrossSection;
            grid.myBasisOrderV = orderv;
            grid.myBasisOrderU = orderu;
        }
    }
    if (vclosed)
    {
        if (uclosed)
            grid.initTorus(nedgerows, nedgecols, grid_start_ptnum);
        else if (!uendpoles)
            grid.initRowTube(nedgerows, nedgecols, grid_start_ptnum);
        else
        {
            grid.myFirstColIfNotWrapped = false;
            grid.myLastColIfNotWrapped = false;
            const exint nmid_points = nedgerows*(nedgecols - 1);
            grid.initRowSphere(nedgerows, nedgecols, grid_start_ptnum, grid_start_ptnum+1+nmid_points, grid_start_ptnum+1);
        }
    }
    else
    {
        if (uclosed)
        {
            if (!vendpoles)
                grid.initColTube(nedgerows, nedgecols, grid_start_ptnum);
            else
            {
                grid.myFirstRowIfNotWrapped = false;
                grid.myLastRowIfNotWrapped = false;
                const exint nmid_points = (nedgerows - 1)*nedgecols;
                grid.initColSphere(nedgerows, nedgecols, grid_start_ptnum, grid_start_ptnum+1+nmid_points, grid_start_ptnum+1);
            }
        }
        else
        {
            if (!vendpoles)
                grid.initSingleGrid(nedgerows, nedgecols, grid_start_ptnum);
            else
            {
                grid.myFirstRowIfNotWrapped = false;
                grid.myLastRowIfNotWrapped = false;
                const exint nmid_points = (nedgerows - 1)*(nedgecols+1);
                grid.initSplitColSphere(nedgerows, nedgecols, grid_start_ptnum, grid_start_ptnum+1+nmid_points, grid_start_ptnum+1);
            }
        }
    }
}

static void
appendPrimTypeCountPair(
    UT_Array<std::pair<int,exint>> &prim_type_count_pairs,
    int primtype,
    exint count)
{
    if (prim_type_count_pairs.isEmpty() || prim_type_count_pairs.last().first != primtype)
    {
        prim_type_count_pairs.append(std::pair<int,exint>(primtype, count));
    }
    else
    {
        prim_type_count_pairs.last().second += count;
    }
}

// NOTE: closed_span_lengths must be non-empty.  It can have an entry with value 0 instead.
//       createGrids always ensures that closed_span_lengths is not empty.
static void
appendClosedSpans(
    UT_Array<exint> &closed_span_lengths,
    bool closed)
{
    // Odd sizes (even indices) are for open polygon counts.
    // Even sizes (odd indices) are for closed polygon counts.
    if (!(closed_span_lengths.size() & 1) == closed)
        ++closed_span_lengths.last();
    else
        closed_span_lengths.append(1);
}

// appends to GEObuildPrimitives arrays, the info for building
// a single grid based on the data in grid_info.
// NOTE: num_grid_prims and num_grid_verts include caps.
static void
appendSingleGridTopology(
    const sop_SweepGrid &grid_info,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const bool single_polygon_caps,
    const bool swap_row_col,

    UT_Array<std::pair<int,exint>> &prim_type_count_pairs,
    //GA_Size &npoints, // npoints should already have been computed for grid_info
    GA_PolyCounts &vertexlistsizelist,
    UT_Array<exint> &vertexpointnumbers,
    UT_Array<exint> &closed_span_lengths,
    GA_Size &num_grid_prims,
    GA_Size &num_grid_verts)
{
    // Before creating the geometry, myStartPtOff is relative,
    // so just an exint, not a true GA_Offset.
    exint grid_start_ptnum = exint(grid_info.myStartPtOff);
    GU_GridT<exint> grid;
    initGUGrid(grid_info, surface_type, output_points_only, triangular_poles, swap_row_col, grid_start_ptnum, grid);

    num_grid_prims = grid.myNumPrimitives;
    num_grid_verts = grid.myNumVertices;

    if (num_grid_prims == 0)
        return;

    bool current_has_polygon_caps = grid_info.myHasPolygonCaps;
    bool is_row_cap = current_has_polygon_caps && grid.myNoWrapV;
    bool is_cross_section_cap = !grid_info.myCrossSectionClosed;
    exint cap_count = current_has_polygon_caps ? 2 : 0;

    int primtype = GA_PRIMPOLY;
    int cap_primtype = GA_PRIMPOLY;
    using PrimitiveType = GU_GridT<exint>::PrimitiveType;
    if (grid.myPrimitiveType == PrimitiveType::NURBS)
    {
        // FIXME: Take into account grid.myCurvesIfBasisRowCol when implemented!!!
        primtype = GA_PRIMNURBSURF;
        cap_primtype = GA_PRIMNURBCURVE;
    }
    else if (grid.myPrimitiveType == PrimitiveType::BEZIER)
    {
        // FIXME: Take into account grid.myCurvesIfBasisRowCol when implemented!!!
        primtype = GA_PRIMBEZSURF;
        cap_primtype = GA_PRIMBEZCURVE;
    }
    else if (grid.myPrimitiveType == PrimitiveType::MESH || grid.myPrimitiveType == PrimitiveType::POLYSOUP)
    {
        primtype = (grid.myPrimitiveType == PrimitiveType::MESH) ? GA_PRIMMESH : GA_PRIMPOLYSOUP;
        cap_primtype = GA_PRIMPOLY;
    }

    if (primtype == GA_PRIMPOLY || cap_count == 0)
    {
        appendPrimTypeCountPair(prim_type_count_pairs, primtype, num_grid_prims + cap_count);
    }
    else
    {
        appendPrimTypeCountPair(prim_type_count_pairs, cap_primtype, 1);
        appendPrimTypeCountPair(prim_type_count_pairs, primtype, num_grid_prims);
        appendPrimTypeCountPair(prim_type_count_pairs, cap_primtype, 1);
    }

    exint cap_vertex_count = 0;
    if (current_has_polygon_caps)
        cap_vertex_count = is_row_cap ? grid.myNumEdgeCols : grid.myNumEdgeRows;
    auto &&add_polygon_cap_functor = [is_row_cap,cap_vertex_count,swap_row_col,is_cross_section_cap,&grid,&vertexlistsizelist,&closed_span_lengths,&vertexpointnumbers](bool last_cap)
    {
        vertexlistsizelist.append(cap_vertex_count);

        // Single polygon caps are closed.
        appendClosedSpans(closed_span_lengths, true);

        const exint old_size = vertexpointnumbers.size();
        vertexpointnumbers.bumpSize(old_size + cap_vertex_count);
        exint *vertexpointnumber_start = vertexpointnumbers.getArray() + old_size;
        if (is_row_cap)
        {
            // First or last row
            exint row = last_cap ? grid.myNumEdgeRows : 0;
            for (exint col = 0; col < cap_vertex_count; ++col)
            {
                exint point_col = ((last_cap != swap_row_col) != is_cross_section_cap) ? col : reverseVtx(col, cap_vertex_count, true);
                vertexpointnumber_start[col] = grid.getPoint(row, point_col);
            }
        }
        else
        {
            // First or last column
            exint col = last_cap ? grid.myNumEdgeCols : 0;
            for (exint row = 0; row < cap_vertex_count; ++row)
            {
                exint point_row = ((last_cap != swap_row_col) != is_cross_section_cap) ? row : reverseVtx(row, cap_vertex_count, true);
                vertexpointnumber_start[row] = grid.getPoint(point_row, col);
            }
        }
    };
    if (current_has_polygon_caps)
    {
        // Start cap comes before main grid
        add_polygon_cap_functor(false);
    }

    // Add main grid primitives
    GUiterateGridPrimitives(grid,
        [&vertexlistsizelist,&closed_span_lengths
#if UT_ASSERT_LEVEL >= UT_ASSERT_LEVEL_PARANOID
        ,num_grid_prims
#endif
        ](exint primnum, exint row, exint col, exint primvtxcount, bool closed)
    {
        UT_ASSERT_P(primnum >= 0 && primnum < num_grid_prims);
        vertexlistsizelist.append(primvtxcount);

        appendClosedSpans(closed_span_lengths, closed);
    });

    const exint old_size = vertexpointnumbers.size();
    vertexpointnumbers.bumpSize(old_size + grid.myNumVertices);
    exint *vertexpointnumber_start = vertexpointnumbers.getArray() + old_size;
    GUiterateGridVertices(grid,
        [vertexpointnumber_start,&grid](exint vtxnum, exint row, exint col, bool isrowend, bool iscolend, exint primnum, exint primvtxnum)
    {
        UT_ASSERT_P(vtxnum >= 0 && vtxnum < grid.myNumVertices);
        vertexpointnumber_start[vtxnum] = grid.getPoint(row+exint(isrowend),col+exint(iscolend));
    });

    if (current_has_polygon_caps)
    {
        // End cap comes after main grid
        add_polygon_cap_functor(true);
    }

    // Make sure that caps are counted in num_grid_prims and num_grid_verts,
    // so that the caller knows the total for this grid (including caps).
    num_grid_prims += cap_count;
    num_grid_verts += 2*cap_vertex_count;
}

static void
initNonPolyGridPrims(
    const sop_SweepGrid &grid_info,
    const GU_GridT<GA_Offset> &grid,
    const bool swap_row_col,
    const GA_Basis *source_basisu,
    const GA_Basis *source_basisv,
    GEO_Detail *output_geo)
{
    using PrimitiveType = GU_GridT<GA_Offset>::PrimitiveType;
    if (grid.myPrimitiveType == PrimitiveType::POLYGON ||
        grid.myPrimitiveType == PrimitiveType::POINTS)
        return;

    GA_Offset primoff = grid_info.myStartPrimOff;
    if (grid_info.myHasPolygonCaps)
        ++primoff;

    GA_Primitive *prim = output_geo->getPrimitive(primoff);
    const exint nedgerows = grid.myNumEdgeRows;
    const exint nedgecols = grid.myNumEdgeCols;
    const bool hull_wrapv = grid.myAllWrapV && !grid.myUnrollCurves;
    const bool hull_wrapu = grid.myAllWrapU && !grid.myUnrollCurves;
    const exint nvtxrows = nedgerows + exint(!hull_wrapv);
    const exint nvtxcols = nedgecols + exint(!hull_wrapu);

    if (grid.myPrimitiveType == PrimitiveType::POLYSOUP)
    {
        GEO_PrimPolySoup *polysoup = UTverify_cast<GEO_PrimPolySoup *>(prim);

        // Iterate over the internal polygons
        sop_SweepGrid polygrid_info(grid_info);
        polygrid_info.myPrimitiveType = sop_SweepGrid::PrimitiveType::POLYGON;
        GU_GridT<GA_Offset> polygrid;
        initGUGrid(polygrid_info, grid.mySurfaceType, false, grid.myTriangularPoles, swap_row_col, polygrid_info.myStartPtOff, polygrid);

        GA_PolyCounts polygonsizes;
        GUiterateGridPrimitives(polygrid,
            [&polygonsizes](exint primnum, exint row, exint col, exint primvtxcount, bool closed)
        {
            polygonsizes.append(primvtxcount, 1);
        });

        // Preallocate memory for polygonvertexlist,
        // since it's unlikely to be trivial-compressed anyway.
        GA_OffsetList polygonvertexlist;
        polygonvertexlist.harden(polygrid.myNumVertices);

        // The following comment and two bool definitions were copied from GUiterateGridVertices.
        // "Unroll" in this case allows for UV seams.
        // FIXME: Does this need to take into account myFirstRowIfNotWrapped,
        //        myLastRowIfNotWrapped, myFirstColIfNotWrapped, myLastColIfNotWrapped
        //        if surface_type is rows or cols or rowcol?
        const bool has_endrow = grid.myNoWrapV || grid.myUnrollCurves;
        const bool has_endcol = grid.myNoWrapU || grid.myUnrollCurves;
        const exint nvtxcols = grid.myNumEdgeCols + exint(has_endcol);

        // Remember that the polygon soup primitive's vertices start after the first cap.
        exint cap_vertex_count = 0;
        if (grid_info.myHasPolygonCaps)
        {
            cap_vertex_count = !grid_info.myCurveClosed ? grid_info.myCrossSectionNEdges : grid_info.myCurveNEdges;
        }
        const GA_Offset start_vtxoff = grid_info.myStartVtxOff + cap_vertex_count;
        GUiterateGridVertices(polygrid,
            [&polygonvertexlist,start_vtxoff,&grid,has_endrow,has_endcol,nvtxcols](exint vtxnum, exint row, exint col,
                bool isrowend, bool iscolend, exint primnum, exint primvtxnum)
        {
            // NOTE: vtxnum is the vtxnum if it were polygons, but we need the vtxnum within the soup.
            if (isrowend)
            {
                if (!has_endrow && row == grid.myNumEdgeRows-1)
                    row = 0;
                else
                    ++row;
            }
            if (iscolend)
            {
                if (!has_endcol && col == grid.myNumEdgeCols-1)
                    col = 0;
                else
                    ++col;
            }
            exint soupvtxnum = row*nvtxcols + col;
            polygonvertexlist.append(start_vtxoff + soupvtxnum);
        });

        // This initializes GEO_PrimPolySoup::myPolygonSizes and myPolygonVertexList
        polysoup->appendPolygons(polygonsizes, polygonvertexlist);

        return;
    }

    // Bilinear mesh, NURBS surface, or Bezier surface
    GEO_Hull *hull = UTverify_cast<GEO_Hull *>(prim);
    hull->initHullData(nvtxrows, nvtxcols, hull_wrapv, hull_wrapu);
    hull->setSurfaceType(grid.mySurfaceType);

    const bool is_nurbs = (grid.myPrimitiveType == PrimitiveType::NURBS);
    const bool is_bezier = (grid.myPrimitiveType == PrimitiveType::BEZIER);
    if (!is_nurbs && !is_bezier)
        return;

    GEO_TPSurf *tpsurf = UTverify_cast<GEO_TPSurf *>(hull);

    GA_Basis *basisu = nullptr;
    GA_Basis *basisv = nullptr;

    GA_BASIS_TYPE basis_type = is_nurbs ? GA_NURBS_BASIS : GA_BEZIER_BASIS;
    if (source_basisu != nullptr && source_basisu->getType() != basis_type)
        source_basisu = nullptr;
    if (source_basisv != nullptr && source_basisv->getType() != basis_type)
        source_basisv = nullptr;

    // Copy any source basis
    if (source_basisu != nullptr)
    {
        basisu = GA_Basis::newSpecies(basis_type);
        basisu->copyFrom(*source_basisu);

        tpsurf->setUBasis(basisu);
        // NOTE: The "Ensure Unique Seam Vertices" option might mean
        //       the source basis isn't valid for the target.
        if (!tpsurf->getUBasis())
        {
            delete basisu;
            basisu = nullptr;
        }
    }
    if (source_basisv != nullptr)
    {
        basisv = GA_Basis::newSpecies(basis_type);
        basisv->copyFrom(*source_basisv);

        tpsurf->setVBasis(basisv);
        // NOTE: The "Ensure Unique Seam Vertices" option might mean
        //       the source basis isn't valid for the target.
        if (!tpsurf->getVBasis())
        {
            delete basisv;
            basisv = nullptr;
        }
    }

    if (is_nurbs)
    {
        auto &&make_nurbs_basis = [](exint nvertices, int order, bool closed) -> GA_NUBBasis*
        {
            // For now, we never end-interpolate closed cases.
            bool interpolate_ends = !closed;
            int extra_knots = order + (closed ? (interpolate_ends ? 1 : (order - 1)) : 0);
            // Number of knots = cvs+order.
            // However, if closed we need to add yet a few more knots:
            // 1 if interpEnds and order-1 otherwise
            return new GA_NUBBasis(0, 1,
                (nvertices + extra_knots),
                order,
                interpolate_ends);
        };

        if (basisu == nullptr)
        {
            basisu = make_nurbs_basis(nvtxcols, grid.myBasisOrderU, hull_wrapu);
            tpsurf->setUBasis(basisu);
            UT_ASSERT(tpsurf->getUBasis() != nullptr);
        }
        if (basisv == nullptr)
        {
            basisv = make_nurbs_basis(nvtxrows, grid.myBasisOrderV, hull_wrapv);
            tpsurf->setVBasis(basisv);
            UT_ASSERT(tpsurf->getVBasis() != nullptr);
        }
    }
    else
    {
        UT_ASSERT(is_bezier);

        auto &&make_bez_basis = [](exint nvertices, int order, bool closed) -> GA_BezBasis*
        {
            int extra = ((nvertices > 2 && order > 2) || (order <= 2 && closed));
            return new GA_BezBasis(0, 1,
                extra + (nvertices / (order - 1)),
                order);
        };
        if (basisu == nullptr)
        {
            basisu = make_bez_basis(nvtxcols, grid.myBasisOrderU, hull_wrapu);
            tpsurf->setUBasis(basisu);
            UT_ASSERT(tpsurf->getUBasis() != nullptr);
        }
        if (basisv == nullptr)
        {
            basisv = make_bez_basis(nvtxrows, grid.myBasisOrderV, hull_wrapv);
            tpsurf->setVBasis(basisv);
            UT_ASSERT(tpsurf->getVBasis() != nullptr);
        }
    }

    // setUBasis and setVBasis should always have succeeded,
    // because we created the bases correctly.
    UT_ASSERT(tpsurf->getUBasis() != nullptr);
    UT_ASSERT(tpsurf->getVBasis() != nullptr);

    if (grid_info.myHasPolygonCaps)
    {
        const bool side_caps = !grid_info.myCrossSectionClosed;
        const GA_Basis *cap_source_basis = (swap_row_col != side_caps) ? basisv : basisu;
        // Copy the U basis for each of the cap curves.
        GA_Basis *cap0_basis = GA_Basis::newSpecies(cap_source_basis->getType());
        GA_Basis *cap1_basis = GA_Basis::newSpecies(cap_source_basis->getType());
        cap0_basis->copyFrom(*cap_source_basis);
        cap1_basis->copyFrom(*cap_source_basis);
        // The caps are just before and just after the surface primitive.
        GEO_Curve *cap0 = UTverify_cast<GEO_Curve *>(output_geo->getPrimitive(primoff-1));
        GEO_Curve *cap1 = UTverify_cast<GEO_Curve *>(output_geo->getPrimitive(primoff+1));
        cap0->setBasis(cap0_basis);
        cap1->setBasis(cap1_basis);
    }
}

static bool
createGrids(
    const GEO_Detail *cross_section_input,
    const GA_PrimitiveGroup *cross_section_group,
    SurfaceShape cross_section_shape,
    exint cross_section_nedges,
    const CopyOrder copy_order,
    const CrossSectionAttribMatchData *const copy_order_attrib_data,

    const GEO_Detail *curve_input,
    const GA_PrimitiveGroup *curve_group,
    const bool closed_if_no_curve_input,

    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool unroll_closed_row_col,
    const int primitive_type,
    const EndCapType end_cap_type,
    const exint cap_divisions,
    const bool triangular_poles,
    const bool swap_row_col,

    GEO_Detail *output_geo,
    UT_Array<sop_SweepGrid> &grids)
{
    // Clear the array of grids.
    grids.setCapacity(0);

    // Destroy whatever was in the previous detail.
    output_geo->clearAndDestroy();

    UT_AutoInterrupt interrupt("Computing surface topology");
    if (interrupt.wasInterrupted())
        return false;

    // These arrays keep a pointer to the U or V basis of each grid,
    // if there are NURBS/Bezier curves or cross sections.
    UT_Array<const GA_Basis*> grid_basisus;
    UT_Array<const GA_Basis*> grid_basisvs;
    if (cross_section_input != nullptr && (
        cross_section_input->countPrimitiveType(GA_PRIMNURBCURVE) != 0 ||
        cross_section_input->countPrimitiveType(GA_PRIMBEZCURVE) != 0))
    {
        // Some grids may be invalid, so this will sometimes overallocate, but should be fine.
        exint max_num_grids = 1;
        if (curve_input != nullptr)
            max_num_grids = curve_group ? curve_group->entries() : curve_input->getNumPrimitives();
        grid_basisus.setSizeNoInit(max_num_grids);
        grid_basisus.constant(nullptr);
    }
    if (curve_input != nullptr && (
        curve_input->countPrimitiveType(GA_PRIMNURBCURVE) != 0 ||
        curve_input->countPrimitiveType(GA_PRIMBEZCURVE) != 0))
    {
        // Some grids may be invalid, so this will sometimes overallocate, but should be fine.
        const exint max_num_grids = curve_group ? curve_group->entries() : curve_input->getNumPrimitives();
        grid_basisvs.setSizeNoInit(max_num_grids);
        grid_basisvs.constant(nullptr);
    }

    bool single_cross_section = true;
    GA_Offset single_cross_section_primoff = GA_INVALID_OFFSET;
    bool cross_section_closed = (cross_section_shape == SurfaceShape::TUBE || cross_section_shape == SurfaceShape::SQUARE);
    bool cross_section_unrolled = false;
    GA_Range cross_section_range;
    if (cross_section_input != nullptr)
    {
        // If cross_section_group is null, this will be the whole range of primitives.
        cross_section_range = cross_section_input->getPrimitiveRange(cross_section_group);
        GA_Size ncross_sections = cross_section_range.getEntries();
        if (ncross_sections == 0)
        {
            // Nothing to do if no cross sections.
            // We must exit early, because code below assumes that there's
            // at least one cross section.
            return true;
        }
        // If selecting cross sections by attribute, there may be some invalid selections
        // that must be handled, even if there's only one valid selection.
        single_cross_section = (cross_section_range.getEntries() == 1 && copy_order != CopyOrder::ATTRIB);
        if (single_cross_section)
        {
            // Special case for a single cross section, since
            // it's a common case, and can be faster.
            GA_Iterator it(cross_section_range);
            UT_ASSERT(!it.atEnd());
            single_cross_section_primoff = *it;
            bool nonempty = getPolyProperties(cross_section_input, single_cross_section_primoff,
                cross_section_nedges, cross_section_closed, cross_section_unrolled);
            if (!nonempty)
                return true;
        }
    }

    GA_Iterator cross_section_it;
    if (!single_cross_section || curve_input == nullptr)
        cross_section_it = GA_Iterator(cross_section_range);

    const bool is_primtype_auto = !output_points_only && (primitive_type == GA_PRIMNONE);

    UT_SmallArray<std::pair<int,exint>,sizeof(std::pair<int,exint>)> prim_type_count_pairs;
    GA_PolyCounts vertexlistsizelist;
    UT_Array<exint> vertexpointnumbers;
    UT_SmallArray<exint,2*sizeof(exint)> closed_span_lengths;
    // Code in appendSingleGridTopology requires at least one initial entry in closed_span_lengths.
    closed_span_lengths.append(0);

    // TODO: If it's worthwhile for the no shared points case,
    //       take into account unrolling to determine hassharedpoints accurately.
    bool hassharedpoints = true;//(!output_points_only && surface_type != GEO_PATCH_COLS && surface_type != GEO_PATCH_ROWS);
    exint total_num_points = 0;
    exint total_num_verts = 0;
    exint total_num_prims = 0;
    if (curve_input == nullptr)
    {
        // No curve input, so just one grid of all cross sections.
        UT_ASSERT(cross_section_input != nullptr);

        UT_ASSERT(grid_basisvs.size() == 0);

        int local_primitive_type = primitive_type;
        unsigned char fallback_orderu = 0;
        unsigned char fallback_orderv;
        initPrimType(
            output_points_only,
            is_primtype_auto,
            local_primitive_type,
            fallback_orderv,
            nullptr,
            nullptr, GA_INVALID_OFFSET); // curve

        const GA_Basis **pbasisu = grid_basisus.isEmpty() ? nullptr : &grid_basisus[0];

        sop_SweepGrid grid_info;
        exint num_points;
        bool valid_grid = computeSingleGridSetup(
            cross_section_input,
            cross_section_group,
            false, // single_cross_section
            cross_section_it,
            GA_INVALID_OFFSET,
            0, false, false, CopyOrder::CYCLEVTX, nullptr, false, nullptr, // unused
            nullptr, GA_INVALID_OFFSET, // curve
            closed_if_no_curve_input,
            surface_type, output_points_only,
            unroll_closed_row_col,
            is_primtype_auto,
            local_primitive_type,
            fallback_orderu, fallback_orderv,
            pbasisu,
            end_cap_type,
            cap_divisions,
            grid_info, num_points);

        if (!valid_grid)
            return true;

        grid_info.myStartPtOff = GA_Offset(0);
        total_num_points = num_points;

        exint num_grid_prims;
        exint num_grid_verts;
        appendSingleGridTopology(
            grid_info, surface_type, output_points_only, triangular_poles,
            grid_info.myHasPolygonCaps, swap_row_col,
            prim_type_count_pairs, vertexlistsizelist, vertexpointnumbers,
            closed_span_lengths, num_grid_prims, num_grid_verts);

        grid_info.myStartVtxOff = GA_Offset(0);
        total_num_verts = num_grid_verts;
        grid_info.myStartPrimOff = GA_Offset(0);
        total_num_prims = num_grid_prims;
        grids.append(std::move(grid_info));
    }
    else if (!single_cross_section && copy_order == CopyOrder::EACH)
    {
        // For each cross section, loop over all curves.
        // FIXME: Parallelize this!!!
        for (; !cross_section_it.atEnd(); ++cross_section_it)
        {
            GA_Offset cross_section_primoff = *cross_section_it;

            bool nonempty = getPolyProperties(cross_section_input, cross_section_primoff,
                cross_section_nedges, cross_section_closed, cross_section_unrolled);
            if (!nonempty)
                continue;

            GA_Offset start;
            GA_Offset end;
            for (GA_Iterator it(curve_input->getPrimitiveRange(curve_group)); it.blockAdvance(start, end); )
            {
                if (interrupt.wasInterrupted())
                    return false;

                GA_Iterator invalid_it;

                for (GA_Offset curve_primoff = start; curve_primoff < end; ++curve_primoff)
                {
                    const exint gridi = grids.size();
                    const GA_Basis **pbasisu = grid_basisus.isEmpty() ? nullptr : &grid_basisus[gridi];
                    const GA_Basis **pbasisv = grid_basisvs.isEmpty() ? nullptr : &grid_basisvs[gridi];

                    int local_primitive_type = primitive_type;
                    unsigned char fallback_orderu = 0;
                    unsigned char fallback_orderv;
                    initPrimType(
                        output_points_only,
                        is_primtype_auto,
                        local_primitive_type,
                        fallback_orderv,
                        pbasisv,
                        curve_input,
                        curve_primoff);

                    // Single cross section, so primitive type must be handled in advance.
                    if (is_primtype_auto && cross_section_input != nullptr)
                        updateAutoPrimType(cross_section_input, cross_section_primoff, local_primitive_type, fallback_orderu, pbasisu);

                    sop_SweepGrid grid_info;
                    exint num_points;
                    bool valid_grid = computeSingleGridSetup(
                        nullptr, nullptr, // cross section resolved above
                        true,   // single_cross_section for this grid
                        invalid_it,
                        cross_section_primoff,
                        cross_section_nedges,
                        cross_section_closed,
                        cross_section_unrolled,
                        copy_order,
                        nullptr,// copy_order_attrib_data unused
                        false,  // varying_nedges_all_case unused
                        nullptr,// cross_section_primoffs_all_case unused
                        curve_input, curve_primoff,
                        false,  // closed_if_no_curve_input unused
                        surface_type,
                        output_points_only,
                        unroll_closed_row_col,
                        is_primtype_auto,
                        local_primitive_type,
                        fallback_orderu, fallback_orderv,
                        pbasisu,
                        end_cap_type,
                        cap_divisions,
                        grid_info,
                        num_points);

                    if (!valid_grid)
                        continue;

                    grid_info.myStartPtOff = GA_Offset(total_num_points);
                    total_num_points += num_points;

                    exint num_grid_prims;
                    exint num_grid_verts;
                    appendSingleGridTopology(
                        grid_info, surface_type, output_points_only, triangular_poles,
                        grid_info.myHasPolygonCaps, swap_row_col,
                        prim_type_count_pairs, vertexlistsizelist, vertexpointnumbers,
                        closed_span_lengths, num_grid_prims, num_grid_verts);

                    grid_info.myStartVtxOff = GA_Offset(total_num_verts);
                    total_num_verts += num_grid_verts;
                    grid_info.myStartPrimOff = GA_Offset(total_num_prims);
                    total_num_prims += num_grid_prims;
                    grids.append(std::move(grid_info));
                }
            }
        }
    }
    else if (!single_cross_section && (copy_order == CopyOrder::CYCLEPR ||
        (copy_order == CopyOrder::ATTRIB &&
            (copy_order_attrib_data->myCurveAttribOwner == GA_ATTRIB_DETAIL ||
                copy_order_attrib_data->myCurveAttribOwner == GA_ATTRIB_PRIMITIVE))))
    {
        // CopyOrder::CYCLEPR means "For each curve, pick the next cross section."
        // CopyOrder::ATTRIB has primitive or detail attribute on curve input selecting the cross section primitives in this case.
        GA_AttributeOwner curve_attrib_owner = (copy_order == CopyOrder::ATTRIB) ? copy_order_attrib_data->myCurveAttribOwner : GA_ATTRIB_INVALID;
        GA_Offset cross_section_primoff;
        if (curve_attrib_owner == GA_ATTRIB_DETAIL)
        {
            cross_section_primoff = lookupCrossSectionFromAttrib(copy_order_attrib_data,
                GA_DETAIL_OFFSET, cross_section_input, cross_section_group);
            // If no cross section for this detail, skip
            if (!GAisValid(cross_section_primoff))
                return true;
            bool nonempty = getPolyProperties(cross_section_input, cross_section_primoff,
                cross_section_nedges, cross_section_closed, cross_section_unrolled);
            if (!nonempty)
                return true;
        }

        GA_Offset start;
        GA_Offset end;
        for (GA_Iterator it(curve_input->getPrimitiveRange(curve_group)); it.blockAdvance(start, end); )
        {
            if (interrupt.wasInterrupted())
                return false;

            GA_Iterator invalid_it;

            for (GA_Offset curve_primoff = start; curve_primoff < end; ++curve_primoff)
            {
                if (copy_order == CopyOrder::CYCLEPR)
                {
                    cross_section_primoff = *cross_section_it;
                    ++cross_section_it;
                    if (cross_section_it.atEnd())
                    {
                        cross_section_it.rewind();
                        UT_ASSERT(!cross_section_it.atEnd());
                    }
                }
                else if (curve_attrib_owner == GA_ATTRIB_PRIMITIVE)
                {
                    cross_section_primoff = lookupCrossSectionFromAttrib(copy_order_attrib_data,
                        curve_primoff, cross_section_input, cross_section_group);
                    // If no cross section for this curve, skip
                    if (!GAisValid(cross_section_primoff))
                        continue;
                }

                if (curve_attrib_owner != GA_ATTRIB_DETAIL)
                {
                    bool nonempty = getPolyProperties(cross_section_input, cross_section_primoff,
                        cross_section_nedges, cross_section_closed, cross_section_unrolled);
                    if (!nonempty)
                        continue;
                }

                const exint gridi = grids.size();
                const GA_Basis **pbasisu = grid_basisus.isEmpty() ? nullptr : &grid_basisus[gridi];
                const GA_Basis **pbasisv = grid_basisvs.isEmpty() ? nullptr : &grid_basisvs[gridi];

                int local_primitive_type = primitive_type;
                unsigned char fallback_orderu = 0;
                unsigned char fallback_orderv;
                initPrimType(
                    output_points_only,
                    is_primtype_auto,
                    local_primitive_type,
                    fallback_orderv,
                    pbasisv,
                    curve_input,
                    curve_primoff);

                // Single cross section, so primitive type must be handled in advance.
                if (is_primtype_auto && cross_section_input != nullptr)
                    updateAutoPrimType(cross_section_input, cross_section_primoff, local_primitive_type, fallback_orderu, pbasisu);

                sop_SweepGrid grid_info;
                exint num_points;
                bool valid_grid = computeSingleGridSetup(
                    nullptr, nullptr, // cross section resolved above
                    true,   // single_cross_section for this grid
                    invalid_it,
                    cross_section_primoff,
                    cross_section_nedges,
                    cross_section_closed,
                    cross_section_unrolled,
                    copy_order,
                    nullptr,// copy_order_attrib_data unused
                    false,  // varying_nedges_all_case unused
                    nullptr,// cross_section_primoffs_all_case unused
                    curve_input, curve_primoff,
                    false,  // closed_if_no_curve_input unused
                    surface_type, output_points_only,
                    unroll_closed_row_col,
                    is_primtype_auto,
                    local_primitive_type,
                    fallback_orderu, fallback_orderv,
                    pbasisu,
                    end_cap_type,
                    cap_divisions,
                    grid_info, num_points);

                if (!valid_grid)
                    continue;

                grid_info.myStartPtOff = GA_Offset(total_num_points);
                total_num_points += num_points;

                exint num_grid_prims;
                exint num_grid_verts;
                appendSingleGridTopology(
                    grid_info, surface_type, output_points_only, triangular_poles,
                    grid_info.myHasPolygonCaps, swap_row_col,
                    prim_type_count_pairs, vertexlistsizelist, vertexpointnumbers,
                    closed_span_lengths, num_grid_prims, num_grid_verts);

                grid_info.myStartVtxOff = GA_Offset(total_num_verts);
                total_num_verts += num_grid_verts;
                grid_info.myStartPrimOff = GA_Offset(total_num_prims);
                total_num_prims += num_grid_prims;
                grids.append(std::move(grid_info));
            }
        }
    }
    else
    {
        unsigned char fallback_orderu = 0;
        int cross_section_primitive_type = is_primtype_auto ? GA_PRIMPOLY : primitive_type;
        bool varying_nedges_all_case = false;
        GA_OffsetList cross_section_primoffs_all_case;
        const bool all_case = (!single_cross_section && copy_order == CopyOrder::ALL);
        const GA_Basis *all_case_grid_basisu = nullptr;
        if (all_case)
        {
            // At each vertex, we'll want all cross sections.
            // To avoid having to recompute the cross section properties for every vertex,
            // iterate through all cross sections in advance.
            exint num_cross_sections = (cross_section_group ? cross_section_group->entries() : cross_section_input->getNumPrimitives());

            bool is_valid_grid = computeCombinedCrossSectionProperties(
                cross_section_input,
                cross_section_group,
                cross_section_it,
                num_cross_sections,
                cross_section_nedges,
                cross_section_closed,
                cross_section_unrolled,
                varying_nedges_all_case,
                cross_section_primoffs_all_case,
                is_primtype_auto,
                cross_section_primitive_type,
                fallback_orderu,
                &all_case_grid_basisu);

            if (!is_valid_grid)
                return true;
        }

        // FIXME: Parallelize this!!!
        GA_Offset start;
        GA_Offset end;
        for (GA_Iterator it(curve_input->getPrimitiveRange(curve_group)); it.blockAdvance(start, end); )
        {
            if (interrupt.wasInterrupted())
                return false;

            for (GA_Offset curve_primoff = start; curve_primoff < end; ++curve_primoff)
            {
                const exint gridi = grids.size();
                const GA_Basis **pbasisu = grid_basisus.isEmpty() ? nullptr : &grid_basisus[gridi];
                const GA_Basis **pbasisv = grid_basisvs.isEmpty() ? nullptr : &grid_basisvs[gridi];

                int local_primitive_type = primitive_type;
                unsigned char fallback_orderv;
                initPrimType(
                    output_points_only,
                    is_primtype_auto,
                    local_primitive_type,
                    fallback_orderv,
                    pbasisv,
                    curve_input,
                    curve_primoff);

                // If single cross section, primitive type must be handled in advance.
                if (single_cross_section && is_primtype_auto && cross_section_input != nullptr)
                    updateAutoPrimType(cross_section_input, single_cross_section_primoff, local_primitive_type, fallback_orderu, pbasisu);
                else if (all_case && local_primitive_type != GA_PRIMNURBSURF)
                {
                    if (cross_section_primitive_type == GA_PRIMNURBSURF || cross_section_primitive_type == GA_PRIMBEZSURF)
                        local_primitive_type = cross_section_primitive_type;
                }

                if (all_case && pbasisu != nullptr)
                {
                    // In the all cross sections at each vertex case,
                    // all grids have the same U basis.
                    *pbasisu = all_case_grid_basisu;
                }

                sop_SweepGrid grid_info;
                exint num_points;
                bool valid_grid = computeSingleGridSetup(
                    cross_section_input,
                    cross_section_group,
                    single_cross_section,
                    cross_section_it,
                    single_cross_section_primoff,
                    cross_section_nedges,
                    cross_section_closed,
                    cross_section_unrolled,
                    copy_order,
                    copy_order_attrib_data,
                    varying_nedges_all_case,
                    (cross_section_primoffs_all_case.size() == 0) ? nullptr : &cross_section_primoffs_all_case,
                    curve_input, curve_primoff,
                    closed_if_no_curve_input,
                    surface_type, output_points_only,
                    unroll_closed_row_col,
                    is_primtype_auto,
                    local_primitive_type,
                    fallback_orderu, fallback_orderv,
                    pbasisu,
                    end_cap_type,
                    cap_divisions,
                    grid_info, num_points);

                if (!valid_grid)
                    continue;

                grid_info.myStartPtOff = GA_Offset(total_num_points);
                total_num_points += num_points;

                exint num_grid_prims;
                exint num_grid_verts;
                appendSingleGridTopology(
                    grid_info, surface_type, output_points_only, triangular_poles,
                    grid_info.myHasPolygonCaps, swap_row_col,
                    prim_type_count_pairs, vertexlistsizelist, vertexpointnumbers,
                    closed_span_lengths, num_grid_prims, num_grid_verts);

                grid_info.myStartVtxOff = GA_Offset(total_num_verts);
                total_num_verts += num_grid_verts;
                grid_info.myStartPrimOff = GA_Offset(total_num_prims);
                total_num_prims += num_grid_prims;
                grids.append(std::move(grid_info));
            }
        }
    }

    if (interrupt.wasInterrupted())
        return false;

    // Create the geometry in output_geo
    GA_Offset start_ptoff = output_geo->appendPointBlock(total_num_points);
    GA_Offset start_vtxoff = GA_INVALID_OFFSET;
    GA_Offset start_primoff = GA_INVALID_OFFSET;
    if (output_points_only)
        output_geo->bumpDataIdsForAddOrRemove(true, false, false);
    else
    {
        start_primoff = GEObuildPrimitives(
            output_geo,
            prim_type_count_pairs.getArray(),
            start_ptoff, total_num_points,
            vertexlistsizelist, vertexpointnumbers.getArray(),
            hassharedpoints,
            closed_span_lengths.getArray());
        if (output_geo->getNumVertices() != 0)
            start_vtxoff = output_geo->vertexOffset(GA_Index(0));

        output_geo->bumpDataIdsForAddOrRemove(true, true, true);
    }

    // NOTE: Since there was never anything else in the detail, start_ptoff,
    //       start_primoff, and start_vtxoff should all be GA_Offset(0),
    //       but just in case we ever have anything before it, we'll write
    //       the code as if they could be anything.

    // Adjust all myStartPtOff, myStartVtxOff, and myStartPrimOff if starts aren't zero.
    if (start_ptoff != GA_Offset(0))
    {
        for (exint gridi = 0, num_grids = grids.size(); gridi < num_grids; ++gridi)
        {
            grids[gridi].myStartPtOff += start_ptoff;
        }
    }
    if (start_vtxoff != GA_INVALID_OFFSET && start_vtxoff != GA_Offset(0))
    {
        for (exint gridi = 0, num_grids = grids.size(); gridi < num_grids; ++gridi)
        {
            grids[gridi].myStartVtxOff += start_vtxoff;
        }
    }
    if (start_primoff != GA_INVALID_OFFSET && start_primoff != GA_Offset(0))
    {
        for (exint gridi = 0, num_grids = grids.size(); gridi < num_grids; ++gridi)
        {
            grids[gridi].myStartPrimOff += start_primoff;
        }
    }

    if (output_geo->getNumPrimitives() != output_geo->countPrimitiveType(GA_PRIMPOLY))
    {
        // There are non-polygon primitives, so we must initialize
        // primitive member data.
        for (exint gridi = 0, num_grids = grids.size(); gridi < num_grids; ++gridi)
        {
            const sop_SweepGrid &grid_info = grids[gridi];
            GU_GridT<GA_Offset> grid;
            initGUGrid(grid_info, surface_type, output_points_only, triangular_poles, swap_row_col, grid_info.myStartPtOff, grid);
            const GA_Basis *basisu = grid_basisus.isEmpty() ? nullptr : grid_basisus[gridi];
            const GA_Basis *basisv = grid_basisvs.isEmpty() ? nullptr : grid_basisvs[gridi];
            if (grid.myPrimitiveType != GU_GridT<GA_Offset>::PrimitiveType::POLYGON)
            {
                initNonPolyGridPrims(grid_info, grid, swap_row_col, basisu, basisv, output_geo);
            }
        }
    }

    return true;
}

template<typename FUNCTOR>
static void
copyVertexCrossSectionWrapper(
    const GU_GridT<GA_Offset> &grid,
    const sop_SweepGrid &grid_info,
    const FUNCTOR &functor)
{
    // FIXME: Is this function producing correct results when swap_row_col is true???!!!

    exint cap_vertex_count = 0;
    if (grid_info.myHasPolygonCaps)
    {
        if (grid.myNoWrapV)
        {
            // First row cap
            cap_vertex_count = grid.myNumEdgeCols;

            for (exint col = 0; col < cap_vertex_count; ++col)
            {
                // First cap is reversed
                functor(grid_info.myStartVtxOff + col, 0, reverseVtx(col, cap_vertex_count, true));
            }
        }
        else
        {
            // First side col cap
            cap_vertex_count = grid.myNumEdgeRows;

            for (exint row = 0; row < cap_vertex_count; ++row)
            {
                // First cap is reversed
                functor(grid_info.myStartVtxOff + row, reverseVtx(row, cap_vertex_count, true), 0);
            }
        }
    }
    // Main grid vertices
    const GA_Offset start_vtxoff = grid_info.myStartVtxOff + cap_vertex_count;
    auto &&functor_wrapper = [&functor,start_vtxoff](exint vtxnum, exint row, exint col, bool isrowend, bool iscolend, exint primnum, exint primvtxnum)
    {
        GA_Offset output_vtxoff = start_vtxoff + vtxnum;
        functor(output_vtxoff, row + exint(isrowend), col + exint(iscolend));
    };
    GUiterateGridVertices(grid, functor_wrapper);
    if (grid_info.myHasPolygonCaps)
    {
        // Last cap starts after main grid
        const GA_Offset cap_start_vtxoff = start_vtxoff + grid.myNumVertices;
        if (grid.myNoWrapV)
        {
            // Last row cap
            for (exint col = 0; col < cap_vertex_count; ++col)
            {
                functor(cap_start_vtxoff + col, grid.myNumEdgeRows, col);
            }
        }
        else
        {
            // Last side col cap
            for (exint row = 0; row < cap_vertex_count; ++row)
            {
                functor(cap_start_vtxoff + row, row, grid.myNumEdgeCols);
            }
        }
    }
}

template<typename TRANSFORM_T,GA_AttributeOwner output_attrib_owner,bool wrap_to_invalid=false,typename OUTPUT_ATTRIB_T,typename INPUT_ATTRIB_T,typename GET_TRANSFORM_FUNCTOR,typename TRANSFORM_FUNCTOR,typename INTERP_FUNCTOR>
static void
copyCrossSectionAttributeWrapper2(
    const GU_GridT<GA_Offset> &grid,
    const OUTPUT_ATTRIB_T &outputh,
    const INPUT_ATTRIB_T &cross_sectionh,
    const GA_AttributeOwner cross_section_owner,
    const GEO_Detail *cross_section_input,
    const sop_SweepGridTransformWrapper *transforms,
    const sop_SweepGrid &grid_info,
    const bool reverse_cross_sections,
    const bool swap_row_col,
    const GET_TRANSFORM_FUNCTOR &get_transform_functor,
    const TRANSFORM_FUNCTOR &transform_and_copy_functor,
    const INTERP_FUNCTOR &transform_and_interp_functor)
{
    UT_ASSERT(cross_section_owner != GA_ATTRIB_INVALID);
    UT_ASSERT(cross_section_owner == output_attrib_owner ||
        (cross_section_owner == GA_ATTRIB_POINT && output_attrib_owner == GA_ATTRIB_VERTEX) ||
        (cross_section_owner == GA_ATTRIB_VERTEX && output_attrib_owner == GA_ATTRIB_POINT));

    exint prev_curve_vtxi = -1;
    GA_Offset source_cross_section_primoff;
    GA_OffsetListRef cross_section_vertices;
    exint current_cross_section_nedges;
    bool current_cross_section_closed;
    bool current_cross_section_unrolled;
    const TRANSFORM_T *transform;
    auto &&functor = [&grid_info,&outputh,&cross_sectionh,
        cross_section_owner,
        &get_transform_functor,&transform_and_copy_functor,
        &transform_and_interp_functor,
        cross_section_input,
        transforms,
        reverse_cross_sections,
        swap_row_col,
        &prev_curve_vtxi,
        &source_cross_section_primoff,
        &cross_section_vertices,
        &current_cross_section_nedges,
        &current_cross_section_closed,
        &current_cross_section_unrolled,
        &transform](GA_Offset output_offset, exint row, exint col)
    {
        exint num_curve_edges = grid_info.myCurveNEdges;
        bool is_curve_closed = grid_info.myCurveClosed;
        exint curve_vtxi = swap_row_col ? col : row;
        exint num_cross_section_edges = grid_info.myCrossSectionNEdges;
        //bool is_cross_section_closed = grid_info.myCrossSectionClosed;
        exint cross_section_vtxi = swap_row_col ? row : col;

        if (curve_vtxi != prev_curve_vtxi)
        {
            // NOTE: This function is only for copying cross section attributes,
            //       so wrap_to_invalid only applies to column wrapping.
            //       Rows wrap normally when closed in this case.
            if (output_attrib_owner == GA_ATTRIB_VERTEX && is_curve_closed && curve_vtxi == num_curve_edges)
                curve_vtxi = 0;
            transform = get_transform_functor(transforms, curve_vtxi, grid_info);
            source_cross_section_primoff =
                grid_info.mySingleCrossSection ?
                GA_Offset(grid_info.myCrossSectionPrimOff) :
                (*grid_info.myCrossSectionPrimOffs)[curve_vtxi];
            UT_ASSERT_P(GAisValid(source_cross_section_primoff));
            if (output_attrib_owner != GA_ATTRIB_PRIMITIVE)
            {
                cross_section_vertices = cross_section_input->getPrimitiveVertexList(source_cross_section_primoff);
                getPolyProperties(cross_section_input, cross_section_vertices, current_cross_section_nedges, current_cross_section_closed, current_cross_section_unrolled);
            }
            prev_curve_vtxi = curve_vtxi;
        }

        if (output_attrib_owner == GA_ATTRIB_PRIMITIVE)
        {
            transform_and_copy_functor(cross_sectionh, source_cross_section_primoff, transform, outputh, output_offset);
            return;
        }

        constexpr bool is_vertex_attrib = (output_attrib_owner == GA_ATTRIB_VERTEX);

        if (current_cross_section_nedges == num_cross_section_edges)
        {
            // Copy from a single point.

            if (reverse_cross_sections)
            {
                // We handle wrapping below, so we reverse like an open polygon for all vertex attributes.
                cross_section_vtxi = reverseVtx(cross_section_vtxi, current_cross_section_nedges + exint(is_vertex_attrib || !current_cross_section_closed),
                    !is_vertex_attrib && current_cross_section_closed);
            }

            // NOTE: cross_section_vtxi may not be in-bounds, if this cross section is closed and some are open,
            //       since in that case, the grid will be open in that direction,
            //       so two output points will need to copy from vertex 0 of this cross section.
            GA_Offset vtxoff;
            if (cross_section_vtxi == cross_section_vertices.size())
            {
                if (wrap_to_invalid)
                {
                    // vertex UV attribute wraps to 1.0 value, not first value.
                    UT_ASSERT(is_vertex_attrib);
                    vtxoff = GA_INVALID_OFFSET;
                }
                else
                    vtxoff = cross_section_vertices[0];
            }
            else
                vtxoff = cross_section_vertices[cross_section_vtxi];
            GA_Offset cross_section_offset = (cross_section_owner == GA_ATTRIB_VERTEX || vtxoff == GA_INVALID_OFFSET) ? vtxoff : cross_section_input->vertexPoint(vtxoff);
            transform_and_copy_functor(cross_sectionh, cross_section_offset, transform, outputh, output_offset);
        }
        else
        {
            // Possibly interpolate between points.

            // The grid should have at least as many columns as the number of edges in each cross section.
            UT_ASSERT_P(num_cross_section_edges > current_cross_section_nedges);

            // Distribute the points evenly, but then snap the first point on a current edge
            // to the beginning of the edge and redistribute the points along that edge.
            // The division/modulus math is a bit hairy, but hopefully this works correctly.
            exint fine_fractions = cross_section_vtxi*current_cross_section_nedges;
            if (reverse_cross_sections)
                fine_fractions = num_cross_section_edges*current_cross_section_nedges - fine_fractions;
            exint current_cross_section_edge = fine_fractions / num_cross_section_edges;
            exint current_cross_section_fractions = fine_fractions % num_cross_section_edges;
            exint current_cross_section_pt = current_cross_section_fractions / current_cross_section_nedges;
            if (current_cross_section_pt == 0)
            {
                // First point on this edge: no need to interpolate, can just copy.
                GA_Offset vtxoff;
                if (current_cross_section_edge == cross_section_vertices.size())
                {
                    if (wrap_to_invalid)
                    {
                        // vertex UV attribute wraps to 1.0 value, not first value.
                        UT_ASSERT(is_vertex_attrib);
                        vtxoff = GA_INVALID_OFFSET;
                    }
                    else
                        vtxoff = cross_section_vertices[0];
                }
                else
                    vtxoff = cross_section_vertices[current_cross_section_edge];
                GA_Offset cross_section_offset = (cross_section_owner == GA_ATTRIB_VERTEX || vtxoff == GA_INVALID_OFFSET) ? vtxoff : cross_section_input->vertexPoint(vtxoff);
                transform_and_copy_functor(cross_sectionh, cross_section_offset, transform, outputh, output_offset);
            }
            else
            {
                // Partway along an edge: interpolate.
                // current_cross_section_edge_start is the smallest value of cross_section_vtxi that would yield current_cross_section_edge
                // current_cross_section_edge_end is the smallest value of cross_section_vtxi that would yield current_cross_section_edge+1
                // The difference is the number of points that will yield current_cross_section_edge
                exint current_cross_section_edge_start = (current_cross_section_edge*num_cross_section_edges + current_cross_section_nedges-1) / current_cross_section_nedges;
                exint current_cross_section_edge_end = ((current_cross_section_edge+1)*num_cross_section_edges + current_cross_section_nedges-1) / current_cross_section_nedges;
                exint current_cross_section_edge_npts = current_cross_section_edge_end - current_cross_section_edge_start;
                double u = double(current_cross_section_pt)/double(current_cross_section_edge_npts);

                // If current_cross_section_edge == current_cross_section_nedges,
                // the branch above to copy should have been taken.
                UT_ASSERT_P(current_cross_section_edge != current_cross_section_nedges);
                exint vtxi0 = current_cross_section_edge;
                GA_Offset vtxoff0 = cross_section_vertices[vtxi0];

                GA_Offset vtxoff1;
                if (current_cross_section_edge+1 == cross_section_vertices.size())
                {
                    if (wrap_to_invalid)
                    {
                        // vertex UV attribute wraps to 1.0 value, not first value.
                        UT_ASSERT(is_vertex_attrib);
                        vtxoff1 = GA_INVALID_OFFSET;
                    }
                    else
                        vtxoff1 = cross_section_vertices[0];
                }
                else
                    vtxoff1 = cross_section_vertices[current_cross_section_edge+1];

                GA_Offset cross_section_offset0;
                GA_Offset cross_section_offset1;
                if (cross_section_owner == GA_ATTRIB_VERTEX)
                {
                    cross_section_offset0 = vtxoff0;
                    cross_section_offset1 = vtxoff1;
                }
                else
                {
                    cross_section_offset0 = cross_section_input->vertexPoint(vtxoff0);
                    if (vtxoff1 != GA_INVALID_OFFSET)
                        cross_section_offset1 = cross_section_input->vertexPoint(vtxoff1);
                    else
                        cross_section_offset1 = vtxoff1;
                }
                transform_and_interp_functor(cross_sectionh, cross_section_offset0, cross_section_offset1, u, transform, outputh, output_offset);
            }
        }
    };

    SYS_STATIC_ASSERT(output_attrib_owner != GA_ATTRIB_DETAIL);

    if (output_attrib_owner == GA_ATTRIB_VERTEX)
    {
        copyVertexCrossSectionWrapper(grid, grid_info, functor);
    }
    else if (output_attrib_owner == GA_ATTRIB_POINT)
        GUiterateGridPoints(grid, functor);
    else
    {
        UT_ASSERT_P(output_attrib_owner == GA_ATTRIB_PRIMITIVE);
        if (grid_info.myHasPolygonCaps)
        {
            // First row/col cap
            functor(grid_info.myStartPrimOff, 0, 0);
        }
        // Main grid primitives
        const GA_Offset start_primoff = grid_info.myStartPrimOff + exint(grid_info.myHasPolygonCaps);
        auto &&functor_wrapper = [&functor,start_primoff](exint primnum, exint row, exint col, exint primvtxcount, bool closed)
        {
            GA_Offset output_primoff = start_primoff + primnum;
            functor(output_primoff, row, col);
        };
        GUiterateGridPrimitives(grid, functor_wrapper);
        if (grid_info.myHasPolygonCaps)
        {
            const GA_Offset cap_start_primoff = start_primoff + grid.myNumPrimitives;
            if (grid.myNoWrapV)
            {
                // Last row cap
                functor(cap_start_primoff, grid.myNumEdgeRows, 0);
            }
            else
            {
                // Last side col cap
                functor(cap_start_primoff, 0, grid.myNumEdgeCols);
            }
        }
    }
}

template<typename VALUE_T,typename TRANSFORM_T,GA_AttributeOwner attrib_owner,typename GET_TRANSFORM_FUNCTOR,typename TRANSFORM_FUNCTOR,typename INTERP_FUNCTOR>
static void
copyCrossSectionAttributeWrapper(
    GU_GridT<GA_Offset> &grid,
    GA_ATINumeric *output_attrib,
    const GA_ATINumeric *cross_section_attrib,
    const GEO_Detail *cross_section_input,
    const sop_SweepGridTransformWrapper *transforms,
    const sop_SweepGrid &grid_info,
    const bool reverse_cross_sections,
    const bool swap_row_col,
    const GET_TRANSFORM_FUNCTOR &get_transform_functor,
    const TRANSFORM_FUNCTOR &transform_and_copy_functor,
    const INTERP_FUNCTOR &transform_and_interp_functor)
{
    GA_RWHandleT<VALUE_T> outputh(output_attrib);
    GA_ROHandleT<VALUE_T> cross_sectionh(cross_section_attrib);
    UT_ASSERT_P(outputh.isValid());
    UT_ASSERT_P(cross_sectionh.isValid());
    UT_ASSERT(attrib_owner == cross_section_attrib->getOwner());
    copyCrossSectionAttributeWrapper2<TRANSFORM_T,attrib_owner>(
        grid, outputh, cross_sectionh, attrib_owner,
        cross_section_input, transforms, grid_info,
        reverse_cross_sections,
        swap_row_col,
        get_transform_functor,
        transform_and_copy_functor,
        transform_and_interp_functor);
}

template<typename T,GA_AttributeOwner attrib_owner>
static void
copyIntegerSingleGrid(
    GA_ATINumeric *output_attrib,
    const GA_ATINumeric *cross_section_attrib,
    const GEO_Detail *cross_section_input,
    const sop_SweepGridTransformWrapper *transforms,
    const sop_SweepGrid &grid_info,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const bool reverse_cross_sections,
    const bool swap_row_col)
{
    UT_ASSERT_P(cross_section_attrib != nullptr);
    UT_ASSERT_P(cross_section_input != nullptr);

    SYS_STATIC_ASSERT(std::is_integral<T>::value);

    GU_GridT<GA_Offset> grid;
    initGUGrid(grid_info, surface_type, output_points_only, triangular_poles, swap_row_col, grid_info.myStartPtOff, grid);

    const int tuple_size = output_attrib->getTupleSize();

    // Non-transforming cases follow
    auto &&get_transform = [](const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const void*
    {
        return nullptr;
    };

    if (tuple_size == 1)
    {
        // Copy single-component numeric attribute
        auto &&transform_and_copy = [](
            const GA_ROHandleT<T> &cross_sectionh, GA_Offset cross_section_offset,
            const void *transform,
            const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
        {
            T value = cross_sectionh.get(cross_section_offset);
            outputh.set(output_offset, value);
        };
        auto &&transform_and_interp = [](
            const GA_ROHandleT<T> &cross_sectionh,
            GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
            const void *transform,
            const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
        {
            GA_Offset cross_section_offset = (t < 0.5) ? cross_section_offset0 : cross_section_offset1;
            T value = cross_sectionh.get(cross_section_offset);
            outputh.set(output_offset, value);
        };
        copyCrossSectionAttributeWrapper<T, void, attrib_owner>(grid,
            output_attrib, cross_section_attrib, cross_section_input, transforms, grid_info,
            reverse_cross_sections, swap_row_col,
            get_transform, transform_and_copy, transform_and_interp);
        return;
    }

    // Copy arbitrary-component numeric attribute
    auto &&transform_and_copy = [tuple_size](
        const GA_ROHandleT<T> &cross_sectionh, GA_Offset cross_section_offset,
        const void *transform,
        const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
    {
        for (exint component = 0; component < tuple_size; ++component)
        {
            T value = cross_sectionh.get(cross_section_offset, component);
            outputh.set(output_offset, component, value);
        }
    };
    auto &&transform_and_interp = [tuple_size](
        const GA_ROHandleT<T> &cross_sectionh,
        GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, double t,
        const void *transform,
        const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
    {
        GA_Offset cross_section_offset = (t < 0.5) ? cross_section_offset0 : cross_section_offset1;
        for (exint component = 0; component < tuple_size; ++component)
        {
            T value = cross_sectionh.get(cross_section_offset, component);
            outputh.set(output_offset, component, value);
        }
    };
    copyCrossSectionAttributeWrapper<T, void, attrib_owner>(grid,
        output_attrib, cross_section_attrib, cross_section_input, transforms, grid_info,
        reverse_cross_sections, swap_row_col,
        get_transform, transform_and_copy, transform_and_interp);
}

template<typename T,GA_TypeInfo transform_type,GA_AttributeOwner attrib_owner>
static void
copyFloatSingleGrid(
    GA_ATINumeric *output_attrib,
    const GA_ATINumeric *cross_section_attrib,
    const GEO_Detail *cross_section_input,
    const sop_SweepGridTransformWrapper *transforms,
    const sop_SweepGrid &grid_info,
    const exint cross_sections_per_vertex,
    const exint cap_divisions,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const bool reverse_cross_sections,
    const bool swap_row_col)
{
    UT_ASSERT_P(cross_section_attrib != nullptr);
    UT_ASSERT_P(cross_section_input != nullptr);

    SYS_STATIC_ASSERT(!std::is_integral<T>::value);

    GU_GridT<GA_Offset> grid;
    initGUGrid(grid_info, surface_type, output_points_only, triangular_poles, swap_row_col, grid_info.myStartPtOff, grid);

    const exint cap_rows = (grid_info.myVEndPoles && !grid_info.myHasPolygonCaps) ? cap_divisions : 0;
    exint last_cap_start_row = -1;
    exint last_cap_start_transform = -1;
    if (cross_sections_per_vertex != 1 && cap_rows > 0)
    {
        last_cap_start_row = grid_info.myCurveNEdges - cap_rows;
        last_cap_start_transform = (last_cap_start_row - cap_rows)/cross_sections_per_vertex + cap_rows;
    }

    auto &&fix_transformi_for_all_case = [cap_rows,cross_sections_per_vertex,last_cap_start_row,last_cap_start_transform](exint &transformi)
    {
        // We have multiple cross sections per vertex, except in the caps,
        // when CopyOrder::ALL, but only one transform, so we need to
        // adjust transformi.
        if (cap_rows == 0)
            transformi /= cross_sections_per_vertex;
        else if (transformi > cap_rows)
        {
            if (transformi < last_cap_start_row)
                transformi = (transformi - cap_rows)/cross_sections_per_vertex + cap_rows;
            else
                transformi = last_cap_start_transform + (transformi - last_cap_start_row);
        }
    };

    const int tuple_size = output_attrib->getTupleSize();

    if (transforms)
    {
        if (transform_type == GA_TYPE_POINT)
        {
            // Transform position attribute
            UT_Matrix4T<T> transform;
            transform.identity();
            UT_ASSERT(tuple_size == 3);
            auto &&get_transform = [&transform,cross_sections_per_vertex,&fix_transformi_for_all_case]
                (const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const UT_Matrix4T<T>*
            {
                exint transformi = row;
                if (cross_sections_per_vertex != 1)
                    fix_transformi_for_all_case(transformi);
                transform = UT_Matrix4T<T>(transforms->getMatrix3s<T>()[transformi]);
                transform.setTranslates(transforms->getTranslates<T>()[transformi]);
                return &transform;
            };
            auto &&transform_and_copy = [](
                const GA_ROHandleT<UT_Vector3T<T>> &cross_sectionh, GA_Offset cross_section_offset,
                const UT_Matrix4T<T> *transform,
                const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
            {
                UT_Vector3T<T> value = cross_sectionh.get(cross_section_offset);
                value *= *transform;
                outputh.set(output_offset, value);
            };
            auto &&transform_and_interp = [](
                const GA_ROHandleT<UT_Vector3T<T>> &cross_sectionh,
                GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
                const UT_Matrix4T<T> *transform,
                const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
            {
                const UT_Vector3T<T> value0 = cross_sectionh.get(cross_section_offset0);
                const UT_Vector3T<T> value1 = cross_sectionh.get(cross_section_offset1);
                UT_Vector3T<T> value = SYSlerp(value0, value1, t);
                value *= *transform;
                outputh.set(output_offset, value);
            };
            copyCrossSectionAttributeWrapper<UT_Vector3T<T>, UT_Matrix4T<T>, attrib_owner>(grid,
                output_attrib, cross_section_attrib, cross_section_input, transforms, grid_info,
                reverse_cross_sections, swap_row_col,
                get_transform, transform_and_copy, transform_and_interp);
            return;
        }
        if (transform_type == GA_TYPE_NORMAL)
        {
            // Transform normal attribute
            UT_ASSERT(tuple_size == 3);
            auto &&get_transform = [cross_sections_per_vertex,&fix_transformi_for_all_case]
                (const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const UT_Matrix3T<T>*
            {
                exint transformi = row;
                if (cross_sections_per_vertex != 1)
                    fix_transformi_for_all_case(transformi);
                return &transforms->getInverse3s<T>()[transformi];
            };
            auto &&transform_and_copy = [](
                const GA_ROHandleT<UT_Vector3T<T>> &cross_sectionh, GA_Offset cross_section_offset,
                const UT_Matrix3T<T> *transform,
                const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
            {
                UT_Vector3T<T> value = cross_sectionh.get(cross_section_offset);
                value.colVecMult(*transform);
                outputh.set(output_offset, value);
            };
            auto &&transform_and_interp = [](
                const GA_ROHandleT<UT_Vector3T<T>> &cross_sectionh,
                GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
                const UT_Matrix3T<T> *transform,
                const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
            {
                const UT_Vector3T<T> value0 = cross_sectionh.get(cross_section_offset0);
                const UT_Vector3T<T> value1 = cross_sectionh.get(cross_section_offset1);

                // FIXME: slerp, instead of lerping and normalizing!!!
                UT_Vector3T<T> value = SYSlerp(value0, value1, t);
                value.normalize();

                T orig_length2 = value.length2();
                value.colVecMult(*transform);
                T new_length2 = value.length2();
                // Preserve normal length
                if (new_length2 != 0)
                    value *= SYSsqrt(orig_length2/new_length2);
                outputh.set(output_offset, value);
            };
            copyCrossSectionAttributeWrapper<UT_Vector3T<T>, UT_Matrix3T<T>, attrib_owner>(grid,
                output_attrib, cross_section_attrib, cross_section_input, transforms, grid_info,
                reverse_cross_sections, swap_row_col,
                get_transform, transform_and_copy, transform_and_interp);
            return;
        }
        if (transform_type == GA_TYPE_VECTOR)
        {
            // Transform vector attribute
            UT_ASSERT(tuple_size == 3);
            auto &&get_transform = [cross_sections_per_vertex,&fix_transformi_for_all_case]
                (const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const UT_Matrix3T<T>*
            {
                exint transformi = row;
                if (cross_sections_per_vertex != 1)
                    fix_transformi_for_all_case(transformi);
                return &transforms->getMatrix3s<T>()[transformi];
            };
            auto &&transform_and_copy = [](
                const GA_ROHandleT<UT_Vector3T<T>> &cross_sectionh, GA_Offset cross_section_offset,
                const UT_Matrix3T<T> *transform,
                const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
            {
                UT_Vector3T<T> value = cross_sectionh.get(cross_section_offset);
                value *= *transform;
                outputh.set(output_offset, value);
            };
            auto &&transform_and_interp = [](
                const GA_ROHandleT<UT_Vector3T<T>> &cross_sectionh,
                GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
                const UT_Matrix3T<T> *transform,
                const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
            {
                const UT_Vector3T<T> value0 = cross_sectionh.get(cross_section_offset0);
                const UT_Vector3T<T> value1 = cross_sectionh.get(cross_section_offset1);
                UT_Vector3T<T> value = SYSlerp(value0, value1, t);
                value *= *transform;
                outputh.set(output_offset, value);
            };
            copyCrossSectionAttributeWrapper<UT_Vector3T<T>, UT_Matrix3T<T>, attrib_owner>(grid,
                output_attrib, cross_section_attrib, cross_section_input, transforms, grid_info,
                reverse_cross_sections, swap_row_col,
                get_transform, transform_and_copy, transform_and_interp);
            return;
        }
        if (transform_type == GA_TYPE_QUATERNION)
        {
            // Transform vector attribute
            UT_ASSERT(tuple_size == 4);
            auto &&get_transform = [cross_sections_per_vertex,&fix_transformi_for_all_case]
                (const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const UT_QuaternionT<T>*
            {
                exint transformi = row;
                if (cross_sections_per_vertex != 1)
                    fix_transformi_for_all_case(transformi);
                return &transforms->getQuaternions<T>()[transformi];
            };
            auto &&transform_and_copy = [](
                const GA_ROHandleT<UT_QuaternionT<T>> &cross_sectionh, GA_Offset cross_section_offset,
                const UT_QuaternionT<T> *transform,
                const GA_RWHandleT<UT_QuaternionT<T>> &outputh, GA_Offset output_offset)
            {
                UT_QuaternionT<T> value = cross_sectionh.get(cross_section_offset);
                value *= *transform;
                outputh.set(output_offset, value);
            };
            auto &&transform_and_interp = [](
                const GA_ROHandleT<UT_QuaternionT<T>> &cross_sectionh,
                GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
                const UT_QuaternionT<T> *transform,
                const GA_RWHandleT<UT_QuaternionT<T>> &outputh, GA_Offset output_offset)
            {
                const UT_QuaternionT<T> value0 = cross_sectionh.get(cross_section_offset0);
                const UT_QuaternionT<T> value1 = cross_sectionh.get(cross_section_offset1);
                UT_QuaternionT<T> value = value0;
                value.interpolate(value1, t);
                value = *transform * value;
                outputh.set(output_offset, value);
            };
            copyCrossSectionAttributeWrapper<UT_QuaternionT<T>, UT_QuaternionT<T>, attrib_owner>(grid,
                output_attrib, cross_section_attrib, cross_section_input, transforms, grid_info,
                reverse_cross_sections, swap_row_col,
                get_transform, transform_and_copy, transform_and_interp);
            return;
        }
        if (transform_type == GA_TYPE_TRANSFORM)
        {
            if (tuple_size == 9)
            {
                // Transform 3x3 matrix attribute
                auto &&get_transform = [cross_sections_per_vertex,&fix_transformi_for_all_case]
                    (const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const UT_Matrix3T<T>*
                {
                    exint transformi = row;
                    if (cross_sections_per_vertex != 1)
                        fix_transformi_for_all_case(transformi);
                    return &transforms->getMatrix3s<T>()[transformi];
                };
                auto &&transform_and_copy = [](
                    const GA_ROHandleT<UT_Matrix3T<T>> &cross_sectionh, GA_Offset cross_section_offset,
                    const UT_Matrix3T<T> *transform,
                    const GA_RWHandleT<UT_Matrix3T<T>> &outputh, GA_Offset output_offset)
                {
                    UT_Matrix3T<T> value = cross_sectionh.get(cross_section_offset);
                    value *= *transform;
                    outputh.set(output_offset, value);
                };
                auto &&transform_and_interp = [](
                    const GA_ROHandleT<UT_Matrix3T<T>> &cross_sectionh,
                    GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
                    const UT_Matrix3T<T> *transform,
                    const GA_RWHandleT<UT_Matrix3T<T>> &outputh, GA_Offset output_offset)
                {
                    const UT_Matrix3T<T> value0 = cross_sectionh.get(cross_section_offset0);
                    const UT_Matrix3T<T> value1 = cross_sectionh.get(cross_section_offset1);
                    UT_Matrix3T<T> value = SYSlerp(value0, value1, t);
                    value *= *transform;
                    outputh.set(output_offset, value);
                };
                copyCrossSectionAttributeWrapper<UT_Matrix3T<T>, UT_Matrix3T<T>, attrib_owner>(grid,
                    output_attrib, cross_section_attrib, cross_section_input, transforms, grid_info,
                    reverse_cross_sections, swap_row_col,
                    get_transform, transform_and_copy, transform_and_interp);
                return;
            }
            if (tuple_size == 16)
            {
                // Transform 4x4 matrix attribute
                UT_Matrix4T<T> transform;
                transform.identity();
                auto &&get_transform = [&transform,cross_sections_per_vertex,&fix_transformi_for_all_case]
                    (const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const UT_Matrix4T<T>*
                {
                    exint transformi = row;
                    if (cross_sections_per_vertex != 1)
                        fix_transformi_for_all_case(transformi);
                    transform = UT_Matrix4T<T>(transforms->getMatrix3s<T>()[transformi]);
                    transform.setTranslates(transforms->getTranslates<T>()[transformi]);
                    return &transform;
                };
                auto &&transform_and_copy = [](
                    const GA_ROHandleT<UT_Matrix4T<T>> &cross_sectionh, GA_Offset cross_section_offset,
                    const UT_Matrix4T<T> *transform,
                    const GA_RWHandleT<UT_Matrix4T<T>> &outputh, GA_Offset output_offset)
                {
                    UT_Matrix4T<T> value = cross_sectionh.get(cross_section_offset);
                    value *= *transform;
                    outputh.set(output_offset, value);
                };
                auto &&transform_and_interp = [](
                    const GA_ROHandleT<UT_Matrix4T<T>> &cross_sectionh,
                    GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
                    const UT_Matrix4T<T> *transform,
                    const GA_RWHandleT<UT_Matrix4T<T>> &outputh, GA_Offset output_offset)
                {
                    const UT_Matrix4T<T> value0 = cross_sectionh.get(cross_section_offset0);
                    const UT_Matrix4T<T> value1 = cross_sectionh.get(cross_section_offset1);
                    UT_Matrix4T<T> value = SYSlerp(value0, value1, t);
                    value *= *transform;
                    outputh.set(output_offset, value);
                };
                copyCrossSectionAttributeWrapper<UT_Matrix4T<T>, UT_Matrix4T<T>, attrib_owner>(grid,
                    output_attrib, cross_section_attrib, cross_section_input, transforms, grid_info,
                    reverse_cross_sections, swap_row_col,
                    get_transform, transform_and_copy, transform_and_interp);
                return;
            }
        }
    }

    // Non-transforming cases follow
    auto &&get_transform = [](const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const void*
    {
        return nullptr;
    };

    bool is_integer_type = std::is_integral<T>::value;
    if (tuple_size == 1)
    {
        // Copy single-component numeric attribute
        auto &&transform_and_copy = [](
            const GA_ROHandleT<T> &cross_sectionh, GA_Offset cross_section_offset,
            const void *transform,
            const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
        {
            T value = cross_sectionh.get(cross_section_offset);
            outputh.set(output_offset, value);
        };
        if (is_integer_type)
        {
            auto &&transform_and_interp = [](
                const GA_ROHandleT<T> &cross_sectionh,
                GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
                const void *transform,
                const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
            {
                GA_Offset cross_section_offset = (t < 0.5) ? cross_section_offset0 : cross_section_offset1;
                T value = cross_sectionh.get(cross_section_offset);
                outputh.set(output_offset, value);
            };
            copyCrossSectionAttributeWrapper<T, void, attrib_owner>(grid,
                output_attrib, cross_section_attrib, cross_section_input, nullptr, grid_info,
                reverse_cross_sections, swap_row_col,
                get_transform, transform_and_copy, transform_and_interp);
        }
        else
        {
            auto &&transform_and_interp = [](
                const GA_ROHandleT<T> &cross_sectionh,
                GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
                const void *transform,
                const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
            {
                const T value0 = cross_sectionh.get(cross_section_offset0);
                const T value1 = cross_sectionh.get(cross_section_offset1);
                T value = SYSlerp(value0, value1, t);
                outputh.set(output_offset, value);
            };
            copyCrossSectionAttributeWrapper<T, void, attrib_owner>(grid,
                output_attrib, cross_section_attrib, cross_section_input, nullptr, grid_info,
                reverse_cross_sections, swap_row_col,
                get_transform, transform_and_copy, transform_and_interp);
        }
        return;
    }
    if (tuple_size == 2 && !is_integer_type)
    {
        // Copy 2-component numeric attribute
        auto &&transform_and_copy = [](
            const GA_ROHandleT<UT_Vector2T<T>> &cross_sectionh, GA_Offset cross_section_offset,
            const void *transform,
            const GA_RWHandleT<UT_Vector2T<T>> &outputh, GA_Offset output_offset)
        {
            UT_Vector2T<T> value = cross_sectionh.get(cross_section_offset);
            outputh.set(output_offset, value);
        };
        auto &&transform_and_interp = [](
            const GA_ROHandleT<UT_Vector2T<T>> &cross_sectionh,
            GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
            const void *transform,
            const GA_RWHandleT<UT_Vector2T<T>> &outputh, GA_Offset output_offset)
        {
            const UT_Vector2T<T> value0 = cross_sectionh.get(cross_section_offset0);
            const UT_Vector2T<T> value1 = cross_sectionh.get(cross_section_offset1);
            UT_Vector2T<T> value = SYSlerp(value0, value1, t);
            outputh.set(output_offset, value);
        };
        copyCrossSectionAttributeWrapper<UT_Vector2T<T>, void, attrib_owner>(grid,
            output_attrib, cross_section_attrib, cross_section_input, nullptr, grid_info,
            reverse_cross_sections, swap_row_col,
            get_transform, transform_and_copy, transform_and_interp);
        return;
    }
    if (tuple_size == 3 && !is_integer_type)
    {
        // Copy 3-component numeric attribute
        auto &&transform_and_copy = [](
            const GA_ROHandleT<UT_Vector3T<T>> &cross_sectionh, GA_Offset cross_section_offset,
            const void *transform,
            const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
        {
            UT_Vector3T<T> value = cross_sectionh.get(cross_section_offset);
            outputh.set(output_offset, value);
        };
        auto &&transform_and_interp = [](
            const GA_ROHandleT<UT_Vector3T<T>> &cross_sectionh,
            GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
            const void *transform,
            const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
        {
            const UT_Vector3T<T> value0 = cross_sectionh.get(cross_section_offset0);
            const UT_Vector3T<T> value1 = cross_sectionh.get(cross_section_offset1);
            UT_Vector3T<T> value = SYSlerp(value0, value1, t);
            outputh.set(output_offset, value);
        };
        copyCrossSectionAttributeWrapper<UT_Vector3T<T>, void, attrib_owner>(grid,
            output_attrib, cross_section_attrib, cross_section_input, nullptr, grid_info,
            reverse_cross_sections, swap_row_col,
            get_transform, transform_and_copy, transform_and_interp);
        return;
    }

    // Copy arbitrary-component numeric attribute
    auto &&transform_and_copy = [tuple_size](
        const GA_ROHandleT<T> &cross_sectionh, GA_Offset cross_section_offset,
        const void *transform,
        const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
    {
        for (exint component = 0; component < tuple_size; ++component)
        {
            T value = cross_sectionh.get(cross_section_offset, component);
            outputh.set(output_offset, component, value);
        }
    };
    if (is_integer_type)
    {
        auto &&transform_and_interp = [tuple_size](
            const GA_ROHandleT<T> &cross_sectionh,
            GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, double t,
            const void *transform,
            const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
        {
            GA_Offset cross_section_offset = (t < 0.5) ? cross_section_offset0 : cross_section_offset1;
            for (exint component = 0; component < tuple_size; ++component)
            {
                T value = cross_sectionh.get(cross_section_offset, component);
                outputh.set(output_offset, component, value);
            }
        };
        copyCrossSectionAttributeWrapper<T, void, attrib_owner>(grid,
            output_attrib, cross_section_attrib, cross_section_input, nullptr, grid_info,
            reverse_cross_sections, swap_row_col,
            get_transform, transform_and_copy, transform_and_interp);
    }
    else
    {
        auto &&transform_and_interp = [tuple_size](
            const GA_ROHandleT<T> &cross_sectionh,
            GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, double t,
            const void *transform,
            const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
        {
            for (exint component = 0; component < tuple_size; ++component)
            {
                const T value0 = cross_sectionh.get(cross_section_offset0, component);
                const T value1 = cross_sectionh.get(cross_section_offset1, component);
                T value = SYSlerp(value0, value1, t);
                outputh.set(output_offset, component, value);
            }
        };
        copyCrossSectionAttributeWrapper<T, void, attrib_owner>(grid,
            output_attrib, cross_section_attrib, cross_section_input, nullptr, grid_info,
            reverse_cross_sections, swap_row_col,
            get_transform, transform_and_copy, transform_and_interp);
    }
}

template<GA_AttributeOwner attrib_owner>
static void
copyAttribSingleGrid(
    GA_Attribute *output_attrib,
    const GA_Attribute *cross_section_attrib,
    const GEO_Detail *cross_section_input,
    const sop_SweepGrid &grid_info,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const bool reverse_cross_sections,
    const bool swap_row_col)
{
    // Copy non-numeric attribute

    GU_GridT<GA_Offset> grid;
    initGUGrid(grid_info, surface_type, output_points_only, triangular_poles, swap_row_col, grid_info.myStartPtOff, grid);

    // Non-transforming
    auto &&get_transform = [](const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const void*
    {
        return nullptr;
    };

    auto &&transform_and_copy = [](
        const GA_Attribute *cross_section_attrib, GA_Offset cross_section_offset,
        const void *transform,
        GA_Attribute *output_attrib, GA_Offset output_offset)
    {
        output_attrib->copy(output_offset, *cross_section_attrib, cross_section_offset);
    };
    auto &&transform_and_interp = [](
        const GA_Attribute *cross_section_attrib,
        GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, double t,
        const void *transform,
        GA_Attribute *output_attrib, GA_Offset output_offset)
    {
        GA_Offset cross_section_offset = (t < 0.5) ? cross_section_offset0 : cross_section_offset1;
        output_attrib->copy(output_offset, *cross_section_attrib, cross_section_offset);
    };

    UT_ASSERT(attrib_owner == cross_section_attrib->getOwner());
    copyCrossSectionAttributeWrapper2<void, attrib_owner>(grid,
        output_attrib, cross_section_attrib, attrib_owner, cross_section_input, nullptr, grid_info,
        reverse_cross_sections, swap_row_col,
        get_transform, transform_and_copy, transform_and_interp);
}

static const sop_SweepGridTransformWrapper *
gridOffsetTransforms(
    const SOP_SweepHDKCache *const transform_cache,
    sop_SweepGridTransformWrapper &grid_transforms,
    const exint gridi)
{
    if (transform_cache == nullptr)
        return nullptr;

    grid_transforms.init(*transform_cache, gridi);

    return &grid_transforms;
}

template<GA_AttributeOwner attrib_owner>
static void
copyCrossSectionAttrib2(
    GA_Attribute *output_attrib,
    const GA_Attribute *cross_section_attrib,
    const GEO_Detail *cross_section_input,
    const SOP_SweepHDKCache *transform_cache,
    const sop_SweepGrid *grids,
    exint ngrids,
    const exint cross_sections_per_vertex,
    const exint cap_divisions,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const bool reverse_cross_sections,
    const bool swap_row_col)
{
    UT_ASSERT(output_attrib->getOwner() == attrib_owner);
    UT_ASSERT(cross_section_attrib->getOwner() == attrib_owner);

    const exint PARALLEL_THRESHOLD = 2048;
    const bool parallel = (ngrids > 1 &&
        output_attrib->getIndexMap().indexSize() >= PARALLEL_THRESHOLD);
    const UT_BlockedRange<exint> grid_range(0, ngrids);

    GA_ATINumeric *const output_numeric = GA_ATINumeric::cast(output_attrib);
    if (!output_numeric)
    {
        output_attrib->bumpDataId();
        auto&& functor = [&](const UT_BlockedRange<exint>& r)
        {
            for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
            {
                copyAttribSingleGrid<attrib_owner>(
                    output_attrib, cross_section_attrib, cross_section_input,
                    grids[gridi],
                    surface_type, output_points_only, triangular_poles,
                    reverse_cross_sections, swap_row_col);
            }
        };
        if (parallel)
        {
            // Must harden all pages before multi-threading.
            output_attrib->hardenAllPages();
            UTparallelFor(grid_range, functor);
        }
        else
        {
            functor(grid_range);
        }
        return;
    }

    const GA_ATINumeric *const cross_section_numeric = GA_ATINumeric::cast(cross_section_attrib);
    UT_ASSERT(cross_section_numeric);
    if (!cross_section_numeric)
        return;
    const int tuple_size = output_numeric->getTupleSize();
    UT_ASSERT(tuple_size == cross_section_numeric->getTupleSize());
    if (tuple_size != cross_section_numeric->getTupleSize())
        return;

    output_attrib->bumpDataId();

    if (parallel)
    {
        // Must harden all pages before multi-threading.
        output_attrib->hardenAllPages();
    }

    auto&& functor = [&](const UT_BlockedRange<exint>& r)
    {
        const GA_TypeInfo type_info = cross_section_numeric->getTypeInfo();
        const GA_Storage storage_type = output_numeric->getStorage();
        sop_SweepGridTransformWrapper local_grid_transforms;
        if (tuple_size == 3)
        {
            if (type_info == GA_TYPE_POINT)
            {
                if (storage_type == GA_STORE_REAL64)
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal64,GA_TYPE_POINT,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                else
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal32,GA_TYPE_POINT,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                return;
            }
            if (type_info == GA_TYPE_NORMAL)
            {
                if (storage_type == GA_STORE_REAL64)
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal64,GA_TYPE_NORMAL,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                else
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal32,GA_TYPE_NORMAL,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                return;
            }
            if (type_info == GA_TYPE_VECTOR)
            {
                if (storage_type == GA_STORE_REAL64)
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal64,GA_TYPE_VECTOR,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                else
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal32,GA_TYPE_VECTOR,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                return;
            }
        }
        else if (tuple_size == 4)
        {
            if (type_info == GA_TYPE_QUATERNION)
            {
                if (storage_type == GA_STORE_REAL64)
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal64,GA_TYPE_QUATERNION,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                else
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal32,GA_TYPE_QUATERNION,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                return;
            }
        }
        else if (tuple_size == 9 || tuple_size == 16)
        {
            if (type_info == GA_TYPE_TRANSFORM)
            {
                if (storage_type == GA_STORE_REAL64)
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal64,GA_TYPE_TRANSFORM,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                else
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal32,GA_TYPE_TRANSFORM,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                return;
            }
        }

        if (storage_type == GA_STORE_REAL64)
        {
            for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
            {
                copyFloatSingleGrid<fpreal64,GA_TYPE_VOID,attrib_owner>(
                    output_numeric, cross_section_numeric, cross_section_input,
                    nullptr, grids[gridi], cross_sections_per_vertex, cap_divisions,
                    surface_type, output_points_only, triangular_poles,
                    reverse_cross_sections, swap_row_col);
            }
        }
        else if (storage_type == GA_STORE_REAL32 || storage_type == GA_STORE_REAL16)
        {
            for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
            {
                copyFloatSingleGrid<fpreal32,GA_TYPE_VOID,attrib_owner>(
                    output_numeric, cross_section_numeric, cross_section_input,
                    nullptr, grids[gridi], cross_sections_per_vertex, cap_divisions,
                    surface_type, output_points_only, triangular_poles,
                    reverse_cross_sections, swap_row_col);
            }
        }
        else if (storage_type == GA_STORE_INT64)
        {
            for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
            {
                copyIntegerSingleGrid<int64,attrib_owner>(
                    output_numeric, cross_section_numeric, cross_section_input,
                    nullptr, grids[gridi],
                    surface_type, output_points_only, triangular_poles,
                    reverse_cross_sections, swap_row_col);
            }
        }
        else if (storage_type == GA_STORE_INT32 || storage_type == GA_STORE_INT16 || storage_type == GA_STORE_INT8)
        {
            for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
            {
                copyIntegerSingleGrid<int32,attrib_owner>(
                    output_numeric, cross_section_numeric, cross_section_input,
                    nullptr, grids[gridi],
                    surface_type, output_points_only, triangular_poles,
                    reverse_cross_sections, swap_row_col);
            }
        }
    };

    if (parallel)
        UTparallelFor(grid_range, functor);
    else
        functor(grid_range);
}

static void
copyCrossSectionAttrib(
    GA_Attribute *output_attrib,
    const GA_Attribute *cross_section_attrib,
    const GEO_Detail *cross_section_input,
    const SOP_SweepHDKCache *transform_cache,
    const sop_SweepGrid *grids,
    exint ngrids,
    const exint cross_sections_per_vertex,
    const exint cap_divisions,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const bool reverse_cross_sections,
    const bool swap_row_col)
{
    UT_ASSERT(output_attrib->getOwner() == cross_section_attrib->getOwner());

    GA_AttributeOwner owner = output_attrib->getOwner();
    if (owner == GA_ATTRIB_POINT)
    {
        copyCrossSectionAttrib2<GA_ATTRIB_POINT>(
            output_attrib, cross_section_attrib, cross_section_input,
            transform_cache, grids, ngrids, cross_sections_per_vertex, cap_divisions,
            surface_type, output_points_only, triangular_poles,
            reverse_cross_sections, swap_row_col);
    }
    else if (owner == GA_ATTRIB_VERTEX)
    {
        copyCrossSectionAttrib2<GA_ATTRIB_VERTEX>(
            output_attrib, cross_section_attrib, cross_section_input,
            transform_cache, grids, ngrids, cross_sections_per_vertex, cap_divisions,
            surface_type, output_points_only, triangular_poles,
            reverse_cross_sections, swap_row_col);
    }
    else if (owner == GA_ATTRIB_PRIMITIVE)
    {
        copyCrossSectionAttrib2<GA_ATTRIB_PRIMITIVE>(
            output_attrib, cross_section_attrib, cross_section_input,
            transform_cache, grids, ngrids, cross_sections_per_vertex, cap_divisions,
            surface_type, output_points_only, triangular_poles,
            reverse_cross_sections, swap_row_col);
    }
    else if (owner == GA_ATTRIB_DETAIL)
    {
        output_attrib->replace(*cross_section_attrib);
    }
}

template<bool wrap_to_invalid,typename FUNCTOR>
static void
copyVertexCurveAttribWrapper(
    const sop_SweepGrid &grid_info,
    const GU_GridT<GA_Offset> &grid,
    exint num_vertices,
    exint cap_divisions,
    exint cross_sections_per_vertex,
    const bool swap_row_col,
    const FUNCTOR &copy_functor)
{
    const exint curve_nedges = grid_info.myCurveNEdges;
    const exint cross_section_nedges = grid_info.myCrossSectionNEdges;

    const exint cap_divs = (grid_info.myVEndPoles && !grid_info.myHasPolygonCaps) ? cap_divisions : 0;
    exint prev_vtxi = -1;
    exint curve_vtxi;
    exint cap_vertex_count = 0;
    if (grid_info.myHasPolygonCaps)
    {
        if (swap_row_col ? grid.myNoWrapU : grid.myNoWrapV)
        {
            // First row cap
            cap_vertex_count = cross_section_nedges;

            curve_vtxi = 0;
            prev_vtxi = 0;

            for (exint col = 0; col < cap_vertex_count; ++col)
            {
                copy_functor(grid_info.myStartVtxOff + col, 0);
            }
        }
        else
        {
            // First side col cap
            cap_vertex_count = curve_nedges;

            for (exint row = 0; row < cap_vertex_count; ++row)
            {
                copy_functor(grid_info.myStartVtxOff + row, row);
            }
        }
    }
    // Copy to main grid vertices
    const GA_Offset start_vtxoff = grid_info.myStartVtxOff + cap_vertex_count;
    const bool closed_curve = grid_info.myCurveClosed;
    GUiterateGridVertices(grid, [cap_divs, &prev_vtxi, &curve_vtxi, num_vertices,
        start_vtxoff, cross_sections_per_vertex, swap_row_col, closed_curve, &copy_functor]
        (exint vtxnum, exint row, exint col, bool isrowend, bool iscolend, exint primnum, exint primvtxnum)
    {
        exint vtxi = swap_row_col ? col : row;
        vtxi += exint(swap_row_col ? iscolend : isrowend);
        if (vtxi != prev_vtxi)
        {
            curve_vtxi = vtxi - cap_divs;
            if (cross_sections_per_vertex != 1)
                curve_vtxi /= cross_sections_per_vertex;
            if (curve_vtxi < 0)
                curve_vtxi = 0;
            else if (curve_vtxi >= num_vertices)
            {
                if (!closed_curve)
                    curve_vtxi = num_vertices-1;
                else if (wrap_to_invalid)
                    curve_vtxi = -1;
                else
                    curve_vtxi = 0;
            }
            prev_vtxi = vtxi;
        }
        copy_functor(start_vtxoff + vtxnum, curve_vtxi);
    });
    if (grid_info.myHasPolygonCaps)
    {
        // Last cap starts after main grid
        const GA_Offset cap_start_vtxoff = start_vtxoff + grid.myNumVertices;
        if (swap_row_col ? grid.myNoWrapU : grid.myNoWrapV)
        {
            // Last row cap
            curve_vtxi = num_vertices-1;

            for (exint col = 0; col < cap_vertex_count; ++col)
            {
                copy_functor(cap_start_vtxoff + col, curve_vtxi);
            }
        }
        else
        {
            // Last side col cap
            for (exint row = 0; row < cap_vertex_count; ++row)
            {
                copy_functor(cap_start_vtxoff + row, row);
            }
        }
    }
}

template<GA_AttributeOwner attrib_owner,bool wrap_to_invalid=false,typename COPY_FUNCTOR>
static void
copyCurveAttrib2(
    GA_Attribute *output_attrib,
    const GEO_Detail *curve_input,
    const sop_SweepGrid *grids,
    exint ngrids,
    const exint cross_sections_per_vertex,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const exint cap_divisions,
    const bool swap_row_col,
    const COPY_FUNCTOR &copy_functor)
{
    UT_ASSERT(output_attrib->getOwner() == attrib_owner);
    SYS_STATIC_ASSERT(attrib_owner == GA_ATTRIB_POINT || attrib_owner == GA_ATTRIB_VERTEX);

    output_attrib->bumpDataId();

    auto&& functor = [&](const UT_BlockedRange<exint>& r)
    {
        for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
        {
            const sop_SweepGrid &grid_info = grids[gridi];
            GU_GridT<GA_Offset> grid;
            initGUGrid(grid_info, surface_type, output_points_only, triangular_poles, swap_row_col, grid_info.myStartPtOff, grid);

            const GA_OffsetListRef vertices = curve_input->getPrimitiveVertexList(grid_info.myCurvePrimOff);
            if (attrib_owner == GA_ATTRIB_VERTEX)
            {
                copyVertexCurveAttribWrapper<wrap_to_invalid>(grid_info, grid, vertices.size(), cap_divisions, cross_sections_per_vertex, swap_row_col,
                    [&copy_functor,&vertices](GA_Offset output_vtxoff, exint curve_vtxi)
                {
                    GA_Offset curve_vtxoff = (wrap_to_invalid && curve_vtxi < 0) ? GA_INVALID_OFFSET : vertices(curve_vtxi);
                    copy_functor(output_vtxoff, curve_vtxoff);
                });
            }
            else
            {
                UT_ASSERT(attrib_owner == GA_ATTRIB_POINT);
                const exint cap_divs = (grid_info.myVEndPoles && !grid_info.myHasPolygonCaps) ? cap_divisions : 0;
                exint prev_vtxi = -1;
                GA_Offset curve_ptoff;
                GUiterateGridPoints(grid, [cap_divs, &vertices, &prev_vtxi,
                    &curve_ptoff, curve_input, cross_sections_per_vertex, swap_row_col, &copy_functor]
                    (GA_Offset output_ptoff, exint row, exint col)
                {
                    exint vtxi = swap_row_col ? col : row;
                    if (vtxi != prev_vtxi)
                    {
                        exint curve_vtxi = vtxi - cap_divs;
                        if (cross_sections_per_vertex != 1)
                            curve_vtxi /= cross_sections_per_vertex;
                        if (curve_vtxi < 0)
                            curve_vtxi = 0;
                        else if (curve_vtxi >= vertices.size())
                            curve_vtxi = vertices.size()-1;
                        GA_Offset curve_vtxoff = vertices(curve_vtxi);
                        curve_ptoff = curve_input->vertexPoint(curve_vtxoff);
                        prev_vtxi = vtxi;
                    }
                    copy_functor(output_ptoff, curve_ptoff);
                });
            }
        }
    };

    const exint PARALLEL_THRESHOLD = 2048;
    if (ngrids > 1 && output_attrib->getIndexMap().indexSize() >= PARALLEL_THRESHOLD)
    {
        // Must harden all pages before multi-threading.
        output_attrib->hardenAllPages();

        UTparallelFor(UT_BlockedRange<exint>(0, ngrids), functor);
    }
    else
    {
        functor(UT_BlockedRange<exint>(0, ngrids));
    }
}

static void
copyCurveAttrib(
    GA_Attribute *output_attrib,
    const GA_Attribute *curve_attrib,
    const GEO_Detail *curve_input,
    const sop_SweepGrid *grids,
    exint ngrids,
    const exint cross_sections_per_vertex,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const exint cap_divisions,
    const bool swap_row_col)
{
    UT_ASSERT(output_attrib->getOwner() == curve_attrib->getOwner());

    const GA_AttributeOwner owner = output_attrib->getOwner();
    if (owner == GA_ATTRIB_POINT)
    {
        auto &&copy_functor = [output_attrib,curve_attrib](GA_Offset output_off, GA_Offset curve_off)
        {
            output_attrib->copy(output_off, *curve_attrib, curve_off);
        };
        copyCurveAttrib2<GA_ATTRIB_POINT>(
            output_attrib, curve_input,
            grids, ngrids, cross_sections_per_vertex,
            surface_type, output_points_only, triangular_poles, cap_divisions,
            swap_row_col, copy_functor);
    }
    else if (owner == GA_ATTRIB_VERTEX)
    {
        if (!output_points_only)
        {
            auto &&copy_functor = [output_attrib,curve_attrib](GA_Offset output_off, GA_Offset curve_off)
            {
                output_attrib->copy(output_off, *curve_attrib, curve_off);
            };
            copyCurveAttrib2<GA_ATTRIB_VERTEX>(
                output_attrib, curve_input,
                grids, ngrids, cross_sections_per_vertex,
                surface_type, output_points_only, triangular_poles, cap_divisions,
                swap_row_col, copy_functor);
        }
    }
    else if (owner == GA_ATTRIB_PRIMITIVE)
    {
        if (!output_points_only)
        {
            UT_ASSERT(curve_attrib->getOwner() == GA_ATTRIB_PRIMITIVE);

            output_attrib->bumpDataId();

            auto&& functor = [&](const UT_BlockedRange<exint>& r)
            {
                for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                {
                    const sop_SweepGrid &grid_info = grids[gridi];
                    GU_GridT<GA_Offset> grid;
                    initGUGrid(grid_info, surface_type, output_points_only, triangular_poles, swap_row_col, grid_info.myStartPtOff, grid);

                    // Copy same value to all primitives in grid
                    const GA_Offset startprimoff = grid_info.myStartPrimOff;
                    const GA_Offset endprimoff = startprimoff + grid.myNumPrimitives + (grid_info.myHasPolygonCaps ? 2 : 0);
                    output_attrib->fill(GA_Range(output_attrib->getIndexMap(), startprimoff, endprimoff), *curve_attrib, grid_info.myCurvePrimOff);
                }
            };

            const exint PARALLEL_THRESHOLD = 2048;
            if (ngrids > 1 && output_attrib->getIndexMap().indexSize() >= PARALLEL_THRESHOLD)
            {
                // Must harden all pages before multi-threading.
                output_attrib->hardenAllPages();

                UTparallelFor(UT_BlockedRange<exint>(0, ngrids), functor);
            }
            else
            {
                functor(UT_BlockedRange<exint>(0, ngrids));
            }
        }
    }
    else if (owner == GA_ATTRIB_DETAIL)
    {
        output_attrib->replace(*curve_attrib);
    }
}

enum class UVStyle {
    NORMALIZED,
    ROUNDED,
    FULL
};

// This is for copying a single component from the cross section attribute to the grid.
// NOTE: UVStyle should already be folded into uscale by the caller!
template<typename T,GA_AttributeOwner output_owner>
static void
copyCrossSectionUVSingleGrid(
    GA_ATINumeric *output_attrib,
    const GA_ATINumeric *cross_section_attrib,
    const GA_AttributeOwner cross_section_owner,
    const GEO_Detail *cross_section_input,
    const sop_SweepGrid &grid_info,
    const GU_GridT<GA_Offset> &grid,
    const bool is_cross_section_uv_computed,
    const bool reverse_cross_sections,
    const bool swap_row_col,
    const bool flipu,
    const T uscale,
    const UT_Array<double> *missing_input_us = nullptr)
{
    UT_ASSERT_P((cross_section_attrib != nullptr && cross_section_input != nullptr && cross_section_owner != GA_ATTRIB_INVALID)
        || (cross_section_owner == GA_ATTRIB_INVALID && missing_input_us != nullptr));

    SYS_STATIC_ASSERT(!std::is_integral<T>::value);

    const int tuple_size = output_attrib->getTupleSize();

    // Non-transforming
    auto &&get_transform = [](const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const void*
    {
        return nullptr;
    };

    if (cross_section_owner == GA_ATTRIB_INVALID)
    {
        // Single cross section with implicit U value already computed.
        UT_ASSERT(missing_input_us != nullptr);
        UT_ASSERT(output_owner == GA_ATTRIB_VERTEX || output_owner == GA_ATTRIB_POINT);
        if (tuple_size == 2)
        {
            const GA_RWHandleT<UT_Vector2T<T>> outputh(output_attrib);
            UT_ASSERT_P(outputh.isValid());
            auto &&copy_functor = [missing_input_us,&outputh,flipu,swap_row_col,uscale](
                GA_Offset output_offset, exint row, exint col)
            {
                const exint cross_section_vtxi = swap_row_col ? row : col;
                T value = (cross_section_vtxi == missing_input_us->size()) ? T(1.0) : (*missing_input_us)[cross_section_vtxi];
                if (flipu)
                    value = T(1.0)-value;
                UT_Vector2T<T> output_value = outputh.get(output_offset);
                output_value[theUComponent] = uscale*value;
                outputh.set(output_offset, output_value);
            };
            if (output_owner == GA_ATTRIB_VERTEX)
                copyVertexCrossSectionWrapper(grid, grid_info, copy_functor);
            else
                GUiterateGridPoints(grid, copy_functor);
        }
        else if (tuple_size == 3)
        {
            const GA_RWHandleT<UT_Vector3T<T>> outputh(output_attrib);
            UT_ASSERT_P(outputh.isValid());
            auto &&copy_functor = [missing_input_us,&outputh,flipu,swap_row_col,uscale](
                GA_Offset output_offset, exint row, exint col)
            {
                const exint cross_section_vtxi = swap_row_col ? row : col;
                T value = (cross_section_vtxi == missing_input_us->size()) ? T(1.0) : (*missing_input_us)[cross_section_vtxi];
                if (flipu)
                    value = T(1.0)-value;
                UT_Vector3T<T> output_value = outputh.get(output_offset);
                output_value[theUComponent] = uscale*value;
                outputh.set(output_offset, output_value);
            };
            if (output_owner == GA_ATTRIB_VERTEX)
                copyVertexCrossSectionWrapper(grid, grid_info, copy_functor);
            else
                GUiterateGridPoints(grid, copy_functor);
        }
        return;
    }

    if (tuple_size == 2)
    {
        // Copy u component of 2-component numeric attribute
        auto &&transform_and_copy = [flipu,reverse_cross_sections,uscale,is_cross_section_uv_computed](
            const GA_ROHandleT<T> &cross_sectionh, GA_Offset cross_section_offset,
            const void *transform,
            const GA_RWHandleT<UT_Vector2T<T>> &outputh, GA_Offset output_offset)
        {
            T value;
            if (output_owner == GA_ATTRIB_VERTEX && cross_section_offset == GA_INVALID_OFFSET)
                value = reverse_cross_sections ? T(0.0) : T(1.0);
            else
                value = cross_sectionh.get(cross_section_offset);

            if (flipu)
                value = T(1.0)-value;
            if (is_cross_section_uv_computed)
                value *= uscale;
            UT_Vector2T<T> output_value = outputh.get(output_offset);
            output_value[theUComponent] = value;
            outputh.set(output_offset, output_value);
        };
        auto &&transform_and_interp = [flipu,reverse_cross_sections,uscale,is_cross_section_uv_computed](
            const GA_ROHandleT<T> &cross_sectionh,
            GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
            const void *transform,
            const GA_RWHandleT<UT_Vector2T<T>> &outputh, GA_Offset output_offset)
        {
            UT_ASSERT_P(GAisValid(cross_section_offset0));
            const T value0 = cross_sectionh.get(cross_section_offset0);
            // cross_section_offset1 might be invalid here if we have closed, non-unrolled
            // cross sections with different numbers of vertices and we're on the last edge.
            T value1;
            if (output_owner == GA_ATTRIB_VERTEX && cross_section_offset1 == GA_INVALID_OFFSET)
                value1 = reverse_cross_sections ? T(0.0) : T(1.0);
            else
                value1 = cross_sectionh.get(cross_section_offset1);

            T value = SYSlerp(value0, value1, t);
            if (flipu)
                value = T(1.0)-value;
            if (is_cross_section_uv_computed)
                value *= uscale;
            UT_Vector2T<T> output_value = outputh.get(output_offset);
            output_value[theUComponent] = value;
            outputh.set(output_offset, output_value);
        };
        GA_ROHandleT<T> cross_sectionh(cross_section_attrib);
        GA_RWHandleT<UT_Vector2T<T>> outputh(output_attrib);
        // true indicates to specify GA_INVALID_OFFSET, instead of the first vertex,
        // when wrapping, so that 1.0 can be written.
        constexpr bool wrap_to_invalid = output_owner == GA_ATTRIB_VERTEX;
        copyCrossSectionAttributeWrapper2<void, output_owner, wrap_to_invalid>(grid,
            outputh, cross_sectionh, cross_section_owner, cross_section_input, nullptr, grid_info,
            reverse_cross_sections, swap_row_col,
            get_transform, transform_and_copy, transform_and_interp);
        return;
    }
    if (tuple_size == 3)
    {
        // Copy u component of 3-component numeric attribute
        auto &&transform_and_copy = [flipu,reverse_cross_sections,uscale,is_cross_section_uv_computed](
            const GA_ROHandleT<T> &cross_sectionh, GA_Offset cross_section_offset,
            const void *transform,
            const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
        {
            T value;
            if (output_owner == GA_ATTRIB_VERTEX && cross_section_offset == GA_INVALID_OFFSET)
                value = reverse_cross_sections ? T(0.0) : T(1.0);
            else
                value = cross_sectionh.get(cross_section_offset);

            if (flipu)
                value = T(1.0)-value;
            if (is_cross_section_uv_computed)
                value *= uscale;
            UT_Vector3T<T> output_value = outputh.get(output_offset);
            output_value[theUComponent] = value;
            outputh.set(output_offset, output_value);
        };
        auto &&transform_and_interp = [flipu,reverse_cross_sections,uscale,is_cross_section_uv_computed](
            const GA_ROHandleT<T> &cross_sectionh,
            GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
            const void *transform,
            const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
        {
            UT_ASSERT_P(GAisValid(cross_section_offset0));
            const T value0 = cross_sectionh.get(cross_section_offset0);
            // cross_section_offset1 might be invalid here if we have closed, non-unrolled
            // cross sections with different numbers of vertices and we're on the last edge.
            T value1;
            if (output_owner == GA_ATTRIB_VERTEX && cross_section_offset1 == GA_INVALID_OFFSET)
                value1 = reverse_cross_sections ? T(0.0) : T(1.0);
            else
                value1 = cross_sectionh.get(cross_section_offset1);

            T value = SYSlerp(value0, value1, t);
            if (flipu)
                value = T(1.0)-value;
            if (is_cross_section_uv_computed)
                value *= uscale;
            UT_Vector3T<T> output_value = outputh.get(output_offset);
            output_value[theUComponent] = value;
            outputh.set(output_offset, output_value);
        };
        GA_ROHandleT<T> cross_sectionh(cross_section_attrib);
        GA_RWHandleT<UT_Vector3T<T>> outputh(output_attrib);
        // true indicates to specify GA_INVALID_OFFSET, instead of the first vertex,
        // when wrapping, so that 1.0 can be written.
        constexpr bool wrap_to_invalid = output_owner == GA_ATTRIB_VERTEX;
        copyCrossSectionAttributeWrapper2<void, output_owner, wrap_to_invalid>(grid,
            outputh, cross_sectionh, cross_section_owner, cross_section_input, nullptr, grid_info,
            reverse_cross_sections, swap_row_col,
            get_transform, transform_and_copy, transform_and_interp);
        return;
    }
}

template<typename T>
static UT_Vector3D crossSectionCenter(
    bool swap_row_col,
    const GA_ROHandleT<UT_Vector3T<T>> &pos,
    const GU_GridT<GA_Offset> &grid,
    const exint cross_section_nedges,
    const exint curve_row)
{
    UT_Vector3D sum(0,0,0);
    for (exint cross_section_vtxi = 0; cross_section_vtxi < cross_section_nedges; ++cross_section_vtxi)
    {
        exint row = curve_row;;
        exint col = cross_section_vtxi;
        if (swap_row_col)
            UTswap(row, col);
        const UT_Vector3T<T> curr_pos = pos.get(grid.getPoint(row, col));
        sum += curr_pos;
    }

    return sum / cross_section_nedges;
}

// Computes the total "length" of a single cross section in
// the given grid.  If dir0 is null, positions are treated as is.
// If dir0 is non-null and dir1 is null, dir0 will be projected
// out of the positions before length is computed.
// If dir0 and dir1 are both non-null, the average of the two projections
// will be computed.  Each must be normalized if non-null.
template<typename T>
static double crossSectionLength(
    bool swap_row_col,
    const GA_ROHandleT<UT_Vector3T<T>> &pos,
    const GU_GridT<GA_Offset> &grid,
    const exint cross_section_nedges,
    const exint curve_row,
    const UT_Vector3T<T> *dir0,
    const UT_Vector3T<T> *dir1)
{
    double cross_section_length = 0;
    exint row = curve_row;
    exint col = 0;
    if (swap_row_col)
        UTswap(row, col);
    UT_Vector3T<T> prevpos = pos.get(grid.getPoint(row, col));
    UT_Vector3T<T> prevpos0;
    UT_Vector3T<T> prevpos1;
    if (dir0 != nullptr)
    {
        T d = prevpos.dot(*dir0);
        prevpos0 = prevpos - d*(*dir0);
        if (dir1 != nullptr)
        {
            d = prevpos.dot(*dir1);
            prevpos1 = prevpos - d*(*dir1);
        }
    }
    for (exint cross_section_vtxi = 0; cross_section_vtxi < cross_section_nedges; ++cross_section_vtxi)
    {
        exint row = curve_row;
        exint col = cross_section_vtxi+1;
        if (swap_row_col)
            UTswap(row, col);
        const UT_Vector3T<T> nextpos = pos.get(grid.getPoint(row, col));
        UT_Vector3T<T> nextpos0;
        UT_Vector3T<T> nextpos1;
        if (dir0 != nullptr)
        {
            T d = nextpos.dot(*dir0);
            nextpos0 = nextpos - d*(*dir0);
            T dist0 = prevpos0.distance(nextpos0);
            if (dir1 != nullptr)
            {
                d = nextpos.dot(*dir1);
                nextpos1 = nextpos - d*(*dir1);

                cross_section_length += 0.5f*(dist0 + prevpos1.distance(nextpos1));
            }
            else
            {
                cross_section_length += dist0;
            }
        }
        else
        {
            cross_section_length += prevpos.distance(nextpos);
        }
        prevpos = nextpos;
        if (dir0 != nullptr)
        {
            prevpos0 = nextpos0;
            if (dir1 != nullptr)
                prevpos1 = nextpos1;
        }
    }
    return cross_section_length;
}

template<typename T, typename FUNCTOR>
static void iterateCurveEdgeLengths(
    const exint curve_nedges,
    const bool use_mesh_edge_lengths,

    const exint cross_section_npts,
    const bool swap_row_col,
    const GA_ROHandleT<UT_Vector3T<T>> &pos,
    const GU_GridT<GA_Offset> &grid,

    const sop_SweepGrid &grid_info,
    const exint cap_divisions,
    const GA_ROHandleT<UT_Vector3T<T>> &curve_pos,
    const GEO_Detail *curve_input,
    const GA_OffsetListRef &curve_vertices,

    FUNCTOR&& functor)
{
    for (exint curve_vtxi = 0; curve_vtxi < curve_nedges; ++curve_vtxi)
    {
        double length_sum = 0;
        exint length_sum_count;
        if (use_mesh_edge_lengths)
        {
            length_sum_count = cross_section_npts;
            for (exint cross_section_vtxi = 0; cross_section_vtxi < cross_section_npts; ++cross_section_vtxi)
            {
                exint col0 = swap_row_col ? curve_vtxi : cross_section_vtxi;
                exint col1 = swap_row_col ? curve_vtxi+1 : cross_section_vtxi;
                exint row0 = swap_row_col ? cross_section_vtxi : curve_vtxi;
                exint row1 = swap_row_col ? cross_section_vtxi : curve_vtxi+1;
                const UT_Vector3T<T> p0 = pos.get(grid.getPoint(row0, col0));
                const UT_Vector3T<T> p1 = pos.get(grid.getPoint(row1, col1));
                length_sum += p0.distance(p1);
            }
        }
        else
        {
            length_sum_count = 1;
            exint orig_curve_vtxi = curve_vtxi;
            if (grid_info.myVEndPoles)
            {
                // Caps all correspond with the curve end positions
                orig_curve_vtxi -= cap_divisions;
                orig_curve_vtxi = SYSclamp(orig_curve_vtxi, GA_Size(0), curve_vertices.size()-1);
            }
            const UT_Vector3T<T> p0 = curve_pos.get(curve_input->vertexPoint(curve_vertices(orig_curve_vtxi)));
            exint orig_curve_vtxi1 = (curve_vertices.getExtraFlag() && curve_vtxi+1 == curve_nedges) ? 0 : curve_vtxi+1;
            if (grid_info.myVEndPoles)
            {
                // Same shift and clamping as with the previous vertex.
                // This can end up with both at the same vertex, so a length of zero for this edge.
                orig_curve_vtxi1 -= cap_divisions;
                orig_curve_vtxi1 = SYSclamp(orig_curve_vtxi1, GA_Size(0), curve_vertices.size()-1);
            }
            const UT_Vector3T<T> p1 = curve_pos.get(curve_input->vertexPoint(curve_vertices(orig_curve_vtxi1)));
            length_sum = p0.distance(p1);
        }

        functor(curve_vtxi, length_sum, length_sum_count);
    }
}

// NOTE: pos is double-precision to match computeGridUVScales
template<GA_AttributeOwner output_owner, typename T>
static void
generateLengthWeightedV(
    const sop_SweepGrid &grid_info,
    const GU_GridT<GA_Offset> &grid,
    const exint cross_sections_per_vertex,
    const GA_RWHandleT<T> &outputh,
    const GA_ROHandleV3D &pos,
    UVStyle ustyle,
    UVStyle vstyle,
    bool scalevasu_usingmax,
    double vscale,
    double orig_vscale,
    bool swap_row_col,
    bool use_mesh_edge_lengths,
    const GEO_Detail *curve_input)
{
    //const exint nedgerows = grid.myNumEdgeRows;
    //const exint nedgecols = grid.myNumEdgeCols;
    const exint curve_nedges = grid_info.myCurveNEdges;
    const exint cross_section_nedges = grid_info.myCrossSectionNEdges;

    GA_OffsetListRef curve_vertices;
    // NOTE: curve_pos is double-precision to match computeGridUVScales
    GA_ROHandleV3D curve_pos;
    exint cap_divisions = 0;
    if (curve_input != nullptr)
    {
        curve_vertices = curve_input->getPrimitiveVertexList(grid_info.myCurvePrimOff);
        if (grid_info.myVEndPoles)
        {
            UT_ASSERT_MSG(!curve_vertices.getExtraFlag(), "Curve should be open, not closed");
            exint orig_curve_nedges = curve_vertices.size() - 1;
            cap_divisions = (grid_info.myCurveNEdges - orig_curve_nedges)/2;
            UT_ASSERT(cap_divisions >= 1);
        }
        curve_pos.bind(curve_input->getP());
    }

    bool norm_u_unnorm_v = (ustyle == UVStyle::NORMALIZED && vstyle != UVStyle::NORMALIZED);
    bool special_case_u_division = (!scalevasu_usingmax && norm_u_unnorm_v);
    //bool need_max_cross_section_length = (scalevasu_usingmax && norm_u_unnorm_v);

    UT_Vector3D prevPos;
    bool prevPosValid = false;
    UT_Vector3D currPos;
    bool currPosValid = false;
    UT_Vector3D nextPos;
    UT_Vector3D dir0;
    UT_Vector3D dir1;
    double length0 = 0;
    double length1 = 0;
    UT_Vector3D *pdir0 = nullptr;
    UT_Vector3D *pdir1 = nullptr;
    double prev_cross_section_length = 0;
    if (special_case_u_division)
    {
        if (curve_input != nullptr)
        {
            UT_ASSERT_P(curve_pos.isValid());
            UT_ASSERT(curve_vertices.size() > 0);
            if (curve_vertices.size() >= 2)
            {
                currPos = curve_pos.get(curve_input->vertexPoint(curve_vertices[0]));
                nextPos = curve_pos.get(curve_input->vertexPoint(curve_vertices[1]));
                currPosValid = true;
                if (grid_info.myCurveClosed)
                {
                    // Closed grid in curve direction, possibly open curve with shared point (unrolled)
                    bool unrolled = !curve_vertices.getExtraFlag();
                    exint last_vtxi = curve_vertices.size() - (unrolled ? 2 : 1);
                    prevPos = curve_pos.get(curve_input->vertexPoint(curve_vertices[last_vtxi]));
                    prevPosValid = true;
                }
            }
        }
        else if (curve_nedges >= 1 + (grid_info.myVEndPoles ? 2*cap_divisions : 0))
        {
            // If there's no curve, we use the cross section centers to
            // determine the implicit curve egde directions.
            exint start = grid_info.myVEndPoles ? cap_divisions : 0;
            currPos = crossSectionCenter(swap_row_col, pos, grid, cross_section_nedges, start);
            nextPos = crossSectionCenter(swap_row_col, pos, grid, cross_section_nedges, start+1);
            currPosValid = true;
            if (grid_info.myCurveClosed)
            {
                prevPos = crossSectionCenter(swap_row_col, pos, grid, cross_section_nedges, curve_nedges-1);
                prevPosValid = true;
            }
        }

        if (prevPosValid)
        {
            dir0 = (currPos - prevPos);
            dir1 = (nextPos - currPos);
            length0 = dir0.normalize();
            length1 = dir1.normalize();
            if (length0 != 0 && length1 != 0)
            {
                pdir0 = &dir0;
                pdir1 = &dir1;
            }
            else if (length0 != 0 || length1 != 0)
                pdir0 = (length0 != 0) ? &dir0 : &dir1;
        }
        else if (currPosValid)
        {
            dir1 = (nextPos - currPos);
            length1 = dir1.normalize();
            if (length1 != 0)
                pdir0 = &dir1;
        }

        prev_cross_section_length = crossSectionLength(swap_row_col, pos, grid, cross_section_nedges, 0, pdir0, pdir1);
        if (currPosValid)
        {
            currPos = nextPos;
            dir0 = dir1;
            length0 = length1;
        }
    }
#if 0
    double max_cross_section_length = 0;
    if (need_max_cross_section_length)
    {
        for (exint curve_vtxi = 0; curve_vtxi <= curve_nedges; ++curve_vtxi)
        {
            double cross_section_length = crossSectionLength(swap_row_col, pos, grid, cross_section_nedges, curve_vtxi, dir0, dir1);
            max_cross_section_length = SYSmax(cross_section_length, max_cross_section_length);
        }
    }
#endif

    UT_SmallArray<double> length_sums;
    length_sums.setSizeNoInit(curve_nedges+1);
    length_sums[0] = 0;
    double total_length_sum = 0;
    exint curve_npts = curve_nedges + !grid_info.myCurveClosed;
    exint cross_section_npts = cross_section_nedges + !grid_info.myCrossSectionClosed;
    iterateCurveEdgeLengths(
        curve_nedges,
        use_mesh_edge_lengths,
        cross_section_npts,
        swap_row_col,
        pos,
        grid,
        grid_info,
        cap_divisions,
        curve_pos,
        curve_input,
        curve_vertices,
        [&](exint curve_vtxi, double length_sum, exint length_sum_count)
    {
        if (special_case_u_division)
        {
            bool nextPosValid = false;
            // FIXME: Double-check these bounds!!!
            if (!grid_info.myVEndPoles || (curve_vtxi >= cap_divisions && curve_vtxi < curve_npts-cap_divisions))
            {
                nextPosValid = true;
                if (cross_section_nedges >= 1)
                {
                    exint nextPosVtxi = curve_vtxi+2;
                    exint threshold = curve_npts;
                    if (grid_info.myVEndPoles)
                    {
                        nextPosVtxi -= cap_divisions;
                        threshold -= 2*cap_divisions;
                    }
                    if (nextPosVtxi >= threshold)
                    {
                        if (grid_info.myCurveClosed)
                            nextPosVtxi -= curve_npts;
                        else
                            nextPosValid = false;
                    }
                    if (nextPosValid)
                    {
                        if (curve_input != nullptr)
                        {
                            UT_ASSERT_P(curve_pos.isValid());
                            exint next_curve_vtxi = nextPosVtxi;
                            if (cross_sections_per_vertex != 1)
                                next_curve_vtxi /= cross_sections_per_vertex;
                            if (next_curve_vtxi < 0)
                                next_curve_vtxi = 0;
                            else if (next_curve_vtxi >= curve_vertices.size())
                                next_curve_vtxi = curve_vertices.size()-1;
                            GA_Offset curve_vtxoff = curve_vertices[next_curve_vtxi];
                            GA_Offset curve_ptoff = curve_input->vertexPoint(curve_vtxoff);
                            nextPos = curve_pos.get(curve_ptoff);
                        }
                        else
                        {
                            nextPos = crossSectionCenter(swap_row_col, pos, grid, cross_section_nedges, nextPosVtxi);
                        }
                    }
                }
                pdir0 = nullptr;
                pdir1 = nullptr;
                if (nextPosValid)
                {
                    dir1 = (nextPos - currPos);
                    length1 = dir1.normalize();
                    if (length0 != 0 && length1 != 0)
                    {
                        pdir0 = &dir0;
                        pdir1 = &dir1;
                    }
                    else if (length0 != 0 || length1 != 0)
                        pdir0 = (length0 != 0) ? &dir0 : &dir1;
                }
                else if (length0 != 0)
                {
                    pdir0 = &dir0;
                }
            }
            double next_cross_section_length = crossSectionLength(swap_row_col, pos, grid, cross_section_nedges, curve_vtxi+1, pdir0, pdir1);
            if (nextPosValid)
            {
                currPos = nextPos;
                dir0 = dir1;
                length0 = length1;
            }
            // Use adjacent cross section lengths
            double curr_cross_section_length_avg = 0.5*(prev_cross_section_length + next_cross_section_length);
            if (curr_cross_section_length_avg == 0)
                length_sum = 0;
            else
            {
                // Also normalize length_sum to an average at the same time
                length_sum /= (length_sum_count*curr_cross_section_length_avg);
            }

            prev_cross_section_length = next_cross_section_length;
        }
        else
        {
            // Normalize length_sum to an average
            length_sum /= length_sum_count;
        }

        total_length_sum += length_sum;
        length_sums[curve_vtxi+1] = vscale*total_length_sum;
    });

    UT_ASSERT_MSG(total_length_sum != 0 || (vstyle != UVStyle::NORMALIZED), "computeGridUVScales should have fallen back to v being uniform");

    if (vstyle == UVStyle::NORMALIZED)
    {
        // Ensure that the end is exactly 1 (or the original V scale), regardless of any roundoff error
        length_sums[curve_nedges] = orig_vscale;
        // If any earlier values are greater than 1, make them exactly 1.
        for (exint curve_vtxi = curve_nedges-1; curve_vtxi >= 0 && length_sums[curve_vtxi] > orig_vscale; ++curve_vtxi)
        {
            length_sums[curve_vtxi] = orig_vscale;
        }
    }
    else if (vstyle == UVStyle::ROUNDED)
    {
        // Ensure that the end is exactly an integer >= 1, regardless of any roundoff error
        double &rounded = length_sums[curve_nedges];
        rounded = SYSrint(rounded);
        if (rounded < 1)
            rounded = 1;
        length_sums[curve_nedges] = rounded;
        // If any earlier values are greater than rounded, make them exactly rounded.
        for (exint curve_vtxi = curve_nedges-1; curve_vtxi >= 0 && length_sums[curve_vtxi] > rounded; ++curve_vtxi)
        {
            length_sums[curve_vtxi] = rounded;
        }
    }

    // length_sums array should be ready for use, at this point.


    exint cap_vertex_count = 0;
    if (grid_info.myHasPolygonCaps && output_owner == GA_ATTRIB_VERTEX)
    {
        if (swap_row_col ? grid.myNoWrapU : grid.myNoWrapV)
        {
            // First row cap
            cap_vertex_count = cross_section_nedges;
            for (exint col = 0; col < cap_vertex_count; ++col)
            {
                outputh.set(grid_info.myStartVtxOff + col, theVComponent, 0);
            }
        }
        else
        {
            // First side col cap
            cap_vertex_count = curve_nedges;
            // TODO: This won't work.
        }
    }
    const GA_Offset start_vtxoff = grid_info.myStartVtxOff + cap_vertex_count;
    if (output_owner == GA_ATTRIB_VERTEX)
    {
        // Copy to main grid vertices
        GUiterateGridVertices(grid, [&outputh, start_vtxoff, swap_row_col, &length_sums]
            (exint vtxnum, exint row, exint col, bool isrowend, bool iscolend, exint primnum, exint primvtxnum)
        {
            exint curve_vtxi = swap_row_col ? col : row;
            curve_vtxi += exint(swap_row_col ? iscolend : isrowend);
            outputh.set(start_vtxoff + vtxnum, theVComponent, length_sums[curve_vtxi]);
        });
    }
    else
    {
        // Copy to grid points
        const GA_Offset start_ptoff = grid_info.myStartPtOff;
        GUiterateGridPoints(grid, [&outputh, start_ptoff, swap_row_col, &length_sums]
            (exint ptnum, exint row, exint col)
        {
            exint curve_vtxi = swap_row_col ? col : row;
            outputh.set(start_ptoff + ptnum, theVComponent, length_sums[curve_vtxi]);
        });
    }
    if (grid_info.myHasPolygonCaps && output_owner == GA_ATTRIB_VERTEX)
    {
        // Last cap starts after main grid
        const GA_Offset cap_start_vtxoff = start_vtxoff + grid.myNumVertices;
        if (swap_row_col ? grid.myNoWrapU : grid.myNoWrapV)
        {
            // Last row cap
            for (exint col = 0; col < cap_vertex_count; ++col)
            {
                outputh.set(cap_start_vtxoff + col, theVComponent, length_sums[curve_nedges]);
            }
        }
        else
        {
            // Last side col cap
            // TODO: This won't work.
        }
    }
}

template<GA_AttributeOwner output_owner, typename T>
static void
generateUniformV(
    const sop_SweepGrid &grid_info,
    const GU_GridT<GA_Offset> &grid,
    const GA_RWHandleT<T> &outputh,
    bool swap_row_col,
    const T vscale)
{
    const exint curve_nedges = grid_info.myCurveNEdges;
    const exint cross_section_nedges = grid_info.myCrossSectionNEdges;

    // Uniform V coordinate along grid
    exint cap_vertex_count = 0;
    if (grid_info.myHasPolygonCaps && output_owner == GA_ATTRIB_VERTEX)
    {
        if (swap_row_col ? grid.myNoWrapU : grid.myNoWrapV)
        {
            // First row cap
            cap_vertex_count = cross_section_nedges;
            for (exint col = 0; col < cap_vertex_count; ++col)
            {
                outputh.set(grid_info.myStartVtxOff + col, theVComponent, 0);
            }
        }
        else
        {
            // First side col cap
            cap_vertex_count = curve_nedges;
            // TODO: This won't work.
        }
    }

    const GA_Offset start_vtxoff = grid_info.myStartVtxOff + cap_vertex_count;
    const T recip_curve_nedges = (curve_nedges == 0) ? T(0.0) : (vscale/curve_nedges);
    if (output_owner == GA_ATTRIB_VERTEX)
    {
        // Copy to main grid vertices
        GUiterateGridVertices(grid, [&outputh, recip_curve_nedges, start_vtxoff, swap_row_col]
            (exint vtxnum, exint row, exint col, bool isrowend, bool iscolend, exint primnum, exint primvtxnum)
        {
            exint curve_vtxi = swap_row_col ? col : row;
            curve_vtxi += exint(swap_row_col ? iscolend : isrowend);
            outputh.set(start_vtxoff + vtxnum, theVComponent, T(curve_vtxi)*recip_curve_nedges);
        });
    }
    else
    {
        // Copy to grid points
        const GA_Offset start_ptoff = grid_info.myStartPtOff;
        GUiterateGridPoints(grid, [&outputh, recip_curve_nedges, start_ptoff, swap_row_col]
            (exint ptnum, exint row, exint col)
        {
            exint curve_vtxi = swap_row_col ? col : row;
            outputh.set(start_ptoff + ptnum, theVComponent, T(curve_vtxi)*recip_curve_nedges);
        });
    }
    if (grid_info.myHasPolygonCaps && output_owner == GA_ATTRIB_VERTEX)
    {
        // Last cap starts after main grid
        const GA_Offset cap_start_vtxoff = start_vtxoff + grid.myNumVertices;
        if (swap_row_col ? grid.myNoWrapU : grid.myNoWrapV)
        {
            // Last row cap
            for (exint col = 0; col < cap_vertex_count; ++col)
            {
                outputh.set(cap_start_vtxoff + col, theVComponent, vscale);
            }
        }
        else
        {
            // Last side col cap
            // TODO: This won't work.
        }
    }
}

static UT_Vector2D computeGridUVScales(
    const GA_Detail *output_detail,
    const GEO_Detail *cross_section_input,
    const GEO_Detail *curve_input,
    const sop_SweepGrid &grid_info,
    GU_GridT<GA_Offset> grid,
    const bool swap_row_col,
    const exint cross_sections_per_vertex,
    const exint cap_divisions,
    const UVStyle ustyle,
    const UVStyle vstyle,
    const bool use_mesh_edge_lengths,
    const bool scalevasu_usingmax,
    UT_Vector2D uvscale,
    bool &fallback_to_uniform_v)
{
    fallback_to_uniform_v = false;

    const exint curve_nedges = grid_info.myCurveNEdges;
    const exint curve_npts = curve_nedges + !grid_info.myCurveClosed;
    const exint cross_section_nedges = grid_info.myCrossSectionNEdges;
    exint cross_section_npts = cross_section_nedges + !grid_info.myCrossSectionClosed;

    // For simplicity, for now, always compute everything.
    // TODO: Only compute what's needed.
    const GA_ROHandleV3D pos(output_detail->getP());
    GA_ROHandleV3D curve_pos;
    GA_OffsetListRef curve_vertices;
    UT_Vector3D prevPos;
    bool prevPosValid = false;
    UT_Vector3D currPos;
    bool currPosValid = false;
    UT_Vector3D nextPos;
    if (curve_input != nullptr)
    {
        curve_pos.bind(curve_input->getP());
        UT_ASSERT_P(curve_pos.isValid());
        curve_vertices = curve_input->getPrimitiveVertexList(grid_info.myCurvePrimOff);
        UT_ASSERT(curve_vertices.size() > 0);
        if (curve_vertices.size() >= 2)
        {
            currPos = curve_pos.get(curve_input->vertexPoint(curve_vertices[0]));
            nextPos = curve_pos.get(curve_input->vertexPoint(curve_vertices[1]));
            currPosValid = true;
            if (grid_info.myCurveClosed)
            {
                // Closed grid in curve direction, possibly open curve with shared point (unrolled)
                bool unrolled = !curve_vertices.getExtraFlag();
                exint last_vtxi = curve_vertices.size() - (unrolled ? 2 : 1);
                prevPos = curve_pos.get(curve_input->vertexPoint(curve_vertices[last_vtxi]));
                prevPosValid = true;
            }
        }
    }
    else if (curve_nedges >= 1 + (grid_info.myVEndPoles ? 2*cap_divisions : 0))
    {
        // If there's no curve, we use the cross section centers to
        // determine the implicit curve egde directions.
        exint start = grid_info.myVEndPoles ? cap_divisions : 0;
        currPos = crossSectionCenter(swap_row_col, pos, grid, cross_section_nedges, start);
        nextPos = crossSectionCenter(swap_row_col, pos, grid, cross_section_nedges, start+1);
        currPosValid = true;
        if (grid_info.myCurveClosed)
        {
            prevPos = crossSectionCenter(swap_row_col, pos, grid, cross_section_nedges, curve_nedges-1);
            prevPosValid = true;
        }
    }

    UT_Vector3D dir0;
    UT_Vector3D dir1;
    double length0 = 0;
    double length1 = 0;
    UT_Vector3D *pdir0 = nullptr;
    UT_Vector3D *pdir1 = nullptr;
    if (prevPosValid)
    {
        dir0 = (currPos - prevPos);
        dir1 = (nextPos - currPos);
        length0 = dir0.normalize();
        length1 = dir1.normalize();
        if (length0 != 0 && length1 != 0)
        {
            pdir0 = &dir0;
            pdir1 = &dir1;
        }
        else if (length0 != 0 || length1 != 0)
            pdir0 = (length0 != 0) ? &dir0 : &dir1;
    }
    else if (currPosValid)
    {
        dir1 = (nextPos - currPos);
        length1 = dir1.normalize();
        if (length1 != 0)
            pdir0 = &dir1;
    }

    double prev_cross_section_length = crossSectionLength(swap_row_col, pos, grid, cross_section_nedges, 0, pdir0, pdir1);
    if (currPosValid)
    {
        currPos = nextPos;
        dir0 = dir1;
        length0 = length1;
    }
    double curve_length = 0;
    double curve_length_per_cross_section_length_sum = 0;
    double cross_section_length_sum = prev_cross_section_length;
    exint cross_section_length_count = 1;
    double cross_section_length_max = prev_cross_section_length;
    iterateCurveEdgeLengths(
        curve_nedges,
        use_mesh_edge_lengths,
        cross_section_npts,
        swap_row_col,
        pos,
        grid,
        grid_info,
        cap_divisions,
        curve_pos,
        curve_input,
        curve_vertices,
        [&](exint curve_vtxi, double length_sum, exint length_sum_count)
    {
        double curr_curve_length = (length_sum/length_sum_count);
        curve_length += curr_curve_length;

        bool nextPosValid = false;
        // FIXME: Double-check these bounds!!!
        if (!grid_info.myVEndPoles || (curve_vtxi >= cap_divisions && curve_vtxi < curve_npts-cap_divisions))
        {
            nextPosValid = true;
            if (cross_section_nedges >= 1)
            {
                exint nextPosVtxi = curve_vtxi+2;
                exint threshold = curve_npts;
                if (grid_info.myVEndPoles)
                {
                    nextPosVtxi -= cap_divisions;
                    threshold -= 2*cap_divisions;
                }
                if (nextPosVtxi >= threshold)
                {
                    if (grid_info.myCurveClosed)
                        nextPosVtxi -= curve_npts;
                    else
                        nextPosValid = false;
                }
                if (nextPosValid)
                {
                    if (curve_input != nullptr)
                    {
                        UT_ASSERT_P(curve_pos.isValid());
                        exint next_curve_vtxi = nextPosVtxi;
                        if (cross_sections_per_vertex != 1)
                            next_curve_vtxi /= cross_sections_per_vertex;
                        if (next_curve_vtxi < 0)
                            next_curve_vtxi = 0;
                        else if (next_curve_vtxi >= curve_vertices.size())
                            next_curve_vtxi = curve_vertices.size()-1;
                        GA_Offset curve_vtxoff = curve_vertices[next_curve_vtxi];
                        GA_Offset curve_ptoff = curve_input->vertexPoint(curve_vtxoff);
                        nextPos = curve_pos.get(curve_ptoff);
                    }
                    else
                    {
                        nextPos = crossSectionCenter(swap_row_col, pos, grid, cross_section_nedges, nextPosVtxi);
                    }
                }
            }
            pdir0 = nullptr;
            pdir1 = nullptr;
            if (nextPosValid)
            {
                dir1 = (nextPos - currPos);
                length1 = dir1.normalize();
                if (length0 != 0 && length1 != 0)
                {
                    pdir0 = &dir0;
                    pdir1 = &dir1;
                }
                else if (length0 != 0 || length1 != 0)
                    pdir0 = (length0 != 0) ? &dir0 : &dir1;
            }
            else if (length0 != 0)
            {
                pdir0 = &dir0;
            }
        }
        double next_cross_section_length = crossSectionLength(swap_row_col, pos, grid, cross_section_nedges, curve_vtxi+1, pdir0, pdir1);
        // Don't overwrite dir0 and length0 if we might need them for end caps.
        if (nextPosValid)
        {
            currPos = nextPos;
            dir0 = dir1;
            length0 = length1;
        }

        double curr_cross_section_length_avg = 0.5*(prev_cross_section_length + next_cross_section_length);
        if (curr_cross_section_length_avg != 0)
        {
            // Use adjacent cross section lengths
            // NOTE: Code using this scale elsewhere will need to accumulate multiplying by
            //       Vlen[i]/avg(Ulen[i], Ulen[i+1]), instead of just Vlen[i].
            curve_length_per_cross_section_length_sum += (curr_curve_length/curr_cross_section_length_avg);
        }
        // Don't double-count first cross section if wrapped
        if (curve_vtxi+1 != curve_nedges || !grid_info.myCurveClosed)
        {
            cross_section_length_max = SYSmax(next_cross_section_length, cross_section_length_max);
            cross_section_length_sum += next_cross_section_length;
            ++cross_section_length_count;
            prev_cross_section_length = next_cross_section_length;
        }
    });
    double cross_section_length_avg = (cross_section_length_sum/cross_section_length_count);

    // NOTE: U coordinates from missing_input_us and cross_section_attrib are already normalized.

    if (ustyle == UVStyle::NORMALIZED)
    {
        // NOTE: No need to re-normalize U.

        if (vstyle == UVStyle::NORMALIZED)
        {
            // Both normalized: scale V down by curve length.
            if (curve_length == 0)
                fallback_to_uniform_v = true;
            else
                uvscale[1] /= curve_length;
        }
        else
        {
            // Just U normalized: scale V down by U length to keep them consistent.

            if ((scalevasu_usingmax && cross_section_length_max == 0) || (!scalevasu_usingmax && curve_length_per_cross_section_length_sum == 0))
            {
                uvscale[1] = 1;
                fallback_to_uniform_v = true;
            }
            else if (vstyle == UVStyle::FULL)
            {
                if (scalevasu_usingmax)
                    uvscale[1] /= cross_section_length_max;
                // NOTE: When !scalevasu_usingmax, the code using the scale elsewhere
                //       will automatically apply the scale, since it must
                //       accumulate multiplying by Vlen[i]/avg(Ulen[i], Ulen[i+1]),
                //       instead of just Vlen[i].
            }
            else
            {
                UT_ASSERT_P(vstyle == UVStyle::ROUNDED);

                if (scalevasu_usingmax)
                {
                    if (curve_length == 0)
                    {
                        uvscale[1] = 1;
                        fallback_to_uniform_v = true;
                    }
                    else
                    {
                        double rounded = SYSrint(uvscale[1]*curve_length/cross_section_length_max);
                        if (rounded < 1)
                            rounded = 1;
                        uvscale[1] = rounded/curve_length;
                    }
                }
                else
                {
                    UT_ASSERT(curve_length_per_cross_section_length_sum != 0);
                    double rounded = SYSrint(uvscale[1]*curve_length_per_cross_section_length_sum);
                    if (rounded < 1)
                        rounded = 1;
                    uvscale[1] = rounded/curve_length_per_cross_section_length_sum;
                }
            }
        }
    }
    else if (ustyle == UVStyle::FULL)
    {
        // Because U is already normalized, we need to re-introduce
        // the average cross section length scale to U.
        uvscale[0] *= cross_section_length_avg;

        if (vstyle == UVStyle::NORMALIZED)
        {
            // Need to divide uvscale[0] and uvscale[1] by curve length
            if (curve_length == 0)
            {
                fallback_to_uniform_v = true;
            }
            else
            {
                uvscale[0] /= curve_length;
                uvscale[1] /= curve_length;
            }
        }
        else if (vstyle == UVStyle::FULL)
        {
            // No change needed
        }
        else
        {
            UT_ASSERT_P(vstyle == UVStyle::ROUNDED);

            // Need to compute curve length
            if (curve_length == 0)
            {
                uvscale[1] = 1;
                fallback_to_uniform_v = true;
            }
            else
            {
                double old_vscale = uvscale[1];
                double rounded = SYSrint(old_vscale*curve_length);
                if (rounded < 1)
                    rounded = 1;
                uvscale[1] = rounded/curve_length;
                uvscale[0] *= (uvscale[1]/old_vscale);
            }
        }
    }
    else
    {
        UT_ASSERT_P(ustyle == UVStyle::ROUNDED);

        // NOTE: Since Us are already divided by cross section length,
        //       uvscale[0] doesn't need to be divided by cross section length at the end.
        // However, the average cross section length is still needed for the
        // rounded U max.

        if (vstyle == UVStyle::NORMALIZED)
        {
            if (curve_length == 0)
            {
                double rounded = SYSrint(cross_section_length_avg*uvscale[0]);
                if (rounded < 1)
                    rounded = 1;
                uvscale[0] = rounded;
                fallback_to_uniform_v = true;
            }
            else
            {
                double rounded = SYSrint(cross_section_length_avg*uvscale[0]/curve_length);
                if (rounded < 1)
                    rounded = 1;
                uvscale[0] = rounded;
                uvscale[1] /= curve_length;
            }
        }
        else
        {
            const double old_uscale = cross_section_length_avg*uvscale[0];
            uvscale[0] = SYSrint(old_uscale);
            if (uvscale[0] < 1)
                uvscale[0] = 1;

            if (vstyle == UVStyle::FULL)
            {
                if (old_uscale != 0)
                    uvscale[1] *= (uvscale[0]/old_uscale);
            }
            else
            {
                UT_ASSERT_P(vstyle == UVStyle::ROUNDED);
                if (curve_length == 0)
                {
                    uvscale[1] = 1;
                    fallback_to_uniform_v = true;
                }
                else
                {
                    double rounded = SYSrint(curve_length*uvscale[1]);
                    if (rounded < 1)
                        rounded = 1;
                    uvscale[1] = rounded/curve_length;
                }
            }
        }
    }

    return uvscale;
}

template<GA_AttributeOwner output_owner>
static void
copyUVAttribPairPtOrVtx(
    GA_ATINumeric *output_attrib,
    const GA_ATINumeric *cross_section_attrib,
    const GEO_Detail *cross_section_input,
    const GA_ATINumeric *curve_attrib,
    const GEO_Detail *curve_input,
    const sop_SweepGrid *grids,
    const exint ngrids,
    const exint cross_sections_per_vertex,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const exint cap_divisions,
    const bool reverse_cross_sections,
    const bool swap_row_col,
    const UT_Array<double> *missing_input_us,
    const bool length_weighted_uvs,
    const UVStyle ustyle,
    const UVStyle vstyle,
    const bool use_mesh_edge_lengths,
    const bool scalevasu_usingmax,
    const bool flipu,
    const UT_Vector2D &uvscale)
{
    const exint PARALLEL_THRESHOLD = 2048;
    const bool parallel = (ngrids > 1 &&
        output_attrib->getIndexMap().indexSize() >= PARALLEL_THRESHOLD);
    if (parallel)
    {
        // Must harden all pages before multi-threading.
        output_attrib->hardenAllPages();
    }

    const GA_Storage storage = output_attrib->getStorage();

    const bool is_cross_section_uv_computed = cross_section_attrib == nullptr || cross_section_attrib->isDetached();
    GA_AttributeOwner cross_section_owner = cross_section_attrib ? cross_section_attrib->getOwner() : GA_ATTRIB_INVALID;
    GA_AttributeOwner curve_owner = curve_attrib ? curve_attrib->getOwner() : GA_ATTRIB_VERTEX;
    UT_ASSERT((cross_section_attrib != nullptr) != (missing_input_us != nullptr));
    UT_ASSERT(!curve_attrib || (curve_owner == GA_ATTRIB_VERTEX || curve_owner == GA_ATTRIB_POINT));
    UT_ASSERT(!cross_section_attrib || (cross_section_owner == GA_ATTRIB_VERTEX || cross_section_owner == GA_ATTRIB_POINT));

    auto&& functor = [&](const UT_BlockedRange<exint>& r)
    {
        for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
        {
            const sop_SweepGrid &grid_info = grids[gridi];
            GU_GridT<GA_Offset> grid;
            initGUGrid(grid_info, surface_type, output_points_only, triangular_poles, swap_row_col, grid_info.myStartPtOff, grid);

            bool fallback_to_uniform_v = false;
            UT_Vector2D grid_uvscale = uvscale;
            if (length_weighted_uvs && (is_cross_section_uv_computed || curve_attrib == nullptr))
            {
                GA_Detail *output_detail = &output_attrib->getDetail();
                grid_uvscale = computeGridUVScales(
                    output_detail,
                    cross_section_input,
                    curve_input,
                    grid_info, grid,
                    swap_row_col,
                    cross_sections_per_vertex,
                    cap_divisions,
                    ustyle, vstyle,
                    use_mesh_edge_lengths,
                    scalevasu_usingmax,
                    uvscale,
                    fallback_to_uniform_v);
            }

            UT_ASSERT((cross_section_attrib != nullptr) != (missing_input_us != nullptr));
            if (storage == GA_STORE_REAL64)
            {
                copyCrossSectionUVSingleGrid<fpreal64,output_owner>(
                    output_attrib, cross_section_attrib, cross_section_owner, cross_section_input,
                    grid_info, grid, is_cross_section_uv_computed,
                    reverse_cross_sections, swap_row_col, flipu, grid_uvscale[0],
                    missing_input_us);
            }
            else
            {
                copyCrossSectionUVSingleGrid<fpreal32,output_owner>(
                    output_attrib, cross_section_attrib, cross_section_owner, cross_section_input,
                    grid_info, grid, is_cross_section_uv_computed,
                    reverse_cross_sections, swap_row_col, flipu, grid_uvscale[0],
                    missing_input_us);
            }

            if (curve_attrib == nullptr)
            {
                // Use computed implicit backbone curve U values (for V).

                if (storage == GA_STORE_REAL64)
                {
                    GA_RWHandleD outputh(output_attrib);
                    GA_ROHandleV3D pos(output_attrib->getDetail().getP());

                    if (length_weighted_uvs && !fallback_to_uniform_v)
                        generateLengthWeightedV<output_owner>(grid_info, grid, cross_sections_per_vertex, outputh, pos, ustyle, vstyle,
                            scalevasu_usingmax, grid_uvscale[1], uvscale[1], swap_row_col, use_mesh_edge_lengths, curve_input);
                    else
                        generateUniformV<output_owner>(grid_info, grid, outputh, swap_row_col, grid_uvscale[1]);
                }
                else
                {
                    GA_RWHandleF outputh(output_attrib);
                    GA_ROHandleV3D pos(output_attrib->getDetail().getP());
                    if (length_weighted_uvs && !fallback_to_uniform_v)
                        generateLengthWeightedV<output_owner>(grid_info, grid, cross_sections_per_vertex, outputh, pos, ustyle, vstyle,
                            scalevasu_usingmax, float(grid_uvscale[1]), float(uvscale[1]), swap_row_col, use_mesh_edge_lengths, curve_input);
                    else
                        generateUniformV<output_owner>(grid_info, grid, outputh, swap_row_col, float(grid_uvscale[1]));
                }
            }
        }
    };

    const UT_BlockedRange<exint> grid_range(0, ngrids);
    if (parallel)
        UTparallelFor(grid_range, functor);
    else
        functor(grid_range);

    if (curve_attrib != nullptr && curve_owner == GA_ATTRIB_VERTEX)
    {
        if (storage == GA_STORE_REAL64)
        {
            GA_RWHandleD outputh(output_attrib);
            GA_ROHandleD curveh(curve_attrib);
            auto &&copy_functor = [&outputh,&curveh](GA_Offset output_off, GA_Offset curve_off)
            {
                outputh.set(output_off, theVComponent, GAisValid(curve_off) ? curveh.get(curve_off) : 1.0);
            };
            copyCurveAttrib2<output_owner,true>(
                output_attrib, curve_input,
                grids, ngrids, cross_sections_per_vertex,
                surface_type, output_points_only, triangular_poles, cap_divisions,
                swap_row_col, copy_functor);
        }
        else
        {
            GA_RWHandleF outputh(output_attrib);
            GA_ROHandleF curveh(curve_attrib);
            auto &&copy_functor = [&outputh,&curveh](GA_Offset output_off, GA_Offset curve_off)
            {
                outputh.set(output_off, theVComponent, GAisValid(curve_off) ? curveh.get(curve_off) : 1.0f);
            };
            copyCurveAttrib2<output_owner,true>(
                output_attrib, curve_input,
                grids, ngrids, cross_sections_per_vertex,
                surface_type, output_points_only, triangular_poles, cap_divisions,
                swap_row_col, copy_functor);
        }
    }
    else if (curve_attrib != nullptr && curve_owner == GA_ATTRIB_POINT)
    {
        // We do support a point curve owner with a vertex output owner.

        if (storage == GA_STORE_REAL64)
        {
            GA_RWHandleD outputh(output_attrib);
            GA_ROHandleD curveh(curve_attrib);
            auto &&copy_functor = [&outputh,&curveh,curve_input](GA_Offset output_off, GA_Offset curve_vtxoff)
            {
                double value;
                if (GAisValid(curve_vtxoff))
                {
                    GA_Offset curve_off = curve_input->vertexPoint(curve_vtxoff);
                    value = curveh.get(curve_off);
                }
                else
                    value = 1.0;
                outputh.set(output_off, theVComponent, value);
            };
            copyCurveAttrib2<output_owner,true>(
                output_attrib, curve_input,
                grids, ngrids, cross_sections_per_vertex,
                surface_type, output_points_only, triangular_poles, cap_divisions,
                swap_row_col, copy_functor);
        }
        else
        {
            GA_RWHandleF outputh(output_attrib);
            GA_ROHandleF curveh(curve_attrib);
            auto &&copy_functor = [&outputh,&curveh,curve_input](GA_Offset output_off, GA_Offset curve_vtxoff)
            {
                float value;
                if (GAisValid(curve_vtxoff))
                {
                    GA_Offset curve_off = curve_input->vertexPoint(curve_vtxoff);
                    value = curveh.get(curve_off);
                }
                else
                    value = 1.0f;
                outputh.set(output_off, theVComponent, value);
            };
            copyCurveAttrib2<output_owner,true>(
                output_attrib, curve_input,
                grids, ngrids, cross_sections_per_vertex,
                surface_type, output_points_only, triangular_poles, cap_divisions,
                swap_row_col, copy_functor);
        }
    }
}

static void
copyUVAttribPair(
    GA_ATINumeric *output_attrib,
    const GA_ATINumeric *cross_section_attrib,
    const GEO_Detail *cross_section_input,
    const GA_ATINumeric *curve_attrib,
    const GEO_Detail *curve_input,
    const sop_SweepGrid *grids,
    const exint ngrids,
    const exint cross_sections_per_vertex,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const exint cap_divisions,
    const bool reverse_cross_sections,
    const bool swap_row_col,
    const UT_Array<double> *missing_input_us,
    const bool length_weighted_uvs,
    const UVStyle ustyle,
    const UVStyle vstyle,
    const bool use_mesh_edge_lengths,
    const bool scalevasu_usingmax,
    const bool flipu,
    const UT_Vector2D &uvscale)
{
    output_attrib->bumpDataId();

    // NOTE: If UV generation is disabled and one of the two input attributes is missing,
    //       this function shouldn't be called; the existing attribute should be copied as a normal attribute.

    const GA_AttributeOwner output_owner = output_attrib->getOwner();
    if (output_owner == GA_ATTRIB_DETAIL)
    {
        UT_ASSERT(curve_attrib);
        UT_ASSERT(cross_section_attrib);
        UT_ASSERT(curve_attrib->getOwner() == GA_ATTRIB_DETAIL);
        UT_ASSERT(cross_section_attrib->getOwner() == GA_ATTRIB_DETAIL);

        GA_RWHandleV2D outputh(output_attrib);
        GA_ROHandleD cross_sectionh(cross_section_attrib);
        GA_ROHandleD curveh(curve_attrib);
        double u = cross_sectionh.get(GA_DETAIL_OFFSET);
        double v = curveh.get(GA_DETAIL_OFFSET);
        outputh.set(GA_DETAIL_OFFSET, UT_Vector2D(u,v));
        return;
    }
    if (output_owner == GA_ATTRIB_POINT)
    {
        copyUVAttribPairPtOrVtx<GA_ATTRIB_POINT>(
            output_attrib,
            cross_section_attrib,
            cross_section_input,
            curve_attrib,
            curve_input,
            grids, ngrids,
            cross_sections_per_vertex,
            surface_type,
            output_points_only,
            triangular_poles,
            cap_divisions,
            reverse_cross_sections,
            swap_row_col,
            missing_input_us,
            length_weighted_uvs,
            ustyle, vstyle,
            use_mesh_edge_lengths,
            scalevasu_usingmax,
            flipu,
            uvscale);

        return;
    }
    if (output_points_only)
        return;
    if (output_owner == GA_ATTRIB_VERTEX)
    {
        if (output_attrib->getDetail().getNumVertices() == 0)
            return;

        copyUVAttribPairPtOrVtx<GA_ATTRIB_VERTEX>(
            output_attrib,
            cross_section_attrib,
            cross_section_input,
            curve_attrib,
            curve_input,
            grids, ngrids,
            cross_sections_per_vertex,
            surface_type,
            output_points_only,
            triangular_poles,
            cap_divisions,
            reverse_cross_sections,
            swap_row_col,
            missing_input_us,
            length_weighted_uvs,
            ustyle, vstyle,
            use_mesh_edge_lengths,
            scalevasu_usingmax,
            flipu,
            uvscale);

        return;
    }
    if (output_owner == GA_ATTRIB_PRIMITIVE)
    {
        if (output_attrib->getDetail().getNumPrimitives() == 0)
            return;

        const exint PARALLEL_THRESHOLD = 2048;
        const bool parallel = (ngrids > 1 &&
            output_attrib->getIndexMap().indexSize() >= PARALLEL_THRESHOLD);
        if (parallel)
        {
            // Must harden all pages before multi-threading.
            output_attrib->hardenAllPages();
        }

        UT_ASSERT(curve_attrib);
        UT_ASSERT(cross_section_attrib);
        UT_ASSERT(curve_attrib->getOwner() == GA_ATTRIB_PRIMITIVE);
        UT_ASSERT(cross_section_attrib->getOwner() == GA_ATTRIB_PRIMITIVE);

        const GA_Storage storage = output_attrib->getStorage();
        auto&& functor = [&](const UT_BlockedRange<exint>& r)
        {
            if (storage == GA_STORE_REAL64)
            {
                GA_ROHandleD curveh(curve_attrib);
                GA_RWHandleD outputh(output_attrib);
                for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                {
                    const sop_SweepGrid &grid_info = grids[gridi];
                    GU_GridT<GA_Offset> grid;
                    initGUGrid(grid_info, surface_type, output_points_only, triangular_poles, swap_row_col, grid_info.myStartPtOff, grid);

                    copyCrossSectionUVSingleGrid<fpreal64,GA_ATTRIB_PRIMITIVE>(
                        output_attrib, cross_section_attrib, GA_ATTRIB_PRIMITIVE, cross_section_input,
                        grid_info, grid, false,
                        reverse_cross_sections, swap_row_col, flipu, uvscale[0]);

                    if (curveh.isValid() && outputh.isValid() && outputh.getTupleSize() >= 2)
                    {
                        const double v = curveh.get(grid_info.myCurvePrimOff);

                        GUiterateGridPrimitives(grid,
                            [&grid_info,&outputh,v](exint primnum, exint row, exint col, exint primvtxcount, bool closed)
                        {
                            outputh.set(grid_info.myStartPrimOff + primnum, theVComponent, v);
                        });
                    }
                }
            }
            else
            {
                GA_ROHandleF curveh(curve_attrib);
                GA_RWHandleF outputh(output_attrib);
                for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                {
                    const sop_SweepGrid &grid_info = grids[gridi];
                    GU_GridT<GA_Offset> grid;
                    initGUGrid(grid_info, surface_type, output_points_only, triangular_poles, swap_row_col, grid_info.myStartPtOff, grid);

                    copyCrossSectionUVSingleGrid<fpreal32,GA_ATTRIB_PRIMITIVE>(
                        output_attrib, cross_section_attrib, GA_ATTRIB_PRIMITIVE, cross_section_input,
                        grid_info, grid, false,
                        reverse_cross_sections, swap_row_col, flipu, uvscale[0]);

                    if (curveh.isValid() && outputh.isValid() && outputh.getTupleSize() >= 2)
                    {
                        const float v = curveh.get(grid_info.myCurvePrimOff);

                        GUiterateGridPrimitives(grid,
                            [&grid_info,&outputh,v](exint primnum, exint row, exint col, exint primvtxcount, bool closed)
                        {
                            outputh.set(grid_info.myStartPrimOff + primnum, theVComponent, v);
                        });
                    }
                }
            }
        };

        const UT_BlockedRange<exint> grid_range(0, ngrids);
        if (parallel)
            UTparallelFor(grid_range, functor);
        else
            functor(grid_range);
        return;
    }
}

static GEO_SurfaceType sweepSurfaceToGeoSurface(const SurfaceType src_type)
{
    switch (src_type)
    {
        case SurfaceType::ROWS:
            return GEO_PATCH_ROWS;
        case SurfaceType::COLS:
            return GEO_PATCH_COLS;
        case SurfaceType::ROWCOL:
            return GEO_PATCH_ROWCOL;
        case SurfaceType::QUADS:
            return GEO_PATCH_QUADS;
        case SurfaceType::TRIS:
            return GEO_PATCH_TRIANGLE;
        case SurfaceType::REVTRIS:
            return GEO_PATCH_REVTRIANGLE;
        case SurfaceType::ALTTRIS:
            return GEO_PATCH_ALTTRIANGLE;

        case SurfaceType::POINTS:
            break;
    }
    return GEO_PATCH_QUADS;
}

static bool
copySurfaceAttributes(
    GEO_Detail *output_geo,
    const GEO_Detail *curve_input,
    const GEO_Detail *cross_section_input,
    const UT_Array<sop_SweepGrid> &grids,
    const exint cross_sections_per_vertex,
    const UT_Array<std::pair<const GA_Attribute*,GA_Attribute*>> &cross_section_attribs,
    const UT_Array<std::pair<const GA_Attribute*,GA_Attribute*>> &curve_attribs,
    const UT_Array<std::pair<std::pair<const GA_ATINumeric*,const GA_ATINumeric*>,GA_ATINumeric*>> &uv_attribs,
    const SOP_SweepHDKCache *const transform_cache,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const exint cap_divisions,
    const bool reverse_cross_sections,
    const bool swap_row_col,
    const exint uv_attrib_index,
    const UT_Array<double> *missing_input_us,
    const bool length_weighted_uvs,
    const UVStyle ustyle,
    const UVStyle vstyle,
    const bool use_mesh_edge_lengths,
    const bool scalevasu_usingmax,
    const bool flipu,
    const UT_Vector2D &uvscale)
{
    UT_AutoInterrupt interrupt("Copying surface attributes");
    if (interrupt.wasInterrupted())
        return false;

    // Copy/transform cross section attributes
    for (exint attribi = 0; attribi < cross_section_attribs.size(); ++attribi)
    {
        if (interrupt.wasInterrupted())
            return false;

        const GA_Attribute *cross_section_attrib = cross_section_attribs[attribi].first;
        GA_Attribute *output_attrib = cross_section_attribs[attribi].second;
        copyCrossSectionAttrib(
            output_attrib,
            cross_section_attrib,
            cross_section_input,
            transform_cache,
            grids.getArray(), grids.size(),
            cross_sections_per_vertex, cap_divisions,
            surface_type, output_points_only, triangular_poles,
            reverse_cross_sections, swap_row_col);
    }

    // Copy curve attributes
    for (exint attribi = 0; attribi < curve_attribs.size(); ++attribi)
    {
        if (interrupt.wasInterrupted())
            return false;

        const GA_Attribute *curve_attrib = curve_attribs[attribi].first;
        GA_Attribute *output_attrib = curve_attribs[attribi].second;
        copyCurveAttrib(
            output_attrib,
            curve_attrib,
            curve_input,
            grids.getArray(), grids.size(),
            cross_sections_per_vertex,
            surface_type, output_points_only, triangular_poles,
            cap_divisions, swap_row_col);
    }

    // Copy UV attributes
    for (exint attribi = 0; attribi < uv_attribs.size(); ++attribi)
    {
        if (interrupt.wasInterrupted())
            return false;

        const GA_ATINumeric *cross_section_attrib = uv_attribs[attribi].first.first;
        const GA_ATINumeric *curve_attrib = uv_attribs[attribi].first.second;
        GA_ATINumeric *output_attrib = uv_attribs[attribi].second;
        copyUVAttribPair(
            output_attrib,
            cross_section_attrib,
            cross_section_input,
            curve_attrib,
            curve_input,
            grids.getArray(), grids.size(),
            cross_sections_per_vertex,
            surface_type, output_points_only, triangular_poles,
            cap_divisions,
            reverse_cross_sections, swap_row_col,
            (uv_attrib_index == attribi) ? missing_input_us : nullptr,
            length_weighted_uvs,
            ustyle, vstyle,
            use_mesh_edge_lengths,
            scalevasu_usingmax,
            (uv_attrib_index == attribi) && flipu,
            uvscale);
    }

    return true;
}

static void setupCrossSectionAttribs(
    SOP_SweepHDKCache *sopcache,
    const SOP_NodeVerb::CookParms &cookparms,
    const SOP_SweepHDKParms &sopparms,
    bool &same_cross_section_data,
    CopyOrder &copy_order,
    const GEO_Detail *const cross_section_input,
    const GEO_Detail *const curve_input,
    const GA_PrimitiveGroup *cross_section_group)
{
    UT_ASSERT_MSG(cross_section_input && curve_input, "Copy order only makes sense if both inputs are present.");

    CrossSectionAttribMatchData &copy_order_attrib_data = sopcache->myCrossSectionAttribMatchData;

    // Handle data for case where an attribute on the curves
    // selects which cross section primitive to use.

    const UT_StringHolder &cross_section_attrib_name = sopparms.getCrossSectionAttrib();

    // First, find attribute with the given name (of any type or owner) on the curves.
    const GA_AttributeOwner attrib_owners[4] = {
        GA_ATTRIB_VERTEX,
        GA_ATTRIB_POINT,
        GA_ATTRIB_PRIMITIVE,
        GA_ATTRIB_DETAIL
    };
    const GA_Attribute *curve_attrib = curve_input->findAttribute(cross_section_attrib_name, attrib_owners, 4);

    bool string_missing_error_case = false;
    if (curve_attrib) {
        // We found one.
        const int64 new_curve_data_id = curve_attrib->getDataId();
        same_cross_section_data &= (sopcache->myPrevCrossSectCurveAttribDataId == new_curve_data_id);
        sopcache->myPrevCrossSectCurveAttribDataId = new_curve_data_id;

        copy_order_attrib_data.myCurveAttribOwner = curve_attrib->getOwner();

        // Check if it can be read as an integer attribute.  (Handle will
        // automatically convert float attribute values as they're read.)
        copy_order_attrib_data.myCurveIntAttrib.bind(curve_attrib);
        if (!copy_order_attrib_data.myCurveIntAttrib.isValid()) {
            copy_order_attrib_data.myCurveStrAttrib.bind(curve_attrib);
            if (!copy_order_attrib_data.myCurveStrAttrib.isValid()) {
                // Invalid: Must have integer or string attribute.
                curve_attrib = nullptr;
            }
            else {
                GA_ROHandleS cross_section_name_attrib(cross_section_input->findPrimitiveAttribute(cross_section_attrib_name));
                if (!cross_section_name_attrib.isValid()) {
                    // Invalid: Must have matching primitive string attribute.
                    curve_attrib = nullptr;
                    copy_order_attrib_data.myCurveStrAttrib.clear();
                    string_missing_error_case = true;
                }
                else {
                    // Valid: String attribute value matching.
                    const int64 new_cross_section_data_id = cross_section_name_attrib->getDataId();
                    const bool same_map = (sopcache->myPrevCrossSectPrimAttribDataId == new_cross_section_data_id);
                    same_cross_section_data &= same_map;
                    sopcache->myPrevCrossSectPrimAttribDataId = new_cross_section_data_id;
                    copy_order_attrib_data.myIsUsingMap = true;

                    // Avoid recomputing the mapping if same as last cook.
                    if (!same_map) {
                        // Destroy any previous map.
                        copy_order_attrib_data.myIntToPrimOff.destroy();
                        copy_order_attrib_data.myStrToPrimOff.destroy();

                        // Record the mapping from name to cross section primitive offset
                        GA_Offset start;
                        GA_Offset end;
                        for (GA_Iterator it(cross_section_input->getPrimitiveRange(cross_section_group)); it.blockAdvance(start, end); ) {
                            for (GA_Offset primoff = start; primoff < end; ++primoff) {
                                const UT_StringHolder &name = cross_section_name_attrib.get(primoff);
                                if (!name.isstring()) {
                                    // UT_ArrayStringMap doesn't support "" as a key, and if
                                    // "" appears in the matching attribute, the user is
                                    // probably indicating that they don't want to copy
                                    // anything there, so it should be okay.
                                    continue;
                                }

                                // NOTE: This will not overwrite if another primitive with the same name has already been inserted,
                                //       so it only keeps the first match.
                                copy_order_attrib_data.myStrToPrimOff.insert(name, primoff);
                            }
                        }
                    }
                }
            }
        }
        else {
            GA_ROHandleID cross_section_id_attrib(cross_section_input->findPrimitiveAttribute(cross_section_attrib_name));
            if (!cross_section_id_attrib.isValid()) {
                // Valid: Looking up primitives by index.
                copy_order_attrib_data.myIsUsingMap = false;
                same_cross_section_data &= (sopcache->myPrevCrossSectPrimAttribDataId == -1);
                sopcache->myPrevCrossSectPrimAttribDataId = -1;

                // Destroy any previous map.
                copy_order_attrib_data.myIntToPrimOff.destroy();
                copy_order_attrib_data.myStrToPrimOff.destroy();
            }
            else {
                // Valid: Integer attribute value matching.
                copy_order_attrib_data.myIsUsingMap = true;
                const int64 new_cross_section_data_id = cross_section_id_attrib->getDataId();
                const bool same_map = (sopcache->myPrevCrossSectPrimAttribDataId == new_cross_section_data_id);
                same_cross_section_data &= same_map;
                sopcache->myPrevCrossSectPrimAttribDataId = new_cross_section_data_id;

                // Avoid recomputing the mapping if same as last cook.
                if (!same_map) {
                    // Destroy any previous map.
                    copy_order_attrib_data.myIntToPrimOff.destroy();
                    copy_order_attrib_data.myStrToPrimOff.destroy();

                    // Record the mapping from ID to cross section primitive offset
                    GA_Offset start;
                    GA_Offset end;
                    for (GA_Iterator it(cross_section_input->getPrimitiveRange(cross_section_group)); it.blockAdvance(start, end); ) {
                        for (GA_Offset primoff = start; primoff < end; ++primoff) {
                            exint id = cross_section_id_attrib.get(primoff);
                            if (UT::ArrayMap<exint,GA_Offset>::clearer_type::isClear(id)) {
                                // UT::ArrayMap<exint,...> doesn't support
                                // 0x8000000000000000LL as a key.  Hopefully that's okay.
                                continue;
                            }

                            // NOTE: This will not overwrite if another primitive with the same ID has already been inserted,
                            //       so it only keeps the first match.
                            copy_order_attrib_data.myIntToPrimOff.insert(id, primoff);
                        }
                    }
                }
            }
        }
    }
    if (!curve_attrib) {
        // Something went wrong, so warn.
        UT_WorkBuffer buf;
        if (!string_missing_error_case)
            buf.sprintf("Curve input geometry doesn't have an integer or string attribute named \"%s\" for selecting cross section primitives.", cross_section_attrib_name.c_str());
        else
            buf.sprintf("Cross section doesn't have a primitive string attribute named \"%s\" for selecting cross section primitives,", cross_section_attrib_name.c_str());
        cookparms.sopAddWarning(SOP_MESSAGE, buf.buffer());

        // Fall back to the default copy order mode.
        copy_order = CopyOrder::CYCLEVTX;
        same_cross_section_data = (sopcache->myPrevCopyOrder == copy_order);
        sopcache->myPrevCrossSectCurveAttribDataId = -1;
        sopcache->myPrevCrossSectPrimAttribDataId = -1;
        copy_order_attrib_data.myIntToPrimOff.destroy();
        copy_order_attrib_data.myStrToPrimOff.destroy();
        copy_order_attrib_data.myCurveAttribOwner = GA_ATTRIB_INVALID;
    }
}

static void removeUnnecessarySweepAttribs(
    GEO_Detail *output_geo)
{
    // For simplicity, we delete all nonessential attributes and groups
    // from the output detail.
    // TODO: Only delete the ones that won't be in the output this cook
    //       or that don't match the correct type / data type / tuple size.
    UT_SmallArray<GA_Attribute *> attribs_to_delete;
    output_geo->pointAttribs().forEachAttribute([output_geo,&attribs_to_delete](GA_Attribute *attrib)
    {
        if (attrib != output_geo->getP() && !GA_ATITopology::isType(attrib))
            attribs_to_delete.append(attrib);
    });
    for (exint i = 0, n = attribs_to_delete.size(); i < n; ++i)
    {
        const UT_StringHolder &name = attribs_to_delete[i]->getName();
        GA_AttributeScope scope = attribs_to_delete[i]->getScope();
        if (scope != GA_SCOPE_GROUP)
            output_geo->destroyAttribute(GA_ATTRIB_POINT, scope, name);
        else
            output_geo->destroyPointGroup(name);
    }
    attribs_to_delete.clear();
    output_geo->vertexAttribs().forEachAttribute([&attribs_to_delete](GA_Attribute *attrib)
    {
        if (!GA_ATITopology::isType(attrib))
            attribs_to_delete.append(attrib);
    });
    for (exint i = 0, n = attribs_to_delete.size(); i < n; ++i)
    {
        const UT_StringHolder &name = attribs_to_delete[i]->getName();
        GA_AttributeScope scope = attribs_to_delete[i]->getScope();
        if (scope != GA_SCOPE_GROUP)
            output_geo->destroyAttribute(GA_ATTRIB_VERTEX, scope, name);
        else
            output_geo->destroyVertexGroup(name);
    }
    attribs_to_delete.clear();
    output_geo->primitiveAttribs().forEachAttribute([&attribs_to_delete](GA_Attribute *attrib)
    {
        attribs_to_delete.append(attrib);
    });
    for (exint i = 0, n = attribs_to_delete.size(); i < n; ++i)
    {
        const UT_StringHolder &name = attribs_to_delete[i]->getName();
        GA_AttributeScope scope = attribs_to_delete[i]->getScope();
        if (scope != GA_SCOPE_GROUP)
            output_geo->destroyAttribute(GA_ATTRIB_PRIMITIVE, scope, name);
        else
            output_geo->destroyPrimitiveGroup(name);
    }
    attribs_to_delete.clear();
    output_geo->attribs().forEachAttribute([&attribs_to_delete](GA_Attribute *attrib)
    {
        attribs_to_delete.append(attrib);
    });
    for (exint i = 0, n = attribs_to_delete.size(); i < n; ++i)
        output_geo->destroyAttribute(GA_ATTRIB_DETAIL, attribs_to_delete[i]->getScope(), attribs_to_delete[i]->getName());
    attribs_to_delete.setCapacity(0);

    UT_SmallArray<GA_EdgeGroup *> edge_groups_to_delete;
    for (auto it = output_geo->edgeGroups().beginTraverse(); !it.atEnd(); ++it)
    {
        edge_groups_to_delete.append(it.group());
    }
    for (exint i = 0, n = edge_groups_to_delete.size(); i < n; ++i)
    {
        output_geo->destroyEdgeGroup(edge_groups_to_delete[i]);
    }
}

static void setupSweepTransferAttribs(
    GEO_Detail *output_geo,
    const GEO_Detail *cross_section_input,
    const UT_StringHolder &cross_section_attrib_pattern,
    const GEO_Detail *curve_input,
    const UT_StringHolder &curve_attrib_pattern,
    UT_Array<std::pair<const GA_Attribute*,GA_Attribute*>> &cross_section_attribs,
    UT_Array<std::pair<const GA_Attribute*,GA_Attribute*>> &curve_attribs,
    UT_Array<std::pair<std::pair<const GA_ATINumeric*,const GA_ATINumeric*>,GA_ATINumeric*>> &uv_attribs,
    exint &uv_attrib_index,
    const bool compute_uvs,
    const bool override_existing_uvs)
{
    const GA_AttributeFilter curve_filter(
        GA_AttributeFilter::selectAnd(
            GA_AttributeFilter::selectPublic(),
            GA_AttributeFilter::selectByPattern(curve_attrib_pattern)));

    UT_ASSERT(compute_uvs || !override_existing_uvs);
    uv_attrib_index = -1;

    // If matching texture coordinate attributes exist on both inputs, add the pair to uv_attribs.
    // If UV generation is on and "uv" specifically is on only one input or neither input, add it to uv_attribs, with nullptr for the missing one/two.
    // If texture coordinate attribute, but not "uv" specifically and no match exists, add to cross_section_attribs or curve_attribs to copy.

    if (cross_section_input)
    {
        const GA_AttributeFilter filter(
            GA_AttributeFilter::selectAnd(
                GA_AttributeFilter::selectPublic(),
                GA_AttributeFilter::selectByPattern(cross_section_attrib_pattern)));
        auto &&clone_attrib_functor = [&cross_section_attribs,&uv_attribs,&uv_attrib_index,&filter,output_geo,
            curve_input,&curve_filter,override_existing_uvs,compute_uvs](const GA_Attribute *attrib)
        {
            if (!filter.match(attrib))
                return;

            GA_AttributeOwner owner = attrib->getOwner();

            // If we're overriding uv, don't transfer it.
            const bool point_or_vertex = (owner == GA_ATTRIB_POINT || owner == GA_ATTRIB_VERTEX);
            const bool isuv = point_or_vertex &&
                (attrib->getScope() == GA_SCOPE_PUBLIC) &&
                (attrib->getName() == GA_Names::uv);
            if ((compute_uvs && override_existing_uvs) && isuv)
                return;

            if (point_or_vertex && attrib->shouldInterpretAsTexCoord())
            {
                UT_ASSERT_MSG(GA_ATINumeric::isType(attrib), "This should be guaranteed by shouldInterpretAsTexCoord()");
                if (curve_input)
                {
                    const GA_Attribute *other_attrib = curve_input->findAttribute(GA_ATTRIB_VERTEX, attrib->getName());
                    if (!other_attrib)
                        other_attrib = curve_input->findAttribute(GA_ATTRIB_POINT, attrib->getName());
                    if (other_attrib && curve_filter.match(other_attrib) && other_attrib->shouldInterpretAsTexCoord())
                    {
                        UT_ASSERT_MSG(GA_ATINumeric::isType(other_attrib), "This should be guaranteed by shouldInterpretAsTexCoord()");
                        GA_AttributeOwner output_owner = (owner == GA_ATTRIB_VERTEX || other_attrib->getOwner() == GA_ATTRIB_VERTEX) ? GA_ATTRIB_VERTEX : GA_ATTRIB_POINT;

                        GA_Attribute *new_attribute = output_geo->getAttributes().cloneAttribute(
                            output_owner, attrib->getName(),
                            GA_AttributeSet::namevalidcertificate(),
                            *attrib, true);

                        uv_attribs.append(std::make_pair(
                            std::make_pair(
                                GA_ATINumeric::cast(attrib),
                                GA_ATINumeric::cast(other_attrib)),
                            GA_ATINumeric::cast(new_attribute)));
                        return;
                    }
                }
                if (isuv && compute_uvs)
                {
                    // No matching uv attribute, but we're generating UVs, so still put it in uv_attribs.
                    // Generated UVs always result in a vertex attribute, for safety.
                    GA_Attribute *new_attribute = output_geo->getAttributes().cloneAttribute(
                        GA_ATTRIB_VERTEX, attrib->getName(),
                        GA_AttributeSet::namevalidcertificate(),
                        *attrib, true);

                    uv_attrib_index = uv_attribs.size();
                    uv_attribs.append(std::make_pair(
                        std::make_pair(
                            GA_ATINumeric::cast(attrib), nullptr),
                        GA_ATINumeric::cast(new_attribute)));
                    return;
                }
            }

            // NOTE: We even clone P, to match the storage type and metadata
            GA_Attribute *new_attribute;
            if (attrib->getScope() != GA_SCOPE_GROUP)
            {
                new_attribute = output_geo->getAttributes().cloneAttribute(
                    owner, attrib->getName(),
                    GA_AttributeSet::namevalidcertificate(),
                    *attrib, true);
            }
            else
            {
                new_attribute = UTverify_cast<GA_ElementGroup*>(
                    output_geo->getElementGroupTable(owner).newGroup(attrib->getName()));
            }

            if (owner != GA_ATTRIB_DETAIL)
                cross_section_attribs.append(std::make_pair(attrib, new_attribute));
            else
            {
                // Just copy detail attribute values
                new_attribute->copy(GA_DETAIL_OFFSET, *attrib, GA_DETAIL_OFFSET);
            }
        };
        for (int owneri = 0; owneri < GA_ATTRIB_OWNER_N; ++owneri)
        {
            cross_section_input->getAttributes().getDict(GA_AttributeOwner(owneri))
                .forEachAttribute(clone_attrib_functor);
        }
    }
    
    if (curve_input)
    {
        auto &&clone_attrib_functor = [&curve_attribs,&uv_attribs,&uv_attrib_index,&curve_filter,output_geo,
            cross_section_input,override_existing_uvs,compute_uvs](const GA_Attribute *attrib)
        {
            if (!curve_filter.match(attrib))
                return;

            GA_AttributeOwner owner = attrib->getOwner();

            // Don't copy attributes that were copied from cross_section_input,
            // unless it's a uv-like attribute, (since we can combine those).
            // TODO: Handle combining things like v from both inputs.
            // NOTE: This way of checking automatically excludes P if cross_section_input is non-null.
            if (cross_section_input)
            {
                GA_Attribute *old_attrib =
                    output_geo->findAttribute(owner, attrib->getScope(), attrib->getName());

                if (old_attrib)
                {
                    // NOTE: If they're being combined as texture coordinate attributes, they were added to uv_attribs above.
                    return;
                }
                if (owner == GA_ATTRIB_POINT || owner == GA_ATTRIB_VERTEX)
                {
                    // Avoid point-vs-vertex name conflicts, too.
                    GA_AttributeOwner other_owner = (owner == GA_ATTRIB_POINT) ? GA_ATTRIB_VERTEX : GA_ATTRIB_POINT;
                    old_attrib = output_geo->findAttribute(
                        other_owner, attrib->getScope(), attrib->getName());
                    if (old_attrib)
                        return;
                }
            }

            // If we're overriding uv, don't transfer it.
            const bool point_or_vertex = (owner == GA_ATTRIB_POINT || owner == GA_ATTRIB_VERTEX);
            const bool isuv = point_or_vertex &&
                (attrib->getScope() == GA_SCOPE_PUBLIC) &&
                (attrib->getName() == GA_Names::uv);
            if ((compute_uvs && override_existing_uvs) && isuv)
                return;

            if (point_or_vertex && attrib->shouldInterpretAsTexCoord())
            {
                UT_ASSERT_MSG(GA_ATINumeric::isType(attrib), "This should be guaranteed by shouldInterpretAsTexCoord()");

                // NOTE: Don't need to worry about case of conflict with cross_section_input, since that's handled above.
                if (isuv && compute_uvs)
                {
                    // No matching uv attribute, but we're generating UVs, so still put it in uv_attribs.
                    // Generated UVs always result in a vertex attribute, for safety.
                    GA_Attribute *new_attribute = output_geo->getAttributes().cloneAttribute(
                        GA_ATTRIB_VERTEX, attrib->getName(),
                        GA_AttributeSet::namevalidcertificate(),
                        *attrib, true);

                    uv_attrib_index = uv_attribs.size();
                    uv_attribs.append(std::make_pair(
                        std::make_pair(
                            nullptr, GA_ATINumeric::cast(attrib)),
                        GA_ATINumeric::cast(new_attribute)));
                    return;
                }
            }

            GA_Attribute *new_attribute;
            if (attrib->getScope() != GA_SCOPE_GROUP)
            {
                new_attribute = output_geo->getAttributes().cloneAttribute(
                    owner, attrib->getName(),
                    GA_AttributeSet::namevalidcertificate(),
                    *attrib, true);
            }
            else
            {
                new_attribute = UTverify_cast<GA_ElementGroup*>(
                    output_geo->getElementGroupTable(owner).newGroup(attrib->getName()));
            }

            if (owner != GA_ATTRIB_DETAIL)
                curve_attribs.append(std::make_pair(attrib, new_attribute));
            else
            {
                // Just copy detail attribute values
                new_attribute->copy(GA_DETAIL_OFFSET, *attrib, GA_DETAIL_OFFSET);
            }
        };
        for (int owneri = 0; owneri < GA_ATTRIB_OWNER_N; ++owneri)
        {
            curve_input->getAttributes().getDict(GA_AttributeOwner(owneri))
                .forEachAttribute(clone_attrib_functor);
        }
    }
}

static void
sopBoundingTube(
    const GEO_Detail *cross_section_input,
    GA_Offset primoff,
    double &radius,
    UT_Vector3D &centre,
    UT_Vector3D *out_normal)
{
    const GA_OffsetListRef vertices = cross_section_input->getPrimitiveVertexList(primoff);
    const exint n = vertices.size();

    if (n <= 1)
    {
        radius = 0;
        centre = UT_Vector3D(0,0,0);
        return;
    }

    const GA_ROHandleV3D pos(cross_section_input->getP());

    UT_Vector3D p0 = pos.get(cross_section_input->vertexPoint(vertices(0)));
    UT_Vector3D p1 = pos.get(cross_section_input->vertexPoint(vertices(1)));
    if (n == 2)
    {
        radius = 0.5*p0.distance(p1);
        centre = 0.5*(p0+p1);
        if (out_normal)
        {
            // out_normal starts as effective curve edge direction.
            // Subtract component parallel to p1-p0
            UT_Vector3D diff = p1-p0;
            double length = diff.normalize();
            if (length != 0)
            {
                UT_Vector3D new_normal = *out_normal - dot(*out_normal, diff)*diff;
                length = new_normal.normalize();
                if (length != 0)
                    *out_normal = new_normal;
            }
        }
        return;
    }

    // Check if all points approximately in a straight line segment.
    // First, compute average position of points.
    UT_Vector3D pos_sum = p0+p1;
    for (exint i = 2; i < n; ++i)
    {
        UT_Vector3D p = pos.get(cross_section_input->vertexPoint(vertices(i)));
        pos_sum += p;
    }
    const UT_Vector3D pos_avg = pos_sum / n;

    // Compute covariance matrix
    UT_Matrix3D covariance_matrix;
    covariance_matrix.zero();
    UT_Vector3D pdiff = p0 - pos_avg;
    covariance_matrix.outerproductUpdate(1.0, pdiff, pdiff);
    pdiff = p1 - pos_avg;
    covariance_matrix.outerproductUpdate(1.0, pdiff, pdiff);
    for (exint i = 2; i < n; ++i)
    {
        UT_Vector3D p = pos.get(cross_section_input->vertexPoint(vertices(i)));
        pdiff = p - pos_avg;
        covariance_matrix.outerproductUpdate(1.0, pdiff, pdiff);
    }
    const double row_length2s[] = {
        covariance_matrix[0].length2(),
        covariance_matrix[1].length2(),
        covariance_matrix[2].length2()
    };
    const int maxrow = SYSargmax(
        row_length2s[0],
        row_length2s[1],
        row_length2s[2]);
    if (row_length2s[maxrow] == 0)
    {
        // All a single point
        centre = pos_avg;
        radius = 0;
        return;
    }

    UT_Vector3D maxrow_vec = covariance_matrix[maxrow];
    maxrow_vec.normalize();
    UT_Vector3D other_dir0;
    other_dir0.arbitraryPerp(maxrow_vec);
    UT_Vector3D other_dir1 = cross(maxrow_vec, other_dir0);
    double maxrow_vec_eigen2 = (maxrow_vec*covariance_matrix).length2();
    double other_dir0_eigen2 = (other_dir0*covariance_matrix).length2();
    double other_dir1_eigen2 = (other_dir1*covariance_matrix).length2();
    // If max eigenvalue is more than 10000x larger than middle eigenvalue,
    // it's effectively a straight line.
    if (other_dir0_eigen2+other_dir1_eigen2 < 1e-8*maxrow_vec_eigen2)
    {
        pdiff = p0 - pos_avg;
        double min_from_avg = pdiff.dot(maxrow_vec);
        double max_from_avg = min_from_avg;
        pdiff = p1 - pos_avg;
        double d = pdiff.dot(maxrow_vec);
        min_from_avg = SYSmin(min_from_avg, d);
        max_from_avg = SYSmax(max_from_avg, d);
        for (exint i = 2; i < n; ++i)
        {
            UT_Vector3D p = pos.get(cross_section_input->vertexPoint(vertices(i)));
            pdiff = p - pos_avg;
            d = pdiff.dot(maxrow_vec);
            min_from_avg = SYSmin(min_from_avg, d);
            max_from_avg = SYSmax(max_from_avg, d);
        }

        radius = 0.5*(max_from_avg - min_from_avg);
        centre = pos_avg + 0.5*(min_from_avg + max_from_avg);
        if (out_normal)
        {
            UT_Vector3D new_normal = *out_normal - dot(*out_normal, maxrow_vec)*maxrow_vec;
            double length = new_normal.normalize();
            if (length != 0)
                *out_normal = new_normal;
        }
        return;
    }

    // Compute normal
    UT_Vector3D normal(0,0,0);
    UT_Vector3D pprev = p1;
    for (exint i = 2; i < n; ++i)
    {
        UT_Vector3D pnext = pos.get(cross_section_input->vertexPoint(vertices(i)));
        normal += cross(pprev-p0, pnext-p0);
        pprev = pnext;
    }
    normal.normalize();

    if (normal.length2() == 0)
    {
        // No reliable normal, so use point centre and radius.
        centre = pos_avg;

        double max_distance2 = distance2(centre, p0);
        for (exint i = 1; i < n; ++i)
        {
            UT_Vector3D p = pos.get(cross_section_input->vertexPoint(vertices(i)));
            max_distance2 = SYSmax(max_distance2, distance2(centre, p));
        }
        radius = SYSsqrt(max_distance2);
        return;
    }

    // Compute min & max along direction of normal
    double min_normal_dot = 0;
    double max_normal_dot = 0;
    for (exint i = 1; i < n; ++i)
    {
        UT_Vector3D p = pos.get(cross_section_input->vertexPoint(vertices(i)));
        double dot = (p-p0).dot(normal);
        min_normal_dot = SYSmin(dot, min_normal_dot);
        max_normal_dot = SYSmax(dot, max_normal_dot);
    }

    // Take middle of min and max along normal as the centre for that axis
    double mid_normal_dot = 0.5*(min_normal_dot+max_normal_dot);

    // Create arbitrary frame perpendicular to normal
    UT_Vector3D tangent0;
    UT_Vector3D tangent1;
    tangent0.arbitraryPerp(normal);
    tangent1 = cross(normal, tangent0);

    // Compute minimum bounding circle in perpendicular frame
    UT_Array<UT_Vector2D> pos2d;
    pos2d.setSizeNoInit(n);
    pos2d[0] = UT_Vector2D(0,0);
    for (exint i = 1; i < n; ++i)
    {
        UT_Vector3D p = pos.get(cross_section_input->vertexPoint(vertices(i)));
        UT_Vector3D diff = p-p0;
        pos2d[i] = UT_Vector2D(diff.dot(tangent0), diff.dot(tangent1));
    }
    UT_Vector2D centre2d;
    double radius2 = UTboundingCircle(pos2d, &centre2d);
    radius = SYSsqrt(radius2);

    // Take circle centre as centre for remaining directions
    // and circle radius as the cross section radius
    centre = p0 + (normal*mid_normal_dot + tangent0*centre2d[0] + tangent1*centre2d[1]);
    if (out_normal)
    {
        // Ensure that the direction is consistent with the input direction,
        // since the direction doesn't need to be consistent with the
        // cross section winding.
        if (out_normal->dot(normal) < 0)
            *out_normal = -normal;
        else
            *out_normal = normal;
    }
}

static UT_Matrix4D
sopPrescaleTranslate(
    const double scale,
    const UT_Vector3D &centre,
    const UT_Vector3D ztranslate,
    const UT_Matrix4D &transform0)
{
    // Adjustment for scaling around the centre, instead of around the origin.
    UT_Vector3D pret = (1.0-scale)*centre;
    //pret[2] += ztranslate;
    pret += ztranslate;

    UT_Vector3D t(
        pret[0]*transform0[0][0] + pret[1]*transform0[1][0] + pret[2]*transform0[2][0] + transform0[3][0],
        pret[0]*transform0[0][1] + pret[1]*transform0[1][1] + pret[2]*transform0[2][1] + transform0[3][1],
        pret[0]*transform0[0][2] + pret[1]*transform0[1][2] + pret[2]*transform0[2][2] + transform0[3][2]
    );

    return UT_Matrix4D(
        scale*transform0[0][0], scale*transform0[0][1], scale*transform0[0][2], scale*transform0[0][3],
        scale*transform0[1][0], scale*transform0[1][1], scale*transform0[1][2], scale*transform0[1][3],
        scale*transform0[2][0], scale*transform0[2][1], scale*transform0[2][2], scale*transform0[2][3],
        t[0], t[1], t[2], 1.0
    );
}

static UT_Matrix4D
sopEndCapTransform(
    const exint capi,
    const exint cap_divisions,
    const UT_Vector3D &centre,
    UT_Vector3D scaled_z_dir,
    double roundness,
    const UT_Matrix4D &transform0)
{
    // zscale is negated, because the first end cap goes backward
    // from the first cross section.
    scaled_z_dir = -scaled_z_dir;

    double scale;
    UT_Vector3D ztranslate;
    if (capi == 0)
    {
        // The pole
        // NOTE: scale must be exactly zero here, since code checks for zero
        //       to identify special case for inversion.
        scale = 0;
        ztranslate = scaled_z_dir;
    }
    else
    {
        const double scale_portion = double(capi)/double(cap_divisions);
        const double ztranslate_portion = 1.0 - scale_portion;

        // Round portion:
        // Scale by cos((pi/2)*(i-n)/n) (for first cap) about the centre
        // and translate along the z axis by zscale*sin((pi/2)*(i-n)/n),
        // as a pretransform on the cross section at each end.
        const double theta = M_PI_2*ztranslate_portion;
        const double scale_round = SYScos(theta);
        const double ztranslate_round = SYSsin(theta);

        // Pointed portion:
        // Scale by (i/n) (for first cap) about the centre
        // as a pretransform on the cross section at each end.
        // Pretranslate along the z axis by zscale*(i-n)/n,
        // for a pointed shape.
        const double scale_pointed = scale_portion;
        const double ztranslate_pointed = ztranslate_portion;

        // Interpolate from pointed to round
        double ztranslate_scalar;
        if (roundness > 0)
        {
            scale = SYSlerp(scale_pointed, scale_round, roundness);
            ztranslate_scalar = SYSlerp(ztranslate_pointed, ztranslate_round, roundness);
        }
        else if (roundness == 0)
        {
            scale = scale_pointed;
            ztranslate_scalar = ztranslate_pointed;
        }
        else
        {
            // Lerp toward the inverted round point, which is
            // not quite the same as the round point reflected through
            // the pointed point, even though the circle reflected through
            // the straight line is the inverted circle, due to the
            // uniform speed along the line and circle not matching that
            // the circle projected onto the line has nonuniform speed.
            scale = SYSlerp(scale_pointed, 1.0-ztranslate_round, -roundness);
            ztranslate_scalar = SYSlerp(ztranslate_pointed, 1.0-scale_round, -roundness);
        }
        ztranslate = ztranslate_scalar*scaled_z_dir;
    }
    return sopPrescaleTranslate(scale, centre, ztranslate, transform0);
}

static void
sopAllEndCapTransforms(
    const sop_SweepGrid &grid,
    const SOP_SweepHDKParms &sopparms,
    const GEO_Detail *cross_section_input,
    const UT_Matrix4D &transform0,
    const UT_Matrix4D &transform1,
    const exint num_vertices,
    UT_Matrix3D *grid_matrix3ds,
    UT_Vector3D *grid_translate3ds,
    bool use_cross_section_normal_for_z)
{
    const exint cap_divisions = sopparms.getCapDivs();

    // Compute normals of the end cross sections.
    // Compute minimum bounding circles projected into the axis perpendicular to the normals.
    // Use circle radii and centres to form end cap scale pivots and translations.
    double radii[2];
    UT_Vector3D centres[2];
    UT_Vector3D normals[2] = {
        UT_Vector3D(0,0,1),
        UT_Vector3D(0,0,1)
    };
    if (grid.mySingleCrossSection && !GAisValid(grid.myCrossSectionPrimOff))
    {
        // NOTE: Don't use sopparms.getRadius(), since that's already integrated into the transforms.
        radii[0] = 1;
        radii[1] = 1;
        centres[0] = UT_Vector3D(0,0,0);
        centres[1] = UT_Vector3D(0,0,0);
    }
    else if (grid.mySingleCrossSection)
    {
        GA_Offset primoff = GA_Offset(grid.myCrossSectionPrimOff);

        double radius;
        UT_Vector3D centre;
        UT_Vector3D normal;
        sopBoundingTube(cross_section_input, primoff, radius, centre,
            use_cross_section_normal_for_z ? &normal : nullptr);
        radii[0] = radius;
        radii[1] = radius;
        centres[0] = centre;
        centres[1] = centre;
        if (use_cross_section_normal_for_z)
        {
            normals[0] = normal;
            normals[1] = normal;
        }
    }
    else
    {
        GA_Offset primoff0 = (*grid.myCrossSectionPrimOffs)[0];
        GA_Offset primoff1 = grid.myCrossSectionPrimOffs->last();

        if (use_cross_section_normal_for_z && grid.myCrossSectionPrimOffs->size() >= 2*cap_divisions+1)
        {
            double radius;
            UT_Vector3D centreA;
            UT_Vector3D centreB;
            sopBoundingTube(cross_section_input, primoff0, radius, centreA, nullptr);
            sopBoundingTube(cross_section_input, (*grid.myCrossSectionPrimOffs)[cap_divisions+1], radius, centreB, nullptr);
            normals[0] = centreA-centreB;
            normals[0].normalize();
            sopBoundingTube(cross_section_input, primoff1, radius, centreA, nullptr);
            sopBoundingTube(cross_section_input, (*grid.myCrossSectionPrimOffs)[grid.myCrossSectionPrimOffs->size()-2-cap_divisions], radius, centreB, nullptr);
            normals[1] = centreB-centreA;
            normals[1].normalize();
        }
        sopBoundingTube(cross_section_input, primoff0, radii[0], centres[0],
            use_cross_section_normal_for_z ? &normals[0] : nullptr);
        sopBoundingTube(cross_section_input, primoff1, radii[1], centres[1],
            use_cross_section_normal_for_z ? &normals[1] : nullptr);
    }
    if (use_cross_section_normal_for_z)
    {
        normals[0].negate();
        normals[1].negate();
    }

    // FIXME: For inverses on the final (singular) transform, specify an orthogonal matrix, instead of a NaN matrix!!!
    // TODO: Maybe normals should be handled differently for end caps, since translating and uniform scaling won't
    //       change them at all, and for regular surfaces at least, they should match the surface normal.

    const double cap_scale = sopparms.getCapScale();
    const double cap_roundness = sopparms.getCapRoundness();

    // First cap
    for (exint i = 0; i < cap_divisions; ++i)
    {
        const exint row = i;
        const UT_Matrix4D transform = sopEndCapTransform(
            i, cap_divisions,
            centres[0], (cap_scale*radii[0])*normals[0],
            cap_roundness, transform0);

        grid_matrix3ds[row] = UT_Matrix3D(transform);
        transform.getTranslates(grid_translate3ds[row]);
    }

    // Last cap
    for (exint i = 0; i < cap_divisions; ++i)
    {
        // Negate the radius, so that translation is in the positive
        // z direction, instead of the negative z direction.
        const exint row = cap_divisions+num_vertices+i;
        const UT_Matrix4D transform = sopEndCapTransform(
            cap_divisions-1-i, cap_divisions,
            centres[1], (-cap_scale*radii[1])*normals[1],
            cap_roundness, transform1);

        grid_matrix3ds[row] = UT_Matrix3D(transform);
        transform.getTranslates(grid_translate3ds[row]);
    }
}

/// This is the function that does the actual work.
void SOP_SweepHDKVerb::cook(const CookParms &cookparms) const
{
    // Overall behaviour:
    // - Handle invalid input
    // - Parse groups
    // - Delete any output attributes that should no longer exist or
    //   that mismatch what they should be.
    // - Determine whether output topology needs to be different from previous cook
    // - If so,
    //   - Compute a simple representation of the topology to cache
    //   - Construct primitives
    //   - Bump topology and primitive list data IDs
    // - Compute input backbone curve UVs, if needed
    // - Compute transforms for each vertex
    // - Set up missing output attributes from source and target attributes
    // - For each output attribute,
    //   - For each curve,
    //     -

    using namespace GU_Copy;

    ///////////////////////////////////////////////////////////////////
    //                                                               //
    //          0. PREP                                              //
    //                                                               //
    ///////////////////////////////////////////////////////////////////

    // This gives easy access to all of the current parameter values
    auto &&sopparms = cookparms.parms<SOP_SweepHDKParms>();
    auto sopcache = (SOP_SweepHDKCache *)cookparms.cache();

    // The output detail
    GU_Detail *output_geo = cookparms.gdh().gdpNC();

    // Only use the cross_section_input if 
    const GU_Detail *const cross_section_input =
        (sopparms.getSurfaceShape() == SurfaceShape::INPUT)
            ? cookparms.inputGeo(theCrossSectionInput)
            : nullptr;

    const GU_Detail *const curve_input = cookparms.inputGeo(theCurveInput);

    if (!cookparms.inputGeo(theCrossSectionInput) && !curve_input)
    {
        cookparms.sopAddError(SOP_MESSAGE, "At least one input is required.");
        output_geo->clearAndDestroy();
        return;
    }

    if (!cross_section_input && (sopparms.getSurfaceShape() == SurfaceShape::INPUT))
    {
        cookparms.sopAddError(SOP_MESSAGE, "No cross section geometry provided.");
        output_geo->clearAndDestroy();
        return;
    }
    if (!curve_input && (sopparms.getSurfaceShape() != SurfaceShape::INPUT))
    {
        cookparms.sopAddError(SOP_MESSAGE, "No backbone curve geometry provided.");
        output_geo->clearAndDestroy();
        return;
    }

    // GOP_Manager will own any temporary groups it creates
    // and automatically destroy them when it goes out of scope.
    GOP_Manager group_manager;
    const GA_PrimitiveGroup *curve_group = nullptr;
    GA_OffsetList curve_group_list;
    if (curve_input)
    {
        if (sopparms.getCurveGroup().isstring())
        {
            curve_group = group_manager.parsePrimitiveGroups(
                sopparms.getCurveGroup(),
                GOP_Manager::GroupCreator(curve_input));
        }
        if (curve_group == nullptr)
        {
            curve_group_list = curve_input->getPrimitiveMap().getOffsetFromIndexList();
        }
        else
        {
            GA_Offset start;
            GA_Offset end;
            for (GA_Iterator it(curve_input->getPrimitiveRange(curve_group)); it.fullBlockAdvance(start, end); )
            {
                curve_group_list.setTrivialRange(curve_group_list.size(), start, end-start);
            }
        }
    }
    const GA_PrimitiveGroup *cross_section_group = nullptr;
    GA_OffsetList cross_section_group_list;
    if (cross_section_input)
    {
        if (sopparms.getCrossSectionGroup().isstring())
        {
            cross_section_group = group_manager.parsePrimitiveGroups(
                sopparms.getCrossSectionGroup(),
                GOP_Manager::GroupCreator(cross_section_input));
        }
        if (cross_section_group == nullptr)
        {
            cross_section_group_list = cross_section_input->getPrimitiveMap().getOffsetFromIndexList();
        }
        else
        {
            GA_Offset start;
            GA_Offset end;
            for (GA_Iterator it(cross_section_input->getPrimitiveRange(cross_section_group)); it.fullBlockAdvance(start, end); )
            {
                cross_section_group_list.setTrivialRange(cross_section_group_list.size(), start, end-start);
            }
        }
    }

    //GUremoveUnnecessaryAttribs(output_geo, cross_section_input, curve_input, sopcache, target_attrib_info, target_group_info);

    ///////////////////////////////////////////////////////////////////
    //                                                               //
    //          1. SURFACE TOPOLOGY                                  //
    //                                                               //
    ///////////////////////////////////////////////////////////////////

    CopyOrder copy_order = (cross_section_input && curve_input) ? sopparms.getCopyOrder() : CopyOrder::CYCLEVTX;
    bool same_cross_section_data = (sopcache->myPrevCopyOrder == copy_order);
    if (copy_order == CopyOrder::ATTRIB)
    {
        // NOTE: If the attribute matching doesn't work out, this switches copy_order to CopyOrder::CYCLEVTX.
        setupCrossSectionAttribs(
            sopcache, cookparms, sopparms,
            same_cross_section_data, copy_order,
            cross_section_input, curve_input,
            cross_section_group);
    }

    // Remove unnecessary attributes here
    // Add necessary attributes after createGrids, since it calls output_geo->clearAndDestroy()

    removeUnnecessarySweepAttribs(output_geo);

    // We might not have to rebuild the output surface if we still have the previous
    // cook's output surface and it would be regenerated with the same topology.
    // It's a very common case that the surface doesn't need to be rebuilt,
    // but a lot of things affect the output topology, so it's difficult to do,
    // but it could be a big payoff for the common case.
    bool need_to_build_surface = true;

    const bool same_output_geo_as_last_cook =
        (output_geo->getUniqueId() == sopcache->myPrevOutputDetailID);
    int64 new_curve_prim_list_data_id = (curve_input ? curve_input->getPrimitiveList().getDataId() : -1);
    int64 new_curve_topology_data_id = (curve_input ? curve_input->getTopology().getDataId() : -1);
    if (same_output_geo_as_last_cook)
    {
        const bool same_input_curves =
            (new_curve_prim_list_data_id == sopcache->myPrevCurvePrimListDataID) &&
            (new_curve_topology_data_id == sopcache->myPrevCurveTopologyDataID) &&
            (curve_group_list.size() == sopcache->myPrevCurveGroup.size()) &&
            (curve_group_list.isEqual(sopcache->myPrevCurveGroup, 0, curve_group_list.size()));
        // NOTE: Reversing cross sections does not change the topology of the output grids.
        bool same_surface_parms =
            (sopparms.getSurfaceType() == sopcache->myPrevSurfaceType) &&
            (sopparms.getUnrollClosedRowCol() == sopcache->myPrevUnrollClosedRowCol) &&
            (sopparms.getPrimType() == sopcache->myPrevPrimType) &&
            (sopparms.getEndCapType() == sopcache->myPrevEndCapType) &&
            (sopparms.getCapDivs() == sopcache->myPrevEndCapDivs) &&
            (sopparms.getTriangularPoles() == sopcache->myPrevTriangularPoles) &&
            (sopparms.getSwapRowCol() == sopcache->myPrevSwapRowCol);
        if (same_surface_parms)
        {
            if (cross_section_input && sopcache->myPrevSurfaceShape == SurfaceShape::INPUT)
            {
                same_surface_parms =
                    (sopcache->myPrevSurfaceShape == SurfaceShape::INPUT) &&
                    (sopcache->myPrevCloseIfNoCurveInput == sopparms.getCloseIfNoCurveInput()) &&
                    same_cross_section_data &&
                    (cross_section_input->getPrimitiveList().getDataId() == sopcache->myPrevCrossSectionPrimListDataID) &&
                    (cross_section_input->getTopology().getDataId() == sopcache->myPrevCrossSectionTopologyDataID) &&
                    (cross_section_group_list.size() == sopcache->myPrevCrossSectionGroup.size()) &&
                    (cross_section_group_list.isEqual(sopcache->myPrevCrossSectionGroup, 0, cross_section_group_list.size()));
            }
            else
            {
                same_surface_parms =
                    (sopparms.getSurfaceShape() == sopcache->myPrevSurfaceShape) &&
                    (sopparms.getCols() == sopcache->myPrevCols);
            }
        }

        // If the output is cached from the last cook, and the input curve
        // topology is the same, and the output surface type is the same,
        // we only need to move point positions.
        if (same_input_curves && same_surface_parms)
            need_to_build_surface = false;
    }

    sopcache->myPrevOutputDetailID = output_geo->getUniqueId();
    sopcache->myPrevCurvePrimListDataID = new_curve_prim_list_data_id;
    sopcache->myPrevCurveTopologyDataID = new_curve_topology_data_id;
    sopcache->myPrevCurveGroup = std::move(curve_group_list);
    sopcache->myPrevSurfaceType = sopparms.getSurfaceType();
    sopcache->myPrevUnrollClosedRowCol = sopparms.getUnrollClosedRowCol();
    sopcache->myPrevPrimType = sopparms.getPrimType();
    sopcache->myPrevCloseIfNoCurveInput = sopparms.getCloseIfNoCurveInput();
    sopcache->myPrevSurfaceShape = sopparms.getSurfaceShape();
    sopcache->myPrevCols = (cross_section_input && sopcache->myPrevSurfaceShape == SurfaceShape::INPUT) ? -1 : sopparms.getCols();
    sopcache->myPrevEndCapType = sopparms.getEndCapType();
    sopcache->myPrevEndCapDivs = sopparms.getCapDivs();
    sopcache->myPrevTriangularPoles = sopparms.getTriangularPoles();
    sopcache->myPrevSwapRowCol = sopparms.getSwapRowCol();
    sopcache->myPrevCrossSectionPrimListDataID = cross_section_input ? cross_section_input->getPrimitiveList().getDataId() : -1;
    sopcache->myPrevCrossSectionTopologyDataID = cross_section_input ? cross_section_input->getTopology().getDataId() : -1;
    sopcache->myPrevCrossSectionGroup = std::move(cross_section_group_list);
    sopcache->myPrevCopyOrder = copy_order;

    UT_Array<sop_SweepGrid> &grids = sopcache->myGrids;
    const CrossSectionAttribMatchData *copy_order_attrib_data = (copy_order == CopyOrder::ATTRIB) ? &sopcache->myCrossSectionAttribMatchData : nullptr;

    GEO_SurfaceType surface_type = sweepSurfaceToGeoSurface(sopparms.getSurfaceType());
    bool output_points_only = (sopparms.getSurfaceType() == SurfaceType::POINTS);
    exint cap_divisions =
        (sopparms.getEndCapType() == EndCapType::NONE || sopparms.getEndCapType() == EndCapType::SINGLE || sopparms.getEndCapType() == EndCapType::SIDESINGLE) ? 0 : sopparms.getCapDivs();

    if (need_to_build_surface)
    {
        bool finished = createGrids(
            cross_section_input, cross_section_group,
            sopparms.getSurfaceShape(),
            sopparms.getCols() * ((sopparms.getSurfaceShape() == SurfaceShape::SQUARE) ? 4 : 1),
            copy_order, copy_order_attrib_data,
            curve_input, curve_group,
            sopparms.getCloseIfNoCurveInput(),
            surface_type, output_points_only, sopparms.getUnrollClosedRowCol(),
            sopParmToPrimType(sopparms.getPrimType()),
            sopparms.getEndCapType(), cap_divisions,
            sopparms.getTriangularPoles(),
            sopparms.getSwapRowCol(),
            output_geo, grids);

        if (!finished)
            return; // Interrupted, so return.
    }

    // We compute surface point positions, uvs, metadata, and normals,
    // and copy other attributes after computing transforms.
    GA_AttributeUPtr detached_cross_section_uv;

    UT_SmallArray<std::pair<const GA_Attribute*,GA_Attribute*>> cross_section_attribs;
    UT_SmallArray<std::pair<const GA_Attribute*,GA_Attribute*>> curve_attribs;
    UT_SmallArray<std::pair<std::pair<const GA_ATINumeric*,const GA_ATINumeric*>,GA_ATINumeric*>> uv_attribs;
    // If non-negative, this is the index into uv_attribs containing "uv" itself.
    exint uv_attrib_index = -1;

    setupSweepTransferAttribs(output_geo,
        cross_section_input, sopparms.getAttribsFromCrossSection(),
        curve_input, sopparms.getAttribsFromBackbone(),
        cross_section_attribs,
        curve_attribs,
        uv_attribs,
        uv_attrib_index,
        sopparms.getComputeUVs(),
        sopparms.getComputeUVs() && sopparms.getOverrideExistingUVs());

    ///////////////////////////////////////////////////////////////////
    //                                                               //
    //          2. UV                                                //
    //                                                               //
    ///////////////////////////////////////////////////////////////////

    // Optionally compute UVs.
    // If we create a detached uv attribute, it will need to be deleted before we exit.
    //GA_AttributeUPtr curve_uv_deleter;
    UT_Array<double> missing_input_us;
    if (sopparms.getComputeUVs())
    {
        if (cross_section_input)
        {
            GA_ROHandleV3 input_uv_attrib;
            if (!sopparms.getOverrideExistingUVs())
            {
                input_uv_attrib.bind(cross_section_input->findAttribute(GA_ATTRIB_VERTEX, GA_Names::uv));
                if (!input_uv_attrib.isValid())
                    input_uv_attrib.bind(cross_section_input->findAttribute(GA_ATTRIB_POINT, GA_Names::uv));
            }

            GA_RWHandleV3 rw_uv_attrib;
            if (!input_uv_attrib.isValid() || sopparms.getOverrideExistingUVs())
            {
                // We can't modify the input detail to add an attribute, so it must
                // be a "detached" attribute that we're responsible for deleting.
                detached_cross_section_uv =
                    cross_section_input->createDetachedTupleAttribute(
                            GA_ATTRIB_VERTEX, GA_STORE_REAL32, 3);
                rw_uv_attrib.bind(detached_cross_section_uv.get());
            }

            if (rw_uv_attrib.isValid())
            {
                UT_ASSERT(rw_uv_attrib->getOwner() == GA_ATTRIB_VERTEX);
                computeCurveUVs(cross_section_input, cross_section_group, rw_uv_attrib, sopparms.getLengthWeightedUVs(), sopparms.getReverseCrossSections());

                if (uv_attrib_index >= 0)
                {
                    UT_ASSERT(uv_attribs[uv_attrib_index].first.first == nullptr);
                    uv_attribs[uv_attrib_index].first.first = rw_uv_attrib.getAttribute();
                }
                else
                {
                    GA_AttributeOwner output_uv_owner = output_points_only ? GA_ATTRIB_POINT : GA_ATTRIB_VERTEX;
                    GA_ATINumeric *output_attrib = UTverify_cast<GA_ATINumeric*>(output_geo->createTupleAttribute(output_uv_owner, GA_Names::uv, GA_STORE_REAL32, 3));
                    output_attrib->setTypeInfo(GA_TYPE_TEXTURE_COORD);
                    uv_attrib_index = uv_attribs.size();
                    uv_attribs.append(std::make_pair(std::make_pair(rw_uv_attrib.getAttribute(), (const GA_ATINumeric*)nullptr), output_attrib));
                }
            }
        }
        else
        {
            // Compute automatic cross section UVs
            exint nedgecols = sopparms.getCols();
            if (sopparms.getSurfaceShape() == SurfaceShape::SQUARE)
                nedgecols *= 4;
            bool closed = (sopparms.getSurfaceShape() == SurfaceShape::TUBE || sopparms.getSurfaceShape() == SurfaceShape::SQUARE);
            exint nvertices = nedgecols + !closed;
            missing_input_us.setSizeNoInit(nvertices);
            for (exint i = 0; i < nvertices; ++i)
            {
                missing_input_us[i] = double(i)/double(nedgecols);
            }

            if (uv_attrib_index < 0)
            {
                // No UV attribute was added before, so we need to add one here.
                // Curve UVs will be generated later if both source attributes are null.
                GA_AttributeOwner output_uv_owner = output_points_only ? GA_ATTRIB_POINT : GA_ATTRIB_VERTEX;
                GA_ATINumeric *output_attrib = UTverify_cast<GA_ATINumeric*>(output_geo->createTupleAttribute(output_uv_owner, GA_Names::uv, GA_STORE_REAL32, 3));
                output_attrib->setTypeInfo(GA_TYPE_TEXTURE_COORD);
                uv_attrib_index = uv_attribs.size();
                uv_attribs.append(std::make_pair(std::make_pair((const GA_ATINumeric*)nullptr, (const GA_ATINumeric*)nullptr), output_attrib));
            }
        }

        // NOTE: Backbone curve UVs need to be handled differently, since
        //       need V values for end caps, which don't have their own vertices.
#if 0
        if (curve_input)
        {
            GA_ROHandleV3 input_uv_attrib;
            if (!sopparms.getOverrideExistingUVs())
            {
                input_uv_attrib.bind(curve_input->findAttribute(GA_ATTRIB_VERTEX, GA_Names::uv));
                if (!input_uv_attrib.isValid())
                    input_uv_attrib.bind(curve_input->findAttribute(GA_ATTRIB_POINT, GA_Names::uv));
            }

            GA_RWHandleV3 rw_uv_attrib;
            if (!input_uv_attrib.isValid() || sopparms.getOverrideExistingUVs())
            {
                // We can't modify the input detail to add an attribute, so it must
                // be a "detached" attribute that we're responsible for deleting.
                GA_Attribute *detached_uv_attrib = curve_input->createDetachedTupleAttribute(GA_ATTRIB_VERTEX, GA_STORE_REAL32, 3);
                curve_uv_deleter.reset(detached_uv_attrib);
                rw_uv_attrib.bind(detached_uv_attrib);
            }

            if (rw_uv_attrib.isValid())
            {
                UT_ASSERT(rw_uv_attrib->getOwner() == GA_ATTRIB_VERTEX);
                computeCurveUVs(curve_input, curve_group, rw_uv_attrib, sopparms.getLengthWeightedUVs());

                if (uv_attrib_index >= 0)
                {
                    UT_ASSERT(uv_attribs[uv_attrib_index].first.second == nullptr);
                    uv_attribs[uv_attrib_index].first.second = rw_uv_attrib.getAttribute();
                }
                else
                {
                    GA_ATINumeric *output_attrib = UTverify_cast<GA_ATINumeric*>(output_geo->createTupleAttribute(GA_ATTRIB_VERTEX, GA_Names::uv, GA_STORE_REAL32, 3));
                    output_attrib->setTypeInfo(GA_TYPE_TEXTURE_COORD);
                    uv_attrib_index = uv_attribs.size();
                    uv_attribs.append(std::make_pair(std::make_pair((const GA_ATINumeric*)nullptr, rw_uv_attrib.getAttribute()), output_attrib));
                }
            }
        }
        else
        {
            // Compute UVs for the implicit backbone curve when no curve input.
            exint num_cross_sections = cross_section_group ? cross_section_group->entries() : cross_section_input->getNumPrimitives();
            bool closed = sopparms.getCloseIfNoCurveInput();
            exint nedgecols = num_cross_sections - !closed;
            missing_input_us.setSizeNoInit(num_cross_sections);
            bool length_weighted_uvs = sopparms.getLengthWeightedUVs();
            if (length_weighted_uvs)
            {
                // Approximate distance when weighting UVs by length.
                // Compute cross section centroids and distances between them.
                GA_Iterator cross_section_it(cross_section_input->getPrimitiveRange(cross_section_group));
                GA_ROHandleV3D pos_attrib(cross_section_input->getP());
                UT_Vector3D first_centroid;
                UT_Vector3D prev_centroid;
                exint cross_section_i = 0;
                double total_distance = 0;
                for (; !cross_section_it.atEnd(); ++cross_section_it)
                {
                    GA_Offset primoff = *cross_section_it;
                    const GA_OffsetListRef vertices = cross_section_input->getPrimitiveVertexList(primoff);
                    UT_Vector3D centroid(0,0,0);
                    exint n = vertices.size();
                    for (exint i = 0; i < n; ++i)
                    {
                        GA_Offset ptoff = cross_section_input->vertexPoint(vertices(i));
                        centroid += pos_attrib.get(ptoff);
                    }
                    if (n != 0)
                        centroid /= n;

                    if (cross_section_i == 0)
                    {
                        first_centroid = centroid;
                    }
                    else
                    {
                        double distance = centroid.distance(prev_centroid);
                        total_distance += distance;
                    }
                    missing_input_us[cross_section_i] = total_distance;
                    ++cross_section_i;

                    prev_centroid = centroid;
                }

                if (closed)
                {
                    double distance = first_centroid.distance(prev_centroid);
                    total_distance += distance;
                }

                if (total_distance == 0)
                {
                    // Fall back to uniform UVs if the distance is zero.
                    length_weighted_uvs = false;
                }
                else
                {
                    for (exint i = 0, n = missing_input_us.size(); i < n; ++i)
                    {
                        missing_input_us[i] /= total_distance;
                    }
                }
            }

            // NOTE: Not an "else", since length-weighted UVs case might fall back to uniform UVs.
            if (!length_weighted_uvs)
            {
                // Uniform UVs
                for (exint i = 0; i < num_cross_sections; ++i)
                {
                    missing_input_us[i] = double(i)/double(nedgecols);
                }
            }
        }
#endif
    }

    const bool computing_uvs = (uv_attrib_index >= 0);

    ///////////////////////////////////////////////////////////////////
    //                                                               //
    //          3. TRANSFORMS                                        //
    //                                                               //
    ///////////////////////////////////////////////////////////////////

    exint total_transforms = 0;
    if (curve_input != nullptr)
    {
        // FIXME: Don't recompute transforms if nothing affecting transforms has changed!!!

        // Compute transforms on the curves in a detached attribute,
        // since we won't be keeping it, and the index map won't be changing
        // while it's alive, and we can't change curve_input.
        GA_AttributeUPtr detached_transform_attrib =
            curve_input->createDetachedTupleAttribute(
                    GA_ATTRIB_VERTEX, GA_STORE_REAL64, 16);
        GA_RWHandleM4D transform_attrib(detached_transform_attrib.get());

        CurveFrameParms<double> parms;

        parms.myTangentType = GU_CurveFrame::TangentType(int(sopparms.getTangentType()));
        parms.myExtrapolateEndTangents = sopparms.getExtrapolateEndTangents();
        parms.myTransformByInstanceAttribs = sopparms.getTransformByAttribs();

        parms.myRotationOrder = OP_Node::getRotOrder(int(sopparms.getROrd()));

        const bool applypitch = sopparms.getApplyPitch();
        const bool applyyaw = sopparms.getApplyYaw();
        const bool applyroll = sopparms.getApplyRoll();
        const UT_Vector3D angles(
            applypitch ? SYSdegToRad(sopparms.getPitch()) : 0.0,
            applyyaw   ? SYSdegToRad(sopparms.getYaw())   : 0.0,
            applyroll  ? SYSdegToRad(sopparms.getRoll())  : 0.0);
        parms.myAngles = angles;
        const UT_Vector3D incangles(
            applypitch ? SYSdegToRad(sopparms.getIncPitch()) : 0.0,
            applyyaw   ? SYSdegToRad(sopparms.getIncYaw())   : 0.0,
            applyroll  ? SYSdegToRad(sopparms.getIncRoll() + 360.0*sopparms.getFullTwists())  : 0.0);
        parms.myIncAngles = incangles;
        parms.myIncAnglePer[0] = GU_CurveFrame::RotationPer(int(sopparms.getPitchPer()));
        parms.myIncAnglePer[1] = GU_CurveFrame::RotationPer(int(sopparms.getYawPer()));
        parms.myIncAnglePer[2] = GU_CurveFrame::RotationPer(int(sopparms.getRollPer()));

        const GA_AttributeOwner search_order[4] = {
            GA_ATTRIB_VERTEX,
            GA_ATTRIB_POINT,
            GA_ATTRIB_PRIMITIVE,
            GA_ATTRIB_DETAIL
        };
        if (parms.myIncAngles[0] != 0.0 && parms.myIncAnglePer[0] == GU_CurveFrame::RotationPer::ATTRIB)
            parms.myRotAttribs[0].bind(curve_input->findAttribute(sopparms.getPitchAttrib(), search_order, 4));
        if (parms.myIncAngles[1] != 0.0 && parms.myIncAnglePer[1] == GU_CurveFrame::RotationPer::ATTRIB)
            parms.myRotAttribs[1].bind(curve_input->findAttribute(sopparms.getYawAttrib(), search_order, 4));
        if (parms.myIncAngles[2] != 0.0 && parms.myIncAnglePer[2] == GU_CurveFrame::RotationPer::ATTRIB)
            parms.myRotAttribs[2].bind(curve_input->findAttribute(sopparms.getRollAttrib(), search_order, 4));

        using UpVectorType = SOP_SweepHDKEnums::UpVectorType;

        switch (sopparms.getUpVectorType())
        {
            case UpVectorType::X: parms.myTargetUpVector = UT_Vector3D(1,0,0); break;
            case UpVectorType::NORMAL: SYS_FALLTHROUGH; // Fallback up vector for curve normal case is Y Axis.
            case UpVectorType::Y: parms.myTargetUpVector = UT_Vector3D(0,1,0); break;
            case UpVectorType::Z: parms.myTargetUpVector = UT_Vector3D(0,0,1); break;
            case UpVectorType::ATTRIB:
            {
                parms.myTargetUpVectorAttrib.bind(curve_input, GA_ATTRIB_PRIMITIVE, sopparms.getUpVectorAttrib());
                if (!parms.myTargetUpVectorAttrib.isValid())
                {
                    parms.myTargetUpVectorAttrib.bind(curve_input, GA_ATTRIB_DETAIL, sopparms.getUpVectorAttrib());
                }
                if (parms.myTargetUpVectorAttrib.isValid() && parms.myTargetUpVectorAttrib->getOwner() == GA_ATTRIB_DETAIL)
                {
                    // If it's a detail attribute, just read the value here.
                    parms.myTargetUpVector = parms.myTargetUpVectorAttrib.get(GA_DETAIL_OFFSET);
                    parms.myTargetUpVectorAttrib.clear();
                }
                else
                {
                    if (!parms.myTargetUpVectorAttrib.isValid())
                    {
                        cookparms.sopAddWarning(SOP_MESSAGE, "Target up vector attribute not found; defaulting to y axis.");
                    }
                    parms.myTargetUpVector = UT_Vector3D(0,1,0);
                }
                break;
            }
            case UpVectorType::CUSTOM: parms.myTargetUpVector = sopparms.getUpVector(); break;
        }
        parms.myUseCurveNormalAsTargetUp = (sopparms.getUpVectorType() == UpVectorType::NORMAL);
        parms.myTargetUpVectorAtStart = sopparms.getUpVectorAtStart();
        parms.myContinuousClosedCurves = sopparms.getContinuousClosed();

        if (parms.myTargetUpVectorAtStart && sopparms.getUseEndUpVector())
        {
            parms.myUseEndTargetUpVector = true;
            if (sopparms.getUpVectorType() == UpVectorType::ATTRIB)
            {
                parms.myEndTargetUpVectorAttrib.bind(curve_input, GA_ATTRIB_PRIMITIVE, sopparms.getEndUpVectorAttrib());
                if (!parms.myEndTargetUpVectorAttrib.isValid())
                {
                    parms.myEndTargetUpVectorAttrib.bind(curve_input, GA_ATTRIB_DETAIL, sopparms.getEndUpVectorAttrib());
                }
                if (parms.myEndTargetUpVectorAttrib.isValid() && parms.myEndTargetUpVectorAttrib->getOwner() == GA_ATTRIB_DETAIL)
                {
                    // If it's a detail attribute, just read the value here.
                    parms.myEndTargetUpVector = parms.myEndTargetUpVectorAttrib.get(GA_DETAIL_OFFSET);
                    parms.myEndTargetUpVectorAttrib.clear();
                }
                else
                {
                    if (!parms.myEndTargetUpVectorAttrib.isValid())
                    {
                        cookparms.sopAddWarning(SOP_MESSAGE, "End target up vector attribute not found; defaulting to no end target up vector.");
                        parms.myUseEndTargetUpVector = false;
                    }
                    parms.myEndTargetUpVector = UT_Vector3D(0,1,0);
                }
            }
            else if (sopparms.getUpVectorType() == UpVectorType::CUSTOM)
            {
                parms.myEndTargetUpVector = sopparms.getEndUpVector();
            }
            else
            {
                parms.myEndTargetUpVector = parms.myTargetUpVector;
            }
        }

        parms.myNormalizeScales = false;//sopparms.getNormalize();
        //parms.myMakeOrthogonal = sopparms.getOrthogonal();
        if (sopparms.getSurfaceShape() == SurfaceShape::INPUT)
            parms.myUniformScale = sopparms.getScale();
        else if (sopparms.getSurfaceShape() == SurfaceShape::TUBE)
            parms.myUniformScale = sopparms.getRadius();
        else
            parms.myUniformScale = 0.5*sopparms.getWidth();

        if(sopparms.getApplyScale())
            parms.myScaleRamp = sopparms.getScaleRamp().get();

        parms.myStretchAroundTurns = sopparms.getStretchAroundTurns();
        parms.myMaxStretchScale = sopparms.getMaxStretchAroundTurns();

        computeCurveTransforms(curve_input, curve_group, transform_attrib, parms);

        // Compute grid_transform_starts
        total_transforms = 0;
        for (exint gridi = 0, ngrids = grids.size(); gridi < ngrids; ++gridi)
        {
            const sop_SweepGrid &grid = grids[gridi];
            total_transforms += grid.myCurveNEdges + !grid.myCurveClosed;
        }
        sopcache->myGridTransformStarts.reset(new exint[grids.size()]);
        sopcache->clearTransformArrays();
        sopcache->myTransformMatrices3D.reset(new UT_Matrix3D[total_transforms]);
        sopcache->myTransformTranslates3D.reset(new UT_Vector3D[total_transforms]);
        sopcache->myTransformCacheSize = total_transforms;
        exint *grid_transform_starts = sopcache->myGridTransformStarts.get();
        UT_Matrix3D *transform_matrix3ds = sopcache->myTransformMatrices3D.get();
        UT_Vector3D *transform_translate3ds = sopcache->myTransformTranslates3D.get();
        exint current_transform_start = 0;
        for (exint gridi = 0, ngrids = grids.size(); gridi < ngrids; ++gridi)
        {
            const sop_SweepGrid &grid = grids[gridi];
            grid_transform_starts[gridi] = current_transform_start;
            current_transform_start += grid.myCurveNEdges + !grid.myCurveClosed;
        }

        for (exint gridi = 0, ngrids = grids.size(); gridi < ngrids; ++gridi)
        {
            const sop_SweepGrid &grid = grids[gridi];

            const GA_Offset curve_primoff = grid.myCurvePrimOff;
            const GA_OffsetListRef vertices = curve_input->getPrimitiveVertexList(curve_primoff);
            // NOTE: Don't use grid.myCurveUnrolled, since if "Unroll Closed Row or Column Curves" is on,
            //       that doesn't reflect whether we need to skip computing a transform for
            //       the final input vertex.
            bool curve_unrolled = !vertices.getExtraFlag() &&
                (curve_input->vertexPoint(vertices(0)) == curve_input->vertexPoint(vertices.last()));
            exint num_vertices = vertices.size() - exint(curve_unrolled);
            if (vertices.size() == 1)
            {
                // Special case for single vertex, else it'll effectively
                // get incorrectly treated as having zero vertices.
                curve_unrolled = false;
                num_vertices = 1;
            }
            // FIXME: This assert condition is wrong for CopyOrder::ALL!!!
            //UT_ASSERT(num_vertices == grid.myCurveNEdges + !grid.myCurveClosed - (grid.myVEndPoles ? 2*cap_divisions : 0));

            const exint grid_transform_start = grid_transform_starts[gridi];
            UT_Matrix3D *grid_matrix3ds = transform_matrix3ds + grid_transform_start;
            UT_Vector3D *grid_translate3ds = transform_translate3ds + grid_transform_start;

            // Fill in the transform cache from the vertex matrix4 attribute.
            const exint row_start = grid.myVEndPoles ? cap_divisions : 0;
            for (exint i = 0; i < num_vertices; ++i)
            {
                const UT_Matrix4D transform = transform_attrib.get(vertices(i));
                UT_ASSERT(grid_transform_start+row_start+i < total_transforms);
                grid_matrix3ds[row_start+i] = UT_Matrix3D(transform);
                transform.getTranslates(grid_translate3ds[row_start+i]);
            }

            if (grid.myVEndPoles)
            {
                const GA_Offset vtxoff0 = vertices(0);
                const GA_Offset vtxoff1 = vertices.last();
                const UT_Matrix4D transform0 = transform_attrib.get(vtxoff0);
                const UT_Matrix4D transform1 = transform_attrib.get(vtxoff1);

                sopAllEndCapTransforms(
                    grid, sopparms, cross_section_input,
                    transform0, transform1, num_vertices,
                    grid_matrix3ds, grid_translate3ds,
                    false);
            }
        }
    }
    else if (grids.size() == 1 && grids[0].myVEndPoles)
    {
        // Single grid skinning the cross section input and end caps
        // The end caps need transforms; identity for the rest.
        const sop_SweepGrid &grid = grids[0];
        const UT_Matrix4D identity(1.0);

        total_transforms = grid.myCurveNEdges + !grid.myCurveClosed;
        exint num_vertices = total_transforms - 2*cap_divisions;

        sopcache->myGridTransformStarts.reset(new exint[1]);
        sopcache->clearTransformArrays();
        sopcache->myTransformMatrices3D.reset(new UT_Matrix3D[total_transforms]);
        sopcache->myTransformTranslates3D.reset(new UT_Vector3D[total_transforms]);
        sopcache->myTransformCacheSize = total_transforms;
        exint *grid_transform_starts = sopcache->myGridTransformStarts.get();
        UT_Matrix3D *grid_matrix3ds = sopcache->myTransformMatrices3D.get();
        UT_Vector3D *grid_translate3ds = sopcache->myTransformTranslates3D.get();
        grid_transform_starts[0] = 0;

        // Transforms in the middle are all identity
        for (exint i = 0; i < num_vertices; ++i)
        {
            UT_ASSERT(cap_divisions+i < total_transforms);
            grid_matrix3ds[cap_divisions+i].identity();
            grid_translate3ds[cap_divisions+i] = UT_Vector3D(0,0,0);
        }

        // Transforms for the end cap rows aren't identity.
        sopAllEndCapTransforms(
            grid, sopparms, cross_section_input,
            identity, identity, num_vertices,
            grid_matrix3ds, grid_translate3ds,
            true);
    }
    else
    {
        sopcache->clearTransformArrays();
    }

    // Determine which transform caches are needed
    bool needed_transforms[NeededTransforms::num_needed_transforms];
    for (exint i = 0; i < NeededTransforms::num_needed_transforms; ++i)
    {
        needed_transforms[i] = false;
    }
    for (exint attribi = 0, nattribs = cross_section_attribs.size(); attribi < nattribs; ++attribi)
    {
        GA_Attribute *output_attrib = cross_section_attribs[attribi].second;
        GA_ATINumeric *output_numeric = GA_ATINumeric::cast(output_attrib);
        if (output_numeric == nullptr)
            continue;

        GA_TypeInfo transform_type = output_numeric->getTypeInfo();
        if (transform_type == GA_TYPE_VOID)
            continue;

        using namespace NeededTransforms;
        GA_Storage storage = output_numeric->getStorage();
        bool double_precision = (storage == GA_STORE_REAL64);
        if (transform_type == GA_TYPE_POINT || transform_type == GA_TYPE_HPOINT)
        {
            needed_transforms[matrix3f] |= !double_precision;
            needed_transforms[translate3f] |= !double_precision;
        }
        else if (transform_type == GA_TYPE_VECTOR)
        {
            needed_transforms[matrix3f] |= !double_precision;
        }
        else if (transform_type == GA_TYPE_NORMAL)
        {
            needed_transforms[inverse3d] |= double_precision;
            needed_transforms[inverse3f] |= !double_precision;
        }
        else if (transform_type == GA_TYPE_QUATERNION)
        {
            needed_transforms[quaterniond] |= double_precision;
            needed_transforms[quaternionf] |= !double_precision;
        }
        else if (transform_type == GA_TYPE_TRANSFORM)
        {
            needed_transforms[matrix3f] |= !double_precision;
            needed_transforms[translate3f] |= !double_precision && (output_numeric->getTupleSize() == 16);
        }
    }

    GUcomputeTransformTypeCaches(
        sopcache,
        total_transforms,
        true,//transforms_changed,
        needed_transforms);

    const SOP_SweepHDKCache *transform_cache = (sopcache->myTransformCacheSize != 0) ? sopcache : nullptr;

    ///////////////////////////////////////////////////////////////////
    //                                                               //
    //          4. ATTRIBUTES                                        //
    //                                                               //
    ///////////////////////////////////////////////////////////////////

    //exint num_source_attribs[3];
    //GUaddAttributesFromSourceOrTarget(output_geo, cross_section_input, num_source_attribs, has_transform_matrices, needed_transforms, curve_input, );

    if (!cross_section_input)
    {
        // We're using the implicit circle (tube) or line (ribbon) cross section, so we need to compute P specially.

        output_geo->getP()->bumpDataId();
        const GA_RWHandleV3D outputP(output_geo->getP());
        UT_ASSERT(outputP.isValid());

        UT_Array<UT_Vector3D> cross_section_positions;
        const exint cross_section_nedges = sopparms.getCols();
        if (sopparms.getSurfaceShape() == SurfaceShape::TUBE)
        {
            cross_section_positions.setSize(cross_section_nedges);
            if (cross_section_nedges == 1)
            {
                cross_section_positions[0].assign(1,0,0);
            }
            else
            {
                cross_section_positions[0].assign(1,0,0);
                for (exint cross_sectioni = 1; cross_sectioni < cross_section_nedges; ++cross_sectioni)
                {
                    exint tcross_sectioni = cross_sectioni;
                    if (sopparms.getReverseCrossSections())
                        tcross_sectioni = reverseVtx(cross_sectioni, cross_section_nedges, true);
                    double t = double(tcross_sectioni)/double(cross_section_nedges);
                    UT_Vector3D v;
                    if (t == 0.25)
                        v = UT_Vector3D(0,1,0);
                    else if (t == 0.5)
                        v = UT_Vector3D(-1,0,0);
                    else if (t == 0.75)
                        v = UT_Vector3D(0,-1,0);
                    else
                    {
                        double theta = (2.0*M_PI)*t;
                        double c = SYScos(theta);
                        double s = SYSsin(theta);
                        v = UT_Vector3D(c,s,0);
                    }
                    // NOTE: Normals are reversed in Houdini, so cross section
                    //       orientation must be flipped to have outward facing normals.
                    v[1] = -v[1];
                    cross_section_positions[cross_sectioni] = v;
                }
            }
        }
        else if (sopparms.getSurfaceShape() == SurfaceShape::RIBBON)
        {
            cross_section_positions.setSize(cross_section_nedges+1);
            // NOTE: Normals are reversed in Houdini, so cross section
            //       orientation must be flipped to have normals matching up vectors.
            double x0 = (sopparms.getReverseCrossSections() ? 1 : -1);
            double x1 = -x0;
            cross_section_positions[0].assign(x0, 0, 0);
            for (exint cross_sectioni = 1; cross_sectioni < cross_section_nedges; ++cross_sectioni)
            {
                double t = double(cross_sectioni)/double(cross_section_nedges);
                double x = SYSlerp(x0, x1, t);
                cross_section_positions[cross_sectioni] = UT_Vector3D(x,0,0);
            }
            cross_section_positions.last().assign(x1,0,0);
        }
        else
        {
            UT_ASSERT(sopparms.getSurfaceShape() == SurfaceShape::SQUARE);

            cross_section_positions.setSize(4*cross_section_nedges);
            UT_Vector2D corners[4] = {
                UT_Vector2D(-1, -1),
                UT_Vector2D( 1, -1),
                UT_Vector2D( 1,  1),
                UT_Vector2D(-1,  1)
            };
            // NOTE: Normals are reversed in Houdini, so cross section
            //       orientation must be flipped to have outward facing normals.
            if (!sopparms.getReverseCrossSections())
                UTswap(corners[1], corners[3]);

            exint arrayi = 0;
            for (exint big_edgei = 0; big_edgei < 4; ++big_edgei)
            {
                // Exact for first position on each big edge
                cross_section_positions[arrayi].assign(corners[big_edgei][0], corners[big_edgei][1], 0);
                ++arrayi;

                UT_Vector2D prev = corners[big_edgei];
                UT_Vector2D next = corners[(big_edgei==3) ? 0 : (big_edgei+1)];
                for (exint small_edgei = 1; small_edgei < cross_section_nedges; ++small_edgei, ++arrayi)
                {
                    double t = double(small_edgei)/double(cross_section_nedges);
                    UT_Vector2D pos2d = SYSlerp(prev, next, t);
                    cross_section_positions[arrayi].assign(pos2d[0], pos2d[1], 0);
                }
            }
        }

        UT_ASSERT_P(curve_input != nullptr);

        // Transform position attribute
        const exint ngrids = grids.size();
        auto&& functor = [&](const UT_BlockedRange<exint>& r)
        {
            UT_Matrix4D transform;
            sop_SweepGridTransformWrapper local_grid_transforms;
            for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
            {
                auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                const sop_SweepGrid &grid_info = grids[gridi];
                GU_GridT<GA_Offset> grid;
                initGUGrid(grid_info, surface_type, output_points_only, sopparms.getTriangularPoles(), sopparms.getSwapRowCol(), grid_info.myStartPtOff, grid);

                const bool swap_row_col = sopparms.getSwapRowCol();
                exint prev_vtxi = -1;
                auto&& functor = [&prev_vtxi,&cross_section_positions,swap_row_col,grid_transforms,&transform,&outputP]
                    (GA_Offset output_offset, exint row, exint col)
                {
                    const exint curve_vtxi = swap_row_col ? col : row;
                    if (curve_vtxi != prev_vtxi)
                    {
                        transform = UT_Matrix4D(grid_transforms->getMatrix3s<double>()[curve_vtxi]);
                        transform.setTranslates(grid_transforms->getTranslates<double>()[curve_vtxi]);
                        prev_vtxi = curve_vtxi;
                    }

                    // Transform a single position.
                    // NOTE: col should be in-bounds in this case, since all cross sections have the same topology.
                    const exint cross_section_vtxi = swap_row_col ? row : col;
                    const UT_Vector3D &cross_section_pos = cross_section_positions[cross_section_vtxi];
                    outputP.set(output_offset, (cross_section_pos * transform));
                };

                GUiterateGridPoints(grid, functor);
            }
        };

        const exint PARALLEL_THRESHOLD = 2048;
        if (ngrids > 1 && output_geo->getNumPoints() >= PARALLEL_THRESHOLD)
        {
            // Must harden all pages before multi-threading.
            outputP->hardenAllPages();

            UTparallelFor(UT_BlockedRange<exint>(0, ngrids), functor);
        }
        else
        {
            functor(UT_BlockedRange<exint>(0, ngrids));
        }
    }

    exint num_cross_sections;
    if (cross_section_group != nullptr)
    {
        num_cross_sections = cross_section_group->entries();
    }
    else if (cross_section_input != nullptr)
    {
        num_cross_sections = cross_section_input->getNumPrimitives();
    }
    else
    {
        num_cross_sections = 1;
    }

    const UVStyle ustyle = (!computing_uvs || !sopparms.getLengthWeightedUVs() || sopparms.getNormalizeU()) ?
        UVStyle::NORMALIZED :
        (sopparms.getWrapU() ? UVStyle::ROUNDED : UVStyle::FULL);
    const UVStyle vstyle = (!computing_uvs || !sopparms.getLengthWeightedUVs() || sopparms.getNormalizeV()) ?
        UVStyle::NORMALIZED :
        (sopparms.getWrapV() ? UVStyle::ROUNDED : UVStyle::FULL);

    bool finished = copySurfaceAttributes(
        output_geo, curve_input, cross_section_input,
        grids, (copy_order == CopyOrder::ALL) ? num_cross_sections : 1,
        cross_section_attribs,
        curve_attribs, uv_attribs,
        transform_cache,
        surface_type, output_points_only, sopparms.getTriangularPoles(), cap_divisions,
        sopparms.getReverseCrossSections(), sopparms.getSwapRowCol(),
        uv_attrib_index,
        (!missing_input_us.isEmpty()) ? &missing_input_us : nullptr,
        sopparms.getLengthWeightedUVs(),
        ustyle, vstyle,
        (curve_input == nullptr) || sopparms.getUseMeshEdgeLengths(),
        sopparms.getPropScalePerCurve(),
        computing_uvs && sopparms.getFlipU(),
        sopparms.getUVScale());

    if (!finished)
        return; // Interrupted, so return.

    ///////////////////////////////////////////////////////////////////
    //                                                               //
    //          5. METADATA                                          //
    //                                                               //
    ///////////////////////////////////////////////////////////////////


    if (sopparms.getAddPointRow() && sopparms.getPtRowAttrib().isstring())
    {
        // Create point row attribute
        const UT_StringHolder &attribname = sopparms.getPtRowAttrib();
        GA_RWHandleI attrib(output_geo->createTupleAttribute(GA_ATTRIB_POINT, attribname, GA_STORE_INT32, 1, GA_Defaults(-1)));
        if (attrib.isValid())
        {
            for (exint gridi = 0, ngrids = grids.size(); gridi < ngrids; ++gridi)
            {
                const sop_SweepGrid &grid_info = grids[gridi];
                GU_GridT<GA_Offset> grid;
                initGUGrid(grid_info, surface_type, output_points_only, sopparms.getTriangularPoles(), sopparms.getSwapRowCol(), grid_info.myStartPtOff, grid);

                GUiterateGridPoints(grid, [&attrib](GA_Offset output_ptoff, exint ptrow, exint ptcol)
                {
                    attrib.set(output_ptoff, ptrow);
                });
            }
        }
    }
    if (sopparms.getAddPointCol() && sopparms.getPtColAttrib().isstring())
    {
        // Create point col attribute
        const UT_StringHolder &attribname = sopparms.getPtColAttrib();
        GA_RWHandleI attrib(output_geo->createTupleAttribute(GA_ATTRIB_POINT, attribname, GA_STORE_INT32, 1, GA_Defaults(-1)));
        if (attrib.isValid())
        {
            for (exint gridi = 0, ngrids = grids.size(); gridi < ngrids; ++gridi)
            {
                const sop_SweepGrid &grid_info = grids[gridi];
                GU_GridT<GA_Offset> grid;
                initGUGrid(grid_info, surface_type, output_points_only, sopparms.getTriangularPoles(), sopparms.getSwapRowCol(), grid_info.myStartPtOff, grid);

                GUiterateGridPoints(grid, [&attrib](GA_Offset output_ptoff, exint ptrow, exint ptcol)
                {
                    attrib.set(output_ptoff, ptcol);
                });
            }
        }
    }
    if (sopparms.getAddPrimRow() && sopparms.getPrimRowAttrib().isstring())
    {
        // Create primitive row attribute
        const UT_StringHolder &attribname = sopparms.getPrimRowAttrib();
        GA_RWHandleI attrib(output_geo->createTupleAttribute(GA_ATTRIB_PRIMITIVE, attribname, GA_STORE_INT32, 1, GA_Defaults(-1)));
        if (attrib.isValid())
        {
            for (exint gridi = 0, ngrids = grids.size(); gridi < ngrids; ++gridi)
            {
                const sop_SweepGrid &grid_info = grids[gridi];
                GU_GridT<GA_Offset> grid;
                initGUGrid(grid_info, surface_type, output_points_only, sopparms.getTriangularPoles(), sopparms.getSwapRowCol(), grid_info.myStartPtOff, grid);

                GA_Offset grid_start_primoff = grid_info.myStartPrimOff;
                if (grid_info.myHasPolygonCaps)
                {
                    // Row zero for first single polygon cap.
                    attrib.set(grid_start_primoff, 0);
                    ++grid_start_primoff;
                }

                GUiterateGridPrimitives(grid, [&attrib,grid_start_primoff]
                    (exint primnum, exint primrow, exint primcol, exint primvtxcount, bool closed)
                {
                    attrib.set(grid_start_primoff + primnum, primrow);
                });

                if (grid_info.myHasPolygonCaps)
                {
                    // Last row for last single polygon cap.
                    attrib.set(grid_start_primoff + grid.myNumPrimitives, grid_info.myCurveNEdges);
                }
            }
        }
    }
    if (sopparms.getAddPrimCol() && sopparms.getPrimColAttrib().isstring())
    {
        // Create primitive col attribute
        const UT_StringHolder &attribname = sopparms.getPrimColAttrib();
        GA_RWHandleI attrib(output_geo->createTupleAttribute(GA_ATTRIB_PRIMITIVE, attribname, GA_STORE_INT32, 1, GA_Defaults(-1)));
        if (attrib.isValid())
        {
            for (exint gridi = 0, ngrids = grids.size(); gridi < ngrids; ++gridi)
            {
                const sop_SweepGrid &grid_info = grids[gridi];
                GU_GridT<GA_Offset> grid;
                initGUGrid(grid_info, surface_type, output_points_only, sopparms.getTriangularPoles(), sopparms.getSwapRowCol(), grid_info.myStartPtOff, grid);

                GA_Offset grid_start_primoff = grid_info.myStartPrimOff;
                if (grid_info.myHasPolygonCaps)
                {
                    // No meaningful column for single polygon cap.
                    attrib.set(grid_start_primoff, 0);
                    ++grid_start_primoff;
                }

                GUiterateGridPrimitives(grid, [&attrib,grid_start_primoff]
                    (exint primnum, exint primrow, exint primcol, exint primvtxcount, bool closed)
                {
                    attrib.set(grid_start_primoff + primnum, primcol);
                });

                if (grid_info.myHasPolygonCaps)
                {
                    // No meaningful column for single polygon cap.
                    attrib.set(grid_start_primoff + grid.myNumPrimitives, 0);
                }
            }
        }
    }
    if (sopparms.getAddCurveNum() && sopparms.getCurveNumAttrib().isstring())
    {
        // Create input curve number attribute
        const UT_StringHolder &attribname = sopparms.getCurveNumAttrib();
        GA_RWHandleI attrib(output_geo->createTupleAttribute(GA_ATTRIB_POINT, attribname, GA_STORE_INT32, 1, GA_Defaults(-1)));
        if (attrib.isValid())
        {
            for (exint gridi = 0, ngrids = grids.size(); gridi < ngrids; ++gridi)
            {
                const sop_SweepGrid &grid_info = grids[gridi];
                GU_GridT<GA_Offset> grid;
                initGUGrid(grid_info, surface_type, output_points_only, sopparms.getTriangularPoles(), sopparms.getSwapRowCol(), grid_info.myStartPtOff, grid);

                // If no curve input, there's just the one implicit curve.
                exint curve_number = (curve_input != nullptr) ? exint(curve_input->primitiveIndex(grid_info.myCurvePrimOff)) : 0;

                GUiterateGridPoints(grid, [&attrib,curve_number](GA_Offset output_ptoff, exint ptrow, exint ptcol)
                {
                    attrib.set(output_ptoff, curve_number);
                });
            }
        }
    }
    if (sopparms.getAddCrossSectionNum() && sopparms.getCrossSectionNumAttrib().isstring())
    {
        // Create input cross section number attribute
        const UT_StringHolder &attribname = sopparms.getCrossSectionNumAttrib();
        GA_RWHandleI attrib(output_geo->createTupleAttribute(GA_ATTRIB_POINT, attribname, GA_STORE_INT32, 1, GA_Defaults(-1)));
        if (attrib.isValid())
        {
            for (exint gridi = 0, ngrids = grids.size(); gridi < ngrids; ++gridi)
            {
                const sop_SweepGrid &grid_info = grids[gridi];
                GU_GridT<GA_Offset> grid;
                initGUGrid(grid_info, surface_type, output_points_only, sopparms.getTriangularPoles(), sopparms.getSwapRowCol(), grid_info.myStartPtOff, grid);

                if (cross_section_input != nullptr)
                {
                    GUiterateGridPoints(grid, [&attrib,&grid_info,cross_section_input](GA_Offset output_ptoff, exint ptrow, exint ptcol)
                    {
                        GA_Offset source_cross_section_primoff =
                            grid_info.mySingleCrossSection ?
                            GA_Offset(grid_info.myCrossSectionPrimOff) :
                            (*grid_info.myCrossSectionPrimOffs)[ptrow];
                        UT_ASSERT_P(GAisValid(source_cross_section_primoff));
                        exint cross_section_number = cross_section_input->primitiveIndex(source_cross_section_primoff);

                        attrib.set(output_ptoff, cross_section_number);
                    });
                }
                else
                {
                    GUiterateGridPoints(grid, [&attrib](GA_Offset output_ptoff, exint ptrow, exint ptcol)
                    {
                        // Only the one cross section if no cross section input.
                        attrib.set(output_ptoff, 0);
                    });
                }
            }
        }
    }
    if (sopparms.getAddEndCapsGroup() && sopparms.getEndCapsGroup().isstring())
    {
        // Create end caps primitive group
        const UT_StringHolder &groupname = sopparms.getEndCapsGroup();
        GA_PrimitiveGroup *group = output_geo->newPrimitiveGroup(groupname);
        if (group != nullptr && sopparms.getEndCapType() != EndCapType::NONE)
        {
            for (exint gridi = 0, ngrids = grids.size(); gridi < ngrids; ++gridi)
            {
                const sop_SweepGrid &grid_info = grids[gridi];
                GU_GridT<GA_Offset> grid;
                initGUGrid(grid_info, surface_type, output_points_only, sopparms.getTriangularPoles(), sopparms.getSwapRowCol(), grid_info.myStartPtOff, grid);

                GA_Offset grid_start_primoff = grid_info.myStartPrimOff;
                if (grid_info.myHasPolygonCaps)
                {
                    // Only the first and last primitive if single-polygon end caps
                    group->addOffset(grid_start_primoff);
                    group->addOffset(grid_start_primoff+1+grid.myNumPrimitives);
                }
                else if (grid_info.myVEndPoles)
                {
                    // All primitives with primrow < cap_divisions or >= last_cap_start_row are end in caps.
                    exint last_cap_start_vtxi = grid_info.myCurveNEdges - cap_divisions;
                    const bool swap_row_col = sopparms.getSwapRowCol();
                    GUiterateGridPrimitives(grid, [group,cap_divisions,grid_start_primoff,last_cap_start_vtxi,swap_row_col]
                        (exint primnum, exint primrow, exint primcol, exint primvtxcount, bool closed)
                    {
                        exint curve_vtxi = swap_row_col ? primcol : primrow;
                        if (curve_vtxi < cap_divisions || curve_vtxi >= last_cap_start_vtxi)
                        {
                            group->addOffset(grid_start_primoff + primnum);
                        }
                    });
                }
            }
        }
    }


    // FIXME: Separate Us in UV, even if didn't compute UVs!!!

    // Since we're recomputing transforms on every cook for now, we might as well clear the transform cache.
    // FIXME: Reuse the transforms between cooks if they haven't changed!!!
    sopcache->clearTransformArrays();


}

} // End of HDK_Sample namespace