191 lines
8.3 KiB
C++
191 lines
8.3 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-2023 NVIDIA Corporation. All rights reserved.
|
|
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
|
|
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
|
|
|
|
#ifndef PX_GPU_PARTICLE_SYSTEM_H
|
|
#define PX_GPU_PARTICLE_SYSTEM_H
|
|
/** \addtogroup physics
|
|
@{ */
|
|
|
|
#include "foundation/PxSimpleTypes.h"
|
|
#include "foundation/PxVec3.h"
|
|
|
|
#include "PxParticleSystem.h"
|
|
|
|
#if !PX_DOXYGEN
|
|
namespace physx
|
|
{
|
|
#endif
|
|
|
|
/**
|
|
@brief Common material properties for particles. See #PxParticleMaterial.
|
|
|
|
Accessed by either integration or particle-rigid collisions
|
|
*/
|
|
struct PxsParticleMaterialData
|
|
{
|
|
PxReal friction; // 4
|
|
PxReal damping; // 8
|
|
PxReal adhesion; // 12
|
|
PxReal gravityScale; // 16
|
|
PxReal adhesionRadiusScale; // 20
|
|
};
|
|
|
|
#if !PX_DOXYGEN
|
|
} // namespace physx
|
|
#endif
|
|
|
|
#if PX_SUPPORT_GPU_PHYSX
|
|
|
|
struct float4;
|
|
|
|
PX_CUDA_CALLABLE inline physx::PxU32 PxGetGroup(physx::PxU32 phase) { return phase & physx::PxParticlePhaseFlag::eParticlePhaseGroupMask; }
|
|
PX_CUDA_CALLABLE inline bool PxGetFluid(physx::PxU32 phase) { return (phase & physx::PxParticlePhaseFlag::eParticlePhaseFluid) != 0; }
|
|
PX_CUDA_CALLABLE inline bool PxGetSelfCollide(physx::PxU32 phase) { return (phase & physx::PxParticlePhaseFlag::eParticlePhaseSelfCollide) != 0; }
|
|
PX_CUDA_CALLABLE inline bool PxGetSelfCollideFilter(physx::PxU32 phase) { return (phase & physx::PxParticlePhaseFlag::eParticlePhaseSelfCollideFilter) != 0; }
|
|
|
|
#if !PX_DOXYGEN
|
|
namespace physx
|
|
{
|
|
#endif
|
|
|
|
/**
|
|
@brief An iterator class to iterate over the neighbors of a particle during particle system simulation.
|
|
*/
|
|
class PxNeighborhoodIterator
|
|
{
|
|
|
|
const PxU32* PX_RESTRICT mCollisionIndex; //!< Pointer to the current state of the iterator.
|
|
PxU32 mMaxParticles; //!< The maximum number of particles of the particle system this iterator is used on.
|
|
|
|
public:
|
|
PX_CUDA_CALLABLE PxNeighborhoodIterator(const PxU32* PX_RESTRICT collisionIndex, PxU32 maxParticles) :
|
|
mCollisionIndex(collisionIndex), mMaxParticles(maxParticles)
|
|
{
|
|
}
|
|
|
|
PX_CUDA_CALLABLE PxU32 getNextIndex()
|
|
{
|
|
PxU32 result = *mCollisionIndex;
|
|
mCollisionIndex += mMaxParticles;
|
|
return result;
|
|
}
|
|
|
|
PX_INLINE PxNeighborhoodIterator(const PxNeighborhoodIterator& params)
|
|
{
|
|
mCollisionIndex = params.mCollisionIndex;
|
|
mMaxParticles = params.mMaxParticles;
|
|
}
|
|
|
|
PX_INLINE void operator = (const PxNeighborhoodIterator& params)
|
|
{
|
|
mCollisionIndex = params.mCollisionIndex;
|
|
mMaxParticles = params.mMaxParticles;
|
|
}
|
|
};
|
|
|
|
/**
|
|
@brief Structure that holds simulation parameters of a #PxGpuParticleSystem.
|
|
*/
|
|
struct PxGpuParticleData
|
|
{
|
|
PxU32 mGridSizeX; //!< Size of the x-dimension of the background simulation grid. Translates to an absolute size of mGridSizeX * mParticleContactDistance.
|
|
PxU32 mGridSizeY; //!< Size of the y-dimension of the background simulation grid. Translates to an absolute size of mGridSizeY * mParticleContactDistance.
|
|
PxU32 mGridSizeZ; //!< Size of the z-dimension of the background simulation grid. Translates to an absolute size of mGridSizeZ * mParticleContactDistance.
|
|
|
|
PxReal mParticleContactDistance; //!< Two particles start interacting if their distance is lower than mParticleContactDistance.
|
|
PxReal mParticleContactDistanceInv; //!< 1.f / mParticleContactDistance.
|
|
PxReal mParticleContactDistanceSq; //!< mParticleContactDistance * mParticleContactDistance.
|
|
|
|
PxU32 mNumParticles; //!< The number of particles in this particle system.
|
|
PxU32 mMaxParticles; //!< The maximum number of particles that can be simulated in this particle system.
|
|
PxU32 mMaxNeighborhood; //!< The maximum number of particles considered when computing neighborhood based particle interactions.
|
|
PxU32 mMaxDiffuseParticles; //!< The maximum number of diffuse particles that can be simulated using this particle system.
|
|
PxU32 mNumParticleBuffers; //!< The number of particle buffers that are simulated in this particle system.
|
|
};
|
|
|
|
/**
|
|
@brief Container class for a GPU particle system. Used to communicate particle system parameters and simulation state
|
|
between the internal SDK simulation and the particle system callbacks.
|
|
|
|
See #PxParticleSystem, #PxParticleSystemCallback.
|
|
*/
|
|
class PxGpuParticleSystem
|
|
{
|
|
public:
|
|
|
|
/**
|
|
@brief Returns the number of cells of the background simulation grid.
|
|
|
|
@return PxU32 the number of cells.
|
|
*/
|
|
PX_FORCE_INLINE PxU32 getNumCells() { return mCommonData.mGridSizeX * mCommonData.mGridSizeY * mCommonData.mGridSizeZ; }
|
|
|
|
/* Unsorted particle state buffers */
|
|
float4* mUnsortedPositions_InvMass; //!< GPU pointer to unsorted particle positions and inverse masses.
|
|
float4* mUnsortedVelocities; //!< GPU pointer to unsorted particle velocities.
|
|
PxU32* mUnsortedPhaseArray; //!< GPU pointer to unsorted particle phase array. See #PxParticlePhase.
|
|
|
|
/* Sorted particle state buffers. Sorted by increasing hash value in background grid. */
|
|
float4* mSortedPositions_InvMass; //!< GPU pointer to sorted particle positions
|
|
float4* mSortedVelocities; //!< GPU pointer to sorted particle velocities
|
|
PxU32* mSortedPhaseArray; //!< GPU pointer to sorted particle phase array
|
|
|
|
/* Mappings to/from sorted particle states */
|
|
PxU32* mUnsortedToSortedMapping; //!< GPU pointer to the mapping from unsortedParticle ID to sorted particle ID
|
|
PxU32* mSortedToUnsortedMapping; //!< GPU pointer to the mapping from sorted particle ID to unsorted particle ID
|
|
|
|
/* Neighborhood information */
|
|
PxU32* mParticleSelfCollisionCount; //!< Per-particle neighborhood count
|
|
PxU32* mCollisionIndex; //!< Set of sorted particle indices per neighbor
|
|
|
|
PxsParticleMaterialData* mParticleMaterials; //!< GPU pointer to the particle materials used in this particle system.
|
|
PxGpuParticleData mCommonData; //!< Structure holding simulation parameters and state for this particle system. See #PxGpuParticleData.
|
|
|
|
/**
|
|
@brief Get a PxNeighborhoodIterator initialized for usage with this particle system.
|
|
|
|
@param particleId An initial particle index for the initialization of the iterator.
|
|
|
|
@return An initialized PxNeighborhoodIterator.
|
|
*/
|
|
PX_CUDA_CALLABLE PxNeighborhoodIterator getIterator(PxU32 particleId) const
|
|
{
|
|
return PxNeighborhoodIterator(mCollisionIndex + particleId, mCommonData.mMaxParticles);
|
|
}
|
|
};
|
|
|
|
#if !PX_DOXYGEN
|
|
} // namespace physx
|
|
#endif
|
|
|
|
#endif
|
|
|
|
/** @} */
|
|
#endif
|
|
|