flexExt.h

Go to the documentation of this file.

// This code contains NVIDIA Confidential Information and is disclosed to you
// under a form of NVIDIA software license agreement provided separately to you.
//
// Notice
// NVIDIA Corporation and its licensors retain all intellectual property and
// proprietary rights in and to this software and related documentation and
// any modifications thereto. Any use, reproduction, disclosure, or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA Corporation is strictly prohibited.
//
// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
//
// Information and code furnished is believed to be accurate and reliable.
// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2013-2015 NVIDIA Corporation. All rights reserved.


#ifndef FLEX_EXT_H
#define FLEX_EXT_H

#if _WIN32
#define FLEX_API __declspec(dllexport)
#else
#define FLEX_API
#endif


extern "C" {

struct FlexExtAsset
{   
    // particles
    float* mParticles;              
    int mNumParticles;              

    // springs
    int* mSpringIndices;            
    float* mSpringCoefficients;     
    float* mSpringRestLengths;      
    int mNumSprings;                

    // rigid body stiffness
    float mRigidStiffness;          
    float mRigidCenter[3];          

    // faces for cloth
    int* mTriangleIndices;          
    int mNumTriangles;              

    // inflatable params
    bool mInflatable;               
    float mInflatableVolume;        
    float mInflatablePressure;      
    float mInflatableStiffness;     
};

struct FlexExtInstance
{
    int* mParticleIndices;          
    int mNumParticles;              
    
    int mTriangleIndex;             
    int mRigidIndex;                
    int mInflatableIndex;           
    
    const FlexExtAsset* mAsset;     
    
    void* mUserData;                
};

enum FlexForceExtMode
{
    eFlexExtModeForce           =      0,

    eFlexExtModeImpulse         =      1,

    eFlexExtModeVelocityChange  =      2,
};

struct FlexExtForceField
{
    float mPosition[3];     
    float mRadius;          
    float mStrength;        
    FlexForceExtMode mMode;     
    bool mLinearFalloff;    
};

struct FlexExtContainer;

FLEX_API int flexExtCreateWeldedMeshIndices(const float* vertices, int numVertices, int* uniqueVerts, int* originalToUniqueMap, float threshold);

FLEX_API FlexExtAsset* flexExtCreateClothFromMesh(const float* particles, int numVertices, const int* indices, int numTriangles, float stretchStiffness, float bendStiffness, float tetherStiffness, float tetherGive, float pressure);

FLEX_API FlexExtAsset* flexExtCreateRigidFromMesh(const float* vertices, int numVertices, const int* indices, int numTriangleIndices, float radius);

FLEX_API void flexExtDestroyAsset(FlexExtAsset* asset);

FLEX_API FlexExtContainer* flexExtCreateContainer(FlexSolver* solver, int maxParticles);

FLEX_API void flexExtDestroyContainer(FlexExtContainer* container);

FLEX_API int  flexExtAllocParticles(FlexExtContainer* container, int n, int* indices);

FLEX_API void flexExtFreeParticles(FlexExtContainer* container, int n, const int* indices);

FLEX_API int flexExtGetActiveList(FlexExtContainer* container, int* indices);

FLEX_API FlexExtInstance* flexExtCreateInstance(FlexExtContainer* container, const FlexExtAsset* asset, const float* transform, float vx, float vy, float vz, int phase, float invMassScale);

FLEX_API void flexExtDestroyInstance(FlexExtContainer* container, const FlexExtInstance* instance);

FLEX_API void flexExtGetParticleData(FlexExtContainer* container, float** particles, float** velocities, int** phases, float** normals);

FLEX_API void flexExtGetTriangleData(FlexExtContainer* container, int** indices, float** normals);

FLEX_API void flexExtGetRigidData(FlexExtContainer* container, float** rotations, float** positions);

FLEX_API void flexExtTickContainer(FlexExtContainer* container, float dt, int numSubsteps, FlexTimers* timers=NULL);

FLEX_API void flexExtPushToDevice(FlexExtContainer* container);

FLEX_API void flexExtPullFromDevice(FlexExtContainer* container);

/*
 * Set force fields on the container
 * @param[in] container The container to update
 * @param[in] forceFields A pointer to an array of force field data, may be host or GPU memory
 * @param[in] numForceFields The number of force fields to send to the device
 * @param[in] source The memory space to copy the force fields from
 */
FLEX_API void flexExtSetForceFields(FlexExtContainer* container, const FlexExtForceField* forceFields, int numForceFields, FlexMemory source);

/*
 * Evaluate force fields and update particle velocities
 * expected to be called in the following sequence: flexExtPushToDevice, flexExtApplyForceFields, flexUpdateSolver, flexExtPullFromDevice, flexSynchronize
 * @param[in] container The container to update
 * @param[in] dt The time-step in seconds
 */
FLEX_API void flexExtApplyForceFields(FlexExtContainer* container, float dt);

} // extern "C"

#endif // FLEX_EXT_H