FLEX  1.2.0
Data Structures | Typedefs | Enumerations | Functions
NvFlexExt.h File Reference

Go to the source code of this file.

Data Structures

struct  NvFlexVector< T >
 
struct  NvFlexExtMovingFrame
 
struct  NvFlexExtAsset
 
struct  NvFlexExtInstance
 
struct  NvFlexExtTearingParticleClone
 
struct  NvFlexExtTearingMeshEdit
 
struct  NvFlexExtParticleData
 
struct  NvFlexExtTriangleData
 
struct  NvFlexExtShapeData
 
struct  NvFlexExtForceField
 

Typedefs

typedef struct NvFlexExtContainer NvFlexExtContainer
 
typedef struct NvFlexExtForceFieldCallback NvFlexExtForceFieldCallback
 

Enumerations

enum  NvFlexExtForceMode {
  eNvFlexExtModeForce = 0,
  eNvFlexExtModeImpulse = 1,
  eNvFlexExtModeVelocityChange = 2
}
 

Functions

NV_FLEX_API void NvFlexExtMovingFrameInit (NvFlexExtMovingFrame *frame, const float *worldTranslation, const float *worldRotation)
 
NV_FLEX_API void NvFlexExtMovingFrameUpdate (NvFlexExtMovingFrame *frame, const float *worldTranslation, const float *worldRotation, float dt)
 
NV_FLEX_API void NvFlexExtMovingFrameApply (NvFlexExtMovingFrame *frame, float *positions, float *velocities, int numParticles, float linearScale, float angularScale, float dt)
 
NV_FLEX_API int NvFlexExtCreateWeldedMeshIndices (const float *vertices, int numVertices, int *uniqueVerts, int *originalToUniqueMap, float threshold)
 
NV_FLEX_API NvFlexExtAssetNvFlexExtCreateClothFromMesh (const float *particles, int numParticles, const int *indices, int numTriangles, float stretchStiffness, float bendStiffness, float tetherStiffness, float tetherGive, float pressure)
 
NV_FLEX_API NvFlexExtAssetNvFlexExtCreateTearingClothFromMesh (const float *particles, int numParticles, int maxParticles, const int *indices, int numTriangles, float stretchStiffness, float bendStiffness, float pressure)
 
NV_FLEX_API void NvFlexExtDestroyTearingCloth (NvFlexExtAsset *asset)
 
NV_FLEX_API void NvFlexExtTearClothMesh (NvFlexExtAsset *asset, float maxStrain, int maxSplits, NvFlexExtTearingParticleClone *particleCopies, int *numParticleCopies, int maxCopies, NvFlexExtTearingMeshEdit *triangleEdits, int *numTriangleEdits, int maxEdits)
 
NV_FLEX_API NvFlexExtAssetNvFlexExtCreateRigidFromMesh (const float *vertices, int numVertices, const int *indices, int numTriangleIndices, float radius, float expand)
 
NV_FLEX_API NvFlexExtAssetNvFlexExtCreateSoftFromMesh (const float *vertices, int numVertices, const int *indices, int numTriangleIndices, float particleSpacing, float volumeSampling, float surfaceSampling, float clusterSpacing, float clusterRadius, float clusterStiffness, float linkRadius, float linkStiffness, float globalStiffness, float clusterPlasticThreshold, float clusterPlasticCreep)
 
NV_FLEX_API void NvFlexExtDestroyAsset (NvFlexExtAsset *asset)
 
NV_FLEX_API void NvFlexExtCreateSoftMeshSkinning (const float *vertices, int numVertices, const float *bones, int numBones, float falloff, float maxDistance, float *skinningWeights, int *skinningIndices)
 
NV_FLEX_API NvFlexExtContainerNvFlexExtCreateContainer (NvFlexLibrary *lib, NvFlexSolver *solver, int maxParticles)
 
NV_FLEX_API void NvFlexExtDestroyContainer (NvFlexExtContainer *container)
 
NV_FLEX_API int NvFlexExtAllocParticles (NvFlexExtContainer *container, int n, int *indices)
 
NV_FLEX_API void NvFlexExtFreeParticles (NvFlexExtContainer *container, int n, const int *indices)
 
NV_FLEX_API int NvFlexExtGetActiveList (NvFlexExtContainer *container, int *indices)
 
NV_FLEX_API NvFlexExtParticleData NvFlexExtMapParticleData (NvFlexExtContainer *container)
 
NV_FLEX_API void NvFlexExtUnmapParticleData (NvFlexExtContainer *container)
 
NV_FLEX_API NvFlexExtTriangleData NvFlexExtMapTriangleData (NvFlexExtContainer *container)
 
NV_FLEX_API void NvFlexExtUnmapTriangleData (NvFlexExtContainer *container)
 
NV_FLEX_API NvFlexExtShapeData NvFlexExtMapShapeData (NvFlexExtContainer *container)
 
NV_FLEX_API void NvFlexExtUnmapShapeData (NvFlexExtContainer *container)
 
NV_FLEX_API NvFlexExtInstanceNvFlexExtCreateInstance (NvFlexExtContainer *container, NvFlexExtParticleData *particleData, const NvFlexExtAsset *asset, const float *transform, float vx, float vy, float vz, int phase, float invMassScale)
 
NV_FLEX_API void NvFlexExtDestroyInstance (NvFlexExtContainer *container, const NvFlexExtInstance *instance)
 
NV_FLEX_API void NvFlexExtNotifyAssetChanged (NvFlexExtContainer *container, const NvFlexExtAsset *asset)
 
NV_FLEX_API void NvFlexExtTickContainer (NvFlexExtContainer *container, float dt, int numSubsteps, bool enableTimers=false)
 
NV_FLEX_API void NvFlexExtPushToDevice (NvFlexExtContainer *container)
 
NV_FLEX_API void NvFlexExtPullFromDevice (NvFlexExtContainer *container)
 
NV_FLEX_API void NvFlexExtUpdateInstances (NvFlexExtContainer *container)
 
NV_FLEX_API NvFlexExtForceFieldCallbackNvFlexExtCreateForceFieldCallback (NvFlexSolver *solver)
 
NV_FLEX_API void NvFlexExtDestroyForceFieldCallback (NvFlexExtForceFieldCallback *callback)
 
NV_FLEX_API void NvFlexExtSetForceFields (NvFlexExtForceFieldCallback *callback, const NvFlexExtForceField *forceFields, int numForceFields)
 

Detailed Description

The main include file for the Flex extensions API, this is a collection of helper functions for asset creation, scene management, and sample code that builds on the Flex core API.


Data Structure Documentation

struct NvFlexExtMovingFrame

Helper struct for storing the state of a moving frame, see NvFlexExtMovingFrameInit()

Data Fields
float position[3]
float rotation[4]
float velocity[3]
float omega[3]
float acceleration[3]
float tau[3]
float delta[4][4]
struct NvFlexExtAsset

Represents a group of particles and constraints, each asset can be instanced into a container using NvFlexExtCreateInstance()

Data Fields
float * particles Local space particle positions, x,y,z,1/mass.
int numParticles Number of particles.
int maxParticles Maximum number of particles, allows extra space for tearable assets which duplicate particles.
int * springIndices Spring indices.
float * springCoefficients Spring coefficients.
float * springRestLengths Spring rest-lengths.
int numSprings Number of springs.
int * shapeIndices The indices of the shape matching constraints.
int numShapeIndices Total number of indices for shape constraints.
int * shapeOffsets Each entry stores the end of the shape's indices in the indices array (exclusive prefix sum of shape lengths)
float * shapeCoefficients The stiffness coefficient for each shape.
float * shapeCenters The position of the center of mass of each shape, an array of vec3s mNumShapes in length.
int numShapes The number of shape matching constraints.
float * shapePlasticThresholds The plastic threshold coefficient for each shape.
float * shapePlasticCreeps The plastic creep coefficient for each shape.
int * triangleIndices Indexed triangle mesh indices for clothing.
int numTriangles Number of triangles.
bool inflatable Whether an inflatable constraint should be added.
float inflatableVolume The rest volume for the inflatable constraint.
float inflatablePressure How much over the rest volume the inflatable should attempt to maintain.
float inflatableStiffness How stiff the inflatable is.
struct NvFlexExtInstance

Represents an instance of a FlexAsset in a container

Data Fields
int * particleIndices Simulation particle indices.
int numParticles Number of simulation particles.
int triangleIndex Index in the container's triangle array.
int shapeIndex Index in the container's shape body constraints array.
int inflatableIndex Index in the container's inflatables array.
float * shapeTranslations Shape matching group translations (vec3s)
float * shapeRotations Shape matching group rotations (quaternions)
const NvFlexExtAsset * asset Source asset used to create this instance.
void * userData User data pointer.
struct NvFlexExtTearingParticleClone

Particles and vertices may need to be copied during tearing. Because the user may maintain particle data outside of Flex, this structure describes how to update the particle data. The application should copy each existing particle given by srcIndex (in the asset's particle array) to the destIndex (also in the asset's array).

Data Fields
int srcIndex
int destIndex
struct NvFlexExtTearingMeshEdit

The mesh topology may need to be updated to reference new particles during tearing. Because the user may maintain mesh topology outside of Flex, this structure describes the necessary updates that should be performed on the mesh. The triIndex member is the index of the index to be updated, e.g.: a triIndex value of 4 refers to the index 1 vertex (4%3) of the index 1 triangle (4/3). This entry in the indices array should be updated to point to the newParticleIndex.

Data Fields
int triIndex
int newParticleIndex
struct NvFlexExtParticleData
Data Fields
float * particles Receives a pointer to the particle position / mass data.
float * restParticles Receives a pointer to the particle's rest position (used for self collision culling)
float * velocities Receives a pointer to the particle velocity data.
int * phases Receives a pointer to the particle phase data.
float * normals Receives a pointer to the particle normal data with 16 byte stride in format [nx, ny, nz, nw].
const float * lower Receive a pointer to the particle lower bounds [x, y, z].
const float * upper Receive a pointer to the particle upper bounds [x, y, z].
struct NvFlexExtTriangleData
Data Fields
int * indices Receives a pointer to the array of triangle index data.
float * normals Receives a pointer to an array of triangle normal data stored with 16 byte stride, i.e.: [nx, ny, nz].
struct NvFlexExtShapeData
Data Fields
float * rotations Receives a pointer to the array quaternion rotation data in [x, y z, w] format.
float * positions Receives a pointer to an array of shape body translations in [x, y, z] format.
int n Number of valid tranforms.
struct NvFlexExtForceField

Force field data, currently just supports radial fields

Data Fields
float mPosition[3] Center of force field.
float mRadius Radius of the force field.
float mStrength Strength of the force field.
NvFlexExtForceMode mMode Mode of field application.
bool mLinearFalloff Linear or no falloff.

Typedef Documentation

Opaque type representing a simulation

Opaque type representing a force field callback structure that ecapsulates the force field kernels and associated data applied as a callback during the Flex update

Enumeration Type Documentation

Controls the way that force fields affect particles

Enumerator
eNvFlexExtModeForce 

Apply field value as a force.

eNvFlexExtModeImpulse 

Apply field value as an impulse.

eNvFlexExtModeVelocityChange 

Apply field value as a velocity change.

Function Documentation

NV_FLEX_API void NvFlexExtMovingFrameInit ( NvFlexExtMovingFrame frame,
const float *  worldTranslation,
const float *  worldRotation 
)

Creates a new moving frame struct. This helper method is used to calculate inertial forces for particles inside an attached parent frame. For example, when simulating cloth attached to the character, we would like to perform a local space simulation of the cloth to avoid excessive stretching and collision issues during fast animations. However, we would still like the cloth to respond to character movements in at least a limited, or controlled fashion. The NvFlexExtMovingFrame provides a way to include or remove these inertial forces. The basic usage is as follows:

NvFlexExtMovingFrameInit(&frame, initialTranslation, initialRotation);
const linearInertiaScale = 0.25f;
const angularInertiaScale 0.5;
while(simulating)
{
float3 newPosition;
float4 newRotation;
// move parent frame (character / emitter) according to application's animation system
Animate(newPosition, newRotation);
// update the frame
NvFlexExtMovingFrameUpdate(frame, newPosition, newRotation, dt);
// apply inertial forces and update particles
NvFlexExtMovingFrameApply(frame, particlePositions, particleVelocities, numParticles, linearInertiaScale, angularInertiaScale, dt);
}
Parameters
[in]frameA pointer to a user-allocated NvFlexExtMovingFrame struct
[in]worldTranslationA pointer to a vec3 storing the frame's initial translation in world space
[in]worldRotationA pointer to a quaternion storing the frame's initial rotation in world space
NV_FLEX_API void NvFlexExtMovingFrameUpdate ( NvFlexExtMovingFrame frame,
const float *  worldTranslation,
const float *  worldRotation,
float  dt 
)
NV_FLEX_API void NvFlexExtMovingFrameApply ( NvFlexExtMovingFrame frame,
float *  positions,
float *  velocities,
int  numParticles,
float  linearScale,
float  angularScale,
float  dt 
)
NV_FLEX_API int NvFlexExtCreateWeldedMeshIndices ( const float *  vertices,
int  numVertices,
int *  uniqueVerts,
int *  originalToUniqueMap,
float  threshold 
)

Create an index buffer of unique vertices in the mesh (collapses vertices in the same position even if they have different normals / texcoords). This can be used to create simulation meshes from render meshes, and is typically done as a pre-pass before calling NvFlexExtCreateClothFromMesh().

Parameters
[in]verticesA pointer to an array of float3 positions
[in]numVerticesThe number of vertices in the mesh
[out]uniqueVertsA list of unique mesh vertex indices, should be numVertices in length (worst case all verts are unique)
[out]originalToUniqueMapMapping from the original vertex index to the unique vertex index, should be numVertices in length
[in]thresholdThe distance below which two vertices are considered duplicates
Returns
The number of unique vertices in the mesh
NV_FLEX_API NvFlexExtAsset* NvFlexExtCreateClothFromMesh ( const float *  particles,
int  numParticles,
const int *  indices,
int  numTriangles,
float  stretchStiffness,
float  bendStiffness,
float  tetherStiffness,
float  tetherGive,
float  pressure 
)

Create a cloth asset consisting of stretch and bend distance constraints given an indexed triangle mesh. Stretch constraints will be placed along triangle edges, while bending constraints are placed over two edges.

Parameters
[in]particlesPositions and masses of the particles in the format [x, y, z, 1/m]
[in]numParticlesThe number of particles
[in]indicesThe triangle indices, these should be 'welded' using NvFlexExtCreateWeldedMeshIndices() first
[in]numTrianglesThe number of triangles
[in]stretchStiffnessThe stiffness coefficient for stretch constraints
[in]bendStiffnessThe stiffness coefficient used for bending constraints
[in]tetherStiffnessIf > 0.0f then the function will create tethers attached to particles with zero inverse mass. These are unilateral, long-range attachments, which can greatly reduce stretching even at low iteration counts.
[in]tetherGiveBecause tether constraints are so effective at reducing stiffness, it can be useful to allow a small amount of extension before the constraint activates.
[in]pressureIf > 0.0f then a volume (pressure) constraint will also be added to the asset, the rest volume and stiffness will be automatically computed by this function
Returns
A pointer to an asset structure holding the particles and constraints
NV_FLEX_API NvFlexExtAsset* NvFlexExtCreateTearingClothFromMesh ( const float *  particles,
int  numParticles,
int  maxParticles,
const int *  indices,
int  numTriangles,
float  stretchStiffness,
float  bendStiffness,
float  pressure 
)

Create a cloth asset consisting of stretch and bend distance constraints given an indexed triangle mesh. This creates an asset with the same structure as NvFlexExtCreateClothFromMesh(), however tether constraints are not supported, and additional information regarding mesh topology will be stored with the asset to allow tearing.

Note
: Typically each instance of a tearable cloth mesh will have it's own asset. This is because the asset holds the topology of the mesh which is unique for each instance.
Parameters
[in]particlesPositions and masses of the particles in the format [x, y, z, 1/m]
[in]numParticlesThe number of particles
[in]maxParticlesThe maximum number of particles for this asset, this will limit the amount of tearing that can be performed.
[in]indicesThe triangle indices, these should be 'welded' using NvFlexExtCreateWeldedMeshIndices() first
[in]numTrianglesThe number of triangles
[in]stretchStiffnessThe stiffness coefficient for stretch constraints
[in]bendStiffnessThe stiffness coefficient used for bending constraints
[in]pressureIf > 0.0f then a volume (pressure) constraint will also be added to the asset, the rest volume and stiffness will be automatically computed by this function
Returns
A pointer to an asset structure holding the particles and constraints
NV_FLEX_API void NvFlexExtDestroyTearingCloth ( NvFlexExtAsset asset)

Destroy an asset created with NvFlexExtCreateTearingClothFromMesh()

Parameters
[in]assetThe asset to be destroyed.
NV_FLEX_API void NvFlexExtTearClothMesh ( NvFlexExtAsset asset,
float  maxStrain,
int  maxSplits,
NvFlexExtTearingParticleClone particleCopies,
int *  numParticleCopies,
int  maxCopies,
NvFlexExtTearingMeshEdit triangleEdits,
int *  numTriangleEdits,
int  maxEdits 
)

Perform cloth mesh tearing, this function will calculate the strain on each distance constraint and perform splits if it is above a certain strain threshold (i.e.: length/restLength > maxStrain).

Parameters
[in]assetThe asset describing the cloth constraint network, this must be created with NvFlexExtCreateTearingClothFromMesh()
[in]maxStrainThe maximum allowable strain on each edge
[in]maxSplitsThe maximum number of constraint breaks that will be performed, this controls the 'rate' of mesh tearing
[in]particleCopiesPointer to an array of NvFlexExtTearingParticleClone structures that describe the particle copies that need to be performed
[in]numParticleCopiesPointer to an integer that will have the number of copies performed written to it
[in]maxCopiesThe maximum number of particle copies that will be performed, multiple particles copies may be performed in response to one split
[in]triangleEditsPointer to an array of NvFlexExtTearingMeshEdit structures that describe the topology updates that need to be performed
[in]numTriangleEditsPointer to an integer that will have the number of topology updates written to it
[in]maxEditsThe maximum number of index buffer edits that will be output
NV_FLEX_API NvFlexExtAsset* NvFlexExtCreateRigidFromMesh ( const float *  vertices,
int  numVertices,
const int *  indices,
int  numTriangleIndices,
float  radius,
float  expand 
)

Create a shape body asset from a closed triangle mesh. The mesh is first voxelized at a spacing specified by the radius, and particles are placed at occupied voxels.

Parameters
[in]verticesVertices of the triangle mesh
[in]numVerticesThe number of vertices
[in]indicesThe triangle indices
[in]numTriangleIndicesThe number of triangles indices (triangles*3)
[in]radiusThe spacing used for voxelization, note that the number of voxels grows proportional to the inverse cube of radius, currently this method limits construction to resolutions < 64^3
[in]expandParticles will be moved inwards (if negative) or outwards (if positive) from the surface of the mesh according to this factor
Returns
A pointer to an asset structure holding the particles and constraints
NV_FLEX_API NvFlexExtAsset* NvFlexExtCreateSoftFromMesh ( const float *  vertices,
int  numVertices,
const int *  indices,
int  numTriangleIndices,
float  particleSpacing,
float  volumeSampling,
float  surfaceSampling,
float  clusterSpacing,
float  clusterRadius,
float  clusterStiffness,
float  linkRadius,
float  linkStiffness,
float  globalStiffness,
float  clusterPlasticThreshold,
float  clusterPlasticCreep 
)

Create a shape body asset from a closed triangle mesh. The mesh is first voxelized at a spacing specified by the radius, and particles are placed at occupied voxels.

Parameters
[in]verticesVertices of the triangle mesh
[in]numVerticesThe number of vertices
[in]indicesThe triangle indices
[in]numTriangleIndicesThe number of triangles indices (triangles*3)
[in]particleSpacingThe spacing to use when creating particles
[in]volumeSamplingControl the resolution the mesh is voxelized at in order to generate interior sampling, if the mesh is not closed then this should be set to zero and surface sampling should be used instead
[in]surfaceSamplingControls how many samples are taken of the mesh surface, this is useful to ensure fine features of the mesh are represented by particles, or if the mesh is not closed
[in]clusterSpacingThe spacing for shape-matching clusters, should be at least the particle spacing
[in]clusterRadiusControls the overall size of the clusters, this controls how much overlap the clusters have which affects how smooth the final deformation is, if parts of the body are detaching then it means the clusters are not overlapping sufficiently to form a fully connected set of clusters
[in]clusterStiffnessControls the stiffness of the resulting clusters
[in]linkRadiusAny particles below this distance will have additional distance constraints created between them
[in]linkStiffnessThe stiffness of distance links
[in]globalStiffnessIf this parameter is > 0.0f, adds an additional global cluster that consists of all particles in the shape. The stiffness of this cluster is the globalStiffness.
[in]clusterPlasticThresholdParticles belonging to rigid shapes that move with a position delta magnitude > threshold will be permanently deformed in the rest pose, if clusterPlasticCreep > 0.0f
[in]clusterPlasticCreepControls the rate at which particles in the rest pose are deformed for particles passing the deformation threshold
Returns
A pointer to an asset structure holding the particles and constraints
NV_FLEX_API void NvFlexExtDestroyAsset ( NvFlexExtAsset asset)

Frees all memory associated with an asset created by one of the creation methods param[in] asset The asset to destroy.

NV_FLEX_API void NvFlexExtCreateSoftMeshSkinning ( const float *  vertices,
int  numVertices,
const float *  bones,
int  numBones,
float  falloff,
float  maxDistance,
float *  skinningWeights,
int *  skinningIndices 
)

Creates information for linear blend skining a graphics mesh to a set of transforms (bones)

Parameters
[in]verticesVertices of the triangle mesh
[in]numVerticesThe number of vertices
[in]bonesPointer to an array of vec3 positions representing the bone positions
[in]numBonesThen number of bones
[in]falloffThe speed at which the bone's influence on a vertex falls off with distance
[in]maxDistanceThe maximum distance a bone can be from a vertex before it will not influence it any more
[out]skinningWeightsThe normalized weights for each bone, there are up to 4 weights per-vertex so this should be numVertices*4 in length
[out]skinningIndicesThe indices of each bone corresponding to the skinning weight, will be -1 if this weight is not used
NV_FLEX_API NvFlexExtContainer* NvFlexExtCreateContainer ( NvFlexLibrary lib,
NvFlexSolver solver,
int  maxParticles 
)

Creates a wrapper object around a Flex solver that can hold assets / instances, the container manages sending and retrieving partical data from the solver

Parameters
[in]libThe library instance to use
[in]solverThe solver to wrap
[in]maxParticlesThe maximum number of particles to manage
Returns
A pointer to the new container
NV_FLEX_API void NvFlexExtDestroyContainer ( NvFlexExtContainer container)

Frees all memory associated with a container

Parameters
[in]containerThe container to destroy
NV_FLEX_API int NvFlexExtAllocParticles ( NvFlexExtContainer container,
int  n,
int *  indices 
)

Allocates particles in the container.

Parameters
[in]containerThe container to allocate out of
[in]nThe number of particles to allocate
[out]indicesAn n-length array of ints that will store the indices to the allocated particles
NV_FLEX_API void NvFlexExtFreeParticles ( NvFlexExtContainer container,
int  n,
const int *  indices 
)

Free allocated particles

Parameters
[in]containerThe container to free from
[in]nThe number of particles to free
[in]indicesThe indices of the particles to free
NV_FLEX_API int NvFlexExtGetActiveList ( NvFlexExtContainer container,
int *  indices 
)

Retrives the indices of all active particles

Parameters
[in]containerThe container to free from
[out]indicesReturns the number of active particles
Returns
The number of active particles
NV_FLEX_API NvFlexExtParticleData NvFlexExtMapParticleData ( NvFlexExtContainer container)

Returns pointers to the internal data stored by the container. These are host-memory pointers, and will remain valid NvFlexExtUnmapParticleData() is called.

Parameters
containerThe container whose data should be accessed
NV_FLEX_API void NvFlexExtUnmapParticleData ( NvFlexExtContainer container)
NV_FLEX_API NvFlexExtTriangleData NvFlexExtMapTriangleData ( NvFlexExtContainer container)

Access triangle constraint data, see NvFlexExtGetParticleData() for notes on ownership.

Parameters
containerThe container to retrive from
NV_FLEX_API void NvFlexExtUnmapTriangleData ( NvFlexExtContainer container)

Unmap triangle data, see NvFlexExtMapTriangleData()

NV_FLEX_API NvFlexExtShapeData NvFlexExtMapShapeData ( NvFlexExtContainer container)

Access shape body constraint data, see NvFlexExtGetParticleData() for notes on ownership.

Parameters
containerThe container to retrive from
NV_FLEX_API void NvFlexExtUnmapShapeData ( NvFlexExtContainer container)

Unmap shape transform data, see NvFlexExtMapShapeData()

NV_FLEX_API NvFlexExtInstance* NvFlexExtCreateInstance ( NvFlexExtContainer container,
NvFlexExtParticleData particleData,
const NvFlexExtAsset asset,
const float *  transform,
float  vx,
float  vy,
float  vz,
int  phase,
float  invMassScale 
)

Creates an instance of an asset, the container will internally store a reference to the asset so it should remain valid for the instance lifetime. This method will allocate particles for the asset, assign their initial positions, velocity and phase.

Parameters
[in]containerThe container to spawn into
[in]particleDataPointer to a mapped particle data struct, returned from NvFlexExtMapParticleData()
[in]assetThe asset to be spawned
[in]transformA pointer to a 4x4 column major, column vector transform that specifies the initial world space configuration of the particles
[in]vxThe velocity of the particles along the x axis
[in]vyThe velocity of the particles along the y axis
[in]vzThe velocity of the particles along the z axis
[in]phaseThe phase used for the particles
[in]invMassScaleA factor applied to the per particle inverse mass
Returns
A pointer to the instance of the asset
NV_FLEX_API void NvFlexExtDestroyInstance ( NvFlexExtContainer container,
const NvFlexExtInstance instance 
)

Destoy an instance of an asset

Parameters
[in]containerThe container the instance belongs to
[in]instanceThe instance to destroy
NV_FLEX_API void NvFlexExtNotifyAssetChanged ( NvFlexExtContainer container,
const NvFlexExtAsset asset 
)

Notifies the container that asset data has changed and needs to be sent to the GPU this should be called if the constraints for an existing asset are modified by the user

Parameters
[in]containerThe container the instance referencing the asset belongs to
[in]assetThe asset which was modified (can be NULL)
NV_FLEX_API void NvFlexExtTickContainer ( NvFlexExtContainer container,
float  dt,
int  numSubsteps,
bool  enableTimers = false 
)

Updates the container, applies force fields, steps the solver forward in time, updates the host with the results synchronously. This is a helper function which performs a synchronous update using the following flow.

// async update GPU data
// update solver
NvFlexUpdateSolver(container, dt, iterations);
// async read data back to CPU
// read / write particle data on CPU
// CPU particle processing
ProcessParticles(data);
// unmap data
Parameters
[in]containerThe container to update
[in]dtThe time-step in seconds
[in]numSubstepsThe number of substeps to perform
[in]enableTimersWhether to record detailed timers, see NvFlexUpdateSolver()
NV_FLEX_API void NvFlexExtPushToDevice ( NvFlexExtContainer container)

Updates the device asynchronously, transfers any particle and constraint changes to the flex solver, expected to be called in the following sequence: NvFlexExtPushToDevice, NvFlexUpdateSolver, NvFlexExtPullFromDevice, flexSynchronize

Parameters
[in]containerThe container to update
NV_FLEX_API void NvFlexExtPullFromDevice ( NvFlexExtContainer container)

Updates the host asynchronously, transfers particle and constraint data back to he host, expected to be called in the following sequence: NvFlexExtPushToDevice, NvFlexUpdateSolver, NvFlexExtPullFromDevice

Parameters
[in]containerThe container to update
NV_FLEX_API void NvFlexExtUpdateInstances ( NvFlexExtContainer container)

Synchronizes the per-instance data with the container's data, should be called after the synchronization with the solver read backs are complete

Parameters
[in]containerThe instances belonging to this container will be updated
NV_FLEX_API NvFlexExtForceFieldCallback* NvFlexExtCreateForceFieldCallback ( NvFlexSolver solver)

Create a NvFlexExtForceFieldCallback structure, each callback is associated with the passed in solver once the NvFlexExtSetForceFields() is called.

Parameters
[in]solverA valid solver created with NvFlexCreateSolver()
Returns
A pointer to a callback structure
NV_FLEX_API void NvFlexExtDestroyForceFieldCallback ( NvFlexExtForceFieldCallback callback)

Destroy the force field callback

Parameters
[in]callbackA valid solver created with NvFlexExtCreateForceFieldCallback()
NV_FLEX_API void NvFlexExtSetForceFields ( NvFlexExtForceFieldCallback callback,
const NvFlexExtForceField forceFields,
int  numForceFields 
)

Set force fields on the container, these will be applied during the Flex update

Parameters
[in]callbackThe callback to update
[in]forceFieldsA pointer to an array of force field data, may be host or GPU memory
[in]numForceFieldsThe number of force fields to send to the device