SOP_VolumeVisualization.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 <SOP/SOP_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_VolumeVisualizationEnums
{
    enum class VisMode
    {
        NONE = 0,
        SMOKE,
        HEIGHTFIELD
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(VisMode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case VisMode::NONE: return "none"_sh;
        case VisMode::SMOKE: return "smoke"_sh;
        case VisMode::HEIGHTFIELD: return "heightfield"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Densityrampmode
    {
        NONE = 0,
        CLAMP,
        PERIODIC
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Densityrampmode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Densityrampmode::NONE: return "none"_sh;
        case Densityrampmode::CLAMP: return "clamp"_sh;
        case Densityrampmode::PERIODIC: return "periodic"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Cdrampmode
    {
        NONE = 0,
        CLAMP,
        PERIODIC
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Cdrampmode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Cdrampmode::NONE: return "none"_sh;
        case Cdrampmode::CLAMP: return "clamp"_sh;
        case Cdrampmode::PERIODIC: return "periodic"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Emitrampmode
    {
        NONE = 0,
        CLAMP,
        PERIODIC
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Emitrampmode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Emitrampmode::NONE: return "none"_sh;
        case Emitrampmode::CLAMP: return "clamp"_sh;
        case Emitrampmode::PERIODIC: return "periodic"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Emitcdrampmode
    {
        NONE = 0,
        CLAMP,
        PERIODIC,
        PHYSICAL,
        PLANCK
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Emitcdrampmode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Emitcdrampmode::NONE: return "none"_sh;
        case Emitcdrampmode::CLAMP: return "clamp"_sh;
        case Emitcdrampmode::PERIODIC: return "periodic"_sh;
        case Emitcdrampmode::PHYSICAL: return "physical"_sh;
        case Emitcdrampmode::PLANCK: return "planck"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

}


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

    SOP_VolumeVisualizationParms()
    {
        myVisMode = 1;
        myRangemin = 0;
        myRangemax = 1;
        myDensityscale = 1;
        myShadowscale = 1;
        mySetambientcolors = false;
        myAmbientexposed = UT_Vector3D(1,1,1);
        myAmbientoccluded = UT_Vector3D(0,0,0);
        mySetambientshadows = false;
        myAmbientshadows = 1;
        mySetshadowcolor = false;
        myShadowcolor = UT_Vector3D(1,1,1);
        mySetmaxres = false;
        myMaxres = 128;
        mySetambientmapsize = false;
        myAmbientmapsize = 0.5;
        mySetambientsteprate = false;
        myAmbientsteprate = 4;
        myDensityfield = "density"_UTsh;
        myDensityrampmode = 1;
        myDensityramp = UT_SharedPtr<UT_Ramp>(0);
        myCdfield = ""_UTsh;
        myCdrangeoverride = false;
        myCdrange = UT_Vector2D(0,1);
        myCdrampmode = 1;
        myCdramp = UT_SharedPtr<UT_Ramp>(0);
        myEmitscale = 0;
        myEmitfield = ""_UTsh;
        myEmitrangeoverride = false;
        myEmitrange = UT_Vector2D(0,1);
        myEmitrampmode = 1;
        myEmitramp = UT_SharedPtr<UT_Ramp>(0);
        myEmitcdfield = ""_UTsh;
        myEmitcdrampmode = 1;
        myEmitcdramp = UT_SharedPtr<UT_Ramp>(0);
        myEmitcdfieldscale = 1;
        myEmitcdtemperature0 = 0;
        myEmitcdtemperature = 5000;
        myEmitcdtonemap = true;
        myEmitcdadaptation = 0.15;
        myEmitcdburn = 0;
        myEnablescatter = false;
        myExtinctionratio = 1;
        myScatteringiter = 25;
        myEmitcdrangeoverride = false;
        myEmitcdrange = UT_Vector2D(0,1);

    }

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

    ~SOP_VolumeVisualizationParms() override {}

    bool operator==(const SOP_VolumeVisualizationParms &src) const
    {
        if (myVisMode != src.myVisMode) return false;
        if (myRangemin != src.myRangemin) return false;
        if (myRangemax != src.myRangemax) return false;
        if (myDensityscale != src.myDensityscale) return false;
        if (myShadowscale != src.myShadowscale) return false;
        if (mySetambientcolors != src.mySetambientcolors) return false;
        if (myAmbientexposed != src.myAmbientexposed) return false;
        if (myAmbientoccluded != src.myAmbientoccluded) return false;
        if (mySetambientshadows != src.mySetambientshadows) return false;
        if (myAmbientshadows != src.myAmbientshadows) return false;
        if (mySetshadowcolor != src.mySetshadowcolor) return false;
        if (myShadowcolor != src.myShadowcolor) return false;
        if (mySetmaxres != src.mySetmaxres) return false;
        if (myMaxres != src.myMaxres) return false;
        if (mySetambientmapsize != src.mySetambientmapsize) return false;
        if (myAmbientmapsize != src.myAmbientmapsize) return false;
        if (mySetambientsteprate != src.mySetambientsteprate) return false;
        if (myAmbientsteprate != src.myAmbientsteprate) return false;
        if (myDensityfield != src.myDensityfield) return false;
        if (myDensityrampmode != src.myDensityrampmode) return false;
        if (myDensityramp != src.myDensityramp)
        { if (!myDensityramp || !src.myDensityramp || !(*myDensityramp == *src.myDensityramp)) return false; }
        if (myCdfield != src.myCdfield) return false;
        if (myCdrangeoverride != src.myCdrangeoverride) return false;
        if (myCdrange != src.myCdrange) return false;
        if (myCdrampmode != src.myCdrampmode) return false;
        if (myCdramp != src.myCdramp)
        { if (!myCdramp || !src.myCdramp || !(*myCdramp == *src.myCdramp)) return false; }
        if (myEmitscale != src.myEmitscale) return false;
        if (myEmitfield != src.myEmitfield) return false;
        if (myEmitrangeoverride != src.myEmitrangeoverride) return false;
        if (myEmitrange != src.myEmitrange) return false;
        if (myEmitrampmode != src.myEmitrampmode) return false;
        if (myEmitramp != src.myEmitramp)
        { if (!myEmitramp || !src.myEmitramp || !(*myEmitramp == *src.myEmitramp)) return false; }
        if (myEmitcdfield != src.myEmitcdfield) return false;
        if (myEmitcdrampmode != src.myEmitcdrampmode) return false;
        if (myEmitcdramp != src.myEmitcdramp)
        { if (!myEmitcdramp || !src.myEmitcdramp || !(*myEmitcdramp == *src.myEmitcdramp)) return false; }
        if (myEmitcdfieldscale != src.myEmitcdfieldscale) return false;
        if (myEmitcdtemperature0 != src.myEmitcdtemperature0) return false;
        if (myEmitcdtemperature != src.myEmitcdtemperature) return false;
        if (myEmitcdtonemap != src.myEmitcdtonemap) return false;
        if (myEmitcdadaptation != src.myEmitcdadaptation) return false;
        if (myEmitcdburn != src.myEmitcdburn) return false;
        if (myEnablescatter != src.myEnablescatter) return false;
        if (myExtinctionratio != src.myExtinctionratio) return false;
        if (myScatteringiter != src.myScatteringiter) return false;
        if (myEmitcdrangeoverride != src.myEmitcdrangeoverride) return false;
        if (myEmitcdrange != src.myEmitcdrange) return false;

        return true;
    }
    bool operator!=(const SOP_VolumeVisualizationParms &src) const
    {
        return !operator==(src);
    }
    using VisMode = SOP_VolumeVisualizationEnums::VisMode;
    using Densityrampmode = SOP_VolumeVisualizationEnums::Densityrampmode;
    using Cdrampmode = SOP_VolumeVisualizationEnums::Cdrampmode;
    using Emitrampmode = SOP_VolumeVisualizationEnums::Emitrampmode;
    using Emitcdrampmode = SOP_VolumeVisualizationEnums::Emitcdrampmode;



    void        buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
    {
        myVisMode = 1;
        if (true)
            graph->evalOpParm(myVisMode, nodeidx, "vismode", time, 0);
        myRangemin = 0;
        if (true)
            graph->evalOpParm(myRangemin, nodeidx, "rangemin", time, 0);
        myRangemax = 1;
        if (true)
            graph->evalOpParm(myRangemax, nodeidx, "rangemax", time, 0);
        myDensityscale = 1;
        if (true)
            graph->evalOpParm(myDensityscale, nodeidx, "densityscale", time, 0);
        myShadowscale = 1;
        if (true)
            graph->evalOpParm(myShadowscale, nodeidx, "shadowscale", time, 0);
        mySetambientcolors = false;
        if (true)
            graph->evalOpParm(mySetambientcolors, nodeidx, "setambientcolors", time, 0);
        myAmbientexposed = UT_Vector3D(1,1,1);
        if (true && ( (true&&!(((getSetambientcolors()==0)))) ) )
            graph->evalOpParm(myAmbientexposed, nodeidx, "ambientexposed", time, 0);
        myAmbientoccluded = UT_Vector3D(0,0,0);
        if (true && ( (true&&!(((getSetambientcolors()==0)))) ) )
            graph->evalOpParm(myAmbientoccluded, nodeidx, "ambientoccluded", time, 0);
        mySetambientshadows = false;
        if (true)
            graph->evalOpParm(mySetambientshadows, nodeidx, "setambientshadows", time, 0);
        myAmbientshadows = 1;
        if (true && ( (true&&!(((getSetambientshadows()==0)))) ) )
            graph->evalOpParm(myAmbientshadows, nodeidx, "ambientshadows", time, 0);
        mySetshadowcolor = false;
        if (true)
            graph->evalOpParm(mySetshadowcolor, nodeidx, "setshadowcolor", time, 0);
        myShadowcolor = UT_Vector3D(1,1,1);
        if (true && ( (true&&!(((getSetshadowcolor()==0)))) ) )
            graph->evalOpParm(myShadowcolor, nodeidx, "shadowcolor", time, 0);
        mySetmaxres = false;
        if (true)
            graph->evalOpParm(mySetmaxres, nodeidx, "setmaxres", time, 0);
        myMaxres = 128;
        if (true && ( (true&&!(((getSetmaxres()==0)))) ) )
            graph->evalOpParm(myMaxres, nodeidx, "maxres", time, 0);
        mySetambientmapsize = false;
        if (true)
            graph->evalOpParm(mySetambientmapsize, nodeidx, "setambientmapsize", time, 0);
        myAmbientmapsize = 0.5;
        if (true && ( (true&&!(((getSetambientmapsize()==0)))) ) )
            graph->evalOpParm(myAmbientmapsize, nodeidx, "ambientmapsize", time, 0);
        mySetambientsteprate = false;
        if (true)
            graph->evalOpParm(mySetambientsteprate, nodeidx, "setambientsteprate", time, 0);
        myAmbientsteprate = 4;
        if (true && ( (true&&!(((getSetambientsteprate()==0)))) ) )
            graph->evalOpParm(myAmbientsteprate, nodeidx, "ambientsteprate", time, 0);
        myDensityfield = "density"_UTsh;
        if (true)
            graph->evalOpParm(myDensityfield, nodeidx, "densityfield", time, 0);
        myDensityrampmode = 1;
        if (true)
            graph->evalOpParm(myDensityrampmode, nodeidx, "densityrampmode", time, 0);
        myDensityramp = UT_SharedPtr<UT_Ramp>(0);
        if (true && ( (true&&!(((int64(getDensityrampmode())==0)))) ) )
            graph->evalOpParm(myDensityramp, nodeidx, "densityramp", time, 0);
        myCdfield = ""_UTsh;
        if (true)
            graph->evalOpParm(myCdfield, nodeidx, "cdfield", time, 0);
        myCdrangeoverride = false;
        if (true)
            graph->evalOpParm(myCdrangeoverride, nodeidx, "cdrangeoverride", time, 0);
        myCdrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((getCdrangeoverride()==0)))) ) )
            graph->evalOpParm(myCdrange, nodeidx, "cdrange", time, 0);
        myCdrampmode = 1;
        if (true)
            graph->evalOpParm(myCdrampmode, nodeidx, "cdrampmode", time, 0);
        myCdramp = UT_SharedPtr<UT_Ramp>(0);
        if (true && ( (true&&!(((int64(getCdrampmode())==0)))) ) )
            graph->evalOpParm(myCdramp, nodeidx, "cdramp", time, 0);
        myEmitscale = 0;
        if (true)
            graph->evalOpParm(myEmitscale, nodeidx, "emitscale", time, 0);
        myEmitfield = ""_UTsh;
        if (true)
            graph->evalOpParm(myEmitfield, nodeidx, "emitfield", time, 0);
        myEmitrangeoverride = false;
        if (true)
            graph->evalOpParm(myEmitrangeoverride, nodeidx, "emitrangeoverride", time, 0);
        myEmitrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((getEmitrangeoverride()==0)))) ) )
            graph->evalOpParm(myEmitrange, nodeidx, "emitrange", time, 0);
        myEmitrampmode = 1;
        if (true)
            graph->evalOpParm(myEmitrampmode, nodeidx, "emitrampmode", time, 0);
        myEmitramp = UT_SharedPtr<UT_Ramp>(0);
        if (true && ( (true&&!(((int64(getEmitrampmode())==0)))) ) )
            graph->evalOpParm(myEmitramp, nodeidx, "emitramp", time, 0);
        myEmitcdfield = ""_UTsh;
        if (true)
            graph->evalOpParm(myEmitcdfield, nodeidx, "emitcdfield", time, 0);
        myEmitcdrampmode = 1;
        if (true)
            graph->evalOpParm(myEmitcdrampmode, nodeidx, "emitcdrampmode", time, 0);
        myEmitcdramp = UT_SharedPtr<UT_Ramp>(0);
        if (true && ( (true&&!(((int64(getEmitcdrampmode())==0))||((int64(getEmitcdrampmode())==3))||((int64(getEmitcdrampmode())==4)))) ) )
            graph->evalOpParm(myEmitcdramp, nodeidx, "emitcdramp", time, 0);
        myEmitcdfieldscale = 1;
        if (true && ( (true&&!(((int64(getEmitcdrampmode())!=3)&&(int64(getEmitcdrampmode())!=4)))) ) )
            graph->evalOpParm(myEmitcdfieldscale, nodeidx, "emitcdfieldscale", time, 0);
        myEmitcdtemperature0 = 0;
        if (true && ( (true&&!(((int64(getEmitcdrampmode())!=3)&&(int64(getEmitcdrampmode())!=4)))) ) )
            graph->evalOpParm(myEmitcdtemperature0, nodeidx, "emitcdtemperature0", time, 0);
        myEmitcdtemperature = 5000;
        if (true && ( (true&&!(((int64(getEmitcdrampmode())!=3)&&(int64(getEmitcdrampmode())!=4)))) ) )
            graph->evalOpParm(myEmitcdtemperature, nodeidx, "emitcdtemperature", time, 0);
        myEmitcdtonemap = true;
        if (true && ( (true&&!(((int64(getEmitcdrampmode())!=3)))) ) )
            graph->evalOpParm(myEmitcdtonemap, nodeidx, "emitcdtonemap", time, 0);
        myEmitcdadaptation = 0.15;
        if (true && ( (true&&!(((int64(getEmitcdrampmode())!=3))||((getEmitcdtonemap()==0)))) ) )
            graph->evalOpParm(myEmitcdadaptation, nodeidx, "emitcdadaptation", time, 0);
        myEmitcdburn = 0;
        if (true && ( (true&&!(((int64(getEmitcdrampmode())!=3))||((getEmitcdtonemap()==0)))) ) )
            graph->evalOpParm(myEmitcdburn, nodeidx, "emitcdburn", time, 0);
        myEnablescatter = false;
        if (true)
            graph->evalOpParm(myEnablescatter, nodeidx, "enablescatter", time, 0);
        myExtinctionratio = 1;
        if (true && ( (true&&!(((getEnablescatter()==0)))) ) )
            graph->evalOpParm(myExtinctionratio, nodeidx, "extinctionratio", time, 0);
        myScatteringiter = 25;
        if (true && ( (true&&!(((getEnablescatter()==0)))) ) )
            graph->evalOpParm(myScatteringiter, nodeidx, "scatteringiter", time, 0);
        myEmitcdrangeoverride = false;
        if (true && ( (true&&!(((int64(getEmitcdrampmode())==3))||((int64(getEmitcdrampmode())==4)))) ) )
            graph->evalOpParm(myEmitcdrangeoverride, nodeidx, "emitcdrangeoverride", time, 0);
        myEmitcdrange = UT_Vector2D(0,1);
        if (true && ( (true&&!(((getEmitcdrangeoverride()==0))||((int64(getEmitcdrampmode())==3))||((int64(getEmitcdrampmode())==4)))) ) )
            graph->evalOpParm(myEmitcdrange, nodeidx, "emitcdrange", time, 0);

    }


    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_VolumeVisualizationParms *)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, myVisMode);
                break;
            case 1:
                coerceValue(value, myRangemin);
                break;
            case 2:
                coerceValue(value, myRangemax);
                break;
            case 3:
                coerceValue(value, myDensityscale);
                break;
            case 4:
                coerceValue(value, myShadowscale);
                break;
            case 5:
                coerceValue(value, mySetambientcolors);
                break;
            case 6:
                coerceValue(value, myAmbientexposed);
                break;
            case 7:
                coerceValue(value, myAmbientoccluded);
                break;
            case 8:
                coerceValue(value, mySetambientshadows);
                break;
            case 9:
                coerceValue(value, myAmbientshadows);
                break;
            case 10:
                coerceValue(value, mySetshadowcolor);
                break;
            case 11:
                coerceValue(value, myShadowcolor);
                break;
            case 12:
                coerceValue(value, mySetmaxres);
                break;
            case 13:
                coerceValue(value, myMaxres);
                break;
            case 14:
                coerceValue(value, mySetambientmapsize);
                break;
            case 15:
                coerceValue(value, myAmbientmapsize);
                break;
            case 16:
                coerceValue(value, mySetambientsteprate);
                break;
            case 17:
                coerceValue(value, myAmbientsteprate);
                break;
            case 18:
                coerceValue(value, myDensityfield);
                break;
            case 19:
                coerceValue(value, myDensityrampmode);
                break;
            case 20:
                coerceValue(value, myDensityramp);
                break;
            case 21:
                coerceValue(value, myCdfield);
                break;
            case 22:
                coerceValue(value, myCdrangeoverride);
                break;
            case 23:
                coerceValue(value, myCdrange);
                break;
            case 24:
                coerceValue(value, myCdrampmode);
                break;
            case 25:
                coerceValue(value, myCdramp);
                break;
            case 26:
                coerceValue(value, myEmitscale);
                break;
            case 27:
                coerceValue(value, myEmitfield);
                break;
            case 28:
                coerceValue(value, myEmitrangeoverride);
                break;
            case 29:
                coerceValue(value, myEmitrange);
                break;
            case 30:
                coerceValue(value, myEmitrampmode);
                break;
            case 31:
                coerceValue(value, myEmitramp);
                break;
            case 32:
                coerceValue(value, myEmitcdfield);
                break;
            case 33:
                coerceValue(value, myEmitcdrampmode);
                break;
            case 34:
                coerceValue(value, myEmitcdramp);
                break;
            case 35:
                coerceValue(value, myEmitcdfieldscale);
                break;
            case 36:
                coerceValue(value, myEmitcdtemperature0);
                break;
            case 37:
                coerceValue(value, myEmitcdtemperature);
                break;
            case 38:
                coerceValue(value, myEmitcdtonemap);
                break;
            case 39:
                coerceValue(value, myEmitcdadaptation);
                break;
            case 40:
                coerceValue(value, myEmitcdburn);
                break;
            case 41:
                coerceValue(value, myEnablescatter);
                break;
            case 42:
                coerceValue(value, myExtinctionratio);
                break;
            case 43:
                coerceValue(value, myScatteringiter);
                break;
            case 44:
                coerceValue(value, myEmitcdrangeoverride);
                break;
            case 45:
                coerceValue(value, myEmitcdrange);
                break;

        }
    }

    bool isParmColorRamp(exint idx) const override
    { 
            switch (idx)
            {
                case 25:
                case 34:
                    return true;
            }
            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(myVisMode, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 1:
                coerceValue(myRangemin, ( ( value ) ));
                break;
            case 2:
                coerceValue(myRangemax, ( ( value ) ));
                break;
            case 3:
                coerceValue(myDensityscale, clampMinValue(0,  ( value ) ));
                break;
            case 4:
                coerceValue(myShadowscale, clampMinValue(0,  ( value ) ));
                break;
            case 5:
                coerceValue(mySetambientcolors, ( ( value ) ));
                break;
            case 6:
                coerceValue(myAmbientexposed, clampMinValue(0,  ( value ) ));
                break;
            case 7:
                coerceValue(myAmbientoccluded, clampMinValue(0,  ( value ) ));
                break;
            case 8:
                coerceValue(mySetambientshadows, ( ( value ) ));
                break;
            case 9:
                coerceValue(myAmbientshadows, clampMinValue(0,  ( value ) ));
                break;
            case 10:
                coerceValue(mySetshadowcolor, ( ( value ) ));
                break;
            case 11:
                coerceValue(myShadowcolor, clampMinValue(0,  clampMaxValue(1,  value ) ));
                break;
            case 12:
                coerceValue(mySetmaxres, ( ( value ) ));
                break;
            case 13:
                coerceValue(myMaxres, clampMinValue(1,  ( value ) ));
                break;
            case 14:
                coerceValue(mySetambientmapsize, ( ( value ) ));
                break;
            case 15:
                coerceValue(myAmbientmapsize, clampMinValue(0.1,  clampMaxValue(1,  value ) ));
                break;
            case 16:
                coerceValue(mySetambientsteprate, ( ( value ) ));
                break;
            case 17:
                coerceValue(myAmbientsteprate, clampMinValue(1,  clampMaxValue(10,  value ) ));
                break;
            case 18:
                coerceValue(myDensityfield, ( ( value ) ));
                break;
            case 19:
                coerceValue(myDensityrampmode, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 20:
                coerceValue(myDensityramp, clampMinValue(1,  ( value ) ));
                break;
            case 21:
                coerceValue(myCdfield, ( ( value ) ));
                break;
            case 22:
                coerceValue(myCdrangeoverride, ( ( value ) ));
                break;
            case 23:
                coerceValue(myCdrange, ( ( value ) ));
                break;
            case 24:
                coerceValue(myCdrampmode, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 25:
                coerceValue(myCdramp, clampMinValue(1,  ( value ) ));
                break;
            case 26:
                coerceValue(myEmitscale, clampMinValue(0,  ( value ) ));
                break;
            case 27:
                coerceValue(myEmitfield, ( ( value ) ));
                break;
            case 28:
                coerceValue(myEmitrangeoverride, ( ( value ) ));
                break;
            case 29:
                coerceValue(myEmitrange, ( ( value ) ));
                break;
            case 30:
                coerceValue(myEmitrampmode, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 31:
                coerceValue(myEmitramp, clampMinValue(1,  ( value ) ));
                break;
            case 32:
                coerceValue(myEmitcdfield, ( ( value ) ));
                break;
            case 33:
                coerceValue(myEmitcdrampmode, clampMinValue(0,  clampMaxValue(4,  value ) ));
                break;
            case 34:
                coerceValue(myEmitcdramp, clampMinValue(1,  ( value ) ));
                break;
            case 35:
                coerceValue(myEmitcdfieldscale, ( ( value ) ));
                break;
            case 36:
                coerceValue(myEmitcdtemperature0, clampMinValue(0,  ( value ) ));
                break;
            case 37:
                coerceValue(myEmitcdtemperature, clampMinValue(350,  ( value ) ));
                break;
            case 38:
                coerceValue(myEmitcdtonemap, ( ( value ) ));
                break;
            case 39:
                coerceValue(myEmitcdadaptation, clampMinValue(0,  ( value ) ));
                break;
            case 40:
                coerceValue(myEmitcdburn, ( ( value ) ));
                break;
            case 41:
                coerceValue(myEnablescatter, ( ( value ) ));
                break;
            case 42:
                coerceValue(myExtinctionratio, clampMinValue(0,  clampMaxValue(1,  value ) ));
                break;
            case 43:
                coerceValue(myScatteringiter, clampMinValue(1,  ( value ) ));
                break;
            case 44:
                coerceValue(myEmitcdrangeoverride, ( ( value ) ));
                break;
            case 45:
                coerceValue(myEmitcdrange, ( ( 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 46;
        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 "vismode";
            case 1:
                return "rangemin";
            case 2:
                return "rangemax";
            case 3:
                return "densityscale";
            case 4:
                return "shadowscale";
            case 5:
                return "setambientcolors";
            case 6:
                return "ambientexposed";
            case 7:
                return "ambientoccluded";
            case 8:
                return "setambientshadows";
            case 9:
                return "ambientshadows";
            case 10:
                return "setshadowcolor";
            case 11:
                return "shadowcolor";
            case 12:
                return "setmaxres";
            case 13:
                return "maxres";
            case 14:
                return "setambientmapsize";
            case 15:
                return "ambientmapsize";
            case 16:
                return "setambientsteprate";
            case 17:
                return "ambientsteprate";
            case 18:
                return "densityfield";
            case 19:
                return "densityrampmode";
            case 20:
                return "densityramp";
            case 21:
                return "cdfield";
            case 22:
                return "cdrangeoverride";
            case 23:
                return "cdrange";
            case 24:
                return "cdrampmode";
            case 25:
                return "cdramp";
            case 26:
                return "emitscale";
            case 27:
                return "emitfield";
            case 28:
                return "emitrangeoverride";
            case 29:
                return "emitrange";
            case 30:
                return "emitrampmode";
            case 31:
                return "emitramp";
            case 32:
                return "emitcdfield";
            case 33:
                return "emitcdrampmode";
            case 34:
                return "emitcdramp";
            case 35:
                return "emitcdfieldscale";
            case 36:
                return "emitcdtemperature0";
            case 37:
                return "emitcdtemperature";
            case 38:
                return "emitcdtonemap";
            case 39:
                return "emitcdadaptation";
            case 40:
                return "emitcdburn";
            case 41:
                return "enablescatter";
            case 42:
                return "extinctionratio";
            case 43:
                return "scatteringiter";
            case 44:
                return "emitcdrangeoverride";
            case 45:
                return "emitcdrange";

        }
        return 0;
    }

    ParmType getNestParmType(TempIndex fieldnum) const override
    {
        if (fieldnum.size() < 1)
            return PARM_UNSUPPORTED;
        switch (fieldnum[0])
        {
            case 0:
                return PARM_INTEGER;
            case 1:
                return PARM_FLOAT;
            case 2:
                return PARM_FLOAT;
            case 3:
                return PARM_FLOAT;
            case 4:
                return PARM_FLOAT;
            case 5:
                return PARM_INTEGER;
            case 6:
                return PARM_VECTOR3;
            case 7:
                return PARM_VECTOR3;
            case 8:
                return PARM_INTEGER;
            case 9:
                return PARM_FLOAT;
            case 10:
                return PARM_INTEGER;
            case 11:
                return PARM_VECTOR3;
            case 12:
                return PARM_INTEGER;
            case 13:
                return PARM_INTEGER;
            case 14:
                return PARM_INTEGER;
            case 15:
                return PARM_FLOAT;
            case 16:
                return PARM_INTEGER;
            case 17:
                return PARM_FLOAT;
            case 18:
                return PARM_STRING;
            case 19:
                return PARM_INTEGER;
            case 20:
                return PARM_RAMP;
            case 21:
                return PARM_STRING;
            case 22:
                return PARM_INTEGER;
            case 23:
                return PARM_VECTOR2;
            case 24:
                return PARM_INTEGER;
            case 25:
                return PARM_RAMP;
            case 26:
                return PARM_FLOAT;
            case 27:
                return PARM_STRING;
            case 28:
                return PARM_INTEGER;
            case 29:
                return PARM_VECTOR2;
            case 30:
                return PARM_INTEGER;
            case 31:
                return PARM_RAMP;
            case 32:
                return PARM_STRING;
            case 33:
                return PARM_INTEGER;
            case 34:
                return PARM_RAMP;
            case 35:
                return PARM_FLOAT;
            case 36:
                return PARM_FLOAT;
            case 37:
                return PARM_FLOAT;
            case 38:
                return PARM_INTEGER;
            case 39:
                return PARM_FLOAT;
            case 40:
                return PARM_FLOAT;
            case 41:
                return PARM_INTEGER;
            case 42:
                return PARM_FLOAT;
            case 43:
                return PARM_INTEGER;
            case 44:
                return PARM_INTEGER;
            case 45:
                return PARM_VECTOR2;

        }
        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, myVisMode);
        saveData(os, myRangemin);
        saveData(os, myRangemax);
        saveData(os, myDensityscale);
        saveData(os, myShadowscale);
        saveData(os, mySetambientcolors);
        saveData(os, myAmbientexposed);
        saveData(os, myAmbientoccluded);
        saveData(os, mySetambientshadows);
        saveData(os, myAmbientshadows);
        saveData(os, mySetshadowcolor);
        saveData(os, myShadowcolor);
        saveData(os, mySetmaxres);
        saveData(os, myMaxres);
        saveData(os, mySetambientmapsize);
        saveData(os, myAmbientmapsize);
        saveData(os, mySetambientsteprate);
        saveData(os, myAmbientsteprate);
        saveData(os, myDensityfield);
        saveData(os, myDensityrampmode);
        saveData(os, myDensityramp);
        saveData(os, myCdfield);
        saveData(os, myCdrangeoverride);
        saveData(os, myCdrange);
        saveData(os, myCdrampmode);
        saveData(os, myCdramp);
        saveData(os, myEmitscale);
        saveData(os, myEmitfield);
        saveData(os, myEmitrangeoverride);
        saveData(os, myEmitrange);
        saveData(os, myEmitrampmode);
        saveData(os, myEmitramp);
        saveData(os, myEmitcdfield);
        saveData(os, myEmitcdrampmode);
        saveData(os, myEmitcdramp);
        saveData(os, myEmitcdfieldscale);
        saveData(os, myEmitcdtemperature0);
        saveData(os, myEmitcdtemperature);
        saveData(os, myEmitcdtonemap);
        saveData(os, myEmitcdadaptation);
        saveData(os, myEmitcdburn);
        saveData(os, myEnablescatter);
        saveData(os, myExtinctionratio);
        saveData(os, myScatteringiter);
        saveData(os, myEmitcdrangeoverride);
        saveData(os, myEmitcdrange);

    }

    bool         load(UT_IStream &is)
    {
        int32           v;
        is.bread(&v, 1);
        if (version() != v)
        {
            // Fail incompatible versions
            return false;
        }
        loadData(is, myVisMode);
        loadData(is, myRangemin);
        loadData(is, myRangemax);
        loadData(is, myDensityscale);
        loadData(is, myShadowscale);
        loadData(is, mySetambientcolors);
        loadData(is, myAmbientexposed);
        loadData(is, myAmbientoccluded);
        loadData(is, mySetambientshadows);
        loadData(is, myAmbientshadows);
        loadData(is, mySetshadowcolor);
        loadData(is, myShadowcolor);
        loadData(is, mySetmaxres);
        loadData(is, myMaxres);
        loadData(is, mySetambientmapsize);
        loadData(is, myAmbientmapsize);
        loadData(is, mySetambientsteprate);
        loadData(is, myAmbientsteprate);
        loadData(is, myDensityfield);
        loadData(is, myDensityrampmode);
        loadData(is, myDensityramp);
        loadData(is, myCdfield);
        loadData(is, myCdrangeoverride);
        loadData(is, myCdrange);
        loadData(is, myCdrampmode);
        loadData(is, myCdramp);
        loadData(is, myEmitscale);
        loadData(is, myEmitfield);
        loadData(is, myEmitrangeoverride);
        loadData(is, myEmitrange);
        loadData(is, myEmitrampmode);
        loadData(is, myEmitramp);
        loadData(is, myEmitcdfield);
        loadData(is, myEmitcdrampmode);
        loadData(is, myEmitcdramp);
        loadData(is, myEmitcdfieldscale);
        loadData(is, myEmitcdtemperature0);
        loadData(is, myEmitcdtemperature);
        loadData(is, myEmitcdtonemap);
        loadData(is, myEmitcdadaptation);
        loadData(is, myEmitcdburn);
        loadData(is, myEnablescatter);
        loadData(is, myExtinctionratio);
        loadData(is, myScatteringiter);
        loadData(is, myEmitcdrangeoverride);
        loadData(is, myEmitcdrange);

        return true;
    }

    VisMode getVisMode() const { return VisMode(myVisMode); }
    void setVisMode(VisMode val) { myVisMode = int64(val); }
    VisMode opVisMode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getVisMode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "vismode", cookparms.getCookTime(), 0);
        return VisMode(result);
    }
    fpreal64 getRangemin() const { return myRangemin; }
    void setRangemin(fpreal64 val) { myRangemin = val; }
    fpreal64 opRangemin(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getRangemin();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "rangemin", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getRangemax() const { return myRangemax; }
    void setRangemax(fpreal64 val) { myRangemax = val; }
    fpreal64 opRangemax(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getRangemax();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "rangemax", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getDensityscale() const { return myDensityscale; }
    void setDensityscale(fpreal64 val) { myDensityscale = val; }
    fpreal64 opDensityscale(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDensityscale();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "densityscale", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getShadowscale() const { return myShadowscale; }
    void setShadowscale(fpreal64 val) { myShadowscale = val; }
    fpreal64 opShadowscale(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getShadowscale();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "shadowscale", cookparms.getCookTime(), 0);
        return result;
    }
    bool getSetambientcolors() const { return mySetambientcolors; }
    void setSetambientcolors(bool val) { mySetambientcolors = val; }
    bool opSetambientcolors(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetambientcolors();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "setambientcolors", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector3D getAmbientexposed() const { return myAmbientexposed; }
    void setAmbientexposed(UT_Vector3D val) { myAmbientexposed = val; }
    UT_Vector3D opAmbientexposed(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getAmbientexposed();
        UT_Vector3D result;
        OP_Utils::evalOpParm(result, thissop, "ambientexposed", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector3D getAmbientoccluded() const { return myAmbientoccluded; }
    void setAmbientoccluded(UT_Vector3D val) { myAmbientoccluded = val; }
    UT_Vector3D opAmbientoccluded(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getAmbientoccluded();
        UT_Vector3D result;
        OP_Utils::evalOpParm(result, thissop, "ambientoccluded", cookparms.getCookTime(), 0);
        return result;
    }
    bool getSetambientshadows() const { return mySetambientshadows; }
    void setSetambientshadows(bool val) { mySetambientshadows = val; }
    bool opSetambientshadows(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetambientshadows();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "setambientshadows", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getAmbientshadows() const { return myAmbientshadows; }
    void setAmbientshadows(fpreal64 val) { myAmbientshadows = val; }
    fpreal64 opAmbientshadows(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getAmbientshadows();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "ambientshadows", cookparms.getCookTime(), 0);
        return result;
    }
    bool getSetshadowcolor() const { return mySetshadowcolor; }
    void setSetshadowcolor(bool val) { mySetshadowcolor = val; }
    bool opSetshadowcolor(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetshadowcolor();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "setshadowcolor", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector3D getShadowcolor() const { return myShadowcolor; }
    void setShadowcolor(UT_Vector3D val) { myShadowcolor = val; }
    UT_Vector3D opShadowcolor(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getShadowcolor();
        UT_Vector3D result;
        OP_Utils::evalOpParm(result, thissop, "shadowcolor", cookparms.getCookTime(), 0);
        return result;
    }
    bool getSetmaxres() const { return mySetmaxres; }
    void setSetmaxres(bool val) { mySetmaxres = val; }
    bool opSetmaxres(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetmaxres();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "setmaxres", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getMaxres() const { return myMaxres; }
    void setMaxres(int64 val) { myMaxres = val; }
    int64 opMaxres(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMaxres();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "maxres", cookparms.getCookTime(), 0);
        return result;
    }
    bool getSetambientmapsize() const { return mySetambientmapsize; }
    void setSetambientmapsize(bool val) { mySetambientmapsize = val; }
    bool opSetambientmapsize(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetambientmapsize();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "setambientmapsize", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getAmbientmapsize() const { return myAmbientmapsize; }
    void setAmbientmapsize(fpreal64 val) { myAmbientmapsize = val; }
    fpreal64 opAmbientmapsize(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getAmbientmapsize();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "ambientmapsize", cookparms.getCookTime(), 0);
        return result;
    }
    bool getSetambientsteprate() const { return mySetambientsteprate; }
    void setSetambientsteprate(bool val) { mySetambientsteprate = val; }
    bool opSetambientsteprate(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSetambientsteprate();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "setambientsteprate", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getAmbientsteprate() const { return myAmbientsteprate; }
    void setAmbientsteprate(fpreal64 val) { myAmbientsteprate = val; }
    fpreal64 opAmbientsteprate(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getAmbientsteprate();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "ambientsteprate", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getDensityfield() const { return myDensityfield; }
    void setDensityfield(const UT_StringHolder & val) { myDensityfield = val; }
    UT_StringHolder opDensityfield(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDensityfield();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "densityfield", cookparms.getCookTime(), 0);
        return result;
    }
    Densityrampmode getDensityrampmode() const { return Densityrampmode(myDensityrampmode); }
    void setDensityrampmode(Densityrampmode val) { myDensityrampmode = int64(val); }
    Densityrampmode opDensityrampmode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDensityrampmode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "densityrampmode", cookparms.getCookTime(), 0);
        return Densityrampmode(result);
    }
    UT_SharedPtr<UT_Ramp> getDensityramp() const { return myDensityramp; }
    void setDensityramp(UT_SharedPtr<UT_Ramp> val) { myDensityramp = val; }
    UT_SharedPtr<UT_Ramp> opDensityramp(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDensityramp();
        UT_SharedPtr<UT_Ramp> result;
        OP_Utils::evalOpParm(result, thissop, "densityramp", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getCdfield() const { return myCdfield; }
    void setCdfield(const UT_StringHolder & val) { myCdfield = val; }
    UT_StringHolder opCdfield(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getCdfield();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "cdfield", cookparms.getCookTime(), 0);
        return result;
    }
    bool getCdrangeoverride() const { return myCdrangeoverride; }
    void setCdrangeoverride(bool val) { myCdrangeoverride = val; }
    bool opCdrangeoverride(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getCdrangeoverride();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "cdrangeoverride", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getCdrange() const { return myCdrange; }
    void setCdrange(UT_Vector2D val) { myCdrange = val; }
    UT_Vector2D opCdrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getCdrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "cdrange", cookparms.getCookTime(), 0);
        return result;
    }
    Cdrampmode getCdrampmode() const { return Cdrampmode(myCdrampmode); }
    void setCdrampmode(Cdrampmode val) { myCdrampmode = int64(val); }
    Cdrampmode opCdrampmode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getCdrampmode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "cdrampmode", cookparms.getCookTime(), 0);
        return Cdrampmode(result);
    }
    UT_SharedPtr<UT_Ramp> getCdramp() const { return myCdramp; }
    void setCdramp(UT_SharedPtr<UT_Ramp> val) { myCdramp = val; }
    UT_SharedPtr<UT_Ramp> opCdramp(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getCdramp();
        UT_SharedPtr<UT_Ramp> result;
        OP_Utils::evalOpParm(result, thissop, "cdramp", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getEmitscale() const { return myEmitscale; }
    void setEmitscale(fpreal64 val) { myEmitscale = val; }
    fpreal64 opEmitscale(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEmitscale();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "emitscale", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getEmitfield() const { return myEmitfield; }
    void setEmitfield(const UT_StringHolder & val) { myEmitfield = val; }
    UT_StringHolder opEmitfield(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEmitfield();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "emitfield", cookparms.getCookTime(), 0);
        return result;
    }
    bool getEmitrangeoverride() const { return myEmitrangeoverride; }
    void setEmitrangeoverride(bool val) { myEmitrangeoverride = val; }
    bool opEmitrangeoverride(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEmitrangeoverride();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "emitrangeoverride", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getEmitrange() const { return myEmitrange; }
    void setEmitrange(UT_Vector2D val) { myEmitrange = val; }
    UT_Vector2D opEmitrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEmitrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "emitrange", cookparms.getCookTime(), 0);
        return result;
    }
    Emitrampmode getEmitrampmode() const { return Emitrampmode(myEmitrampmode); }
    void setEmitrampmode(Emitrampmode val) { myEmitrampmode = int64(val); }
    Emitrampmode opEmitrampmode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEmitrampmode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "emitrampmode", cookparms.getCookTime(), 0);
        return Emitrampmode(result);
    }
    UT_SharedPtr<UT_Ramp> getEmitramp() const { return myEmitramp; }
    void setEmitramp(UT_SharedPtr<UT_Ramp> val) { myEmitramp = val; }
    UT_SharedPtr<UT_Ramp> opEmitramp(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEmitramp();
        UT_SharedPtr<UT_Ramp> result;
        OP_Utils::evalOpParm(result, thissop, "emitramp", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getEmitcdfield() const { return myEmitcdfield; }
    void setEmitcdfield(const UT_StringHolder & val) { myEmitcdfield = val; }
    UT_StringHolder opEmitcdfield(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEmitcdfield();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "emitcdfield", cookparms.getCookTime(), 0);
        return result;
    }
    Emitcdrampmode getEmitcdrampmode() const { return Emitcdrampmode(myEmitcdrampmode); }
    void setEmitcdrampmode(Emitcdrampmode val) { myEmitcdrampmode = int64(val); }
    Emitcdrampmode opEmitcdrampmode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEmitcdrampmode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "emitcdrampmode", cookparms.getCookTime(), 0);
        return Emitcdrampmode(result);
    }
    UT_SharedPtr<UT_Ramp> getEmitcdramp() const { return myEmitcdramp; }
    void setEmitcdramp(UT_SharedPtr<UT_Ramp> val) { myEmitcdramp = val; }
    UT_SharedPtr<UT_Ramp> opEmitcdramp(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEmitcdramp();
        UT_SharedPtr<UT_Ramp> result;
        OP_Utils::evalOpParm(result, thissop, "emitcdramp", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getEmitcdfieldscale() const { return myEmitcdfieldscale; }
    void setEmitcdfieldscale(fpreal64 val) { myEmitcdfieldscale = val; }
    fpreal64 opEmitcdfieldscale(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEmitcdfieldscale();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "emitcdfieldscale", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getEmitcdtemperature0() const { return myEmitcdtemperature0; }
    void setEmitcdtemperature0(fpreal64 val) { myEmitcdtemperature0 = val; }
    fpreal64 opEmitcdtemperature0(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEmitcdtemperature0();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "emitcdtemperature0", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getEmitcdtemperature() const { return myEmitcdtemperature; }
    void setEmitcdtemperature(fpreal64 val) { myEmitcdtemperature = val; }
    fpreal64 opEmitcdtemperature(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEmitcdtemperature();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "emitcdtemperature", cookparms.getCookTime(), 0);
        return result;
    }
    bool getEmitcdtonemap() const { return myEmitcdtonemap; }
    void setEmitcdtonemap(bool val) { myEmitcdtonemap = val; }
    bool opEmitcdtonemap(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEmitcdtonemap();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "emitcdtonemap", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getEmitcdadaptation() const { return myEmitcdadaptation; }
    void setEmitcdadaptation(fpreal64 val) { myEmitcdadaptation = val; }
    fpreal64 opEmitcdadaptation(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEmitcdadaptation();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "emitcdadaptation", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getEmitcdburn() const { return myEmitcdburn; }
    void setEmitcdburn(fpreal64 val) { myEmitcdburn = val; }
    fpreal64 opEmitcdburn(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEmitcdburn();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "emitcdburn", cookparms.getCookTime(), 0);
        return result;
    }
    bool getEnablescatter() const { return myEnablescatter; }
    void setEnablescatter(bool val) { myEnablescatter = val; }
    bool opEnablescatter(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEnablescatter();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "enablescatter", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getExtinctionratio() const { return myExtinctionratio; }
    void setExtinctionratio(fpreal64 val) { myExtinctionratio = val; }
    fpreal64 opExtinctionratio(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getExtinctionratio();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "extinctionratio", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getScatteringiter() const { return myScatteringiter; }
    void setScatteringiter(int64 val) { myScatteringiter = val; }
    int64 opScatteringiter(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getScatteringiter();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "scatteringiter", cookparms.getCookTime(), 0);
        return result;
    }
    bool getEmitcdrangeoverride() const { return myEmitcdrangeoverride; }
    void setEmitcdrangeoverride(bool val) { myEmitcdrangeoverride = val; }
    bool opEmitcdrangeoverride(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEmitcdrangeoverride();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "emitcdrangeoverride", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getEmitcdrange() const { return myEmitcdrange; }
    void setEmitcdrange(UT_Vector2D val) { myEmitcdrange = val; }
    UT_Vector2D opEmitcdrange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getEmitcdrange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "emitcdrange", cookparms.getCookTime(), 0);
        return result;
    }

private:
    int64 myVisMode;
    fpreal64 myRangemin;
    fpreal64 myRangemax;
    fpreal64 myDensityscale;
    fpreal64 myShadowscale;
    bool mySetambientcolors;
    UT_Vector3D myAmbientexposed;
    UT_Vector3D myAmbientoccluded;
    bool mySetambientshadows;
    fpreal64 myAmbientshadows;
    bool mySetshadowcolor;
    UT_Vector3D myShadowcolor;
    bool mySetmaxres;
    int64 myMaxres;
    bool mySetambientmapsize;
    fpreal64 myAmbientmapsize;
    bool mySetambientsteprate;
    fpreal64 myAmbientsteprate;
    UT_StringHolder myDensityfield;
    int64 myDensityrampmode;
    UT_SharedPtr<UT_Ramp> myDensityramp;
    UT_StringHolder myCdfield;
    bool myCdrangeoverride;
    UT_Vector2D myCdrange;
    int64 myCdrampmode;
    UT_SharedPtr<UT_Ramp> myCdramp;
    fpreal64 myEmitscale;
    UT_StringHolder myEmitfield;
    bool myEmitrangeoverride;
    UT_Vector2D myEmitrange;
    int64 myEmitrampmode;
    UT_SharedPtr<UT_Ramp> myEmitramp;
    UT_StringHolder myEmitcdfield;
    int64 myEmitcdrampmode;
    UT_SharedPtr<UT_Ramp> myEmitcdramp;
    fpreal64 myEmitcdfieldscale;
    fpreal64 myEmitcdtemperature0;
    fpreal64 myEmitcdtemperature;
    bool myEmitcdtonemap;
    fpreal64 myEmitcdadaptation;
    fpreal64 myEmitcdburn;
    bool myEnablescatter;
    fpreal64 myExtinctionratio;
    int64 myScatteringiter;
    bool myEmitcdrangeoverride;
    UT_Vector2D myEmitcdrange;

};