498 lines
22 KiB
C++
498 lines
22 KiB
C++
// 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) 2008-2025 NVIDIA Corporation. All rights reserved.
|
|
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
|
|
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
|
|
|
|
#include "PxgPhysXGpu.h"
|
|
#include "PxgMemoryManager.h"
|
|
#include "PxgHeapMemAllocator.h"
|
|
#include "PxgKernelWrangler.h"
|
|
#include "PxgCudaBroadPhaseSap.h"
|
|
#include "PxgAABBManager.h"
|
|
#include "PxgNphaseImplementationContext.h"
|
|
#include "PxgSimulationController.h"
|
|
#include "PxgArticulationCore.h"
|
|
#include "PxgDynamicsContext.h"
|
|
#include "PxgTGSDynamicsContext.h"
|
|
#include "CudaKernelWrangler.h"
|
|
#include "CudaContextManager.h"
|
|
#include "PhysXDeviceSettings.h"
|
|
#include "PxgBroadPhase.h"
|
|
#include "PxgCommon.h"
|
|
#include "PxgNarrowphase.h"
|
|
#include "PxgSolver.h"
|
|
#include "foundation/PxFoundation.h"
|
|
#include "PxgPBDParticleSystemCore.h"
|
|
#include "PxgArrayConverter.h"
|
|
#include "PxgSDFBuilder.h"
|
|
#include "PxgDeformableSkinning.h"
|
|
#include "PxsTransformCache.h"
|
|
|
|
#include "PxgKernelLauncher.h"
|
|
#include "PxgIsosurfaceExtraction.h"
|
|
#include "PxgAnisotropy.h"
|
|
#include "PxgSmoothing.h"
|
|
#include "PxgParticleNeighborhoodProvider.h"
|
|
#include "gpu/PxPhysicsGpu.h"
|
|
|
|
using namespace physx;
|
|
|
|
PxgPhysXGpu* PxgPhysXGpu::sInstance = NULL;
|
|
|
|
//----------------------------------------------------------------------------//
|
|
void PxGpuReleasePhysicsGpu();
|
|
|
|
void PxgPhysXGpu::release()
|
|
{
|
|
for(KernelWranglerMap::Iterator iter = mKernelWranglerInstances.getIterator(); !iter.done(); ++iter)
|
|
{
|
|
if(iter->second)
|
|
{
|
|
PX_DELETE(iter->second);
|
|
}
|
|
}
|
|
|
|
mKernelWranglerInstances.clear();
|
|
|
|
PX_DELETE_THIS;
|
|
sInstance = NULL;
|
|
|
|
PxGpuReleasePhysicsGpu();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
|
|
PxgPhysXGpu& PxgPhysXGpu::getInstance()
|
|
{
|
|
if (!PxgPhysXGpu::sInstance)
|
|
PxgPhysXGpu::sInstance = PX_NEW(PxgPhysXGpu);
|
|
|
|
return *PxgPhysXGpu::sInstance;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
|
|
PxsParticleBuffer* PxgPhysXGpu::createParticleBuffer(PxU32 maxNumParticles, PxU32 maxVolumes, PxCudaContextManager& cudaContextManager)
|
|
{
|
|
PxgParticleBuffer* particleBuffer = PX_NEW(PxgParticleBuffer)(maxNumParticles, maxVolumes, cudaContextManager);
|
|
return static_cast<PxsParticleBuffer*>(particleBuffer);
|
|
}
|
|
|
|
PxsParticleAndDiffuseBuffer* PxgPhysXGpu::createParticleAndDiffuseBuffer(const PxU32 maxParticles, PxU32 maxVolumes, PxU32 maxDiffuseParticles, PxCudaContextManager& cudaContextManager)
|
|
{
|
|
PxgParticleAndDiffuseBuffer* diffuseBuffer = PX_NEW(PxgParticleAndDiffuseBuffer)(maxParticles, maxVolumes, maxDiffuseParticles, cudaContextManager);
|
|
return static_cast<PxsParticleAndDiffuseBuffer*>(diffuseBuffer);
|
|
}
|
|
|
|
PxsParticleClothBuffer* PxgPhysXGpu::createParticleClothBuffer(PxU32 maxNumParticles, PxU32 maxVolumes, PxU32 maxNumCloths, PxU32 maxNumTriangles, PxU32 maxNumSprings, PxCudaContextManager& cudaContextManager)
|
|
{
|
|
PxgParticleClothBuffer* clothBuffer = PX_NEW(PxgParticleClothBuffer)(maxNumParticles, maxVolumes, maxNumCloths, maxNumTriangles, maxNumSprings, cudaContextManager);
|
|
return static_cast<PxsParticleClothBuffer*>(clothBuffer);
|
|
}
|
|
|
|
PxsParticleRigidBuffer* PxgPhysXGpu::createParticleRigidBuffer(PxU32 maxNumParticles, PxU32 maxVolumes, PxU32 maxNumRigids, PxCudaContextManager& cudaContextManager)
|
|
{
|
|
PxgParticleRigidBuffer* rigidBuffer = PX_NEW(PxgParticleRigidBuffer)(maxNumParticles, maxVolumes, maxNumRigids, cudaContextManager);
|
|
return static_cast<PxsParticleRigidBuffer*>(rigidBuffer);
|
|
}
|
|
|
|
PxsMemoryManager* PxgPhysXGpu::createGpuMemoryManager(PxCudaContextManager* cudaContextManager)
|
|
{
|
|
return createPxgMemoryManager(cudaContextManager);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
|
|
PxsHeapMemoryAllocatorManager* PxgPhysXGpu::createGpuHeapMemoryAllocatorManager(const PxU32 heapCapacity, PxsMemoryManager* memoryManager, const PxU32 /*gpuComputeVersion*/)
|
|
{
|
|
return PX_NEW(PxgHeapMemoryAllocatorManager)(heapCapacity, memoryManager);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
|
|
PxsKernelWranglerManager* PxgPhysXGpu::getGpuKernelWranglerManager(PxCudaContextManager* cudaContextManager)
|
|
{
|
|
if (!cudaContextManager)
|
|
return NULL;
|
|
|
|
|
|
const KernelWranglerMap::Entry* entry = mKernelWranglerInstances.find(cudaContextManager);
|
|
if(entry)
|
|
return entry->second;
|
|
|
|
PxgCudaKernelWranglerManager* wrangler = PX_NEW(PxgCudaKernelWranglerManager)(*cudaContextManager, *PxGetErrorCallback());
|
|
mKernelWranglerInstances.insert(cudaContextManager, wrangler);
|
|
return wrangler;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
|
|
Bp::BroadPhase* PxgPhysXGpu::createGpuBroadPhase(const PxGpuBroadPhaseDesc& desc, PxsKernelWranglerManager* gpuKernelWrangler, PxCudaContextManager* cudaContextManager,
|
|
PxU32 gpuComputeVersion, const PxGpuDynamicsMemoryConfig& config,
|
|
PxsHeapMemoryAllocatorManager* heapMemoryManager, PxU64 contextID)
|
|
{
|
|
if (gpuComputeVersion == 0)
|
|
{
|
|
return PX_PLACEMENT_NEW(PX_ALLOC(sizeof(PxgCudaBroadPhaseSap), "PxgCudaBroadPhaseSap"), PxgCudaBroadPhaseSap)(desc,
|
|
static_cast<PxgCudaKernelWranglerManager*>(gpuKernelWrangler), cudaContextManager, config, static_cast<PxgHeapMemoryAllocatorManager*>(heapMemoryManager), contextID);
|
|
}
|
|
else
|
|
{
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
|
|
Bp::AABBManagerBase* PxgPhysXGpu::createGpuAABBManager(
|
|
PxsKernelWranglerManager* gpuKernelWrangler,
|
|
PxCudaContextManager* cudaContextManager,
|
|
const PxU32 gpuComputeVersion,
|
|
const PxGpuDynamicsMemoryConfig& config,
|
|
PxsHeapMemoryAllocatorManager* heapMemoryManager,
|
|
Bp::BroadPhase& bp,
|
|
Bp::BoundsArray& boundsArray,
|
|
PxFloatArrayPinned& contactDistance,
|
|
PxU32 maxNbAggregates, PxU32 maxNbShapes,
|
|
PxVirtualAllocator& allocator,
|
|
PxU64 contextID,
|
|
PxPairFilteringMode::Enum kineKineFilteringMode,
|
|
PxPairFilteringMode::Enum staticKineFilteringMode)
|
|
{
|
|
if (gpuComputeVersion == 0)
|
|
{
|
|
return PX_PLACEMENT_NEW(PX_ALLOC(sizeof(PxgAABBManager), "PxgAABBManager"), PxgAABBManager)(
|
|
static_cast<PxgCudaKernelWranglerManager*>(gpuKernelWrangler), cudaContextManager, static_cast<PxgHeapMemoryAllocatorManager*>(heapMemoryManager),
|
|
config, bp, boundsArray, contactDistance, maxNbAggregates,maxNbShapes, allocator, contextID, kineKineFilteringMode, staticKineFilteringMode);
|
|
}
|
|
else
|
|
{
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
|
|
Bp::BoundsArray* PxgPhysXGpu::createGpuBounds( PxVirtualAllocator& allocator)
|
|
{
|
|
return PX_PLACEMENT_NEW(PX_ALLOC(sizeof(PxgBoundsArray), "PxgBoundsArray"), PxgBoundsArray)(allocator);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
|
|
PxvNphaseImplementationContext* PxgPhysXGpu::createGpuNphaseImplementationContext(PxsContext& context,
|
|
PxsKernelWranglerManager* gpuKernelWrangler,
|
|
PxvNphaseImplementationFallback* fallbackForUnsupportedCMs,
|
|
const PxGpuDynamicsMemoryConfig& gpuDynamicsConfig,
|
|
void* contactStreamBase, void* patchStreamBase, void* forceAndIndiceStreamBase,
|
|
PxBoundsArrayPinned& bounds, IG::IslandSim* islandSim, Dy::Context* dynamicsContext,
|
|
const PxU32 /*gpuComputeVersion*/, PxsHeapMemoryAllocatorManager* heapMemoryManager, bool useGPUBP)
|
|
{
|
|
return PX_PLACEMENT_NEW(PX_ALLOC(sizeof(PxgNphaseImplementationContext), "PxgNphaseImplementationContext"), PxgNphaseImplementationContext)(context, gpuKernelWrangler, fallbackForUnsupportedCMs, gpuDynamicsConfig, contactStreamBase, patchStreamBase, forceAndIndiceStreamBase,
|
|
bounds, islandSim, dynamicsContext, static_cast<PxgHeapMemoryAllocatorManager*>(heapMemoryManager), useGPUBP);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
|
|
PxsSimulationController* PxgPhysXGpu::createGpuSimulationController(PxsKernelWranglerManager* gpuWranglerManagers, PxCudaContextManager* cudaContextManager,
|
|
Dy::Context* dynamicContext, PxvNphaseImplementationContext* npContext,
|
|
Bp::BroadPhase* bp, const bool useGpuBroadphase, PxsSimulationControllerCallback* callback,
|
|
const PxU32 /*gpuComputeVersion*/, PxsHeapMemoryAllocatorManager* heapMemoryManager, const PxU32 maxSoftBodyContacts, const PxU32 maxFemClothContacts,
|
|
const PxU32 maxParticleContacts, const PxU32 collisionStackSizeBytes, bool enableBodyAccelerations)
|
|
{
|
|
return PX_PLACEMENT_NEW(PX_ALLOC(sizeof(PxgSimulationController), "PxgSimulationController"),
|
|
PxgSimulationController)(gpuWranglerManagers, cudaContextManager, static_cast<PxgDynamicsContext*>(dynamicContext), static_cast<PxgNphaseImplementationContext*>(npContext),
|
|
bp, useGpuBroadphase, callback, static_cast<PxgHeapMemoryAllocatorManager*>(heapMemoryManager), maxSoftBodyContacts,
|
|
maxFemClothContacts, maxParticleContacts, collisionStackSizeBytes, enableBodyAccelerations);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
|
|
Dy::Context* PxgPhysXGpu::createGpuDynamicsContext(Cm::FlushPool& taskPool, PxsKernelWranglerManager* gpuKernelWrangler, PxCudaContextManager* cudaContextManager,
|
|
const PxGpuDynamicsMemoryConfig& config, IG::SimpleIslandManager& islandManager, PxU32 maxNumPartitions, PxU32 maxNumStaticPartitions, bool enableStabilization,
|
|
bool useEnhancedDeterminism, PxReal maxBiasCoefficient, PxU32 /*gpuComputeVersion*/, PxvSimStats& simStats, PxsHeapMemoryAllocatorManager* heapMemoryManager,
|
|
bool frictionEveryIteration, bool externalForcesEveryTgsIterationEnabled, PxSolverType::Enum solverType, PxReal lengthScale, bool enableDirectGPUAPI, PxU64 contextID, bool isResidualReportingEnabled)
|
|
{
|
|
if(solverType == PxSolverType::eTGS)
|
|
return PX_PLACEMENT_NEW(PX_ALLOC(sizeof(PxgTGSDynamicsContext), "PxgDynamicsContext"), PxgTGSDynamicsContext)(taskPool, gpuKernelWrangler, cudaContextManager, config, islandManager,
|
|
maxNumPartitions, maxNumStaticPartitions, enableStabilization, useEnhancedDeterminism, maxBiasCoefficient, simStats,
|
|
static_cast<PxgHeapMemoryAllocatorManager*>(heapMemoryManager), externalForcesEveryTgsIterationEnabled, lengthScale, enableDirectGPUAPI, contextID, isResidualReportingEnabled);
|
|
else
|
|
return PX_PLACEMENT_NEW(PX_ALLOC(sizeof(PxgDynamicsContext), "PxgDynamicsContext"), PxgDynamicsContext)(taskPool, gpuKernelWrangler, cudaContextManager, config, islandManager,
|
|
maxNumPartitions, maxNumStaticPartitions, enableStabilization, useEnhancedDeterminism, maxBiasCoefficient, simStats,
|
|
static_cast<PxgHeapMemoryAllocatorManager*>(heapMemoryManager), frictionEveryIteration, lengthScale, enableDirectGPUAPI, contextID, isResidualReportingEnabled);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
// Implementation of exported functions
|
|
//----------------------------------------------------------------------------//
|
|
|
|
PxPhysXGpu* PxCreatePhysXGpu()
|
|
{
|
|
createPxgBroadphase();
|
|
createPxgCommon();
|
|
createPxgNarrowphase();
|
|
createPxgSimulationController();
|
|
createPxgArticulation();
|
|
createPxgSolver();
|
|
return &PxgPhysXGpu::getInstance();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
|
|
physx::PxCudaContextManager* PxCreateCudaContextManager(physx::PxFoundation& foundation, const physx::PxCudaContextManagerDesc& desc, physx::PxProfilerCallback* profilerCallback, bool launchSynchronous)
|
|
{
|
|
//this is only necessary for static lib configs with PhysXGpu still being a shared lib.
|
|
PxSetFoundationInstance(foundation);
|
|
|
|
PxSetProfilerCallback(profilerCallback);
|
|
|
|
return physx::createCudaContextManager(desc, foundation.getErrorCallback(), launchSynchronous);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
|
|
void PxSetPhysXGpuProfilerCallback(physx::PxProfilerCallback* profilerCallback)
|
|
{
|
|
PxSetProfilerCallback(profilerCallback);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
|
|
void PxSetPhysXGpuFoundationInstance(physx::PxFoundation& foundation)
|
|
{
|
|
PxSetFoundationInstance(foundation);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
|
|
int PxGetSuggestedCudaDeviceOrdinal(physx::PxErrorCallback& errc)
|
|
{
|
|
return physx::PhysXDeviceSettings::getSuggestedCudaDeviceOrdinal(errc);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|
|
static const PxU32 s_maxNumFunctions = 1024; // Max number of kernel entry points
|
|
static PxKernelIndex s_FunctionTable[s_maxNumFunctions];
|
|
static PxU32 s_numFunctions = 0;
|
|
|
|
void PxGpuCudaRegisterFunction(int moduleIndex, const char* functionName)
|
|
{
|
|
if(s_numFunctions < s_maxNumFunctions)
|
|
{
|
|
s_FunctionTable[s_numFunctions].moduleIndex = moduleIndex;
|
|
s_FunctionTable[s_numFunctions].functionName = functionName;
|
|
s_numFunctions++;
|
|
}
|
|
else
|
|
{
|
|
if(PxIsFoundationValid()) // error callback requires foundation
|
|
PxGetErrorCallback()->reportError(PxErrorCode::eINTERNAL_ERROR, "Too many cuda kernels registered. Increase maxNumFunctions limit.", PX_FL);
|
|
else
|
|
fprintf(stderr, "Too many cuda kernels registered. Increase maxNumFunctions limit. (%s:%i)\n", PX_FL);
|
|
}
|
|
}
|
|
|
|
PxKernelIndex* PxGpuGetCudaFunctionTable()
|
|
{
|
|
return s_FunctionTable;
|
|
}
|
|
|
|
PxU32 PxGpuGetCudaFunctionTableSize()
|
|
{
|
|
return s_numFunctions;
|
|
}
|
|
|
|
static PxU32 s_numModules = 0;
|
|
static const PxU32 s_maxNumModules = 128; // max number of *.cu files
|
|
static void* s_moduleTable[s_maxNumModules];
|
|
|
|
void** PxGpuCudaRegisterFatBinary(void* fatBin)
|
|
{
|
|
//HACK to get real fatbin in CUDA 4.0
|
|
struct CUIfatbinStruct
|
|
{
|
|
int magic;
|
|
int version;
|
|
void *fatbinArray;
|
|
char *fatbinFile;
|
|
};
|
|
const CUIfatbinStruct *fatbinStruct = (const CUIfatbinStruct *)fatBin;
|
|
if (fatbinStruct->magic == 0x466243B1)
|
|
{
|
|
fatBin = fatbinStruct->fatbinArray;
|
|
}
|
|
|
|
|
|
if (s_numModules < s_maxNumModules)
|
|
{
|
|
s_moduleTable[s_numModules] = fatBin;
|
|
|
|
// what we return here will be the value that is passed in as moduleIndex
|
|
// in PxGpuCudaRegisterFunction. We simply use the index into s_moduleTable
|
|
// as a handle
|
|
return (void**)(size_t) s_numModules++;
|
|
}
|
|
else
|
|
{
|
|
if(PxIsFoundationValid()) // error callback requires foundation
|
|
PxGetErrorCallback()->reportError(PxErrorCode::eINTERNAL_ERROR, "Too many cuda modules registered. Increase maxNumModules limit.", PX_FL);
|
|
else
|
|
fprintf(stderr, "Too many cuda modules registered. Increase maxNumModules limit. (%s:%i)\n", PX_FL);
|
|
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void** PxGpuGetCudaModuleTable()
|
|
{
|
|
return s_moduleTable;
|
|
}
|
|
|
|
PxU32 PxGpuGetCudaModuleTableSize()
|
|
{
|
|
return s_numModules;
|
|
}
|
|
|
|
|
|
|
|
|
|
class PxgPhysicsGpu : public PxPhysicsGpu, public PxUserAllocated
|
|
{
|
|
public:
|
|
PxgPhysicsGpu() {}
|
|
|
|
virtual PxIsosurfaceExtractor* createDenseGridIsosurfaceExtractor(PxCudaContextManager* cudaContextManager, const PxBounds3& worldBounds,
|
|
PxReal cellSize, const PxIsosurfaceParams& isosurfaceParams, PxU32 maxNumParticles, PxU32 maxNumVertices, PxU32 maxNumTriangles);
|
|
|
|
virtual PxSparseGridIsosurfaceExtractor* createSparseGridIsosurfaceExtractor(PxCudaContextManager* cudaContextManager, const PxSparseGridParams& sparseGridParams,
|
|
const PxIsosurfaceParams& isosurfaceParams, PxU32 maxNumParticles, PxU32 maxNumVertices, PxU32 maxNumTriangles);
|
|
|
|
virtual PxAnisotropyGenerator* createAnisotropyGenerator(PxCudaContextManager* cudaContextManager, PxU32 maxNumParticles,
|
|
PxReal anisotropyScale, PxReal minAnisotropy, PxReal maxAnisotropy);
|
|
|
|
virtual PxSmoothedPositionGenerator* createSmoothedPositionGenerator(PxCudaContextManager* cudaContextManager, PxU32 maxNumParticles, PxReal smoothingStrength);
|
|
|
|
virtual PxParticleNeighborhoodProvider* createParticleNeighborhoodProvider(PxCudaContextManager* cudaContextManager, const PxU32 maxNumParticles,
|
|
const PxReal cellSize, const PxU32 maxNumSparseGridCells);
|
|
|
|
virtual PxArrayConverter* createArrayConverter(PxCudaContextManager* cudaContextManager);
|
|
|
|
virtual PxSDFBuilder* createSDFBuilder(PxCudaContextManager* cudaContextManager);
|
|
|
|
virtual PxgDeformableSkinning* createDeformableSkinning(PxCudaContextManager* cudaContextManager);
|
|
|
|
virtual void release();
|
|
|
|
virtual ~PxgPhysicsGpu() {}
|
|
|
|
static PxgPhysicsGpu* sInstance;
|
|
};
|
|
|
|
PxgPhysicsGpu* PxgPhysicsGpu::sInstance = NULL;
|
|
|
|
PxIsosurfaceExtractor* PxgPhysicsGpu::createDenseGridIsosurfaceExtractor(PxCudaContextManager* cudaContextManager, const PxBounds3& worldBounds,
|
|
PxReal cellSize, const PxIsosurfaceParams& isosurfaceParams, PxU32 maxNumParticles, PxU32 maxNumVertices, PxU32 maxNumTriangles)
|
|
{
|
|
PxgCudaKernelWranglerManager* wrangler = static_cast<PxgCudaKernelWranglerManager*>(PxCreatePhysXGpu()->getGpuKernelWranglerManager(cudaContextManager));
|
|
PxgKernelLauncher kernelLauncher(cudaContextManager, wrangler);
|
|
return PX_NEW(PxgDenseGridIsosurfaceExtractor)(kernelLauncher, worldBounds, cellSize, isosurfaceParams, maxNumParticles, maxNumVertices, maxNumTriangles);
|
|
}
|
|
|
|
PxSparseGridIsosurfaceExtractor* PxgPhysicsGpu::createSparseGridIsosurfaceExtractor(PxCudaContextManager* cudaContextManager, const PxSparseGridParams& sparseGridParams,
|
|
const PxIsosurfaceParams& isosurfaceParams, PxU32 maxNumParticles, PxU32 maxNumVertices, PxU32 maxNumTriangles)
|
|
{
|
|
PxgCudaKernelWranglerManager* wrangler = static_cast<PxgCudaKernelWranglerManager*>(PxCreatePhysXGpu()->getGpuKernelWranglerManager(cudaContextManager));
|
|
PxgKernelLauncher kernelLauncher(cudaContextManager, wrangler);
|
|
return PX_NEW(PxgSparseGridIsosurfaceExtractor)(kernelLauncher, sparseGridParams, isosurfaceParams, maxNumParticles, maxNumVertices, maxNumTriangles);
|
|
}
|
|
|
|
PxAnisotropyGenerator* PxgPhysicsGpu::createAnisotropyGenerator(PxCudaContextManager* cudaContextManager, PxU32 maxNumParticles, PxReal anisotropyScale, PxReal minAnisotropy, PxReal maxAnisotropy)
|
|
{
|
|
PxgCudaKernelWranglerManager* wrangler = static_cast<PxgCudaKernelWranglerManager*>(PxCreatePhysXGpu()->getGpuKernelWranglerManager(cudaContextManager));
|
|
PxgKernelLauncher kernelLauncher(cudaContextManager, wrangler);
|
|
return PX_NEW(PxgAnisotropyGenerator)(kernelLauncher, maxNumParticles, anisotropyScale, minAnisotropy, maxAnisotropy);
|
|
}
|
|
|
|
PxSmoothedPositionGenerator* PxgPhysicsGpu::createSmoothedPositionGenerator(PxCudaContextManager* cudaContextManager, PxU32 maxNumParticles, PxReal smoothingStrength)
|
|
{
|
|
PxgCudaKernelWranglerManager* wrangler = static_cast<PxgCudaKernelWranglerManager*>(PxCreatePhysXGpu()->getGpuKernelWranglerManager(cudaContextManager));
|
|
PxgKernelLauncher kernelLauncher(cudaContextManager, wrangler);
|
|
return PX_NEW(PxgSmoothedPositionGenerator)(kernelLauncher, maxNumParticles, smoothingStrength);
|
|
}
|
|
|
|
PxParticleNeighborhoodProvider* PxgPhysicsGpu::createParticleNeighborhoodProvider(PxCudaContextManager* cudaContextManager, const PxU32 maxNumParticles, const PxReal particleContactOffset, const PxU32 maxNumSparseGridCells)
|
|
{
|
|
PxgCudaKernelWranglerManager* wrangler = static_cast<PxgCudaKernelWranglerManager*>(PxCreatePhysXGpu()->getGpuKernelWranglerManager(cudaContextManager));
|
|
PxgKernelLauncher kernelLauncher(cudaContextManager, wrangler);
|
|
return PX_NEW(PxgParticleNeighborhoodProvider)(kernelLauncher, maxNumParticles, particleContactOffset, maxNumSparseGridCells);
|
|
}
|
|
|
|
PxArrayConverter* PxgPhysicsGpu::createArrayConverter(PxCudaContextManager* cudaContextManager)
|
|
{
|
|
PxgCudaKernelWranglerManager* wrangler = static_cast<PxgCudaKernelWranglerManager*>(PxCreatePhysXGpu()->getGpuKernelWranglerManager(cudaContextManager));
|
|
PxgKernelLauncher kernelLauncher(cudaContextManager, wrangler);
|
|
return PX_NEW(PxgArrayConverter)(kernelLauncher);
|
|
}
|
|
|
|
PxSDFBuilder* PxgPhysicsGpu::createSDFBuilder(PxCudaContextManager* cudaContextManager)
|
|
{
|
|
PxgCudaKernelWranglerManager* wrangler = static_cast<PxgCudaKernelWranglerManager*>(PxCreatePhysXGpu()->getGpuKernelWranglerManager(cudaContextManager));
|
|
PxgKernelLauncher kernelLauncher(cudaContextManager, wrangler);
|
|
return PX_NEW(PxgSDFBuilder)(kernelLauncher);
|
|
}
|
|
|
|
PxgDeformableSkinning* PxgPhysicsGpu::createDeformableSkinning(PxCudaContextManager* cudaContextManager)
|
|
{
|
|
PxgCudaKernelWranglerManager* wrangler = static_cast<PxgCudaKernelWranglerManager*>(PxCreatePhysXGpu()->getGpuKernelWranglerManager(cudaContextManager));
|
|
PxgKernelLauncher kernelLauncher(cudaContextManager, wrangler);
|
|
return PX_NEW(PxgDeformableSkinning)(kernelLauncher);
|
|
}
|
|
|
|
void PxgPhysicsGpu::release()
|
|
{
|
|
PX_FREE_THIS;
|
|
}
|
|
|
|
PxPhysicsGpu* PxGpuCreatePhysicsGpu()
|
|
{
|
|
if (!PxgPhysicsGpu::sInstance)
|
|
PxgPhysicsGpu::sInstance = PX_NEW(PxgPhysicsGpu);
|
|
|
|
return PxgPhysicsGpu::sInstance;
|
|
}
|
|
|
|
void PxGpuReleasePhysicsGpu()
|
|
{
|
|
if (PxgPhysicsGpu::sInstance)
|
|
{
|
|
PxgPhysicsGpu::sInstance->release();
|
|
PxgPhysicsGpu::sInstance = NULL;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------//
|