params.h

Go to the documentation of this file.

//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of NVIDIA CORPORATION nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2018 NVIDIA Corporation. All rights reserved.


#ifndef PARAMETERIZED_H
#define PARAMETERIZED_H

namespace physx
{
class physx::PxVec3;
class physx::PxQuat;
class physx::PxMat33Legacy;
class physx::PxMat34Legacy;
class physx::PxBounds3;
};

class       physx::PxI64;
class           physx::PxI32;
class       physx::PxI16;
class           physx::PxI8;

class   PxU64;
class       physx::PxU32;
class       PxU16;
class       PxU8;

class               physx::PxF32;
class               physx::PxF64;

enum ColorChannel
{
    red,
    green,
    blue,
    alpha,
};


enum DensityAdvection
{
    ADVECTION_LINEAR,
    ADVECTION_MACCORMACK,
};


enum EmitterType
{
    rate,
    densityOnce,
    densityBrush,
    fill,
};


enum FieldFormat
{
    FLOAT,
    HALF,
    UCHAR,
    FLOAT4,
    HALF4,
    UCHAR4,
};


enum FieldType
{
    FORCE,
    VELOCITY_DRAG,
    VELOCITY_DIRECT,
};


enum FillMode
{
    SOLID,
    WIREFRAME,
};


enum ImpactAxis
{
    incident,
    normal,
    reflection,
};


enum Max
{
    EGR_12,
    EGR_16,
    EGR_24,
    EGR_32,
    EGR_48,
    EGR_64,
    EGR_96,
    EGR_128,
};


enum Min
{
    EGR_12,
    EGR_16,
    EGR_24,
    EGR_32,
    EGR_48,
    EGR_64,
    EGR_96,
    EGR_128,
};


enum NoiseType
{
    SIMPLEX,
    CURL,
};


enum PlaybackMode
{
    LOOP,
    PLAY_ONCE,
    PING_PONG,
};


enum RenderMethod
{
    RAYCASTING,
    SLICE_BASED,
};


enum RenderMode
{
    VOLUME,
    VOLUME_COLORMAP,
    VOLUME_SHADOWED,
    VOXELS,
    ISOSURFACE,
};


enum RenderTechnique
{
    SPRITE_ONE,
    SPRITE_ONE,
    SPRITE_ALPHA,
    SPRITE_SOLID,
    SPRITE_TEXTURE,
    SPRITE_WIREFRAME,
};


enum Resolution
{
    GDG_8,
    GDG_16,
    GDG_32,
    GDG_64,
    GDG_128,
    GDG_256,
};


enum ResolutionScale
{
    NO_SCALE,
    HALF_SCALE,
    QUARTER_SCALE,
};


enum RollType
{
    SPHERICAL,
    CUBIC,
    FLAT_X,
    FLAT_Y,
    FLAT_Z,
    LONG_X,
    LONG_Y,
    LONG_Z,
};


enum RuntimeFractureType
{
    VORONOI,
    GLASS,
};


enum ScaleAxis
{
    xAxis,
    yAxis,
    zAxis,
};


enum Shape
{
    sphere,
    capsule,
    cylinder,
    cone,
    box,
    none,
};


enum SimulationBackend
{
    Default,
    ForceNative,
    ForceEmbedded,
};


enum SolverMode
{
    SOLVER_JACOBI,
    SOLVER_MULTIGRID,
};


enum SortType
{
    default,
};


enum Type
{
    uniform,
    normal,
};


enum VelocityAdvection
{
    ADVECTION_LINEAR,
    ADVECTION_MACCORMACK,
};

struct ApexEmitterActorParameters
{
    Mat34               initialPose;
    F32                 initialScale;
    Mat34               attachRelativePose;
    Bool                emitAssetParticles;
    String              overlapTestGroupMaskName;
    String              overlapTestGroupsMask128Name;
    F32                 emitterDuration;
};


struct ApexEmitterAssetParameters
{
    F32                 densityRange.min;
    F32                 densityRange.max;
    F32                 rateRange.min;
    F32                 rateRange.max;
    F32                 lifetimeRange.min;
    F32                 lifetimeRange.max;
    Vec3                velocityRange.min;
    Vec3                velocityRange.max;
    F32                 temperatureRange.min;
    F32                 temperatureRange.max;
    U32                 maxSamples;
    U32                 lodParamDesc.version;
    F32                 lodParamDesc.maxDistance;
    F32                 lodParamDesc.distanceWeight;
    F32                 lodParamDesc.speedWeight;
    F32                 lodParamDesc.lifeWeight;
    F32                 lodParamDesc.separationWeight;
    F32                 lodParamDesc.bias;
    Ref                 iofxAssetName;
    Ref                 iosAssetName;
union GeometryType {
    EmitterGeomBoxParams    geometryType;
    EmitterGeomSphereParams geometryType;
    EmitterGeomSphereShellParams    geometryType;
    EmitterGeomCylinderParams   geometryType;
    EmitterGeomExplicitParams   geometryType;
};
GeometryType    geometryType;
    F32                 emitterDuration;
    U32                 minSamplingFPS;
    F32                 rateVsTimeCurvePoints[].x;
    F32                 rateVsTimeCurvePoints[].y;
};


struct AttractorFSActorParams
{
    Mat34               initialPose;
    F32                 initialScale;
    String              fieldBoundaryFilterDataName;
    String              fieldSamplerFilterDataName;
};


struct AttractorFSAssetParams
{
    F32                 boundaryFadePercentage;
    F32                 radius;
    F32                 constFieldStrength;
    F32                 variableFieldStrength;
    F32                 fieldDragCoeff;
    F32                 fieldWeight;
    String              fieldBoundaryFilterDataName;
    String              fieldSamplerFilterDataName;
};


struct AttractorFSPreviewParams
{
    Mat44               globalPose;
    Bool                drawShape;
    Bool                drawAssetInfo;
    U64                 userData;
};


struct AttractorFieldSamplerData
{
    String              Name;
    AttractorFSAssetParams  AttractorFieldSampler;
};


struct AttractorFieldSamplerEffect
{
    String              EffectProperties.UserString;
    Bool                EffectProperties.Enable;
    F32                 EffectProperties.Position.TranslateX;
    F32                 EffectProperties.Position.TranslateY;
    F32                 EffectProperties.Position.TranslateZ;
    F32                 EffectProperties.Orientation.RotateX;
    F32                 EffectProperties.Orientation.RotateY;
    F32                 EffectProperties.Orientation.RotateZ;
    F32                 EffectProperties.InitialDelayTime;
    F32                 EffectProperties.Duration;
    U32                 EffectProperties.RepeatCount;
    F32                 EffectProperties.RepeatDelay;
    F32                 EffectProperties.RandomizeRepeatTime;
    PlaybackMode        EffectProperties.Path.PlaybackMode;
    F32                 EffectProperties.Path.PathDuration;
    U32                 EffectProperties.Path.LoopIndex;
    Transform           EffectProperties.Path.ControlPoints[];
    F32                 EffectProperties.Path.Scale[].x;
    F32                 EffectProperties.Path.Scale[].y;
    F32                 EffectProperties.Path.Speed[].x;
    F32                 EffectProperties.Path.Speed[].y;
    Ref                 AttractorFieldSampler;
};


struct BasicFSDebugRenderParams
{
    Bool                VISUALIZE_JET_FS_ACTOR;
    Bool                VISUALIZE_JET_FS_ACTOR_NAME;
    Bool                VISUALIZE_JET_FS_SHAPE;
    Bool                VISUALIZE_JET_FS_FIELD;
    Bool                VISUALIZE_JET_FS_POSE;
    F32                 JET_FS_FIELD_SCALE;
    Bool                VISUALIZE_ATTRACTOR_FS_ACTOR;
    Bool                VISUALIZE_ATTRACTOR_FS_ACTOR_NAME;
    Bool                VISUALIZE_ATTRACTOR_FS_SHAPE;
    Bool                VISUALIZE_ATTRACTOR_FS_FIELD;
    Bool                VISUALIZE_ATTRACTOR_FS_POSE;
    Bool                VISUALIZE_VORTEX_FS_ACTOR;
    Bool                VISUALIZE_VORTEX_FS_ACTOR_NAME;
    Bool                VISUALIZE_VORTEX_FS_SHAPE;
    Bool                VISUALIZE_VORTEX_FS_FIELD;
    Bool                VISUALIZE_VORTEX_FS_POSE;
    Bool                VISUALIZE_NOISE_FS_ACTOR;
    Bool                VISUALIZE_NOISE_FS_ACTOR_NAME;
    Bool                VISUALIZE_NOISE_FS_SHAPE;
    Bool                VISUALIZE_NOISE_FS_POSE;
    Bool                VISUALIZE_WIND_FS_ACTOR;
    Bool                VISUALIZE_WIND_FS_ACTOR_NAME;
};


struct BasicFSModuleParameters
{
    U32                 unused;
};


struct BasicIOSAssetParam
{
    F32                 restDensity;
    F32                 particleRadius;
    U32                 maxParticleCount;
    F32                 maxInjectedParticleCount;
    U32                 maxCollidingObjects;
    F32                 sceneGravityScale;
    Vec3                externalAcceleration;
    F32                 particleMass.center;
    F32                 particleMass.spread;
    Type                particleMass.type;
    String              collisionFilterDataName;
    String              fieldSamplerFilterDataName;
    Bool                staticCollision;
    F32                 restitutionForStaticShapes;
    Bool                dynamicCollision;
    F32                 restitutionForDynamicShapes;
    F32                 collisionDistanceMultiplier;
    F32                 collisionThreshold;
    Bool                collisionWithConvex;
    Bool                collisionWithTriangleMesh;
    Bool                GridDensity.Enabled;
    Resolution          GridDensity.Resolution;
    F32                 GridDensity.GridSize;
    U32                 GridDensity.MaxCellCount;
    Bool                enableTemperatureBuffer;
};


struct BasicIosDebugRenderParams
{
    Bool                VISUALIZE_BASIC_IOS_ACTOR;
    Bool                VISUALIZE_BASIC_IOS_COLLIDE_SHAPES;
    Bool                VISUALIZE_BASIC_IOS_GRID_DENSITY;
};


struct BasicIosModuleParameters
{
    U32                 unused;
};


struct BufferF32x1
{
    F32                 data[];
};


struct BufferF32x2
{
    F32                 data[].x;
    F32                 data[].y;
};


struct BufferF32x3
{
    Vec3                data[];
};


struct BufferF32x4
{
    F32                 data[].x;
    F32                 data[].y;
    F32                 data[].z;
    F32                 data[].w;
};


struct BufferU16x1
{
    U16                 data[];
};


struct BufferU16x2
{
    U16                 data[].x;
    U16                 data[].y;
};


struct BufferU16x3
{
    U16                 data[].x;
    U16                 data[].y;
    U16                 data[].z;
};


struct BufferU16x4
{
    U16                 data[].x;
    U16                 data[].y;
    U16                 data[].z;
    U16                 data[].w;
};


struct BufferU32x1
{
    U32                 data[];
};


struct BufferU32x2
{
    U32                 data[].x;
    U32                 data[].y;
};


struct BufferU32x3
{
    U32                 data[].x;
    U32                 data[].y;
    U32                 data[].z;
};


struct BufferU32x4
{
    U32                 data[].x;
    U32                 data[].y;
    U32                 data[].z;
    U32                 data[].w;
};


struct BufferU8x1
{
    U8                  data[];
};


struct BufferU8x2
{
    U8                  data[].x;
    U8                  data[].y;
};


struct BufferU8x3
{
    U8                  data[].x;
    U8                  data[].y;
    U8                  data[].z;
};


struct BufferU8x4
{
    U8                  data[].x;
    U8                  data[].y;
    U8                  data[].z;
    U8                  data[].w;
};


struct CachedOverlaps
{
    Bool                isCached;
    I32                 overlaps[].i0;
    I32                 overlaps[].i1;
};


struct ClothingActorParam
{
    Mat44               globalPose;
    Bool                useHardwareCloth;
    Bool                flags.ParallelCpuSkinning;
    Bool                flags.RecomputeNormals;
    Bool                flags.RecomputeTangents;
    Bool                flags.Visualize;
    Bool                flags.CorrectSimulationNormals;
    Bool                flags.ComputeRenderData;
    Bool                flags.ComputePhysicsMeshNormals;
    Bool                fallbackSkinning;
    Bool                slowStart;
    Bool                useInternalBoneOrder;
    Bool                updateStateWithGlobalMatrices;
    U32                 uvChannelForTangentUpdate;
    F32                 maxDistanceBlendTime;
    U32                 clothingMaterialIndex;
    F32                 lodWeights.maxDistance;
    F32                 lodWeights.distanceWeight;
    F32                 lodWeights.bias;
    F32                 lodWeights.benefitsBias;
    Vec3                windParams.Velocity;
    F32                 windParams.Adaption;
    F32                 maxDistanceScale.Scale;
    Bool                maxDistanceScale.Multipliable;
    U64                 userData;
    Mat44               boneMatrices[];
    F32                 clothDescTemplate.collisionResponseCoefficient;
    U16                 clothDescTemplate.collisionGroup;
    U32                 clothDescTemplate.groupsMask.bits0;
    U32                 clothDescTemplate.groupsMask.bits1;
    U32                 clothDescTemplate.groupsMask.bits2;
    U32                 clothDescTemplate.groupsMask.bits3;
    Bounds3             clothDescTemplate.validBounds;
    U64                 clothDescTemplate.compartment;
    U64                 clothDescTemplate.userData;
    Bool                shapeDescTemplate.flags.NX_SF_VISUALIZATION;
    Bool                shapeDescTemplate.flags.NX_SF_DISABLE_COLLISION;
    Bool                shapeDescTemplate.flags.NX_SF_DISABLE_RAYCASTING;
    Bool                shapeDescTemplate.flags.NX_SF_DYNAMIC_DYNAMIC_CCD;
    Bool                shapeDescTemplate.flags.NX_SF_DISABLE_SCENE_QUERIES;
    U16                 shapeDescTemplate.collisionGroup;
    U32                 shapeDescTemplate.groupsMask.bits0;
    U32                 shapeDescTemplate.groupsMask.bits1;
    U32                 shapeDescTemplate.groupsMask.bits2;
    U32                 shapeDescTemplate.groupsMask.bits3;
    U16                 shapeDescTemplate.materialIndex;
    U64                 shapeDescTemplate.userData;
    U64                 shapeDescTemplate.name;
    U64                 actorDescTemplate.userData;
    U64                 actorDescTemplate.name;
    F32                 actorScale;
    ClothingCookedParam runtimeCooked;
    Vec3                morphDisplacements[];
    Vec3                morphPhysicalMeshNewPositions[];
    Vec3                morphGraphicalMeshNewPositions[];
    Bool                allowAdaptiveTargetFrequency;
    Bool                useVelocityClamping;
    Bounds3             vertexVelocityClamp;
    F32                 pressure;
    Bool                multiplyGlobalPoseIntoBones;
    String              overrideMaterialNames[];
    SimulationBackend   simulationBackend;
    Bool                freezeByLOD;
    Bool                localSpaceSim;
    I32                 teleportMode;
};


struct ClothingAssetParameters
{
    ClothingPhysicalMeshParameters  physicalMeshes[];
    ClothingGraphicalLodParameters  graphicalLods[];
    U32                 simulation.hierarchicalLevels;
    F32                 simulation.thickness;
    F32                 simulation.virtualParticleDensity;
    Vec3                simulation.gravityDirection;
    F32                 simulation.sleepLinearVelocity;
    Bool                simulation.disableCCD;
    Bool                simulation.untangling;
    Bool                simulation.twowayInteraction;
    F32                 simulation.restLengthScale;
    I32                 bones[].internalIndex;
    I32                 bones[].externalIndex;
    U32                 bones[].numMeshReferenced;
    U32                 bones[].numRigidBodiesReferenced;
    I32                 bones[].parentIndex;
    Mat34               bones[].bindPose;
    String              bones[].name;
    U32                 bonesReferenced;
    U32                 bonesReferencedByMesh;
    U32                 rootBoneIndex;
    I32                 boneActors[].boneIndex;
    U32                 boneActors[].convexVerticesStart;
    U32                 boneActors[].convexVerticesCount;
    F32                 boneActors[].capsuleRadius;
    F32                 boneActors[].capsuleHeight;
    Mat34               boneActors[].localPose;
    Vec3                boneVertices[];
    I32                 boneSpheres[].boneIndex;
    F32                 boneSpheres[].radius;
    Vec3                boneSpheres[].localPos;
    U16                 boneSphereConnections[];
    I32                 bonePlanes[].boneIndex;
    Vec3                bonePlanes[].n;
    F32                 bonePlanes[].d;
    U32                 collisionConvexes[];
    F32                 cookedData[].scale;
union CookedData {
    ClothingCookedParam cookedData;
    ClothingCookedPhysX3Param   cookedData;
};
CookedData  cookedData;
    Bounds3             boundingBox;
    ClothingMaterialLibraryParameters   materialLibrary;
    U32                 materialIndex;
    U32                 interCollisionChannels;
    String              toolString;
};


struct ClothingCookedParam
{
    F32                 actorScale;
    U8                  convexCookedData[];
    U32                 cookedPhysicalSubmeshes[].physicalMeshId;
    U32                 cookedPhysicalSubmeshes[].submeshId;
    U32                 cookedPhysicalSubmeshes[].cookedDataOffset;
    U32                 cookedPhysicalSubmeshes[].cookedDataLength;
    U32                 cookedPhysicalSubmeshes[].deformableInvParticleWeightsOffset;
    U32                 cookedPhysicalSubmeshes[].virtualParticleIndicesOffset;
    U32                 cookedPhysicalSubmeshes[].virtualParticleIndicesLength;
    U8                  deformableCookedData[];
    U32                 cookedDataVersion;
    F32                 deformableInvParticleWeights[];
    U32                 virtualParticleIndices[];
    Vec3                virtualParticleWeights[];
};


struct ClothingCookedPhysX3Param
{
    U32                 physicalMeshId;
    U32                 physicalSubMeshId;
    U32                 numVertices;
    F32                 deformableRestLengths[];
    U32                 deformableIndices[];
    U32                 selfCollisionIndices[];
    U32                 selfCollisionNormalIndices[];
    U32                 selfCollisionNormalSetSizes[];
    U32                 deformableSets[].fiberEnd;
    U32                 deformableSets[].longestFiber;
    U32                 deformableSets[].shortestFiber;
    U32                 deformableSets[].numEdges;
    F32                 deformableSets[].avgEdgeLength;
    U32                 deformableSets[].avgFiberLength;
    U32                 deformablePhaseDescs[].phaseType;
    U32                 deformablePhaseDescs[].setIndex;
    U32                 deformablePhaseDescs[].restValueOffset;
    U32                 tetherAnchors[];
    F32                 tetherLengths[];
    F32                 deformableInvVertexWeights[];
    U32                 virtualParticleIndices[];
    F32                 virtualParticleWeights[];
    U32                 cookedDataVersion;
    ClothingCookedPhysX3Param   nextCookedData;
};


struct ClothingDebugRenderParams
{
    Bool                Actors;
    F32                 SkinnedPositions;
    Bool                Backstop;
    F32                 BackstopPrecise;
    Bool                MaxDistance;
    Bool                MaxDistanceInwards;
    Bool                SkinMapAll;
    Bool                SkinMapBad;
    Bool                SkinMapActual;
    Bool                SkinMapInvalidBary;
    F32                 PhysicsMeshWire;
    F32                 PhysicsMeshSolid;
    F32                 PhysicsMeshNormals;
    Bool                Skeleton;
    F32                 BoneFrames;
    F32                 BoneNames;
    F32                 Velocities;
    F32                 Wind;
    Bool                GraphicalVertexBones;
    Bool                PhysicalVertexBones;
    Bool                CollisionShapes;
    Bool                CollisionShapesWire;
    Bool                LengthFibers;
    Bool                CrossSectionFibers;
    Bool                BendingFibers;
    Bool                ShearingFibers;
    Bool                ZerostretchFibers;
    Bool                TethersActive;
    Bool                TethersInactive;
    Bool                VirtualCollision;
    Bool                FiberRange;
    Bool                ShowInLocalSpace;
    Bool                GlobalPose;
    Bool                RecomputeSubmeshes;
    Bool                RecomputeVertices;
    Bool                PhysicsMeshIndices;
    Bool                MassScale;
    Bool                SelfCollision;
    Bool                SelfCollisionWire;
    F32                 SelfCollisionAttenuation;
    Bool                SolverMode;
};


struct ClothingGraphicalLodParameters
{
    String              platforms[];
    U32                 lod;
    U32                 physicalMeshId;
    RenderMeshAssetParameters   renderMeshAsset;
    U32                 immediateClothMap[];
    Vec3                skinClothMapB[].vtxTetraBary;
    U32                 skinClothMapB[].vertexIndexPlusOffset;
    Vec3                skinClothMapB[].nrmTetraBary;
    U32                 skinClothMapB[].faceIndex0;
    U32                 skinClothMapB[].tetraIndex;
    U32                 skinClothMapB[].submeshIndex;
    Vec3                skinClothMap[].vertexBary;
    U32                 skinClothMap[].vertexIndex0;
    Vec3                skinClothMap[].normalBary;
    U32                 skinClothMap[].vertexIndex1;
    Vec3                skinClothMap[].tangentBary;
    U32                 skinClothMap[].vertexIndex2;
    U32                 skinClothMap[].vertexIndexPlusOffset;
    F32                 skinClothMapThickness;
    F32                 skinClothMapOffset;
    Vec3                tetraMap[].vertexBary;
    U32                 tetraMap[].tetraIndex0;
    Vec3                tetraMap[].normalBary;
    U32                 tetraMap[]._dummyForAlignment;
    U32                 renderMeshAssetSorting;
    U32                 physicsSubmeshPartitioning[].graphicalSubmesh;
    U32                 physicsSubmeshPartitioning[].physicalSubmesh;
    U32                 physicsSubmeshPartitioning[].numSimulatedVertices;
    U32                 physicsSubmeshPartitioning[].numSimulatedVerticesAdditional;
    U32                 physicsSubmeshPartitioning[].numSimulatedIndices;
};


struct ClothingMaterialLibraryParameters
{
    String              materials[].materialName;
    F32                 materials[].verticalStretchingStiffness;
    F32                 materials[].horizontalStretchingStiffness;
    F32                 materials[].bendingStiffness;
    F32                 materials[].shearingStiffness;
    F32                 materials[].tetherStiffness;
    F32                 materials[].tetherLimit;
    Bool                materials[].orthoBending;
    F32                 materials[].verticalStiffnessScaling.compressionRange;
    F32                 materials[].verticalStiffnessScaling.stretchRange;
    F32                 materials[].verticalStiffnessScaling.scale;
    F32                 materials[].horizontalStiffnessScaling.compressionRange;
    F32                 materials[].horizontalStiffnessScaling.stretchRange;
    F32                 materials[].horizontalStiffnessScaling.scale;
    F32                 materials[].bendingStiffnessScaling.compressionRange;
    F32                 materials[].bendingStiffnessScaling.stretchRange;
    F32                 materials[].bendingStiffnessScaling.scale;
    F32                 materials[].shearingStiffnessScaling.compressionRange;
    F32                 materials[].shearingStiffnessScaling.stretchRange;
    F32                 materials[].shearingStiffnessScaling.scale;
    F32                 materials[].damping;
    F32                 materials[].stiffnessFrequency;
    F32                 materials[].drag;
    Bool                materials[].comDamping;
    F32                 materials[].friction;
    F32                 materials[].massScale;
    U32                 materials[].solverIterations;
    F32                 materials[].solverFrequency;
    F32                 materials[].gravityScale;
    F32                 materials[].inertiaScale;
    F32                 materials[].hardStretchLimitation;
    F32                 materials[].maxDistanceBias;
    U32                 materials[].hierarchicalSolverIterations;
    F32                 materials[].selfcollisionThickness;
    F32                 materials[].selfcollisionSquashScale;
    F32                 materials[].selfcollisionStiffness;
};


struct ClothingModuleParameters
{
    U32                 maxNumCompartments;
    U32                 maxUnusedPhysXResources;
    Bool                allowAsyncCooking;
    Bool                asyncFetchResults;
    U32                 avgSimFrequencyWindow;
    Bool                allowApexWorkBetweenSubsteps;
    F32                 interCollisionDistance;
    F32                 interCollisionStiffness;
    U32                 interCollisionIterations;
    Bool                sparseSelfCollision;
    U32                 maxTimeRenderProxyInPool;
};


struct ClothingPhysicalMeshParameters
{
    U32                 physicalMesh.numVertices;
    U32                 physicalMesh.numIndices;
    U32                 physicalMesh.numBonesPerVertex;
    Vec3                physicalMesh.vertices[];
    Vec3                physicalMesh.normals[];
    Vec3                physicalMesh.skinningNormals[];
    F32                 physicalMesh.constrainCoefficients[].maxDistance;
    F32                 physicalMesh.constrainCoefficients[].collisionSphereRadius;
    F32                 physicalMesh.constrainCoefficients[].collisionSphereDistance;
    U16                 physicalMesh.boneIndices[];
    F32                 physicalMesh.boneWeights[];
    U8                  physicalMesh.optimizationData[];
    Bool                physicalMesh.hasNegativeBackstop;
    Bool                physicalMesh.isClosed;
    U32                 physicalMesh.indices[];
    F32                 physicalMesh.maximumMaxDistance;
    U32                 physicalMesh.physicalMeshSorting;
    F32                 physicalMesh.shortestEdgeLength;
    F32                 physicalMesh.averageEdgeLength;
    Bool                physicalMesh.isTetrahedralMesh;
    Bool                physicalMesh.flipNormals;
    U32                 submeshes[].numIndices;
    U32                 submeshes[].numVertices;
    U32                 submeshes[].numMaxDistance0Vertices;
    U32                 physicalLods[].costWithoutIterations;
    U32                 physicalLods[].submeshId;
    F32                 physicalLods[].solverIterationScale;
    F32                 physicalLods[].maxDistanceReduction;
    Vec3                transitionUpB[].vtxTetraBary;
    U32                 transitionUpB[].vertexIndexPlusOffset;
    Vec3                transitionUpB[].nrmTetraBary;
    U32                 transitionUpB[].faceIndex0;
    U32                 transitionUpB[].tetraIndex;
    U32                 transitionUpB[].submeshIndex;
    Vec3                transitionUp[].vertexBary;
    U32                 transitionUp[].vertexIndex0;
    Vec3                transitionUp[].normalBary;
    U32                 transitionUp[].vertexIndex1;
    Vec3                transitionUp[].tangentBary;
    U32                 transitionUp[].vertexIndex2;
    U32                 transitionUp[].vertexIndexPlusOffset;
    F32                 transitionUpThickness;
    F32                 transitionUpOffset;
    Vec3                transitionDownB[].vtxTetraBary;
    U32                 transitionDownB[].vertexIndexPlusOffset;
    Vec3                transitionDownB[].nrmTetraBary;
    U32                 transitionDownB[].faceIndex0;
    U32                 transitionDownB[].tetraIndex;
    U32                 transitionDownB[].submeshIndex;
    Vec3                transitionDown[].vertexBary;
    U32                 transitionDown[].vertexIndex0;
    Vec3                transitionDown[].normalBary;
    U32                 transitionDown[].vertexIndex1;
    Vec3                transitionDown[].tangentBary;
    U32                 transitionDown[].vertexIndex2;
    U32                 transitionDown[].vertexIndexPlusOffset;
    F32                 transitionDownThickness;
    F32                 transitionDownOffset;
    U32                 referenceCount;
};


struct ClothingPreviewParam
{
    Mat44               globalPose;
    Bool                fallbackSkinning;
    Bool                useInternalBoneOrder;
    Bool                updateStateWithGlobalMatrices;
    U64                 userData;
    Mat44               boneMatrices[];
};


struct ColorVsDensityCompositeModifierParams
{
    F32                 controlPoints[].density;
    Vec4                controlPoints[].color;
};


struct ColorVsDensityModifierParams
{
    ColorChannel        colorChannel;
    F32                 controlPoints[].x;
    F32                 controlPoints[].y;
};


struct ColorVsLifeCompositeModifierParams
{
    F32                 controlPoints[].lifeRemaining;
    Vec4                controlPoints[].color;
};


struct ColorVsLifeModifierParams
{
    ColorChannel        colorChannel;
    F32                 controlPoints[].x;
    F32                 controlPoints[].y;
};


struct ColorVsTemperatureCompositeModifierParams
{
    F32                 controlPoints[].temperature;
    Vec4                controlPoints[].color;
};


struct ColorVsTemperatureModifierParams
{
    ColorChannel        colorChannel;
    F32                 controlPoints[].x;
    F32                 controlPoints[].y;
};


struct ColorVsVelocityCompositeModifierParams
{
    F32                 velocity0;
    F32                 velocity1;
    F32                 controlPoints[].velocity;
    Vec4                controlPoints[].color;
};


struct ColorVsVelocityModifierParams
{
    ColorChannel        colorChannel;
    F32                 velocity0;
    F32                 velocity1;
    F32                 controlPoints[].x;
    F32                 controlPoints[].y;
};


struct ConvexHullParameters
{
    Vec3                vertices[];
    Vec3                uniquePlanes[].normal;
    F32                 uniquePlanes[].d;
    F32                 widths[];
    U32                 edges[];
    U32                 adjacentFaces[];
    Bounds3             bounds;
    F32                 volume;
    U32                 uniqueEdgeDirectionCount;
    U32                 planeCount;
};


struct DebugColorParams
{
    U32                 Default;
    U32                 PoseArrows;
    U32                 MeshStatic;
    U32                 MeshDynamic;
    U32                 Shape;
    U32                 Text0;
    U32                 Text1;
    U32                 ForceArrowsLow;
    U32                 ForceArrowsNorm;
    U32                 ForceArrowsHigh;
    U32                 Color0;
    U32                 Color1;
    U32                 Color2;
    U32                 Color3;
    U32                 Color4;
    U32                 Color5;
    U32                 Red;
    U32                 Green;
    U32                 Blue;
    U32                 DarkRed;
    U32                 DarkGreen;
    U32                 DarkBlue;
    U32                 LightRed;
    U32                 LightGreen;
    U32                 LightBlue;
    U32                 Purple;
    U32                 DarkPurple;
    U32                 Yellow;
    U32                 Orange;
    U32                 Gold;
    U32                 Emerald;
    U32                 White;
    U32                 Black;
    U32                 Gray;
    U32                 LightGray;
    U32                 DarkGray;
};


struct DebugRenderParams
{
    Bool                Enable;
    F32                 Scale;
    F32                 LodBenefits;
    F32                 RelativeLodBenefitsScreenPos;
    F32                 RelativeLodBenefitsThickness;
    F32                 LodDistanceScale;
    F32                 RenderNormals;
    F32                 RenderTangents;
    F32                 RenderBitangents;
    Bool                Bounds;
union ModuleName {
    BasicFSDebugRenderParams    moduleName[];
    BasicIosDebugRenderParams   moduleName[];
    ParticleIosDebugRenderParams    moduleName[];
    ClothingDebugRenderParams   moduleName[];
    DestructibleDebugRenderParams   moduleName[];
    EmitterDebugRenderParams    moduleName[];
    ForceFieldDebugRenderParams moduleName[];
    IofxDebugRenderParams   moduleName[];
    TurbulenceFSDebugRenderParams   moduleName[];
    ParticlesDebugRenderParams  moduleName[];
};
ModuleName  moduleName[];
};


struct DestructibleActorChunks
{
    U8                  data[].state;
    U8                  data[].flags;
    U32                 data[].islandID;
    F32                 data[].damage;
    Vec4                data[].localSphere;
    Vec3                data[].localOffset;
    I32                 data[].visibleAncestorIndex;
    U32                 data[].shapesCount;
    Transform           data[].globalPose;
    Vec3                data[].linearVelocity;
    Vec3                data[].angularVelocity;
};


struct DestructibleActorParam
{
    String              crumbleEmitterName;
    F32                 crumbleParticleSpacing;
    String              dustEmitterName;
    F32                 dustParticleSpacing;
    Mat34               globalPose;
    Vec3                scale;
    Bool                dynamic;
    U32                 supportDepth;
    Bool                formExtendedStructures;
    Bool                performDetailedOverlapTestForExtendedStructures;
    Bool                keepPreviousFrameBoneBuffer;
    Bool                doNotCreateRenderable;
    Bool                useAssetDefinedSupport;
    Bool                useWorldSupport;
    Bool                renderStaticChunksSeparately;
    Bool                keepVisibleBonesPacked;
    Bool                createChunkEvents;
    String              overrideSkinnedMaterialNames[];
    String              overrideStaticMaterialNames[];
    F32                 sleepVelocityFrameDecayConstant;
    Bool                useHardSleeping;
    F32                 destructibleParameters.damageCap;
    F32                 destructibleParameters.forceToDamage;
    F32                 destructibleParameters.impactVelocityThreshold;
    U32                 destructibleParameters.minimumFractureDepth;
    I32                 destructibleParameters.impactDamageDefaultDepth;
    I32                 destructibleParameters.debrisDepth;
    U32                 destructibleParameters.essentialDepth;
    F32                 destructibleParameters.debrisLifetimeMin;
    F32                 destructibleParameters.debrisLifetimeMax;
    F32                 destructibleParameters.debrisMaxSeparationMin;
    F32                 destructibleParameters.debrisMaxSeparationMax;
    F32                 destructibleParameters.debrisDestructionProbability;
    Bounds3             destructibleParameters.validBounds;
    F32                 destructibleParameters.maxChunkSpeed;
    Bool                destructibleParameters.flags.ACCUMULATE_DAMAGE;
    Bool                destructibleParameters.flags.DEBRIS_TIMEOUT;
    Bool                destructibleParameters.flags.DEBRIS_MAX_SEPARATION;
    Bool                destructibleParameters.flags.CRUMBLE_SMALLEST_CHUNKS;
    Bool                destructibleParameters.flags.ACCURATE_RAYCASTS;
    Bool                destructibleParameters.flags.USE_VALID_BOUNDS;
    Bool                destructibleParameters.flags.CRUMBLE_VIA_RUNTIME_FRACTURE;
    F32                 destructibleParameters.fractureImpulseScale;
    U16                 destructibleParameters.damageDepthLimit;
    U16                 destructibleParameters.dynamicChunkDominanceGroup;
    Bool                destructibleParameters.dynamicChunksGroupsMask.useGroupsMask;
    U32                 destructibleParameters.dynamicChunksGroupsMask.bits0;
    U32                 destructibleParameters.dynamicChunksGroupsMask.bits1;
    U32                 destructibleParameters.dynamicChunksGroupsMask.bits2;
    U32                 destructibleParameters.dynamicChunksGroupsMask.bits3;
    RuntimeFractureType destructibleParameters.runtimeFracture.RuntimeFractureType;
    Bool                destructibleParameters.runtimeFracture.sheetFracture;
    U32                 destructibleParameters.runtimeFracture.depthLimit;
    Bool                destructibleParameters.runtimeFracture.destroyIfAtDepthLimit;
    F32                 destructibleParameters.runtimeFracture.minConvexSize;
    F32                 destructibleParameters.runtimeFracture.impulseScale;
    U32                 destructibleParameters.runtimeFracture.glass.numSectors;
    F32                 destructibleParameters.runtimeFracture.glass.sectorRand;
    F32                 destructibleParameters.runtimeFracture.glass.firstSegmentSize;
    F32                 destructibleParameters.runtimeFracture.glass.segmentScale;
    F32                 destructibleParameters.runtimeFracture.glass.segmentRand;
    Vec3                destructibleParameters.runtimeFracture.voronoi.dimensions;
    U32                 destructibleParameters.runtimeFracture.voronoi.numCells;
    F32                 destructibleParameters.runtimeFracture.voronoi.biasExp;
    F32                 destructibleParameters.runtimeFracture.voronoi.maxDist;
    Bool                destructibleParameters.runtimeFracture.attachment.posX;
    Bool                destructibleParameters.runtimeFracture.attachment.negX;
    Bool                destructibleParameters.runtimeFracture.attachment.posY;
    Bool                destructibleParameters.runtimeFracture.attachment.negY;
    Bool                destructibleParameters.runtimeFracture.attachment.posZ;
    Bool                destructibleParameters.runtimeFracture.attachment.negZ;
    F32                 destructibleParameters.supportStrength;
    I8                  destructibleParameters.legacyChunkBoundsTestSetting;
    I8                  destructibleParameters.legacyDamageRadiusSpreadSetting;
    Bool                depthParameters[].OVERRIDE_IMPACT_DAMAGE;
    Bool                depthParameters[].OVERRIDE_IMPACT_DAMAGE_VALUE;
    Bool                depthParameters[].IGNORE_POSE_UPDATES;
    Bool                depthParameters[].IGNORE_RAYCAST_CALLBACKS;
    Bool                depthParameters[].IGNORE_CONTACT_CALLBACKS;
    Bool                depthParameters[].USER_FLAG_0;
    Bool                depthParameters[].USER_FLAG_1;
    Bool                depthParameters[].USER_FLAG_2;
    Bool                depthParameters[].USER_FLAG_3;
    Bool                shapeDescTemplate.flags.NX_TRIGGER_ON_ENTER;
    Bool                shapeDescTemplate.flags.NX_TRIGGER_ON_LEAVE;
    Bool                shapeDescTemplate.flags.NX_TRIGGER_ON_STAY;
    Bool                shapeDescTemplate.flags.NX_SF_VISUALIZATION;
    Bool                shapeDescTemplate.flags.NX_SF_DISABLE_COLLISION;
    Bool                shapeDescTemplate.flags.NX_SF_FEATURE_INDICES;
    Bool                shapeDescTemplate.flags.NX_SF_DISABLE_RAYCASTING;
    Bool                shapeDescTemplate.flags.NX_SF_POINT_CONTACT_FORCE;
    Bool                shapeDescTemplate.flags.NX_SF_FLUID_DRAIN;
    Bool                shapeDescTemplate.flags.NX_SF_FLUID_DISABLE_COLLISION;
    Bool                shapeDescTemplate.flags.NX_SF_FLUID_TWOWAY;
    Bool                shapeDescTemplate.flags.NX_SF_DISABLE_RESPONSE;
    Bool                shapeDescTemplate.flags.NX_SF_DYNAMIC_DYNAMIC_CCD;
    Bool                shapeDescTemplate.flags.NX_SF_DISABLE_SCENE_QUERIES;
    Bool                shapeDescTemplate.flags.NX_SF_CLOTH_DRAIN;
    Bool                shapeDescTemplate.flags.NX_SF_CLOTH_DISABLE_COLLISION;
    Bool                shapeDescTemplate.flags.NX_SF_CLOTH_TWOWAY;
    Bool                shapeDescTemplate.flags.NX_SF_SOFTBODY_DRAIN;
    Bool                shapeDescTemplate.flags.NX_SF_SOFTBODY_DISABLE_COLLISION;
    Bool                shapeDescTemplate.flags.NX_SF_SOFTBODY_TWOWAY;
    U16                 shapeDescTemplate.collisionGroup;
    Bool                shapeDescTemplate.groupsMask.useGroupsMask;
    U32                 shapeDescTemplate.groupsMask.bits0;
    U32                 shapeDescTemplate.groupsMask.bits1;
    U32                 shapeDescTemplate.groupsMask.bits2;
    U32                 shapeDescTemplate.groupsMask.bits3;
    U16                 shapeDescTemplate.materialIndex;
    F32                 shapeDescTemplate.density;
    F32                 shapeDescTemplate.skinWidth;
    U64                 shapeDescTemplate.userData;
    U64                 shapeDescTemplate.name;
    Bool                actorDescTemplate.flags.NX_AF_DISABLE_COLLISION;
    Bool                actorDescTemplate.flags.NX_AF_DISABLE_RESPONSE;
    Bool                actorDescTemplate.flags.NX_AF_LOCK_COM;
    Bool                actorDescTemplate.flags.NX_AF_FLUID_DISABLE_COLLISION;
    Bool                actorDescTemplate.flags.NX_AF_CONTACT_MODIFICATION;
    Bool                actorDescTemplate.flags.NX_AF_FORCE_CONE_FRICTION;
    Bool                actorDescTemplate.flags.NX_AF_USER_ACTOR_PAIR_FILTERING;
    F32                 actorDescTemplate.density;
    U16                 actorDescTemplate.actorCollisionGroup;
    U16                 actorDescTemplate.dominanceGroup;
    Bool                actorDescTemplate.contactReportFlags.NX_IGNORE_PAIR;
    Bool                actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_START_TOUCH;
    Bool                actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_END_TOUCH;
    Bool                actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_TOUCH;
    Bool                actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_IMPACT;
    Bool                actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_ROLL;
    Bool                actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_SLIDE;
    Bool                actorDescTemplate.contactReportFlags.NX_NOTIFY_FORCES;
    Bool                actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_START_TOUCH_FORCE_THRESHOLD;
    Bool                actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_END_TOUCH_FORCE_THRESHOLD;
    Bool                actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_TOUCH_FORCE_THRESHOLD;
    Bool                actorDescTemplate.contactReportFlags.NX_NOTIFY_CONTACT_MODIFICATION;
    U16                 actorDescTemplate.forceFieldMaterial;
    U64                 actorDescTemplate.userData;
    U64                 actorDescTemplate.name;
    U64                 actorDescTemplate.compartment;
    Bool                bodyDescTemplate.flags.NX_BF_DISABLE_GRAVITY;
    Bool                bodyDescTemplate.flags.NX_BF_FILTER_SLEEP_VEL;
    Bool                bodyDescTemplate.flags.NX_BF_ENERGY_SLEEP_TEST;
    Bool                bodyDescTemplate.flags.NX_BF_VISUALIZATION;
    F32                 bodyDescTemplate.wakeUpCounter;
    F32                 bodyDescTemplate.linearDamping;
    F32                 bodyDescTemplate.angularDamping;
    F32                 bodyDescTemplate.maxAngularVelocity;
    F32                 bodyDescTemplate.CCDMotionThreshold;
    F32                 bodyDescTemplate.sleepLinearVelocity;
    F32                 bodyDescTemplate.sleepAngularVelocity;
    U32                 bodyDescTemplate.solverIterationCount;
    F32                 bodyDescTemplate.sleepEnergyThreshold;
    F32                 bodyDescTemplate.sleepDamping;
    F32                 bodyDescTemplate.contactReportThreshold;
    Bool                p3ShapeDescTemplate.flags.eSIMULATION_SHAPE;
    Bool                p3ShapeDescTemplate.flags.eSCENE_QUERY_SHAPE;
    Bool                p3ShapeDescTemplate.flags.eTRIGGER_SHAPE;
    Bool                p3ShapeDescTemplate.flags.eVISUALIZATION;
    Bool                p3ShapeDescTemplate.flags.ePARTICLE_DRAIN;
    Bool                p3ShapeDescTemplate.flags.eDEFORMABLE_DRAIN;
    U32                 p3ShapeDescTemplate.simulationFilterData.word0;
    U32                 p3ShapeDescTemplate.simulationFilterData.word1;
    U32                 p3ShapeDescTemplate.simulationFilterData.word2;
    U32                 p3ShapeDescTemplate.simulationFilterData.word3;
    U32                 p3ShapeDescTemplate.queryFilterData.word0;
    U32                 p3ShapeDescTemplate.queryFilterData.word1;
    U32                 p3ShapeDescTemplate.queryFilterData.word2;
    U32                 p3ShapeDescTemplate.queryFilterData.word3;
    U64                 p3ShapeDescTemplate.material;
    F32                 p3ShapeDescTemplate.contactOffset;
    F32                 p3ShapeDescTemplate.restOffset;
    U64                 p3ShapeDescTemplate.userData;
    U64                 p3ShapeDescTemplate.name;
    Bool                p3ActorDescTemplate.flags.eVISUALIZATION;
    Bool                p3ActorDescTemplate.flags.eDISABLE_GRAVITY;
    Bool                p3ActorDescTemplate.flags.eSEND_SLEEP_NOTIFIES;
    U8                  p3ActorDescTemplate.dominanceGroup;
    U8                  p3ActorDescTemplate.ownerClient;
    U32                 p3ActorDescTemplate.clientBehaviorBits;
    Bool                p3ActorDescTemplate.contactReportFlags.eRESOLVE_CONTACTS;
    Bool                p3ActorDescTemplate.contactReportFlags.eMODIFY_CONTACTS;
    Bool                p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_FOUND;
    Bool                p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_PERSISTS;
    Bool                p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_LOST;
    Bool                p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_FOUND;
    Bool                p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_PERSISTS;
    Bool                p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_LOST;
    Bool                p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_POINTS;
    Bool                p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FORCES;
    Bool                p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FORCE_PER_POINT;
    Bool                p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FEATURE_INDICES_PER_POINT;
    Bool                p3ActorDescTemplate.contactReportFlags.eCCD_LINEAR;
    Bool                p3ActorDescTemplate.contactReportFlags.eCONTACT_DEFAULT;
    Bool                p3ActorDescTemplate.contactReportFlags.eTRIGGER_DEFAULT;
    U64                 p3ActorDescTemplate.userData;
    U64                 p3ActorDescTemplate.name;
    F32                 p3BodyDescTemplate.density;
    Bool                p3BodyDescTemplate.flags.eKINEMATIC;
    Bool                p3BodyDescTemplate.flags.eENABLE_CCD;
    F32                 p3BodyDescTemplate.sleepThreshold;
    F32                 p3BodyDescTemplate.wakeUpCounter;
    F32                 p3BodyDescTemplate.linearDamping;
    F32                 p3BodyDescTemplate.angularDamping;
    F32                 p3BodyDescTemplate.maxAngularVelocity;
    U32                 p3BodyDescTemplate.solverIterationCount;
    U32                 p3BodyDescTemplate.velocityIterationCount;
    F32                 p3BodyDescTemplate.contactReportThreshold;
    F32                 p3BodyDescTemplate.sleepLinearVelocity;
    Bool                structureSettings.useStressSolver;
    F32                 structureSettings.stressSolverTimeDelay;
    F32                 structureSettings.stressSolverMassThreshold;
    String              defaultBehaviorGroup.name;
    F32                 defaultBehaviorGroup.damageThreshold;
    F32                 defaultBehaviorGroup.damageToRadius;
    F32                 defaultBehaviorGroup.damageSpread.minimumRadius;
    F32                 defaultBehaviorGroup.damageSpread.radiusMultiplier;
    F32                 defaultBehaviorGroup.damageSpread.falloffExponent;
    F32                 defaultBehaviorGroup.damageColorSpread.minimumRadius;
    F32                 defaultBehaviorGroup.damageColorSpread.radiusMultiplier;
    F32                 defaultBehaviorGroup.damageColorSpread.falloffExponent;
    Vec4                defaultBehaviorGroup.damageColorChange;
    F32                 defaultBehaviorGroup.materialStrength;
    F32                 defaultBehaviorGroup.density;
    F32                 defaultBehaviorGroup.fadeOut;
    F32                 defaultBehaviorGroup.maxDepenetrationVelocity;
    Bool                defaultBehaviorGroup.groupsMask.useGroupsMask;
    U32                 defaultBehaviorGroup.groupsMask.bits0;
    U32                 defaultBehaviorGroup.groupsMask.bits1;
    U32                 defaultBehaviorGroup.groupsMask.bits2;
    U32                 defaultBehaviorGroup.groupsMask.bits3;
    U64                 defaultBehaviorGroup.userData;
    String              behaviorGroups[].name;
    F32                 behaviorGroups[].damageThreshold;
    F32                 behaviorGroups[].damageToRadius;
    F32                 behaviorGroups[].damageSpread.minimumRadius;
    F32                 behaviorGroups[].damageSpread.radiusMultiplier;
    F32                 behaviorGroups[].damageSpread.falloffExponent;
    F32                 behaviorGroups[].damageColorSpread.minimumRadius;
    F32                 behaviorGroups[].damageColorSpread.radiusMultiplier;
    F32                 behaviorGroups[].damageColorSpread.falloffExponent;
    Vec4                behaviorGroups[].damageColorChange;
    F32                 behaviorGroups[].materialStrength;
    F32                 behaviorGroups[].density;
    F32                 behaviorGroups[].fadeOut;
    F32                 behaviorGroups[].maxDepenetrationVelocity;
    Bool                behaviorGroups[].groupsMask.useGroupsMask;
    U32                 behaviorGroups[].groupsMask.bits0;
    U32                 behaviorGroups[].groupsMask.bits1;
    U32                 behaviorGroups[].groupsMask.bits2;
    U32                 behaviorGroups[].groupsMask.bits3;
    U64                 behaviorGroups[].userData;
    Bool                deleteChunksLeavingUserDefinedBB;
    Bool                deleteChunksEnteringUserDefinedBB;
};


struct DestructibleActorState
{
    Bool                enableCrumbleEmitter;
    Bool                enableDustEmitter;
    F32                 internalLODWeights.maxDistance;
    F32                 internalLODWeights.distanceWeight;
    F32                 internalLODWeights.maxAge;
    F32                 internalLODWeights.ageWeight;
    F32                 internalLODWeights.bias;
    U32                 lod;
    Bool                forceLod;
    F32                 destructibleParameters.damageCap;
    F32                 destructibleParameters.forceToDamage;
    F32                 destructibleParameters.impactVelocityThreshold;
    U32                 destructibleParameters.minimumFractureDepth;
    I32                 destructibleParameters.impactDamageDefaultDepth;
    I32                 destructibleParameters.debrisDepth;
    U32                 destructibleParameters.essentialDepth;
    F32                 destructibleParameters.debrisLifetimeMin;
    F32                 destructibleParameters.debrisLifetimeMax;
    F32                 destructibleParameters.debrisMaxSeparationMin;
    F32                 destructibleParameters.debrisMaxSeparationMax;
    F32                 destructibleParameters.debrisDestructionProbability;
    Bounds3             destructibleParameters.validBounds;
    F32                 destructibleParameters.maxChunkSpeed;
    Bool                destructibleParameters.flags.ACCUMULATE_DAMAGE;
    Bool                destructibleParameters.flags.DEBRIS_TIMEOUT;
    Bool                destructibleParameters.flags.DEBRIS_MAX_SEPARATION;
    Bool                destructibleParameters.flags.CRUMBLE_SMALLEST_CHUNKS;
    Bool                destructibleParameters.flags.ACCURATE_RAYCASTS;
    Bool                destructibleParameters.flags.USE_VALID_BOUNDS;
    Bool                destructibleParameters.flags.CRUMBLE_VIA_RUNTIME_FRACTURE;
    F32                 destructibleParameters.fractureImpulseScale;
    U16                 destructibleParameters.damageDepthLimit;
    U16                 destructibleParameters.dynamicChunkDominanceGroup;
    Bool                destructibleParameters.dynamicChunksGroupsMask.useGroupsMask;
    U32                 destructibleParameters.dynamicChunksGroupsMask.bits0;
    U32                 destructibleParameters.dynamicChunksGroupsMask.bits1;
    U32                 destructibleParameters.dynamicChunksGroupsMask.bits2;
    U32                 destructibleParameters.dynamicChunksGroupsMask.bits3;
    RuntimeFractureType destructibleParameters.runtimeFracture.RuntimeFractureType;
    Bool                destructibleParameters.runtimeFracture.sheetFracture;
    U32                 destructibleParameters.runtimeFracture.depthLimit;
    Bool                destructibleParameters.runtimeFracture.destroyIfAtDepthLimit;
    F32                 destructibleParameters.runtimeFracture.minConvexSize;
    F32                 destructibleParameters.runtimeFracture.impulseScale;
    U32                 destructibleParameters.runtimeFracture.glass.numSectors;
    F32                 destructibleParameters.runtimeFracture.glass.sectorRand;
    F32                 destructibleParameters.runtimeFracture.glass.firstSegmentSize;
    F32                 destructibleParameters.runtimeFracture.glass.segmentScale;
    F32                 destructibleParameters.runtimeFracture.glass.segmentRand;
    Vec3                destructibleParameters.runtimeFracture.voronoi.dimensions;
    U32                 destructibleParameters.runtimeFracture.voronoi.numCells;
    F32                 destructibleParameters.runtimeFracture.voronoi.biasExp;
    F32                 destructibleParameters.runtimeFracture.voronoi.maxDist;
    Bool                destructibleParameters.runtimeFracture.attachment.posX;
    Bool                destructibleParameters.runtimeFracture.attachment.negX;
    Bool                destructibleParameters.runtimeFracture.attachment.posY;
    Bool                destructibleParameters.runtimeFracture.attachment.negY;
    Bool                destructibleParameters.runtimeFracture.attachment.posZ;
    Bool                destructibleParameters.runtimeFracture.attachment.negZ;
    F32                 destructibleParameters.supportStrength;
    I8                  destructibleParameters.legacyChunkBoundsTestSetting;
    I8                  destructibleParameters.legacyDamageRadiusSpreadSetting;
    U64                 userData;
    DestructibleActorParam  actorParameters;
    DestructibleActorChunks actorChunks;
};


struct DestructibleAssetCollisionDataSet
{
    String              assetName;
    U32                 cookingPlatform;
    U32                 cookingVersionNum;
    Vec3                scales[];
    MeshCookedCollisionStreamsAtScale   meshCookedCollisionStreamsAtScale[];
};


struct DestructibleAssetParameters
{
    String              comments;
    U32                 depthCount;
    U32                 originalDepthCount;
    Bounds3             bounds;
    String              defaultBehaviorGroup.name;
    F32                 defaultBehaviorGroup.damageThreshold;
    F32                 defaultBehaviorGroup.damageToRadius;
    F32                 defaultBehaviorGroup.damageSpread.minimumRadius;
    F32                 defaultBehaviorGroup.damageSpread.radiusMultiplier;
    F32                 defaultBehaviorGroup.damageSpread.falloffExponent;
    F32                 defaultBehaviorGroup.damageColorSpread.minimumRadius;
    F32                 defaultBehaviorGroup.damageColorSpread.radiusMultiplier;
    F32                 defaultBehaviorGroup.damageColorSpread.falloffExponent;
    Vec4                defaultBehaviorGroup.damageColorChange;
    F32                 defaultBehaviorGroup.materialStrength;
    F32                 defaultBehaviorGroup.density;
    F32                 defaultBehaviorGroup.fadeOut;
    F32                 defaultBehaviorGroup.maxDepenetrationVelocity;
    U64                 defaultBehaviorGroup.userData;
    String              behaviorGroups[].name;
    F32                 behaviorGroups[].damageThreshold;
    F32                 behaviorGroups[].damageToRadius;
    F32                 behaviorGroups[].damageSpread.minimumRadius;
    F32                 behaviorGroups[].damageSpread.radiusMultiplier;
    F32                 behaviorGroups[].damageSpread.falloffExponent;
    F32                 behaviorGroups[].damageColorSpread.minimumRadius;
    F32                 behaviorGroups[].damageColorSpread.radiusMultiplier;
    F32                 behaviorGroups[].damageColorSpread.falloffExponent;
    Vec4                behaviorGroups[].damageColorChange;
    F32                 behaviorGroups[].materialStrength;
    F32                 behaviorGroups[].density;
    F32                 behaviorGroups[].fadeOut;
    F32                 behaviorGroups[].maxDepenetrationVelocity;
    U64                 behaviorGroups[].userData;
    I8                  RTFractureBehaviorGroup;
    U16                 chunks[].depth;
    U16                 chunks[].parentIndex;
    U16                 chunks[].firstChildIndex;
    U16                 chunks[].numChildren;
    U16                 chunks[].meshPartIndex;
    U16                 chunks[].flags;
    Vec3                chunks[].surfaceNormal;
    I8                  chunks[].behaviorGroupIndex;
    U16                 chunks[].firstScatterMesh;
    U16                 chunks[].scatterMeshCount;
    ConvexHullParameters    chunkConvexHulls[];
    U32                 chunkConvexHullStartIndices[];
    F32                 destructibleParameters.damageCap;
    F32                 destructibleParameters.forceToDamage;
    F32                 destructibleParameters.impactVelocityThreshold;
    U32                 destructibleParameters.minimumFractureDepth;
    I32                 destructibleParameters.impactDamageDefaultDepth;
    I32                 destructibleParameters.debrisDepth;
    U32                 destructibleParameters.essentialDepth;
    F32                 destructibleParameters.debrisLifetimeMin;
    F32                 destructibleParameters.debrisLifetimeMax;
    F32                 destructibleParameters.debrisMaxSeparationMin;
    F32                 destructibleParameters.debrisMaxSeparationMax;
    F32                 destructibleParameters.debrisDestructionProbability;
    Bounds3             destructibleParameters.validBounds;
    F32                 destructibleParameters.maxChunkSpeed;
    Bool                destructibleParameters.flags.ACCUMULATE_DAMAGE;
    Bool                destructibleParameters.flags.DEBRIS_TIMEOUT;
    Bool                destructibleParameters.flags.DEBRIS_MAX_SEPARATION;
    Bool                destructibleParameters.flags.CRUMBLE_SMALLEST_CHUNKS;
    Bool                destructibleParameters.flags.ACCURATE_RAYCASTS;
    Bool                destructibleParameters.flags.USE_VALID_BOUNDS;
    Bool                destructibleParameters.flags.CRUMBLE_VIA_RUNTIME_FRACTURE;
    F32                 destructibleParameters.fractureImpulseScale;
    U16                 destructibleParameters.damageDepthLimit;
    U16                 destructibleParameters.dynamicChunkDominanceGroup;
    Bool                destructibleParameters.dynamicChunksGroupsMask.useGroupsMask;
    U32                 destructibleParameters.dynamicChunksGroupsMask.bits0;
    U32                 destructibleParameters.dynamicChunksGroupsMask.bits1;
    U32                 destructibleParameters.dynamicChunksGroupsMask.bits2;
    U32                 destructibleParameters.dynamicChunksGroupsMask.bits3;
    RuntimeFractureType destructibleParameters.runtimeFracture.RuntimeFractureType;
    Bool                destructibleParameters.runtimeFracture.sheetFracture;
    U32                 destructibleParameters.runtimeFracture.depthLimit;
    Bool                destructibleParameters.runtimeFracture.destroyIfAtDepthLimit;
    F32                 destructibleParameters.runtimeFracture.minConvexSize;
    F32                 destructibleParameters.runtimeFracture.impulseScale;
    U32                 destructibleParameters.runtimeFracture.glass.numSectors;
    F32                 destructibleParameters.runtimeFracture.glass.sectorRand;
    F32                 destructibleParameters.runtimeFracture.glass.firstSegmentSize;
    F32                 destructibleParameters.runtimeFracture.glass.segmentScale;
    F32                 destructibleParameters.runtimeFracture.glass.segmentRand;
    Vec3                destructibleParameters.runtimeFracture.voronoi.dimensions;
    U32                 destructibleParameters.runtimeFracture.voronoi.numCells;
    F32                 destructibleParameters.runtimeFracture.voronoi.biasExp;
    F32                 destructibleParameters.runtimeFracture.voronoi.maxDist;
    Bool                destructibleParameters.runtimeFracture.attachment.posX;
    Bool                destructibleParameters.runtimeFracture.attachment.negX;
    Bool                destructibleParameters.runtimeFracture.attachment.posY;
    Bool                destructibleParameters.runtimeFracture.attachment.negY;
    Bool                destructibleParameters.runtimeFracture.attachment.posZ;
    Bool                destructibleParameters.runtimeFracture.attachment.negZ;
    F32                 destructibleParameters.supportStrength;
    I8                  destructibleParameters.legacyChunkBoundsTestSetting;
    I8                  destructibleParameters.legacyDamageRadiusSpreadSetting;
    Bool                depthParameters[].OVERRIDE_IMPACT_DAMAGE;
    Bool                depthParameters[].OVERRIDE_IMPACT_DAMAGE_VALUE;
    Bool                depthParameters[].IGNORE_POSE_UPDATES;
    Bool                depthParameters[].IGNORE_RAYCAST_CALLBACKS;
    Bool                depthParameters[].IGNORE_CONTACT_CALLBACKS;
    Bool                depthParameters[].USER_FLAG_0;
    Bool                depthParameters[].USER_FLAG_1;
    Bool                depthParameters[].USER_FLAG_2;
    Bool                depthParameters[].USER_FLAG_3;
    String              crumbleEmitterName;
    String              dustEmitterName;
    DestructibleAssetCollisionDataSet   collisionData;
    RenderMeshAssetParameters   renderMeshAsset;
    U32                 initialDestructibleActorAllowanceForInstancing;
    U16                 chunkInstanceInfo[].partIndex;
    Vec3                chunkInstanceInfo[].chunkPositionOffset;
    Vec2                chunkInstanceInfo[].chunkUVOffset;
    String              staticMaterialNames[];
    F32                 neighborPadding;
    CachedOverlaps      overlapsAtDepth[];
    U32                 firstChunkAtDepth[];
    U32                 supportDepth;
    Bool                formExtendedStructures;
    Bool                useAssetDefinedSupport;
    Bool                useWorldSupport;
    Mat44               actorTransforms[];
    RenderMeshAssetParameters   scatterMeshAssets[];
    U8                  scatterMeshIndices[];
    Mat33               scatterMeshTransforms[].matrix;
    Vec3                scatterMeshTransforms[].vector;
};


struct DestructibleDebugRenderParams
{
    Bool                VISUALIZE_DESTRUCTIBLE_ACTOR;
    F32                 VISUALIZE_DESTRUCTIBLE_BOUNDS;
    F32                 VISUALIZE_DESTRUCTIBLE_SUPPORT;
    Bool                VISUALIZE_DESTRUCTIBLE_ACTOR_POSE;
    F32                 THRESHOLD_DISTANCE_DESTRUCTIBLE_ACTOR_POSE;
    Bool                VISUALIZE_DESTRUCTIBLE_ACTOR_NAME;
    F32                 THRESHOLD_DISTANCE_DESTRUCTIBLE_ACTOR_NAME;
    Bool                VISUALIZE_DESTRUCTIBLE_FRAGMENT_POSE;
    F32                 THRESHOLD_DISTANCE_DESTRUCTIBLE_FRAGMENT_POSE;
};


struct DestructibleModuleParameters
{
    U32                 maxDynamicChunkIslandCount;
    Bool                sortFIFOByBenefit;
    F32                 validBoundsPadding;
    F32                 maxChunkSeparationLOD;
    U32                 maxActorCreatesPerFrame;
    U32                 maxChunkDepthOffset;
    F32                 massScale;
    F32                 scaledMassExponent;
};


struct DestructiblePreviewParam
{
    Mat44               globalPose;
    U32                 chunkDepth;
    F32                 explodeAmount;
    Bool                renderUnexplodedChunksStatically;
    String              overrideSkinnedMaterialNames[];
    String              overrideStaticMaterialNames[];
    U64                 userData;
};


struct EffectPackageActorParams
{
    Transform           InitialPose;
    F32                 objectScale;
    Bool                Enabled;
};


struct EffectPackageAssetParams
{
    Bool                LODSettings.UniqueRenderVolume;
    F32                 LODSettings.FadeDistanceBegin;
    F32                 LODSettings.FadeDistanceEnd;
    Bool                LODSettings.RandomizeEmitterRate;
    F32                 LODSettings.FadeOutRate;
    Bool                LODSettings.CullByDistance;
    Bool                LODSettings.CullOffScreen;
    F32                 LODSettings.OffScreenCullTime;
    F32                 LODSettings.NonVisibleDeleteTime;
    F32                 LODSettings.ScreenCullSize;
    F32                 LODSettings.ScreenCullDistance;
    Bool                LODSettings.FadeEmitterRate;
    Bool                LODSettings.FadeAttractorFieldStrength;
    Bool                LODSettings.FadeJetFieldStrength;
    Bool                LODSettings.FadeTurbulenceVelocity;
    Bool                LODSettings.FadeTurbulenceNoise;
    Bool                LODSettings.FadeTurbulenceExternalVelocity;
    Bool                LODSettings.FadeTurbulenceVelocityWeight;
    Bool                LODSettings.FadeHeatSourceTemperature;
    Bool                LODSettings.FadeForceFieldStrength;
    Bool                LODSettings.FadeForceFieldScale;
    PlaybackMode        Path.PlaybackMode;
    F32                 Path.PathDuration;
    U32                 Path.LoopIndex;
    Transform           Path.ControlPoints[];
    F32                 Path.Scale[].x;
    F32                 Path.Scale[].y;
    F32                 Path.Speed[].x;
    F32                 Path.Speed[].y;
union Effects {
    EmitterEffect       Effects[];
    HeatSourceEffect    Effects[];
    JetFieldSamplerEffect   Effects[];
    AttractorFieldSamplerEffect Effects[];
    TurbulenceFieldSamplerEffect    Effects[];
    ForceFieldEffect    Effects[];
    NoiseFieldSamplerEffect Effects[];
    VortexFieldSamplerEffect    Effects[];
    SubstanceSourceEffect   Effects[];
    WindFieldSamplerEffect  Effects[];
    RigidBodyEffect     Effects[];
    VelocitySourceEffect    Effects[];
};
Effects Effects[];
};


struct EffectPackageData
{
    String              Name;
    EffectPackageAssetParams    EffectPackage;
};


struct EffectPackageDatabaseParams
{
    EffectPackageData   EffectPackages[];
};


struct EffectPackageEmitterDatabaseParams
{
    EmitterData         Emitters[];
};


struct EffectPackageFieldSamplerDatabaseParams
{
union FieldSamplers {
    AttractorFieldSamplerData   FieldSamplers[];
    ForceFieldData      FieldSamplers[];
    HeatSourceData      FieldSamplers[];
    JetFieldSamplerData FieldSamplers[];
    TurbulenceFieldSamplerData  FieldSamplers[];
    VortexFieldSamplerData  FieldSamplers[];
    NoiseFieldSamplerData   FieldSamplers[];
    SubstanceSourceData FieldSamplers[];
    WindFieldSamplerData    FieldSamplers[];
    VelocitySourceData  FieldSamplers[];
};
FieldSamplers   FieldSamplers[];
};


struct EffectPackageGraphicsMaterialsParams
{
union GraphicsMaterials {
    GraphicsMaterialData    GraphicsMaterials[];
    VolumeRenderMaterialData    GraphicsMaterials[];
};
GraphicsMaterials   GraphicsMaterials[];
};


struct EffectPackageIOFXDatabaseParams
{
    GraphicsEffectData  GraphicsEffects[];
};


struct EffectPackageIOSDatabaseParams
{
    ParticleSimulationData  ParticleSimulations[];
};


struct EmitterAssetPreviewParameters
{
    Mat34               pose;
    F32                 scale;
};


struct EmitterData
{
    String              Name;
    ApexEmitterAssetParameters  Emitter;
};


struct EmitterDebugRenderParams
{
    Bool                apexEmitterParameters.VISUALIZE_APEX_EMITTER_ACTOR;
    Bool                apexEmitterParameters.VISUALIZE_TOTAL_INJECTED_AABB;
    Bool                apexEmitterParameters.VISUALIZE_APEX_EMITTER_ACTOR_POSE;
    F32                 apexEmitterParameters.THRESHOLD_DISTANCE_APEX_EMITTER_ACTOR_POSE;
    Bool                apexEmitterParameters.VISUALIZE_APEX_EMITTER_ACTOR_NAME;
    F32                 apexEmitterParameters.THRESHOLD_DISTANCE_APEX_EMITTER_ACTOR_NAME;
    Bool                groundEmitterParameters.VISUALIZE_GROUND_EMITTER_ACTOR;
    Bool                groundEmitterParameters.VISUALIZE_GROUND_EMITTER_SPHERE;
    Bool                groundEmitterParameters.VISUALIZE_GROUND_EMITTER_GRID;
    Bool                groundEmitterParameters.VISUALIZE_GROUND_EMITTER_RAYCAST;
    Bool                groundEmitterParameters.VISUALIZE_GROUND_EMITTER_ACTOR_POSE;
    Bool                groundEmitterParameters.VISUALIZE_GROUND_EMITTER_ACTOR_NAME;
    Bool                impactEmitterParameters.VISUALIZE_IMPACT_EMITTER_ACTOR;
    Bool                impactEmitterParameters.VISUALIZE_IMPACT_EMITTER_RAYCAST;
    Bool                impactEmitterParameters.VISUALIZE_IMPACT_EMITTER_ACTOR_NAME;
    F32                 impactEmitterParameters.THRESHOLD_DISTANCE_IMPACT_EMITTER_ACTOR_NAME;
};


struct EmitterEffect
{
    String              EffectProperties.UserString;
    Bool                EffectProperties.Enable;
    F32                 EffectProperties.Position.TranslateX;
    F32                 EffectProperties.Position.TranslateY;
    F32                 EffectProperties.Position.TranslateZ;
    F32                 EffectProperties.Orientation.RotateX;
    F32                 EffectProperties.Orientation.RotateY;
    F32                 EffectProperties.Orientation.RotateZ;
    F32                 EffectProperties.InitialDelayTime;
    F32                 EffectProperties.Duration;
    U32                 EffectProperties.RepeatCount;
    F32                 EffectProperties.RepeatDelay;
    F32                 EffectProperties.RandomizeRepeatTime;
    PlaybackMode        EffectProperties.Path.PlaybackMode;
    F32                 EffectProperties.Path.PathDuration;
    U32                 EffectProperties.Path.LoopIndex;
    Transform           EffectProperties.Path.ControlPoints[];
    F32                 EffectProperties.Path.Scale[].x;
    F32                 EffectProperties.Path.Scale[].y;
    F32                 EffectProperties.Path.Speed[].x;
    F32                 EffectProperties.Path.Speed[].y;
    Bool                EmitterVelocityChanges.AdjustLifetime.AdjustEnabled;
    F32                 EmitterVelocityChanges.AdjustLifetime.VelocityLow;
    F32                 EmitterVelocityChanges.AdjustLifetime.VelocityHigh;
    F32                 EmitterVelocityChanges.AdjustLifetime.LowValue;
    F32                 EmitterVelocityChanges.AdjustLifetime.HighValue;
    Bool                EmitterVelocityChanges.AdjustEmitterRate.AdjustEnabled;
    F32                 EmitterVelocityChanges.AdjustEmitterRate.VelocityLow;
    F32                 EmitterVelocityChanges.AdjustEmitterRate.VelocityHigh;
    F32                 EmitterVelocityChanges.AdjustEmitterRate.LowValue;
    F32                 EmitterVelocityChanges.AdjustEmitterRate.HighValue;
    Ref                 Emitter;
};


struct EmitterGeomBoxParams
{
    EmitterType         emitterType;
    Vec3                extents;
};


struct EmitterGeomCylinderParams
{
    EmitterType         emitterType;
    F32                 radius;
    F32                 height;
};


struct EmitterGeomExplicitParams
{
    F32                 distance;
    Vec3                points.positions[].position;
    Bool                points.positions[].doDetectOverlaps;
    Vec3                points.velocities[];
    Vec3                spheres.positions[].center;
    F32                 spheres.positions[].radius;
    Bool                spheres.positions[].doDetectOverlaps;
    Vec3                spheres.velocities[];
    Vec3                ellipsoids.positions[].center;
    F32                 ellipsoids.positions[].radius;
    Vec3                ellipsoids.positions[].normal;
    F32                 ellipsoids.positions[].polarRadius;
    Bool                ellipsoids.positions[].doDetectOverlaps;
    Vec3                ellipsoids.velocities[];
};


struct EmitterGeomSphereParams
{
    EmitterType         emitterType;
    F32                 radius;
    F32                 hemisphere;
};


struct EmitterGeomSphereShellParams
{
    EmitterType         emitterType;
    F32                 radius;
    F32                 shellThickness;
    F32                 hemisphere;
};


struct EmitterModuleParameters
{
    U32                 unused;
};


struct FieldSamplerModuleParameters
{
    U32                 unused;
};


struct FieldSamplerPhysXMonitorParams
{
    U32                 maxRBCount;
    U32                 maxPSCount;
    U32                 maxParticleCount;
};

struct FluidParticleSystemParams
{
    F32                 restParticleDistance;
    F32                 stiffness;
    F32                 viscosity;
};


struct ForceFieldActorParams
{
    Mat44               initialPose;
    F32                 scale;
    String              fieldBoundaryFilterDataName;
    String              fieldSamplerFilterDataName;
};


struct ForceFieldAssetParams
{
union ForceFieldKernelType {
    GenericForceFieldKernelParams   forceFieldKernelType;
    RadialForceFieldKernelParams    forceFieldKernelType;
};
ForceFieldKernelType    forceFieldKernelType;
    F32                 defScale;
    F32                 strength;
    F32                 lifetime;
    Shape               includeShapeParameters.shape;
    Mat44               includeShapeParameters.forceFieldToShape;
    Vec3                includeShapeParameters.dimensions;
    String              fieldBoundaryFilterDataName;
    String              fieldSamplerFilterDataName;
};


struct ForceFieldAssetPreviewParams
{
    Mat44               pose;
    F32                 iconScale;
    Bool                drawIcon;
    Bool                drawBoundaries;
    Bool                drawBold;
};


struct ForceFieldData
{
    String              Name;
    ForceFieldAssetParams   ForceField;
};


struct ForceFieldDebugRenderParams
{
    Bool                VISUALIZE_FORCEFIELD_ACTOR;
};


struct ForceFieldEffect
{
    String              EffectProperties.UserString;
    Bool                EffectProperties.Enable;
    F32                 EffectProperties.Position.TranslateX;
    F32                 EffectProperties.Position.TranslateY;
    F32                 EffectProperties.Position.TranslateZ;
    F32                 EffectProperties.Orientation.RotateX;
    F32                 EffectProperties.Orientation.RotateY;
    F32                 EffectProperties.Orientation.RotateZ;
    F32                 EffectProperties.InitialDelayTime;
    F32                 EffectProperties.Duration;
    U32                 EffectProperties.RepeatCount;
    F32                 EffectProperties.RepeatDelay;
    F32                 EffectProperties.RandomizeRepeatTime;
    PlaybackMode        EffectProperties.Path.PlaybackMode;
    F32                 EffectProperties.Path.PathDuration;
    U32                 EffectProperties.Path.LoopIndex;
    Transform           EffectProperties.Path.ControlPoints[];
    F32                 EffectProperties.Path.Scale[].x;
    F32                 EffectProperties.Path.Scale[].y;
    F32                 EffectProperties.Path.Speed[].x;
    F32                 EffectProperties.Path.Speed[].y;
    Ref                 ForceField;
};


struct ForceFieldFalloffParams
{
    Type                type;
    F32                 multiplier;
    F32                 start;
    F32                 end;
};


struct ForceFieldModuleParams
{
    U32                 unused;
};


struct ForceFieldNoiseParams
{
    F32                 strength;
    F32                 spaceScale;
    F32                 timeScale;
    U32                 octaves;
};


struct GenericForceFieldKernelParams
{
    Type                coordinateSystemParameters.type;
    F32                 coordinateSystemParameters.torusRadius;
    Vec3                constant;
    Mat33               positionMultiplier;
    Vec3                positionTarget;
    Mat33               velocityMultiplier;
    Vec3                velocityTarget;
    Vec3                noise;
    Vec3                falloffLinear;
    Vec3                falloffQuadratic;
};


struct GraphicsEffectData
{
    String              Name;
    IofxAssetParameters IOFX;
};


struct GraphicsMaterialData
{
    String              Name;
    String              ApplicationMaterialName;
    String              UserProperties;
    RenderTechnique     RenderTechnique;
    String              DiffuseTexture;
    U32                 CellColumn;
    U32                 CellRow;
    U32                 CellCount;
    Bool                CrossBlend;
    F32                 ColorMultiplier;
    Bool                UsePSM;
    Resolution          Resolution;
    U32                 FullResPercent;
    U32                 HalfResPercent;
    F32                 PSM_ShadowBias;
    Bool                PSM_Frustum.ShowFrustum;
    F32                 PSM_Frustum.FrustumDepth;
    F32                 PSM_Frustum.FrustumSize;
};


struct GroundEmitterActorParameters
{
    F32                 densityRange.min;
    F32                 densityRange.max;
    F32                 radius;
    Vec3                upDirection;
    F32                 raycastHeight;
    F32                 spawnHeight;
    U32                 maxRaycastsPerFrame;
    String              raycastCollisionGroupMaskName;
    Vec3                attachRelativePosition;
    Mat34               globalPose;
};


struct GroundEmitterAssetParameters
{
    F32                 densityRange.min;
    F32                 densityRange.max;
    Vec3                velocityRange.min;
    Vec3                velocityRange.max;
    F32                 lifetimeRange.min;
    F32                 lifetimeRange.max;
    F32                 radius;
    F32                 raycastHeight;
    F32                 spawnHeight;
    U32                 maxRaycastsPerFrame;
    String              raycastCollisionGroupMaskName;
    Ref                 materialFactoryMapList[].iofxAssetName;
    Ref                 materialFactoryMapList[].iosAssetName;
    String              materialFactoryMapList[].physMatName;
    F32                 materialFactoryMapList[].weight;
    F32                 materialFactoryMapList[].maxSlopeAngle;
    U32                 materialFactoryMapList[].lodParamDesc.version;
    F32                 materialFactoryMapList[].lodParamDesc.maxDistance;
    F32                 materialFactoryMapList[].lodParamDesc.distanceWeight;
    F32                 materialFactoryMapList[].lodParamDesc.speedWeight;
    F32                 materialFactoryMapList[].lodParamDesc.lifeWeight;
    F32                 materialFactoryMapList[].lodParamDesc.separationWeight;
    F32                 materialFactoryMapList[].lodParamDesc.bias;
};


struct HeatSourceActorParams
{
    Mat34               initialPose;
    F32                 initialScale;
    F32                 averageTemperature;
    F32                 stdTemperature;
union GeometryType {
    HeatSourceGeomBoxParams geometryType;
    HeatSourceGeomSphereParams  geometryType;
};
GeometryType    geometryType;
    String              fieldSamplerFilterDataName;
};


struct HeatSourceAssetParams
{
    F32                 averageTemperature;
    F32                 stdTemperature;
union GeometryType {
    HeatSourceGeomBoxParams geometryType;
    HeatSourceGeomSphereParams  geometryType;
};
GeometryType    geometryType;
    String              fieldSamplerFilterDataName;
};


struct HeatSourceData
{
    String              Name;
    HeatSourceAssetParams   HeatSource;
};


struct HeatSourceEffect
{
    String              EffectProperties.UserString;
    Bool                EffectProperties.Enable;
    F32                 EffectProperties.Position.TranslateX;
    F32                 EffectProperties.Position.TranslateY;
    F32                 EffectProperties.Position.TranslateZ;
    F32                 EffectProperties.Orientation.RotateX;
    F32                 EffectProperties.Orientation.RotateY;
    F32                 EffectProperties.Orientation.RotateZ;
    F32                 EffectProperties.InitialDelayTime;
    F32                 EffectProperties.Duration;
    U32                 EffectProperties.RepeatCount;
    F32                 EffectProperties.RepeatDelay;
    F32                 EffectProperties.RandomizeRepeatTime;
    PlaybackMode        EffectProperties.Path.PlaybackMode;
    F32                 EffectProperties.Path.PathDuration;
    U32                 EffectProperties.Path.LoopIndex;
    Transform           EffectProperties.Path.ControlPoints[];
    F32                 EffectProperties.Path.Scale[].x;
    F32                 EffectProperties.Path.Scale[].y;
    F32                 EffectProperties.Path.Speed[].x;
    F32                 EffectProperties.Path.Speed[].y;
    Ref                 HeatSource;
};


struct HeatSourceGeomBoxParams
{
    Vec3                extents;
};


struct HeatSourceGeomSphereParams
{
    F32                 radius;
};


struct HeatSourcePreviewParams
{
    Mat34               pose;
    F32                 scale;
};


struct ImpactEmitterActorParameters
{
};


struct ImpactEmitterAssetParameters
{
union EventSetList {
    ImpactObjectEvent   eventSetList[];
    ImpactExplosionEvent    eventSetList[];
};
EventSetList    eventSetList[];
};


struct ImpactExplosionEvent
{
    String              eventSetName;
    Ref                 explosionAssetName;
    F32                 delay;
    F32                 duration;
};


struct ImpactObjectEvent
{
    String              eventSetName;
    Ref                 iofxAssetName;
    Ref                 iosAssetName;
    F32                 angleRange.min;
    F32                 angleRange.max;
    F32                 speedRange.min;
    F32                 speedRange.max;
    F32                 lifeRange.min;
    F32                 lifeRange.max;
    F32                 delay;
    U32                 particleSpawnCount;
    ImpactAxis          impactAxis;
    U32                 lodParamDesc.version;
    F32                 lodParamDesc.maxDistance;
    F32                 lodParamDesc.distanceWeight;
    F32                 lodParamDesc.speedWeight;
    F32                 lodParamDesc.lifeWeight;
    F32                 lodParamDesc.separationWeight;
    F32                 lodParamDesc.bias;
};


struct InitialColorModifierParams
{
    Vec4                color;
};


struct IofxAssetParameters
{
union IofxType {
    MeshIofxParameters  iofxType;
    SpriteIofxParameters    iofxType;
};
IofxType    iofxType;
    Bool                renderOutput.useUserSemantic;
    Bool                renderOutput.useFloat4Color;
};


struct IofxDebugRenderParams
{
    Bool                VISUALIZE_IOFX_ACTOR;
    Bool                VISUALIZE_IOFX_BOUNDING_BOX;
    Bool                VISUALIZE_IOFX_ACTOR_NAME;
};


struct IofxModuleParameters
{
    U32                 unused;
};


struct JetFSActorParams
{
    Mat34               initialPose;
    F32                 initialScale;
    String              fieldBoundaryFilterDataName;
    String              fieldSamplerFilterDataName;
};


struct JetFSAssetParams
{
    F32                 defaultScale;
    F32                 boundaryFadePercentage;
    Vec3                fieldDirection;
    F32                 fieldDirectionDeviationAngle;
    F32                 fieldDirectionOscillationPeriod;
    F32                 fieldStrength;
    F32                 fieldStrengthDeviationPercentage;
    F32                 fieldStrengthOscillationPeriod;
    F32                 gridShapeRadius;
    F32                 gridShapeHeight;
    F32                 gridBoundaryFadePercentage;
    F32                 nearRadius;
    F32                 pivotRadius;
    F32                 farRadius;
    F32                 directionalStretch;
    F32                 averageStartDistance;
    F32                 averageEndDistance;
    F32                 noisePercentage;
    F32                 noiseSpaceScale;
    F32                 noiseTimeScale;
    U32                 noiseOctaves;
    F32                 fieldDragCoeff;
    F32                 fieldWeight;
    String              fieldBoundaryFilterDataName;
    String              fieldSamplerFilterDataName;
};


struct JetFSPreviewParams
{
    Mat44               globalPose;
    Bool                drawShape;
    Bool                drawAssetInfo;
    U64                 userData;
};


struct JetFieldSamplerData
{
    String              Name;
    JetFSAssetParams    JetFieldSampler;
};


struct JetFieldSamplerEffect
{
    String              EffectProperties.UserString;
    Bool                EffectProperties.Enable;
    F32                 EffectProperties.Position.TranslateX;
    F32                 EffectProperties.Position.TranslateY;
    F32                 EffectProperties.Position.TranslateZ;
    F32                 EffectProperties.Orientation.RotateX;
    F32                 EffectProperties.Orientation.RotateY;
    F32                 EffectProperties.Orientation.RotateZ;
    F32                 EffectProperties.InitialDelayTime;
    F32                 EffectProperties.Duration;
    U32                 EffectProperties.RepeatCount;
    F32                 EffectProperties.RepeatDelay;
    F32                 EffectProperties.RandomizeRepeatTime;
    PlaybackMode        EffectProperties.Path.PlaybackMode;
    F32                 EffectProperties.Path.PathDuration;
    U32                 EffectProperties.Path.LoopIndex;
    Transform           EffectProperties.Path.ControlPoints[];
    F32                 EffectProperties.Path.Scale[].x;
    F32                 EffectProperties.Path.Scale[].y;
    F32                 EffectProperties.Path.Speed[].x;
    F32                 EffectProperties.Path.Speed[].y;
    Ref                 JetFieldSampler;
};


struct MeshCookedCollisionStream
{
    U8                  bytes[];
};


struct MeshCookedCollisionStreamsAtScale
{
    MeshCookedCollisionStream   meshCookedCollisionStreams[];
};


struct MeshIofxParameters
{
    Ref                 renderMeshList[].meshAssetName;
    U32                 renderMeshList[].weight;
union SpawnModifierList {
    RotationModifierParams  spawnModifierList[];
    SimpleScaleModifierParams   spawnModifierList[];
    RandomScaleModifierParams   spawnModifierList[];
    InitialColorModifierParams  spawnModifierList[];
    ScaleByMassModifierParams   spawnModifierList[];
};
SpawnModifierList   spawnModifierList[];
union ContinuousModifierList {
    RotationModifierParams  continuousModifierList[];
    ScaleVsLife3DModifierParams continuousModifierList[];
    ScaleVsDensity3DModifierParams  continuousModifierList[];
    ScaleVsTemperature3DModifierParams  continuousModifierList[];
    ScaleVsCameraDistance3DModifierParams   continuousModifierList[];
    OrientAlongVelocityModifierParams   continuousModifierList[];
    ScaleAlongVelocityModifierParams    continuousModifierList[];
    ColorVsLifeCompositeModifierParams  continuousModifierList[];
    ColorVsDensityCompositeModifierParams   continuousModifierList[];
    ColorVsTemperatureCompositeModifierParams   continuousModifierList[];
    ScaleVsLifeModifierParams   continuousModifierList[];
    ScaleVsDensityModifierParams    continuousModifierList[];
    ScaleVsTemperatureModifierParams    continuousModifierList[];
    ScaleVsCameraDistanceModifierParams continuousModifierList[];
    ColorVsVelocityCompositeModifierParams  continuousModifierList[];
};
ContinuousModifierList  continuousModifierList[];
};


struct NoiseFSActorParams
{
    Mat34               initialPose;
    F32                 initialScale;
    String              fieldBoundaryFilterDataName;
    String              fieldSamplerFilterDataName;
};


struct NoiseFSAssetParams
{
    F32                 defaultScale;
    Vec3                boundarySize;
    F32                 boundaryFadePercentage;
    FieldType           fieldType;
    F32                 fieldDragCoeff;
    F32                 fieldWeight;
    NoiseType           noiseType;
    U32                 noiseSeed;
    F32                 noiseStrength;
    Vec3                noiseSpacePeriod;
    F32                 noiseTimePeriod;
    U32                 noiseOctaves;
    F32                 noiseStrengthOctaveMultiplier;
    Vec3                noiseSpacePeriodOctaveMultiplier;
    F32                 noiseTimePeriodOctaveMultiplier;
    String              fieldBoundaryFilterDataName;
    String              fieldSamplerFilterDataName;
    Bool                useLocalSpace;
};


struct NoiseFSPreviewParams
{
    Mat44               globalPose;
    Bool                drawShape;
    Bool                drawAssetInfo;
    U64                 userData;
};


struct NoiseFieldSamplerData
{
    String              Name;
    NoiseFSAssetParams  NoiseFieldSampler;
};


struct NoiseFieldSamplerEffect
{
    String              EffectProperties.UserString;
    Bool                EffectProperties.Enable;
    F32                 EffectProperties.Position.TranslateX;
    F32                 EffectProperties.Position.TranslateY;
    F32                 EffectProperties.Position.TranslateZ;
    F32                 EffectProperties.Orientation.RotateX;
    F32                 EffectProperties.Orientation.RotateY;
    F32                 EffectProperties.Orientation.RotateZ;
    F32                 EffectProperties.InitialDelayTime;
    F32                 EffectProperties.Duration;
    U32                 EffectProperties.RepeatCount;
    F32                 EffectProperties.RepeatDelay;
    F32                 EffectProperties.RandomizeRepeatTime;
    PlaybackMode        EffectProperties.Path.PlaybackMode;
    F32                 EffectProperties.Path.PathDuration;
    U32                 EffectProperties.Path.LoopIndex;
    Transform           EffectProperties.Path.ControlPoints[];
    F32                 EffectProperties.Path.Scale[].x;
    F32                 EffectProperties.Path.Scale[].y;
    F32                 EffectProperties.Path.Speed[].x;
    F32                 EffectProperties.Path.Speed[].y;
    Ref                 NoiseFieldSampler;
};


struct OrientAlongVelocityModifierParams
{
    Vec3                modelForward;
};


struct OrientScaleAlongScreenVelocityModifierParams
{
    F32                 scalePerVelocity;
    F32                 scaleChangeLimit;
    F32                 scaleChangeDelay;
};


struct ParticleIosAssetParam
{
union ParticleType {
    SimpleParticleSystemParams  particleType;
    FluidParticleSystemParams   particleType;
};
ParticleType    particleType;
    U32                 maxParticleCount;
    F32                 particleRadius;
    F32                 maxInjectedParticleCount;
    F32                 maxMotionDistance;
    F32                 contactOffset;
    F32                 restOffset;
    F32                 gridSize;
    F32                 damping;
    Vec3                externalAcceleration;
    Vec3                projectionPlaneNormal;
    F32                 projectionPlaneDistance;
    F32                 particleMass;
    F32                 restitution;
    F32                 dynamicFriction;
    F32                 staticFriction;
    String              simulationFilterData;
    String              fieldSamplerFilterData;
    Bool                CollisionTwoway;
    Bool                CollisionWithDynamicActors;
    Bool                Enable;
    Bool                ProjectToPlane;
    Bool                PerParticleRestOffset;
    Bool                PerParticleCollisionCacheHint;
    Bool                DensityBuffer;
    Bool                enableTemperatureBuffer;
};


struct ParticleIosDebugRenderParams
{
    Bool                VISUALIZE_PARTICLE_IOS_ACTOR;
    Bool                VISUALIZE_PARTICLE_IOS_GRID_DENSITY;
};


struct ParticleIosModuleParameters
{
    U32                 unused;
};


struct ParticleSimulationData
{
    String              Name;
union IOS {
    BasicIOSAssetParam  IOS;
    ParticleIosAssetParam   IOS;
};
IOS IOS;
};


struct ParticlesDebugRenderParams
{
    Bool                VISUALIZE_HEAT_SOURCE_ACTOR;
    Bool                VISUALIZE_EFFECT_PACKAGE_ACTOR;
};


struct ParticlesModuleParameters
{
    U32                 unused;
};


struct RadialForceFieldKernelParams
{
    ForceFieldFalloffParams falloffParameters;
    ForceFieldNoiseParams   noiseParameters;
    F32                 radius;
};


struct RandomRotationModifierParams
{
    F32                 minRotation;
    F32                 maxRotation;
};


struct RandomScaleModifierParams
{
    F32                 minScaleFactor;
    F32                 maxScaleFactor;
};


struct RandomSubtextureModifierParams
{
    F32                 minSubtexture;
    F32                 maxSubtexture;
};


struct RenderMeshAssetParameters
{
    SubmeshParameters   submeshes[];
    String              materialNames[];
    Bounds3             partBounds[];
    U32                 textureUVOrigin;
    U32                 boneCount;
    Bool                deleteStaticBuffersAfterUse;
    Bool                isReferenced;
};


struct RigidBodyEffect
{
    String              EffectProperties.UserString;
    Bool                EffectProperties.Enable;
    F32                 EffectProperties.Position.TranslateX;
    F32                 EffectProperties.Position.TranslateY;
    F32                 EffectProperties.Position.TranslateZ;
    F32                 EffectProperties.Orientation.RotateX;
    F32                 EffectProperties.Orientation.RotateY;
    F32                 EffectProperties.Orientation.RotateZ;
    F32                 EffectProperties.InitialDelayTime;
    F32                 EffectProperties.Duration;
    U32                 EffectProperties.RepeatCount;
    F32                 EffectProperties.RepeatDelay;
    F32                 EffectProperties.RandomizeRepeatTime;
    PlaybackMode        EffectProperties.Path.PlaybackMode;
    F32                 EffectProperties.Path.PathDuration;
    U32                 EffectProperties.Path.LoopIndex;
    Transform           EffectProperties.Path.ControlPoints[];
    F32                 EffectProperties.Path.Scale[].x;
    F32                 EffectProperties.Path.Scale[].y;
    F32                 EffectProperties.Path.Speed[].x;
    F32                 EffectProperties.Path.Speed[].y;
    Type                Type;
    String              CollisionFilterDataName;
    Bool                Dynamic;
    Bool                Gravity;
    Vec3                Extents;
    F32                 Mass;
    Vec3                InitialLinearVelocity;
    Vec3                InitialAngularVelocity;
    F32                 LinearDamping;
    F32                 AngularDamping;
};


struct RotationModifierParams
{
    RollType            rollType;
    F32                 maxRotationRatePerSec;
    F32                 maxSettleRatePerSec;
    F32                 inAirRotationMultiplier;
    F32                 collisionRotationMultiplier;
    Bool                includeVerticalDirection;
};


struct RotationRateModifierParams
{
    F32                 rotationRate;
};


struct RotationRateVsLifeModifierParams
{
    F32                 controlPoints[].x;
    F32                 controlPoints[].y;
};


struct ScaleAlongVelocityModifierParams
{
    F32                 scaleFactor;
};


struct ScaleByMassModifierParams
{
};


struct ScaleVsCameraDistance2DModifierParams
{
    F32                 controlPoints[].cameraDistance;
    Vec2                controlPoints[].scale;
};


struct ScaleVsCameraDistance3DModifierParams
{
    F32                 controlPoints[].cameraDistance;
    Vec3                controlPoints[].scale;
};


struct ScaleVsCameraDistanceModifierParams
{
    ScaleAxis           scaleAxis;
    F32                 controlPoints[].x;
    F32                 controlPoints[].y;
};


struct ScaleVsDensity2DModifierParams
{
    F32                 controlPoints[].density;
    Vec2                controlPoints[].scale;
};


struct ScaleVsDensity3DModifierParams
{
    F32                 controlPoints[].density;
    Vec3                controlPoints[].scale;
};


struct ScaleVsDensityModifierParams
{
    ScaleAxis           scaleAxis;
    F32                 controlPoints[].x;
    F32                 controlPoints[].y;
};


struct ScaleVsLife2DModifierParams
{
    F32                 controlPoints[].lifeRemaining;
    Vec2                controlPoints[].scale;
};


struct ScaleVsLife3DModifierParams
{
    F32                 controlPoints[].lifeRemaining;
    Vec3                controlPoints[].scale;
};


struct ScaleVsLifeModifierParams
{
    ScaleAxis           scaleAxis;
    F32                 controlPoints[].x;
    F32                 controlPoints[].y;
};


struct ScaleVsTemperature2DModifierParams
{
    F32                 controlPoints[].temperature;
    Vec2                controlPoints[].scale;
};


struct ScaleVsTemperature3DModifierParams
{
    F32                 controlPoints[].temperature;
    Vec3                controlPoints[].scale;
};


struct ScaleVsTemperatureModifierParams
{
    ScaleAxis           scaleAxis;
    F32                 controlPoints[].x;
    F32                 controlPoints[].y;
};


struct SimpleParticleSystemParams
{
    Bool                GridDensity.Enabled;
    Resolution          GridDensity.Resolution;
    F32                 GridDensity.GridSize;
    U32                 GridDensity.MaxCellCount;
};


struct SimpleScaleModifierParams
{
    Vec3                scaleFactor;
};


struct SpriteIofxParameters
{
    Ref                 spriteMaterialName;
union SpawnModifierList {
    SimpleScaleModifierParams   spawnModifierList[];
    RandomScaleModifierParams   spawnModifierList[];
    InitialColorModifierParams  spawnModifierList[];
    RandomSubtextureModifierParams  spawnModifierList[];
    RandomRotationModifierParams    spawnModifierList[];
    ColorVsLifeModifierParams   spawnModifierList[];
    ScaleByMassModifierParams   spawnModifierList[];
};
SpawnModifierList   spawnModifierList[];
union ContinuousModifierList {
    ColorVsLifeCompositeModifierParams  continuousModifierList[];
    ColorVsDensityCompositeModifierParams   continuousModifierList[];
    ColorVsTemperatureCompositeModifierParams   continuousModifierList[];
    ScaleVsLife2DModifierParams continuousModifierList[];
    ScaleVsDensity2DModifierParams  continuousModifierList[];
    ScaleVsTemperature2DModifierParams  continuousModifierList[];
    ScaleVsCameraDistance2DModifierParams   continuousModifierList[];
    SubtextureVsLifeModifierParams  continuousModifierList[];
    ViewDirectionSortingModifierParams  continuousModifierList[];
    ColorVsLifeModifierParams   continuousModifierList[];
    ColorVsDensityModifierParams    continuousModifierList[];
    ColorVsTemperatureModifierParams    continuousModifierList[];
    ScaleVsLifeModifierParams   continuousModifierList[];
    ScaleVsDensityModifierParams    continuousModifierList[];
    ScaleVsTemperatureModifierParams    continuousModifierList[];
    ScaleVsCameraDistanceModifierParams continuousModifierList[];
    RotationRateModifierParams  continuousModifierList[];
    RotationRateVsLifeModifierParams    continuousModifierList[];
    OrientScaleAlongScreenVelocityModifierParams    continuousModifierList[];
    ColorVsVelocityCompositeModifierParams  continuousModifierList[];
};
ContinuousModifierList  continuousModifierList[];
};


struct SubmeshParameters
{
    VertexBufferParameters  vertexBuffer;
    U32                 indexBuffer[];
    U32                 vertexPartition[];
    U32                 indexPartition[];
    U32                 smoothingGroups[];
};


struct SubstanceSourceActorParams
{
    Mat34               initialPose;
    F32                 initialScale;
    F32                 averageDensity;
    F32                 stdDensity;
union GeometryType {
    HeatSourceGeomBoxParams geometryType;
    HeatSourceGeomSphereParams  geometryType;
};
GeometryType    geometryType;
    String              fieldSamplerFilterDataName;
};


struct SubstanceSourceAssetParams
{
    Vec3                position;
    F32                 averageDensity;
    F32                 stdDensity;
union GeometryType {
    HeatSourceGeomBoxParams geometryType;
    HeatSourceGeomSphereParams  geometryType;
};
GeometryType    geometryType;
    String              fieldSamplerFilterDataName;
};


struct SubstanceSourceData
{
    String              Name;
    SubstanceSourceAssetParams  SubstanceSource;
};


struct SubstanceSourceEffect
{
    String              EffectProperties.UserString;
    Bool                EffectProperties.Enable;
    F32                 EffectProperties.Position.TranslateX;
    F32                 EffectProperties.Position.TranslateY;
    F32                 EffectProperties.Position.TranslateZ;
    F32                 EffectProperties.Orientation.RotateX;
    F32                 EffectProperties.Orientation.RotateY;
    F32                 EffectProperties.Orientation.RotateZ;
    F32                 EffectProperties.InitialDelayTime;
    F32                 EffectProperties.Duration;
    U32                 EffectProperties.RepeatCount;
    F32                 EffectProperties.RepeatDelay;
    F32                 EffectProperties.RandomizeRepeatTime;
    PlaybackMode        EffectProperties.Path.PlaybackMode;
    F32                 EffectProperties.Path.PathDuration;
    U32                 EffectProperties.Path.LoopIndex;
    Transform           EffectProperties.Path.ControlPoints[];
    F32                 EffectProperties.Path.Scale[].x;
    F32                 EffectProperties.Path.Scale[].y;
    F32                 EffectProperties.Path.Speed[].x;
    F32                 EffectProperties.Path.Speed[].y;
    Ref                 SubstanceSource;
};


struct SubtextureVsLifeModifierParams
{
    F32                 controlPoints[].x;
    F32                 controlPoints[].y;
};


struct SurfaceBufferParameters
{
    U32                 width;
    U32                 height;
    U32                 surfaceFormat;
union Buffer {
    BufferU8x1          buffer;
    BufferU8x2          buffer;
    BufferU8x3          buffer;
    BufferU8x4          buffer;
    BufferU16x1         buffer;
    BufferU16x2         buffer;
    BufferU16x3         buffer;
    BufferU16x4         buffer;
    BufferU32x1         buffer;
    BufferU32x2         buffer;
    BufferU32x3         buffer;
    BufferU32x4         buffer;
    BufferF32x1         buffer;
    BufferF32x2         buffer;
    BufferF32x3         buffer;
    BufferF32x4         buffer;
};
Buffer  buffer;
};


struct SurfaceTraceParameters
{
    U8                  submeshIndices[];
    U32                 vertexIndices[];
    Vec3                defaultNormal;
};


struct SurfaceTraceSetParameters
{
    SurfaceTraceParameters  traces[];
    Vec3                positionOffset;
};


struct TurbulenceFSActorParams
{
    Mat34               initialPose;
    F32                 initialScale;
    Vec3                gridSizeWorld;
    String              collisionFilterDataName;
    String              fieldBoundaryFilterDataName;
    String              fieldSamplerFilterDataName;
    Bool                isAutoSwitchingBC;
    F32                 outletPressureBC;
    F32                 dragCoeffForRigidBody;
    F32                 fluidViscosity;
};


struct TurbulenceFSAssetParams
{
    Min                 gridXRange.min;
    Max                 gridXRange.max;
    Min                 gridYRange.min;
    Max                 gridYRange.max;
    Min                 gridZRange.min;
    Max                 gridZRange.max;
    Vec3                gridSizeWorld;
    F32                 updatesPerFrameRange.min;
    F32                 updatesPerFrameRange.max;
    F32                 angularVelocityMultiplier;
    F32                 angularVelocityClamp;
    F32                 linearVelocityMultiplier;
    F32                 linearVelocityClamp;
    F32                 velocityFieldFadeTime;
    F32                 velocityFieldFadeDelay;
    F32                 velocityFieldFadeIntensity;
    F32                 boundaryFadePercentage;
    F32                 boundarySizePercentage;
    String              collisionFilterDataName;
    String              fieldBoundaryFilterDataName;
    String              fieldSamplerFilterDataName;
    U32                 maxCollidingObjects;
    U32                 maxVelocitySources;
    U32                 maxHeatSources;
    U32                 maxSubstanceSources;
    F32                 dragCoeff;
    Vec3                externalVelocity;
    F32                 fieldVelocityMultiplier;
    F32                 fieldVelocityWeight;
    Bool                useHeat;
    F32                 heatParams.temperatureBasedForceMultiplier;
    F32                 heatParams.ambientTemperature;
    Vec3                heatParams.heatForceDirection;
    F32                 heatParams.thermalConductivity;
    Bool                useDensity;
    F32                 densityParams.diffusionCoef;
    F32                 densityParams.densityFieldFade;
    U32                 densityParams.densityGridMultiplier;
    Bool                isEnabledOptimizedLOD;
    F32                 customLOD;
    F32                 lodWeights.maxDistance;
    F32                 lodWeights.distanceWeight;
    F32                 lodWeights.bias;
    F32                 lodWeights.benefitBias;
    F32                 lodWeights.benefitWeight;
    F32                 noiseParams.noiseStrength;
    Vec3                noiseParams.noiseSpacePeriod;
    F32                 noiseParams.noiseTimePeriod;
    U32                 noiseParams.noiseOctaves;
    F32                 dragCoeffForRigidBody;
    F32                 fluidViscosity;
    Ref                 volumeRenderMaterialName;
};


struct TurbulenceFSDebugRenderParams
{
    Bool                VISUALIZE_TURBULENCE_FS_ACTOR;
    Bool                VISUALIZE_HEAT_SOURCE_ACTOR;
    Bool                VISUALIZE_SUBSTANCE_SOURCE_ACTOR;
    Bool                VISUALIZE_VELOCITY_SOURCE_ACTOR;
    Bool                VISUALIZE_TURBULENCE_FS_VELOCITY;
    Bool                VISUALIZE_TURBULENCE_FS_BBOX;
    Bool                VISUALIZE_TURBULENCE_FS_ACTOR_NAME;
    Bool                VISUALIZE_TURBULENCE_FS_VELOCITY_FIELD;
    F32                 TURBULENCE_FS_VELOCITY_FIELD_SCALE;
    U32                 TURBULENCE_FS_VELOCITY_FIELD_SPACING;
    Bool                VISUALIZE_TURBULENCE_FS_TEMPERATURE_FIELD;
    Bool                VISUALIZE_TURBULENCE_FS_PRESSURE_FIELD;
    Bool                VISUALIZE_TURBULENCE_FS_DENSITY_FIELD;
    F32                 TURBULENCE_FS_SCALAR_FIELD_SCALE;
    U32                 TURBULENCE_FS_SCALAR_FIELD_SPACING;
    Bool                VISUALIZE_TURBULENCE_FS_STREAMLINES;
    F32                 TURBULENCE_FS_STREAMLINES.tmax;
    F32                 TURBULENCE_FS_STREAMLINES.tstep;
    Vec3                TURBULENCE_FS_STREAMLINES.grid;
    Bool                VISUALIZE_TURBULENCE_FS_PLANE;
    Vec3                TURBULENCE_FS_PLANE.normal;
    F32                 TURBULENCE_FS_PLANE.offset;
    Bool                VISUALIZE_TURBULENCE_FS_GRID;
    Bool                VISUALIZE_TURBULENCE_FS_LOD;
    Bool                VISUALIZE_TURBULENCE_FS_POSE;
    F32                 TURBULENCE_FS_LOD;
};


struct TurbulenceFSModuleParameters
{
    U32                 unused;
};


struct TurbulenceFSPreviewParams
{
    Mat44               globalPose;
    F32                 iconScale;
    Bool                drawIcon;
    Bool                drawBox;
    Bool                drawGrid;
    Bool                drawAssetInfo;
    U64                 userData;
};


struct TurbulenceFieldSamplerData
{
    String              Name;
    TurbulenceFSAssetParams TurbulenceFieldSampler;
};


struct TurbulenceFieldSamplerEffect
{
    String              EffectProperties.UserString;
    Bool                EffectProperties.Enable;
    F32                 EffectProperties.Position.TranslateX;
    F32                 EffectProperties.Position.TranslateY;
    F32                 EffectProperties.Position.TranslateZ;
    F32                 EffectProperties.Orientation.RotateX;
    F32                 EffectProperties.Orientation.RotateY;
    F32                 EffectProperties.Orientation.RotateZ;
    F32                 EffectProperties.InitialDelayTime;
    F32                 EffectProperties.Duration;
    U32                 EffectProperties.RepeatCount;
    F32                 EffectProperties.RepeatDelay;
    F32                 EffectProperties.RandomizeRepeatTime;
    PlaybackMode        EffectProperties.Path.PlaybackMode;
    F32                 EffectProperties.Path.PathDuration;
    U32                 EffectProperties.Path.LoopIndex;
    Transform           EffectProperties.Path.ControlPoints[];
    F32                 EffectProperties.Path.Scale[].x;
    F32                 EffectProperties.Path.Scale[].y;
    F32                 EffectProperties.Path.Speed[].x;
    F32                 EffectProperties.Path.Speed[].y;
    Ref                 TurbulenceFieldSampler;
};


struct VelocitySourceActorParams
{
    Mat34               initialPose;
    F32                 initialScale;
    F32                 averageVelocity;
    F32                 stdVelocity;
union GeometryType {
    HeatSourceGeomBoxParams geometryType;
    HeatSourceGeomSphereParams  geometryType;
};
GeometryType    geometryType;
    String              fieldSamplerFilterDataName;
};


struct VelocitySourceAssetParams
{
    F32                 averageVelocity;
    F32                 stdVelocity;
union GeometryType {
    HeatSourceGeomBoxParams geometryType;
    HeatSourceGeomSphereParams  geometryType;
};
GeometryType    geometryType;
    String              fieldSamplerFilterDataName;
};


struct VelocitySourceData
{
    String              Name;
    VelocitySourceAssetParams   VelocitySource;
};


struct VelocitySourceEffect
{
    String              EffectProperties.UserString;
    Bool                EffectProperties.Enable;
    F32                 EffectProperties.Position.TranslateX;
    F32                 EffectProperties.Position.TranslateY;
    F32                 EffectProperties.Position.TranslateZ;
    F32                 EffectProperties.Orientation.RotateX;
    F32                 EffectProperties.Orientation.RotateY;
    F32                 EffectProperties.Orientation.RotateZ;
    F32                 EffectProperties.InitialDelayTime;
    F32                 EffectProperties.Duration;
    U32                 EffectProperties.RepeatCount;
    F32                 EffectProperties.RepeatDelay;
    F32                 EffectProperties.RandomizeRepeatTime;
    PlaybackMode        EffectProperties.Path.PlaybackMode;
    F32                 EffectProperties.Path.PathDuration;
    U32                 EffectProperties.Path.LoopIndex;
    Transform           EffectProperties.Path.ControlPoints[];
    F32                 EffectProperties.Path.Scale[].x;
    F32                 EffectProperties.Path.Scale[].y;
    F32                 EffectProperties.Path.Speed[].x;
    F32                 EffectProperties.Path.Speed[].y;
    Ref                 VelocitySource;
};


struct VelocitySourcePreviewParams
{
    Mat34               pose;
    F32                 scale;
};


struct VertexBufferParameters
{
    U32                 vertexCount;
    VertexFormatParameters  vertexFormat;
union Buffers {
    BufferU8x1          buffers[];
    BufferU8x2          buffers[];
    BufferU8x3          buffers[];
    BufferU8x4          buffers[];
    BufferU16x1         buffers[];
    BufferU16x2         buffers[];
    BufferU16x3         buffers[];
    BufferU16x4         buffers[];
    BufferU32x1         buffers[];
    BufferU32x2         buffers[];
    BufferU32x3         buffers[];
    BufferU32x4         buffers[];
    BufferF32x1         buffers[];
    BufferF32x2         buffers[];
    BufferF32x3         buffers[];
    BufferF32x4         buffers[];
};
Buffers buffers[];
};


struct VertexFormatParameters
{
    U32                 winding;
    Bool                hasSeparateBoneBuffer;
    String              bufferFormats[].name;
    I32                 bufferFormats[].semantic;
    U32                 bufferFormats[].id;
    U32                 bufferFormats[].format;
    U32                 bufferFormats[].access;
    Bool                bufferFormats[].serialize;
};


struct ViewDirectionSortingModifierParams
{
    SortType            sortType;
};


struct VolumeRenderMaterialData
{
    String              Name;
    String              ApplicationMaterialName;
    String              UserProperties;
    RenderMode          RenderMode;
    RenderMethod        RenderMethod;
    ResolutionScale     ResolutionScale;
    FillMode            FillMode;
    Bool                GenerateShadows;
    Bool                BlurShadows;
    Bool                GenerateMipmaps;
    Bool                EnableStencilOpt;
    F32                 StepScale;
    F32                 Density;
    F32                 EdgeFade;
    F32                 OpacityThreshold;
    F32                 RayJitter;
    F32                 IsoValue;
    F32                 IsoValueSign;
    U32                 ShadowSamples;
    F32                 ShadowDistance;
    F32                 ShadowDensity;
    F32                 ShadowJitter;
    F32                 ShadowAmount;
    Vec3                LightDir;
    Vec4                LightColor;
    F32                 BlockEmptyThreshold;
    Bool                ReadDepth;
    F32                 ColorMapScale;
    F32                 ColorMapOffset;
    F32                 ColorMap[].density;
    Vec4                ColorMap[].color;
    F32                 TextureRangeMin;
    F32                 TextureRangeMax;
};


struct VortexFSActorParams
{
    Mat34               initialPose;
    F32                 initialScale;
    String              fieldBoundaryFilterDataName;
    String              fieldSamplerFilterDataName;
};


struct VortexFSAssetParams
{
    F32                 boundaryFadePercentage;
    Vec3                axis;
    Bool                bottomSphericalForce;
    Bool                topSphericalForce;
    F32                 height;
    F32                 bottomRadius;
    F32                 topRadius;
    F32                 rotationalStrength;
    F32                 radialStrength;
    F32                 liftStrength;
    F32                 fieldDragCoeff;
    F32                 fieldWeight;
    String              fieldBoundaryFilterDataName;
    String              fieldSamplerFilterDataName;
};


struct VortexFSPreviewParams
{
    Mat44               globalPose;
    Bool                drawShape;
    Bool                drawAssetInfo;
    U64                 userData;
};


struct VortexFieldSamplerData
{
    String              Name;
    VortexFSAssetParams VortexFieldSampler;
};


struct VortexFieldSamplerEffect
{
    String              EffectProperties.UserString;
    Bool                EffectProperties.Enable;
    F32                 EffectProperties.Position.TranslateX;
    F32                 EffectProperties.Position.TranslateY;
    F32                 EffectProperties.Position.TranslateZ;
    F32                 EffectProperties.Orientation.RotateX;
    F32                 EffectProperties.Orientation.RotateY;
    F32                 EffectProperties.Orientation.RotateZ;
    F32                 EffectProperties.InitialDelayTime;
    F32                 EffectProperties.Duration;
    U32                 EffectProperties.RepeatCount;
    F32                 EffectProperties.RepeatDelay;
    F32                 EffectProperties.RandomizeRepeatTime;
    PlaybackMode        EffectProperties.Path.PlaybackMode;
    F32                 EffectProperties.Path.PathDuration;
    U32                 EffectProperties.Path.LoopIndex;
    Transform           EffectProperties.Path.ControlPoints[];
    F32                 EffectProperties.Path.Scale[].x;
    F32                 EffectProperties.Path.Scale[].y;
    F32                 EffectProperties.Path.Speed[].x;
    F32                 EffectProperties.Path.Speed[].y;
    Ref                 VortexFieldSampler;
};


struct WindFSActorParams
{
    Mat34               initialPose;
    F32                 initialScale;
    String              fieldBoundaryFilterDataName;
    String              fieldSamplerFilterDataName;
};


struct WindFSAssetParams
{
    Vec3                fieldDirection;
    F32                 fieldDirectionDeviationAngle;
    F32                 fieldDirectionOscillationPeriod;
    F32                 fieldStrength;
    F32                 fieldStrengthDeviationPercentage;
    F32                 fieldStrengthOscillationPeriod;
    F32                 fieldDragCoeff;
    F32                 fieldWeight;
    String              fieldBoundaryFilterDataName;
    String              fieldSamplerFilterDataName;
};


struct WindFSPreviewParams
{
    Mat44               globalPose;
    Bool                drawAssetInfo;
    U64                 userData;
};


struct WindFieldSamplerData
{
    String              Name;
    WindFSAssetParams   WindFieldSampler;
};


struct WindFieldSamplerEffect
{
    String              EffectProperties.UserString;
    Bool                EffectProperties.Enable;
    F32                 EffectProperties.Position.TranslateX;
    F32                 EffectProperties.Position.TranslateY;
    F32                 EffectProperties.Position.TranslateZ;
    F32                 EffectProperties.Orientation.RotateX;
    F32                 EffectProperties.Orientation.RotateY;
    F32                 EffectProperties.Orientation.RotateZ;
    F32                 EffectProperties.InitialDelayTime;
    F32                 EffectProperties.Duration;
    U32                 EffectProperties.RepeatCount;
    F32                 EffectProperties.RepeatDelay;
    F32                 EffectProperties.RandomizeRepeatTime;
    PlaybackMode        EffectProperties.Path.PlaybackMode;
    F32                 EffectProperties.Path.PathDuration;
    U32                 EffectProperties.Path.LoopIndex;
    Transform           EffectProperties.Path.ControlPoints[];
    F32                 EffectProperties.Path.Scale[].x;
    F32                 EffectProperties.Path.Scale[].y;
    F32                 EffectProperties.Path.Speed[].x;
    F32                 EffectProperties.Path.Speed[].y;
    Ref                 WindFieldSampler;
};



#endif