flex.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_H
#define FLEX_H

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

// least 2 significant digits define minor version, eg: 10 -> version 0.10
#define FLEX_VERSION 26


extern "C" {

struct FlexSolver;

enum FlexRelaxationMode
{
    eFlexRelaxationGlobal = 0,          
    eFlexRelaxationLocal  = 1           
};

struct FlexParams
{
    int mNumIterations;                 

    float mGravity[3];                  
    float mRadius;                      
    float mSolidRestDistance;           
    float mFluidRestDistance;           

    // common params
    float mDynamicFriction;             
    float mStaticFriction;              
    float mParticleFriction;            
    float mRestitution;                 
    float mAdhesion;                    
    float mSleepThreshold;              
    float mMaxVelocity;                 
    float mShockPropagation;            
    float mDissipation;                 
    float mDamping;                     
    float mEnableCCD;                   
    
    // cloth params
    float mWind[3];                     
    float mDrag;                        
    float mLift;                        

    // fluid params
    bool mFluid;                        
    float mCohesion;                    
    float mSurfaceTension;              
    float mViscosity;                   
    float mVorticityConfinement;        
    float mAnisotropyScale;             
    float mSmoothing;                   
    float mSolidPressure;               
    float mFreeSurfaceDrag;             
    float mBuoyancy;                    

    // diffuse params
    float mDiffuseThreshold;            
    float mDiffuseBuoyancy;             
    float mDiffuseDrag;                 
    int mDiffuseBallistic;              
    float mDiffuseSortAxis[3];          

    // rigid params
    float mPlasticThreshold;            
    float mPlasticCreep;                

    // collision params
    float mCollisionDistance;           
    float mParticleCollisionMargin;     
    float mShapeCollisionMargin;        

    float mPlanes[8][4];                
    int mNumPlanes;                     

    FlexRelaxationMode mRelaxationMode; 
    float mRelaxationFactor;            
};

enum FlexPhase
{
    eFlexPhaseGroupMask = 0x00ffffff,       

    eFlexPhaseSelfCollide = 1 << 24,    
    eFlexPhaseFluid = 1 << 25,          
};

FLEX_API inline int flexMakePhase(int group, int flags) { return (group & eFlexPhaseGroupMask) | flags; }

struct FlexSDF
{
    float mLower[3];                    
    float mUpper[3];                    
    float mInvEdgeLength[3];            

    unsigned int mWidth;                
    unsigned int mHeight;               
    unsigned int mDepth;                

    const float* mField;                
};


struct FlexTimers
{
    float mPredict;                     
    float mCreateCellIndices;           
    float mSortCellIndices;             
    float mCreateGrid;                  
    float mReorder;                     
    float mCollideParticles;            
    float mCollideConvexes;             
    float mCollideTriangles;            
    float mCollideFields;               
    float mCalculateDensity;            
    float mSolveDensities;              
    float mSolveVelocities;             
    float mSolveShapes;                 
    float mSolveSprings;                
    float mSolveContacts;               
    float mSolveInflatables;            
    float mCalculateAnisotropy;         
    float mUpdateDiffuse;               
    float mUpdateTriangles;             
    float mUpdateNormals;               
    float mFinalize;                    
    float mUpdateBounds;                
    float mTotal;                       
};


enum FlexError
{
    eFlexErrorNone              = 0,

    eFlexErrorWrongVersion      = 1,

    eFlexErrorInsufficientGPU   = 2,
};
  

enum FlexMemory
{
    eFlexMemoryHost                 = 0,        

    eFlexMemoryDevice               = 1,

    eFlexMemoryHostAsync            = 2,

    eFlexMemoryDeviceAsync          = 3
};

typedef void (*FlexErrorCallback)(const char* msg, const char* file, int line);

FLEX_API FlexError flexInit(int version=FLEX_VERSION, FlexErrorCallback errorFunc=NULL);

FLEX_API void flexShutdown();

FLEX_API int flexGetVersion();

FLEX_API FlexSolver* flexCreateSolver(int maxParticles, int maxDiffuseParticles, unsigned char maxNeighborsPerParticle = 96);
FLEX_API void flexDestroySolver(FlexSolver* s);

FLEX_API void flexUpdateSolver(FlexSolver* s, float dt, int substeps, FlexTimers* timers);

FLEX_API void flexSetParams(FlexSolver* s, const FlexParams* params);

FLEX_API void flexSetActive(FlexSolver* s, const int* indices, int n, FlexMemory source);

FLEX_API void flexGetActive(FlexSolver* s, int* indices, FlexMemory target);

FLEX_API int flexGetActiveCount(FlexSolver* s);

FLEX_API void flexSetParticles(FlexSolver* s, const float* p, int n, FlexMemory source);
FLEX_API void flexGetParticles(FlexSolver* s, float* p, int n, FlexMemory target);

FLEX_API void flexGetSmoothParticles(FlexSolver* s, float* p, int n, FlexMemory target);

FLEX_API void flexSetVelocities(FlexSolver* s, const float* v, int n, FlexMemory source);
FLEX_API void flexGetVelocities(FlexSolver* s, float* v, int n, FlexMemory target);

FLEX_API void flexSetPhases(FlexSolver* s, const int* phases, int n, FlexMemory source);
FLEX_API void flexGetPhases(FlexSolver* s, int* phases, int n, FlexMemory target);

FLEX_API void flexSetSprings(FlexSolver* s, const int* indices, const float* restLengths, const float* stiffness, int numSprings, FlexMemory source);
FLEX_API void flexGetSprings(FlexSolver* s, int* indices, float* restLengths, float* stiffness, int numSprings, FlexMemory target);

FLEX_API void flexSetRigids(FlexSolver* s, const int* offsets, const int* indices, const float* restPositions, const float* restNormals, const float* stiffness, const float* rotations, int numRigids, FlexMemory source);

FLEX_API void flexSetNormals(FlexSolver* s, const float* normals, int n, FlexMemory source);

FLEX_API void flexGetNormals(FlexSolver* s, float* normals, int n, FlexMemory target);

FLEX_API void flexGetRigidTransforms(FlexSolver* s, float* rotations, float* translations, FlexMemory target);

FLEX_API void flexSetConvexes (FlexSolver* s, const float* aabbMin, const float* aabbMax, const int* planeOffsets, const int* planeCounts, const float* planes, const float* positions, const float* rotations, const float* prevPositions, const float* prevRotations, const int* flags, int numConvexes, int numPlanes, FlexMemory source);
FLEX_API void flexSetTriangles(FlexSolver* s, const int* indices, const float* vertices, int numTris, int numVertices, float cellSize, FlexMemory source);  
FLEX_API void flexSetFields(FlexSolver* s, const FlexSDF* shapes, int numShapes);

FLEX_API void flexSetDynamicTriangles(FlexSolver* s, const int* indices, const float* normals, int numTris, FlexMemory source);
FLEX_API void flexGetDynamicTriangles(FlexSolver* s, int* indices, float* normals, int numTris, FlexMemory target);

FLEX_API void flexSetInflatables(FlexSolver* s, const int* startTris, const int* numTris, float* restVolumes, float* overPressures, float* constraintScales, int numInflatables, FlexMemory source);

FLEX_API void flexGetDensities(FlexSolver* s, float* densities, FlexMemory target);
FLEX_API void flexGetAnisotropy(FlexSolver* s, float* q1, float* q2, float* q3, FlexMemory target);
FLEX_API int flexGetDiffuseParticles(FlexSolver* s, float* p, float* v, int* indices, FlexMemory target);   
FLEX_API void flexSetDiffuseParticles(FlexSolver* s, const float* p, const float* v, int n, FlexMemory source);

FLEX_API void flexGetContacts(FlexSolver* s, float* planes, int* indices, unsigned char* counts, FlexMemory target);

FLEX_API void flexGetBounds(FlexSolver* s, float* lower, float* upper);

FLEX_API void* flexAlloc(int size);

FLEX_API void flexFree(void* ptr);

FLEX_API void flexSetFence();

FLEX_API void flexWaitFence();


FLEX_API void flexSetDebug(FlexSolver* s, bool enable);
FLEX_API void flexGetConvexGrid(FlexSolver* s, int* grid, float* lower, float* upper, int* axis);
FLEX_API void flexGetStaticTriangleGrid(FlexSolver* s, int* counts, float* lower, float* cellEdge);
FLEX_API void flexStartRecord(FlexSolver* s, const char* file);
FLEX_API void flexStopRecord(FlexSolver* s);


} // extern "C"

#endif // FLEX_H