SOP_CrowdMotionPathAvoidCore.proto.h

Go to the documentation of this file.

/* Automagically Generated by generate_proto.py
 * Do not Edit
 */
#pragma once

#include <SOP/SOP_API.h>
#include <SOP/SOP_NodeVerb.h>
#include <OP/OP_GraphProxy.h>

#include <OP/OP_Utils.h>
#include <PRM/PRM_Parm.h>
#include <UT/UT_IStream.h>
#include <UT/UT_NTStreamUtil.h>
#include <UT/UT_Ramp.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringStream.h>
#include <UT/UT_VectorTypes.h>
#include <UT/UT_EnvControl.h>
#include <SYS/SYS_Types.h>

class DEP_MicroNode;
namespace SOP_CrowdMotionPathAvoidCoreEnums
{
    enum class SteeringMode
    {
        XY = 0,
        XYZ
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(SteeringMode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case SteeringMode::XY: return "xy"_sh;
        case SteeringMode::XYZ: return "xyz"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class GoalPos
    {
        ORIGENDPOS = 0,
        ORIGPATH
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(GoalPos enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case GoalPos::ORIGENDPOS: return "origendpos"_sh;
        case GoalPos::ORIGPATH: return "origpath"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

}


class SOP_API SOP_CrowdMotionPathAvoidCoreParms  : public SOP_NodeParms
{
public:
    static int version() { return 1; }

    SOP_CrowdMotionPathAvoidCoreParms()
    {
        myGroup = ""_UTsh;
        myEnableAvoidance = true;
        myMaxCollisionTime = 3;
        myEnableNeighbors = true;
        myNeighborDistance = 10;
        myMaxNeighbors = 100;
        myEnableObstacles = true;
        myObstacleDistance = 10;
        myObstaclePadding = 1;
        myHorizontalFOV = 180;
        myVerticalFOV = 0;
        myFOVSamples = 8;
        myFOVSeed = 1;
        mySteeringMode = 0;
        myTurnSpeedThreshold = 0.25;
        myUseMaxInitialRotation = false;
        myMaxInitialRotation = 45;
        myMaxTurnRate = 90;
        myConstrainTurnAccel = false;
        myTurnStiffness = 10;
        myTurnDamping = 5;
        myGoalPos = 0;
        myGoalPosWeight = 0.1;
        myDistanceVariance = 5;
        myAddCollisionPointGroup = false;
        myCollisionPointGroup = "collided"_UTsh;
        myTimestep = 0;
        myUseStartTime = false;
        myStartTime = 0;
        myUseEndTime = false;
        myEndTime = -1;
        myReferenceUp = UT_Vector3D(0,1,0);

    }

    explicit SOP_CrowdMotionPathAvoidCoreParms(const SOP_CrowdMotionPathAvoidCoreParms &) = default;
    SOP_CrowdMotionPathAvoidCoreParms &operator=(const SOP_CrowdMotionPathAvoidCoreParms &) = default;
    SOP_CrowdMotionPathAvoidCoreParms(SOP_CrowdMotionPathAvoidCoreParms &&) noexcept = default;
    SOP_CrowdMotionPathAvoidCoreParms &operator=(SOP_CrowdMotionPathAvoidCoreParms &&) noexcept = default;

    ~SOP_CrowdMotionPathAvoidCoreParms() override {}

    bool operator==(const SOP_CrowdMotionPathAvoidCoreParms &src) const
    {
        if (myGroup != src.myGroup) return false;
        if (myEnableAvoidance != src.myEnableAvoidance) return false;
        if (myMaxCollisionTime != src.myMaxCollisionTime) return false;
        if (myEnableNeighbors != src.myEnableNeighbors) return false;
        if (myNeighborDistance != src.myNeighborDistance) return false;
        if (myMaxNeighbors != src.myMaxNeighbors) return false;
        if (myEnableObstacles != src.myEnableObstacles) return false;
        if (myObstacleDistance != src.myObstacleDistance) return false;
        if (myObstaclePadding != src.myObstaclePadding) return false;
        if (myHorizontalFOV != src.myHorizontalFOV) return false;
        if (myVerticalFOV != src.myVerticalFOV) return false;
        if (myFOVSamples != src.myFOVSamples) return false;
        if (myFOVSeed != src.myFOVSeed) return false;
        if (mySteeringMode != src.mySteeringMode) return false;
        if (myTurnSpeedThreshold != src.myTurnSpeedThreshold) return false;
        if (myUseMaxInitialRotation != src.myUseMaxInitialRotation) return false;
        if (myMaxInitialRotation != src.myMaxInitialRotation) return false;
        if (myMaxTurnRate != src.myMaxTurnRate) return false;
        if (myConstrainTurnAccel != src.myConstrainTurnAccel) return false;
        if (myTurnStiffness != src.myTurnStiffness) return false;
        if (myTurnDamping != src.myTurnDamping) return false;
        if (myGoalPos != src.myGoalPos) return false;
        if (myGoalPosWeight != src.myGoalPosWeight) return false;
        if (myDistanceVariance != src.myDistanceVariance) return false;
        if (myAddCollisionPointGroup != src.myAddCollisionPointGroup) return false;
        if (myCollisionPointGroup != src.myCollisionPointGroup) return false;
        if (myTimestep != src.myTimestep) return false;
        if (myUseStartTime != src.myUseStartTime) return false;
        if (myStartTime != src.myStartTime) return false;
        if (myUseEndTime != src.myUseEndTime) return false;
        if (myEndTime != src.myEndTime) return false;
        if (myReferenceUp != src.myReferenceUp) return false;


        if (baseGetSignature() != src.baseGetSignature()) return false;

        return true;
    }
    bool operator!=(const SOP_CrowdMotionPathAvoidCoreParms &src) const
    {
        return !operator==(src);
    }
    using SteeringMode = SOP_CrowdMotionPathAvoidCoreEnums::SteeringMode;
    using GoalPos = SOP_CrowdMotionPathAvoidCoreEnums::GoalPos;



    void        buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
    {
        myGroup = ""_UTsh;
        if (true)
            graph->evalOpParm(myGroup, nodeidx, "group", time, graph->isDirect()?nullptr:depnode);
        myEnableAvoidance = true;
        if (true)
            graph->evalOpParm(myEnableAvoidance, nodeidx, "enableavoidance", time, graph->isDirect()?nullptr:depnode);
        myMaxCollisionTime = 3;
        if (true && ( (true&&!(((getEnableAvoidance()==0)))) ) )
            graph->evalOpParm(myMaxCollisionTime, nodeidx, "maxcollisiontime", time, graph->isDirect()?nullptr:depnode);
        myEnableNeighbors = true;
        if (true && ( (true&&!(((getEnableAvoidance()==0)))) ) )
            graph->evalOpParm(myEnableNeighbors, nodeidx, "enableneighbors", time, graph->isDirect()?nullptr:depnode);
        myNeighborDistance = 10;
        if (true && ( (true&&!(((getEnableAvoidance()==0))||((getEnableNeighbors()==0)))) ) )
            graph->evalOpParm(myNeighborDistance, nodeidx, "neighbordistance", time, graph->isDirect()?nullptr:depnode);
        myMaxNeighbors = 100;
        if (true && ( (true&&!(((getEnableAvoidance()==0))||((getEnableNeighbors()==0)))) ) )
            graph->evalOpParm(myMaxNeighbors, nodeidx, "maxneighbors", time, graph->isDirect()?nullptr:depnode);
        myEnableObstacles = true;
        if (true && ( (true&&!(((getEnableAvoidance()==0)))) ) )
            graph->evalOpParm(myEnableObstacles, nodeidx, "enableobstacles", time, graph->isDirect()?nullptr:depnode);
        myObstacleDistance = 10;
        if (true && ( (true&&!(((getEnableObstacles()==0))||((getEnableAvoidance()==0)))) ) )
            graph->evalOpParm(myObstacleDistance, nodeidx, "obstacledistance", time, graph->isDirect()?nullptr:depnode);
        myObstaclePadding = 1;
        if (true && ( (true&&!(((getEnableObstacles()==0))||((getEnableAvoidance()==0)))) ) )
            graph->evalOpParm(myObstaclePadding, nodeidx, "obstaclepadding", time, graph->isDirect()?nullptr:depnode);
        myHorizontalFOV = 180;
        if (true && ( (true&&!(((getEnableObstacles()==0))||((getEnableAvoidance()==0)))) ) )
            graph->evalOpParm(myHorizontalFOV, nodeidx, "horizontalfov", time, graph->isDirect()?nullptr:depnode);
        myVerticalFOV = 0;
        if (true && ( (true&&!(((getEnableObstacles()==0))||((getEnableAvoidance()==0)))) ) )
            graph->evalOpParm(myVerticalFOV, nodeidx, "verticalfov", time, graph->isDirect()?nullptr:depnode);
        myFOVSamples = 8;
        if (true && ( (true&&!(((getEnableObstacles()==0))||((getEnableAvoidance()==0)))) ) )
            graph->evalOpParm(myFOVSamples, nodeidx, "fovsamples", time, graph->isDirect()?nullptr:depnode);
        myFOVSeed = 1;
        if (true && ( (true&&!(((getEnableObstacles()==0))||((getEnableAvoidance()==0))||((getVerticalFOV()==0)))) ) )
            graph->evalOpParm(myFOVSeed, nodeidx, "fovseed", time, graph->isDirect()?nullptr:depnode);
        mySteeringMode = 0;
        if (true && ( (true&&!(((getEnableAvoidance()==0)))) ) )
            graph->evalOpParm(mySteeringMode, nodeidx, "steeringmode", time, graph->isDirect()?nullptr:depnode);
        myTurnSpeedThreshold = 0.25;
        if (true && ( (true&&!(((getEnableAvoidance()==0)))) ) )
            graph->evalOpParm(myTurnSpeedThreshold, nodeidx, "turnspeedthreshold", time, graph->isDirect()?nullptr:depnode);
        myUseMaxInitialRotation = false;
        if (true && ( (true&&!(((getEnableAvoidance()==0)))) ) )
            graph->evalOpParm(myUseMaxInitialRotation, nodeidx, "usemaxinitialrotation", time, graph->isDirect()?nullptr:depnode);
        myMaxInitialRotation = 45;
        if (true && ( (true&&!(((getEnableAvoidance()==0))||((getUseMaxInitialRotation()==0)))) ) )
            graph->evalOpParm(myMaxInitialRotation, nodeidx, "maxinitialrotation", time, graph->isDirect()?nullptr:depnode);
        myMaxTurnRate = 90;
        if (true && ( (true&&!(((getEnableAvoidance()==0)))) ) )
            graph->evalOpParm(myMaxTurnRate, nodeidx, "maxturnrate", time, graph->isDirect()?nullptr:depnode);
        myConstrainTurnAccel = false;
        if (true && ( (true&&!(((getEnableAvoidance()==0)))) ) )
            graph->evalOpParm(myConstrainTurnAccel, nodeidx, "constrainturnaccel", time, graph->isDirect()?nullptr:depnode);
        myTurnStiffness = 10;
        if (true && ( (true&&!(((getConstrainTurnAccel()==0))||((getEnableAvoidance()==0)))) ) )
            graph->evalOpParm(myTurnStiffness, nodeidx, "turnstiffness", time, graph->isDirect()?nullptr:depnode);
        myTurnDamping = 5;
        if (true && ( (true&&!(((getConstrainTurnAccel()==0))||((getEnableAvoidance()==0)))) ) )
            graph->evalOpParm(myTurnDamping, nodeidx, "turndamping", time, graph->isDirect()?nullptr:depnode);
        myGoalPos = 0;
        if (true && ( (true&&!(((getEnableAvoidance()==0)))) ) )
            graph->evalOpParm(myGoalPos, nodeidx, "goalpos", time, graph->isDirect()?nullptr:depnode);
        myGoalPosWeight = 0.1;
        if (true && ( (true&&!(((getEnableAvoidance()==0)))) ) )
            graph->evalOpParm(myGoalPosWeight, nodeidx, "goalposweight", time, graph->isDirect()?nullptr:depnode);
        myDistanceVariance = 5;
        if (true && ( (true&&!(((getEnableAvoidance()==0))||((int64(getGoalPos())!=1)))) ) )
            graph->evalOpParm(myDistanceVariance, nodeidx, "distancevariance", time, graph->isDirect()?nullptr:depnode);
        myAddCollisionPointGroup = false;
        if (true)
            graph->evalOpParm(myAddCollisionPointGroup, nodeidx, "addcollisionptgroup", time, graph->isDirect()?nullptr:depnode);
        myCollisionPointGroup = "collided"_UTsh;
        if (true && ( (true&&!(((getAddCollisionPointGroup()==0)))) ) )
            graph->evalOpParm(myCollisionPointGroup, nodeidx, "collisionptgroup", time, graph->isDirect()?nullptr:depnode);
        myTimestep = 0;
        if (true)
            graph->evalOpParm(myTimestep, nodeidx, "timestep", time, graph->isDirect()?nullptr:depnode);
        myUseStartTime = false;
        if (true)
            graph->evalOpParm(myUseStartTime, nodeidx, "usestarttime", time, graph->isDirect()?nullptr:depnode);
        myStartTime = 0;
        if (true && ( (true&&!(((getUseStartTime()==0)))) ) )
            graph->evalOpParm(myStartTime, nodeidx, "starttime", time, graph->isDirect()?nullptr:depnode);
        myUseEndTime = false;
        if (true)
            graph->evalOpParm(myUseEndTime, nodeidx, "useendtime", time, graph->isDirect()?nullptr:depnode);
        myEndTime = -1;
        if (true && ( (true&&!(((getUseEndTime()==0)))) ) )
            graph->evalOpParm(myEndTime, nodeidx, "endtime", time, graph->isDirect()?nullptr:depnode);
        myReferenceUp = UT_Vector3D(0,1,0);
        if (true)
            graph->evalOpParm(myReferenceUp, nodeidx, "refup", time, graph->isDirect()?nullptr:depnode);

    }


    void loadFromOpSubclass(const LoadParms &loadparms) override
    {
        buildFromOp(loadparms.graph(), loadparms.nodeIdx(), loadparms.context().getTime(), loadparms.depnode());
    }


    void copyFrom(const OP_NodeParms *src) override
    {
        *this = *((const SOP_CrowdMotionPathAvoidCoreParms *)src);
    }

    template <typename T>
    void
    doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
    {
        if (idx.size() < 1)
            return;
        UT_ASSERT(idx.size() == instance.size()+1);
        if (idx.size() != instance.size()+1)
            return;
        switch (idx[0])
        {
            case 0:
                coerceValue(value, myGroup);
                break;
            case 1:
                coerceValue(value, myEnableAvoidance);
                break;
            case 2:
                coerceValue(value, myMaxCollisionTime);
                break;
            case 3:
                coerceValue(value, myEnableNeighbors);
                break;
            case 4:
                coerceValue(value, myNeighborDistance);
                break;
            case 5:
                coerceValue(value, myMaxNeighbors);
                break;
            case 6:
                coerceValue(value, myEnableObstacles);
                break;
            case 7:
                coerceValue(value, myObstacleDistance);
                break;
            case 8:
                coerceValue(value, myObstaclePadding);
                break;
            case 9:
                coerceValue(value, myHorizontalFOV);
                break;
            case 10:
                coerceValue(value, myVerticalFOV);
                break;
            case 11:
                coerceValue(value, myFOVSamples);
                break;
            case 12:
                coerceValue(value, myFOVSeed);
                break;
            case 13:
                coerceValue(value, mySteeringMode);
                break;
            case 14:
                coerceValue(value, myTurnSpeedThreshold);
                break;
            case 15:
                coerceValue(value, myUseMaxInitialRotation);
                break;
            case 16:
                coerceValue(value, myMaxInitialRotation);
                break;
            case 17:
                coerceValue(value, myMaxTurnRate);
                break;
            case 18:
                coerceValue(value, myConstrainTurnAccel);
                break;
            case 19:
                coerceValue(value, myTurnStiffness);
                break;
            case 20:
                coerceValue(value, myTurnDamping);
                break;
            case 21:
                coerceValue(value, myGoalPos);
                break;
            case 22:
                coerceValue(value, myGoalPosWeight);
                break;
            case 23:
                coerceValue(value, myDistanceVariance);
                break;
            case 24:
                coerceValue(value, myAddCollisionPointGroup);
                break;
            case 25:
                coerceValue(value, myCollisionPointGroup);
                break;
            case 26:
                coerceValue(value, myTimestep);
                break;
            case 27:
                coerceValue(value, myUseStartTime);
                break;
            case 28:
                coerceValue(value, myStartTime);
                break;
            case 29:
                coerceValue(value, myUseEndTime);
                break;
            case 30:
                coerceValue(value, myEndTime);
                break;
            case 31:
                coerceValue(value, myReferenceUp);
                break;

        }
    }

    bool isParmColorRamp(exint idx) const override
    { 
            switch (idx)
            {

            }
            return false;
    }

    void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr<UT_Ramp> &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
    { doGetParmValue(idx, instance, value); }

    template <typename T>
    void
    doSetParmValue(TempIndex idx, TempIndex instance, const T &value) 
    {
        if (idx.size() < 1)
            return;
        UT_ASSERT(idx.size() == instance.size()+1);
        if (idx.size() != instance.size()+1)
            return;
        switch (idx[0])
        {
            case 0:
                coerceValue(myGroup, ( ( value ) ));
                break;
            case 1:
                coerceValue(myEnableAvoidance, ( ( value ) ));
                break;
            case 2:
                coerceValue(myMaxCollisionTime, ( ( value ) ));
                break;
            case 3:
                coerceValue(myEnableNeighbors, ( ( value ) ));
                break;
            case 4:
                coerceValue(myNeighborDistance, clampMinValue(0,  ( value ) ));
                break;
            case 5:
                coerceValue(myMaxNeighbors, clampMinValue(0,  ( value ) ));
                break;
            case 6:
                coerceValue(myEnableObstacles, ( ( value ) ));
                break;
            case 7:
                coerceValue(myObstacleDistance, clampMinValue(0,  ( value ) ));
                break;
            case 8:
                coerceValue(myObstaclePadding, clampMinValue(0,  ( value ) ));
                break;
            case 9:
                coerceValue(myHorizontalFOV, clampMinValue(0,  ( value ) ));
                break;
            case 10:
                coerceValue(myVerticalFOV, clampMinValue(0,  ( value ) ));
                break;
            case 11:
                coerceValue(myFOVSamples, clampMinValue(0,  ( value ) ));
                break;
            case 12:
                coerceValue(myFOVSeed, ( ( value ) ));
                break;
            case 13:
                coerceValue(mySteeringMode, clampMinValue(0,  clampMaxValue(1,  value ) ));
                break;
            case 14:
                coerceValue(myTurnSpeedThreshold, ( ( value ) ));
                break;
            case 15:
                coerceValue(myUseMaxInitialRotation, ( ( value ) ));
                break;
            case 16:
                coerceValue(myMaxInitialRotation, clampMinValue(0,  ( value ) ));
                break;
            case 17:
                coerceValue(myMaxTurnRate, ( ( value ) ));
                break;
            case 18:
                coerceValue(myConstrainTurnAccel, ( ( value ) ));
                break;
            case 19:
                coerceValue(myTurnStiffness, ( ( value ) ));
                break;
            case 20:
                coerceValue(myTurnDamping, ( ( value ) ));
                break;
            case 21:
                coerceValue(myGoalPos, clampMinValue(0,  clampMaxValue(1,  value ) ));
                break;
            case 22:
                coerceValue(myGoalPosWeight, clampMinValue(0,  ( value ) ));
                break;
            case 23:
                coerceValue(myDistanceVariance, ( ( value ) ));
                break;
            case 24:
                coerceValue(myAddCollisionPointGroup, ( ( value ) ));
                break;
            case 25:
                coerceValue(myCollisionPointGroup, ( ( value ) ));
                break;
            case 26:
                coerceValue(myTimestep, clampMinValue(0,  ( value ) ));
                break;
            case 27:
                coerceValue(myUseStartTime, ( ( value ) ));
                break;
            case 28:
                coerceValue(myStartTime, ( ( value ) ));
                break;
            case 29:
                coerceValue(myUseEndTime, ( ( value ) ));
                break;
            case 30:
                coerceValue(myEndTime, ( ( value ) ));
                break;
            case 31:
                coerceValue(myReferenceUp, ( ( value ) ));
                break;

        }
    }

    void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr<UT_Ramp> &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value)  override
    { doSetParmValue(idx, instance, value); }

    exint getNestNumParms(TempIndex idx) const override
    {
        if (idx.size() == 0)
            return 32;
        switch (idx[0])
        {

        }
        // Invalid
        return 0;
    }

    const char *getNestParmName(TempIndex fieldnum) const override
    {
        if (fieldnum.size() < 1)
            return 0;
        switch (fieldnum[0])
        {
            case 0:
                return "group";
            case 1:
                return "enableavoidance";
            case 2:
                return "maxcollisiontime";
            case 3:
                return "enableneighbors";
            case 4:
                return "neighbordistance";
            case 5:
                return "maxneighbors";
            case 6:
                return "enableobstacles";
            case 7:
                return "obstacledistance";
            case 8:
                return "obstaclepadding";
            case 9:
                return "horizontalfov";
            case 10:
                return "verticalfov";
            case 11:
                return "fovsamples";
            case 12:
                return "fovseed";
            case 13:
                return "steeringmode";
            case 14:
                return "turnspeedthreshold";
            case 15:
                return "usemaxinitialrotation";
            case 16:
                return "maxinitialrotation";
            case 17:
                return "maxturnrate";
            case 18:
                return "constrainturnaccel";
            case 19:
                return "turnstiffness";
            case 20:
                return "turndamping";
            case 21:
                return "goalpos";
            case 22:
                return "goalposweight";
            case 23:
                return "distancevariance";
            case 24:
                return "addcollisionptgroup";
            case 25:
                return "collisionptgroup";
            case 26:
                return "timestep";
            case 27:
                return "usestarttime";
            case 28:
                return "starttime";
            case 29:
                return "useendtime";
            case 30:
                return "endtime";
            case 31:
                return "refup";

        }
        return 0;
    }

    ParmType getNestParmType(TempIndex fieldnum) const override
    {
        if (fieldnum.size() < 1)
            return PARM_UNSUPPORTED;
        switch (fieldnum[0])
        {
            case 0:
                return PARM_STRING;
            case 1:
                return PARM_INTEGER;
            case 2:
                return PARM_FLOAT;
            case 3:
                return PARM_INTEGER;
            case 4:
                return PARM_FLOAT;
            case 5:
                return PARM_INTEGER;
            case 6:
                return PARM_INTEGER;
            case 7:
                return PARM_FLOAT;
            case 8:
                return PARM_FLOAT;
            case 9:
                return PARM_FLOAT;
            case 10:
                return PARM_FLOAT;
            case 11:
                return PARM_INTEGER;
            case 12:
                return PARM_FLOAT;
            case 13:
                return PARM_INTEGER;
            case 14:
                return PARM_FLOAT;
            case 15:
                return PARM_INTEGER;
            case 16:
                return PARM_FLOAT;
            case 17:
                return PARM_FLOAT;
            case 18:
                return PARM_INTEGER;
            case 19:
                return PARM_FLOAT;
            case 20:
                return PARM_FLOAT;
            case 21:
                return PARM_INTEGER;
            case 22:
                return PARM_FLOAT;
            case 23:
                return PARM_FLOAT;
            case 24:
                return PARM_INTEGER;
            case 25:
                return PARM_STRING;
            case 26:
                return PARM_FLOAT;
            case 27:
                return PARM_INTEGER;
            case 28:
                return PARM_FLOAT;
            case 29:
                return PARM_INTEGER;
            case 30:
                return PARM_FLOAT;
            case 31:
                return PARM_VECTOR3;

        }
        return PARM_UNSUPPORTED;
    }

    // Boiler plate to load individual types.
    static void  loadData(UT_IStream &is, int64 &v)
    { is.bread(&v, 1); }
    static void  loadData(UT_IStream &is, bool &v)
    { int64     iv; is.bread(&iv, 1); v = iv; }
    static void  loadData(UT_IStream &is, fpreal64 &v)
    { is.bread<fpreal64>(&v, 1); }
    static void  loadData(UT_IStream &is, UT_Vector2D &v)
    { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector3D &v)
    { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
      is.bread<fpreal64>(&v.z(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector4D &v)
    { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
      is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
    static void  loadData(UT_IStream &is, UT_Matrix2D &v)
    { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
    static void  loadData(UT_IStream &is, UT_Matrix3D &v)
    { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
    static void  loadData(UT_IStream &is, UT_Matrix4D &v)
    { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
    static void  loadData(UT_IStream &is, UT_Vector2I &v)
    { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector3I &v)
    { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
      is.bread<int64>(&v.z(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector4I &v)
    { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
      is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
    static void  loadData(UT_IStream &is, UT_StringHolder &v)
    { is.bread(v); }
    static void  loadData(UT_IStream &is, UT_SharedPtr<UT_Ramp> &v)
    {   UT_StringHolder   rampdata;
        loadData(is, rampdata);
        if (rampdata.isstring())
        {
            v.reset(new UT_Ramp());
            UT_IStream  istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
            v->load(istr);
        }
        else v.reset();
    }
    static void  loadData(UT_IStream &is, PRM_DataItemHandle &v)
    {   UT_StringHolder   data;
        loadData(is, data);
        if (data.isstring())
        {
            // Find the data type.
            const char *colon = UT_StringWrap(data).findChar(':');
            if (colon)
            {
                int             typelen = colon - data.buffer();
                UT_WorkBuffer   type;
                type.strncpy(data.buffer(), typelen);
                UT_IStream  istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
                
                v = PRM_DataFactory::parseBinary(type.buffer(), istr);
            }
        }
        else v.reset();
    }

    static void  saveData(std::ostream &os, int64 v)
    { UTwrite(os, &v); }
    static void  saveData(std::ostream &os, bool v)
    { int64 iv = v; UTwrite(os, &iv); }
    static void  saveData(std::ostream &os, fpreal64 v)
    { UTwrite<fpreal64>(os, &v); }
    static void  saveData(std::ostream &os, UT_Vector2D v)
    { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
    static void  saveData(std::ostream &os, UT_Vector3D v)
    { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
      UTwrite<fpreal64>(os, &v.z()); }
    static void  saveData(std::ostream &os, UT_Vector4D v)
    { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
      UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
    static void  saveData(std::ostream &os, UT_Matrix2D v)
    { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) UTwrite<fpreal64>(os, &v(r, c)); }
    static void  saveData(std::ostream &os, UT_Matrix3D v)
    { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) UTwrite<fpreal64>(os, &v(r, c)); }
    static void  saveData(std::ostream &os, UT_Matrix4D v)
    { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) UTwrite<fpreal64>(os, &v(r, c)); }
    static void  saveData(std::ostream &os, UT_StringHolder s)
    { UT_StringWrap(s).saveBinary(os); }
    static void  saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
    {   UT_StringHolder         result;
        UT_OStringStream        ostr;
        if (s) s->save(ostr);
        result = ostr.str();
        saveData(os, result);
    }
    static void  saveData(std::ostream &os, PRM_DataItemHandle s)
    {   UT_StringHolder         result;
        UT_OStringStream        ostr;
        if (s) 
        {
            ostr << s->getDataTypeToken();
            ostr << ":";
            s->saveBinary(ostr);
        }
        result = ostr.str();
        saveData(os, result);
    }


    void         save(std::ostream &os) const
    {
        int32           v = version();
        UTwrite(os, &v);
        saveData(os, myGroup);
        saveData(os, myEnableAvoidance);
        saveData(os, myMaxCollisionTime);
        saveData(os, myEnableNeighbors);
        saveData(os, myNeighborDistance);
        saveData(os, myMaxNeighbors);
        saveData(os, myEnableObstacles);
        saveData(os, myObstacleDistance);
        saveData(os, myObstaclePadding);
        saveData(os, myHorizontalFOV);
        saveData(os, myVerticalFOV);
        saveData(os, myFOVSamples);
        saveData(os, myFOVSeed);
        saveData(os, mySteeringMode);
        saveData(os, myTurnSpeedThreshold);
        saveData(os, myUseMaxInitialRotation);
        saveData(os, myMaxInitialRotation);
        saveData(os, myMaxTurnRate);
        saveData(os, myConstrainTurnAccel);
        saveData(os, myTurnStiffness);
        saveData(os, myTurnDamping);
        saveData(os, myGoalPos);
        saveData(os, myGoalPosWeight);
        saveData(os, myDistanceVariance);
        saveData(os, myAddCollisionPointGroup);
        saveData(os, myCollisionPointGroup);
        saveData(os, myTimestep);
        saveData(os, myUseStartTime);
        saveData(os, myStartTime);
        saveData(os, myUseEndTime);
        saveData(os, myEndTime);
        saveData(os, myReferenceUp);

    }

    bool         load(UT_IStream &is)
    {
        int32           v;
        is.bread(&v, 1);
        if (version() != v)
        {
            // Fail incompatible versions
            return false;
        }
        loadData(is, myGroup);
        loadData(is, myEnableAvoidance);
        loadData(is, myMaxCollisionTime);
        loadData(is, myEnableNeighbors);
        loadData(is, myNeighborDistance);
        loadData(is, myMaxNeighbors);
        loadData(is, myEnableObstacles);
        loadData(is, myObstacleDistance);
        loadData(is, myObstaclePadding);
        loadData(is, myHorizontalFOV);
        loadData(is, myVerticalFOV);
        loadData(is, myFOVSamples);
        loadData(is, myFOVSeed);
        loadData(is, mySteeringMode);
        loadData(is, myTurnSpeedThreshold);
        loadData(is, myUseMaxInitialRotation);
        loadData(is, myMaxInitialRotation);
        loadData(is, myMaxTurnRate);
        loadData(is, myConstrainTurnAccel);
        loadData(is, myTurnStiffness);
        loadData(is, myTurnDamping);
        loadData(is, myGoalPos);
        loadData(is, myGoalPosWeight);
        loadData(is, myDistanceVariance);
        loadData(is, myAddCollisionPointGroup);
        loadData(is, myCollisionPointGroup);
        loadData(is, myTimestep);
        loadData(is, myUseStartTime);
        loadData(is, myStartTime);
        loadData(is, myUseEndTime);
        loadData(is, myEndTime);
        loadData(is, myReferenceUp);

        return true;
    }

    const UT_StringHolder & getGroup() const { return myGroup; }
    void setGroup(const UT_StringHolder & val) { myGroup = val; }
    UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGroup();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "group", cookparms.getCookTime(), 0);
        return result;
    }
    bool getEnableAvoidance() const { return myEnableAvoidance; }
    void setEnableAvoidance(bool val) { myEnableAvoidance = val; }
    bool opEnableAvoidance(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEnableAvoidance();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "enableavoidance", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getMaxCollisionTime() const { return myMaxCollisionTime; }
    void setMaxCollisionTime(fpreal64 val) { myMaxCollisionTime = val; }
    fpreal64 opMaxCollisionTime(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMaxCollisionTime();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "maxcollisiontime", cookparms.getCookTime(), 0);
        return result;
    }
    bool getEnableNeighbors() const { return myEnableNeighbors; }
    void setEnableNeighbors(bool val) { myEnableNeighbors = val; }
    bool opEnableNeighbors(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEnableNeighbors();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "enableneighbors", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getNeighborDistance() const { return myNeighborDistance; }
    void setNeighborDistance(fpreal64 val) { myNeighborDistance = val; }
    fpreal64 opNeighborDistance(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getNeighborDistance();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "neighbordistance", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getMaxNeighbors() const { return myMaxNeighbors; }
    void setMaxNeighbors(int64 val) { myMaxNeighbors = val; }
    int64 opMaxNeighbors(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMaxNeighbors();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "maxneighbors", cookparms.getCookTime(), 0);
        return result;
    }
    bool getEnableObstacles() const { return myEnableObstacles; }
    void setEnableObstacles(bool val) { myEnableObstacles = val; }
    bool opEnableObstacles(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEnableObstacles();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "enableobstacles", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getObstacleDistance() const { return myObstacleDistance; }
    void setObstacleDistance(fpreal64 val) { myObstacleDistance = val; }
    fpreal64 opObstacleDistance(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getObstacleDistance();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "obstacledistance", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getObstaclePadding() const { return myObstaclePadding; }
    void setObstaclePadding(fpreal64 val) { myObstaclePadding = val; }
    fpreal64 opObstaclePadding(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getObstaclePadding();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "obstaclepadding", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getHorizontalFOV() const { return myHorizontalFOV; }
    void setHorizontalFOV(fpreal64 val) { myHorizontalFOV = val; }
    fpreal64 opHorizontalFOV(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getHorizontalFOV();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "horizontalfov", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getVerticalFOV() const { return myVerticalFOV; }
    void setVerticalFOV(fpreal64 val) { myVerticalFOV = val; }
    fpreal64 opVerticalFOV(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getVerticalFOV();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "verticalfov", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getFOVSamples() const { return myFOVSamples; }
    void setFOVSamples(int64 val) { myFOVSamples = val; }
    int64 opFOVSamples(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getFOVSamples();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "fovsamples", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getFOVSeed() const { return myFOVSeed; }
    void setFOVSeed(fpreal64 val) { myFOVSeed = val; }
    fpreal64 opFOVSeed(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getFOVSeed();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "fovseed", cookparms.getCookTime(), 0);
        return result;
    }
    SteeringMode getSteeringMode() const { return SteeringMode(mySteeringMode); }
    void setSteeringMode(SteeringMode val) { mySteeringMode = int64(val); }
    SteeringMode opSteeringMode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSteeringMode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "steeringmode", cookparms.getCookTime(), 0);
        return SteeringMode(result);
    }
    fpreal64 getTurnSpeedThreshold() const { return myTurnSpeedThreshold; }
    void setTurnSpeedThreshold(fpreal64 val) { myTurnSpeedThreshold = val; }
    fpreal64 opTurnSpeedThreshold(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getTurnSpeedThreshold();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "turnspeedthreshold", cookparms.getCookTime(), 0);
        return result;
    }
    bool getUseMaxInitialRotation() const { return myUseMaxInitialRotation; }
    void setUseMaxInitialRotation(bool val) { myUseMaxInitialRotation = val; }
    bool opUseMaxInitialRotation(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseMaxInitialRotation();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "usemaxinitialrotation", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getMaxInitialRotation() const { return myMaxInitialRotation; }
    void setMaxInitialRotation(fpreal64 val) { myMaxInitialRotation = val; }
    fpreal64 opMaxInitialRotation(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMaxInitialRotation();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "maxinitialrotation", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getMaxTurnRate() const { return myMaxTurnRate; }
    void setMaxTurnRate(fpreal64 val) { myMaxTurnRate = val; }
    fpreal64 opMaxTurnRate(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMaxTurnRate();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "maxturnrate", cookparms.getCookTime(), 0);
        return result;
    }
    bool getConstrainTurnAccel() const { return myConstrainTurnAccel; }
    void setConstrainTurnAccel(bool val) { myConstrainTurnAccel = val; }
    bool opConstrainTurnAccel(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getConstrainTurnAccel();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "constrainturnaccel", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getTurnStiffness() const { return myTurnStiffness; }
    void setTurnStiffness(fpreal64 val) { myTurnStiffness = val; }
    fpreal64 opTurnStiffness(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getTurnStiffness();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "turnstiffness", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getTurnDamping() const { return myTurnDamping; }
    void setTurnDamping(fpreal64 val) { myTurnDamping = val; }
    fpreal64 opTurnDamping(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getTurnDamping();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "turndamping", cookparms.getCookTime(), 0);
        return result;
    }
    GoalPos getGoalPos() const { return GoalPos(myGoalPos); }
    void setGoalPos(GoalPos val) { myGoalPos = int64(val); }
    GoalPos opGoalPos(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGoalPos();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "goalpos", cookparms.getCookTime(), 0);
        return GoalPos(result);
    }
    fpreal64 getGoalPosWeight() const { return myGoalPosWeight; }
    void setGoalPosWeight(fpreal64 val) { myGoalPosWeight = val; }
    fpreal64 opGoalPosWeight(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGoalPosWeight();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "goalposweight", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getDistanceVariance() const { return myDistanceVariance; }
    void setDistanceVariance(fpreal64 val) { myDistanceVariance = val; }
    fpreal64 opDistanceVariance(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDistanceVariance();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "distancevariance", cookparms.getCookTime(), 0);
        return result;
    }
    bool getAddCollisionPointGroup() const { return myAddCollisionPointGroup; }
    void setAddCollisionPointGroup(bool val) { myAddCollisionPointGroup = val; }
    bool opAddCollisionPointGroup(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getAddCollisionPointGroup();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "addcollisionptgroup", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getCollisionPointGroup() const { return myCollisionPointGroup; }
    void setCollisionPointGroup(const UT_StringHolder & val) { myCollisionPointGroup = val; }
    UT_StringHolder opCollisionPointGroup(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getCollisionPointGroup();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "collisionptgroup", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getTimestep() const { return myTimestep; }
    void setTimestep(fpreal64 val) { myTimestep = val; }
    fpreal64 opTimestep(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getTimestep();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "timestep", cookparms.getCookTime(), 0);
        return result;
    }
    bool getUseStartTime() const { return myUseStartTime; }
    void setUseStartTime(bool val) { myUseStartTime = val; }
    bool opUseStartTime(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseStartTime();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "usestarttime", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getStartTime() const { return myStartTime; }
    void setStartTime(fpreal64 val) { myStartTime = val; }
    fpreal64 opStartTime(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getStartTime();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "starttime", cookparms.getCookTime(), 0);
        return result;
    }
    bool getUseEndTime() const { return myUseEndTime; }
    void setUseEndTime(bool val) { myUseEndTime = val; }
    bool opUseEndTime(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseEndTime();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "useendtime", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getEndTime() const { return myEndTime; }
    void setEndTime(fpreal64 val) { myEndTime = val; }
    fpreal64 opEndTime(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEndTime();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "endtime", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector3D getReferenceUp() const { return myReferenceUp; }
    void setReferenceUp(UT_Vector3D val) { myReferenceUp = val; }
    UT_Vector3D opReferenceUp(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getReferenceUp();
        UT_Vector3D result;
        OP_Utils::evalOpParm(result, thissop, "refup", cookparms.getCookTime(), 0);
        return result;
    }

private:
    UT_StringHolder myGroup;
    bool myEnableAvoidance;
    fpreal64 myMaxCollisionTime;
    bool myEnableNeighbors;
    fpreal64 myNeighborDistance;
    int64 myMaxNeighbors;
    bool myEnableObstacles;
    fpreal64 myObstacleDistance;
    fpreal64 myObstaclePadding;
    fpreal64 myHorizontalFOV;
    fpreal64 myVerticalFOV;
    int64 myFOVSamples;
    fpreal64 myFOVSeed;
    int64 mySteeringMode;
    fpreal64 myTurnSpeedThreshold;
    bool myUseMaxInitialRotation;
    fpreal64 myMaxInitialRotation;
    fpreal64 myMaxTurnRate;
    bool myConstrainTurnAccel;
    fpreal64 myTurnStiffness;
    fpreal64 myTurnDamping;
    int64 myGoalPos;
    fpreal64 myGoalPosWeight;
    fpreal64 myDistanceVariance;
    bool myAddCollisionPointGroup;
    UT_StringHolder myCollisionPointGroup;
    fpreal64 myTimestep;
    bool myUseStartTime;
    fpreal64 myStartTime;
    bool myUseEndTime;
    fpreal64 myEndTime;
    UT_Vector3D myReferenceUp;

};