Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 1195 insertions, 0 deletions

diff --git a/PhysX_3.4/Source/PhysX/src/buffering/ScbCloth.h b/PhysX_3.4/Source/PhysX/src/buffering/ScbCloth.h
new file mode 100644
index 00000000..238df91f
--- /dev/null
+++ b/PhysX_3.4/Source/PhysX/src/buffering/ScbCloth.h
@@ -0,0 +1,1195 @@
+// 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) 2008-2016 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_PHYSICS_SCB_CLOTH
+#define PX_PHYSICS_SCB_CLOTH
+
+#include "PxPhysXConfig.h"
+
+#if PX_USE_CLOTH_API
+
+#include "ScbActor.h"
+
+#include "ScClothCore.h"
+#include "NpClothParticleData.h"
+
+namespace physx
+{
+
+struct PxClothCollisionSphere;
+
+namespace Scb
+{
+
+class Cloth : public Scb::Actor
+{
+//= ATTENTION! =====================================================================================
+// Changing the data layout of this class breaks the binary serialization format.  See comments for 
+// PX_BINARY_SERIAL_VERSION.  If a modification is required, please adjust the getBinaryMetaData 
+// function.  If the modification is made on a custom branch, please change PX_BINARY_SERIAL_VERSION
+// accordingly.
+//==================================================================================================
+
+public:
+// PX_SERIALIZATION
+											Cloth(const PxEMPTY) : Scb::Actor(PxEmpty), mCloth(PxEmpty) {}
+				void						exportExtraData(PxSerializationContext& stream) { mCloth.exportExtraData(stream); }
+				void						importExtraData(PxDeserializationContext &context) { mCloth.importExtraData(context); }
+				void						resolveReferences(Sc::ClothFabricCore& fabric) { mCloth.resolveReferences(fabric); }
+				static void					getBinaryMetaData(PxOutputStream& stream);
+//~PX_SERIALIZATION
+											Cloth(const PxTransform& globalPose, Sc::ClothFabricCore& fabric, const PxClothParticle* particles, PxClothFlags flags);
+											~Cloth();
+
+	//---------------------------------------------------------------------------------
+	// Wrapper for Sc::ClothCore interface
+	//---------------------------------------------------------------------------------
+
+	PX_INLINE Sc::ClothFabricCore*		getFabric() const;
+	PX_INLINE void						resetFabric(); 
+
+	PX_INLINE void						setParticles(const PxClothParticle* currentParticles, const PxClothParticle* previousParticles);
+	PX_INLINE PxU32						getNbParticles() const;
+
+	PX_INLINE void						setMotionConstraints(const PxClothParticleMotionConstraint* motionConstraints);
+	PX_INLINE bool						getMotionConstraints(PxClothParticleMotionConstraint* motionConstraintsBuffer) const;
+	PX_INLINE PxU32						getNbMotionConstraints() const;
+
+	PX_INLINE PxClothMotionConstraintConfig getMotionConstraintConfig() const;
+	PX_INLINE void						setMotionConstraintConfig(const PxClothMotionConstraintConfig& config);
+
+	PX_INLINE void						setSeparationConstraints(const PxClothParticleSeparationConstraint* separationConstraints);
+	PX_INLINE bool						getSeparationConstraints(PxClothParticleSeparationConstraint* separationConstraintsBuffer) const;
+	PX_INLINE PxU32						getNbSeparationConstraints() const;
+
+	PX_INLINE void						clearInterpolation();
+
+	PX_INLINE void						setParticleAccelerations(const PxVec4* particleAccelerations);
+	PX_INLINE bool						getParticleAccelerations(PxVec4* particleAccelerationsBuffer) const;
+	PX_INLINE PxU32						getNbParticleAccelerations() const;
+
+	PX_INLINE void						addCollisionSphere(const PxClothCollisionSphere& sphere);
+	PX_INLINE void						removeCollisionSphere(PxU32 index);
+	PX_INLINE void						setCollisionSpheres(const PxClothCollisionSphere* spheresBuffer, PxU32 count);
+	PX_INLINE PxU32						getNbCollisionSpheres() const;
+
+	PX_INLINE void						getCollisionData(PxClothCollisionSphere* spheresBuffer, PxU32* capsulesBuffer, 
+											PxClothCollisionPlane* planesBuffer, PxU32* convexesBuffer, PxClothCollisionTriangle* trianglesBuffer) const;
+
+	PX_INLINE void						addCollisionCapsule(PxU32 first, PxU32 second);
+	PX_INLINE void						removeCollisionCapsule(PxU32 index);
+	PX_INLINE PxU32						getNbCollisionCapsules() const;
+
+	PX_INLINE void						addCollisionTriangle(const PxClothCollisionTriangle& triangle);
+	PX_INLINE void						removeCollisionTriangle(PxU32 index);
+	PX_INLINE void						setCollisionTriangles(const PxClothCollisionTriangle* trianglesBuffer, PxU32 count);
+	PX_INLINE PxU32						getNbCollisionTriangles() const;
+
+	PX_INLINE void						addCollisionPlane(const PxClothCollisionPlane& plane);
+	PX_INLINE void						removeCollisionPlane(PxU32 index);
+	PX_INLINE void						setCollisionPlanes(const PxClothCollisionPlane* planesBuffer, PxU32 count);
+	PX_INLINE PxU32						getNbCollisionPlanes() const;
+
+	PX_INLINE void						addCollisionConvex(PxU32 mask);
+	PX_INLINE void						removeCollisionConvex(PxU32 index);
+	PX_INLINE PxU32						getNbCollisionConvexes() const;
+
+	PX_INLINE void						setVirtualParticles(PxU32 numParticles, const PxU32* indices, PxU32 numWeights, const PxVec3* weights);
+
+	PX_INLINE PxU32						getNbVirtualParticles() const;
+	PX_INLINE void						getVirtualParticles(PxU32* indicesBuffer) const;
+
+	PX_INLINE PxU32						getNbVirtualParticleWeights() const;
+	PX_INLINE void						getVirtualParticleWeights(PxVec3* weightsBuffer) const;
+
+	PX_INLINE PxTransform				getGlobalPose() const;
+	PX_INLINE void						setGlobalPose(const PxTransform& pose);
+
+	PX_INLINE void						setTargetPose(const PxTransform& pose);
+
+	PX_INLINE PxVec3					getExternalAcceleration() const;
+	PX_INLINE void						setExternalAcceleration(PxVec3 acceleration);
+
+	PX_INLINE PxVec3					getLinearInertiaScale() const;
+	PX_INLINE void						setLinearInertiaScale(PxVec3 scale);
+	PX_INLINE PxVec3					getAngularInertiaScale() const;
+	PX_INLINE void						setAngularInertiaScale(PxVec3 scale);
+	PX_INLINE PxVec3					getCentrifugalInertiaScale() const;
+	PX_INLINE void						setCentrifugalInertiaScale(PxVec3 scale);
+
+	PX_INLINE PxVec3					getDampingCoefficient() const;
+	PX_INLINE void						setDampingCoefficient(PxVec3 dampingCoefficient);
+
+	PX_INLINE PxReal					getFrictionCoefficient() const;
+	PX_INLINE void						setFrictionCoefficient(PxReal frictionCoefficient);
+
+	PX_INLINE PxVec3					getLinearDragCoefficient() const;
+	PX_INLINE void						setLinearDragCoefficient(PxVec3 dragCoefficient);
+	PX_INLINE PxVec3					getAngularDragCoefficient() const;
+	PX_INLINE void						setAngularDragCoefficient(PxVec3 dragCoefficient);
+
+	PX_INLINE PxReal					getCollisionMassScale() const;
+	PX_INLINE void						setCollisionMassScale(PxReal scalingCoefficient);
+
+	PX_INLINE void						setSelfCollisionDistance(PxReal distance);
+	PX_INLINE PxReal					getSelfCollisionDistance() const;
+	PX_INLINE void						setSelfCollisionStiffness(PxReal stiffness);
+	PX_INLINE PxReal					getSelfCollisionStiffness() const;
+
+	PX_INLINE void						setSelfCollisionIndices(const PxU32* indices, PxU32 nbIndices);
+	PX_INLINE bool						getSelfCollisionIndices(PxU32* indices) const;
+	PX_INLINE PxU32						getNbSelfCollisionIndices() const;
+
+	PX_INLINE void						setRestPositions(const PxVec4* restPositions);
+	PX_INLINE bool						getRestPositions(PxVec4* restPositions) const;
+	PX_INLINE PxU32						getNbRestPositions() const; 
+
+	PX_INLINE PxReal					getSolverFrequency() const;
+	PX_INLINE void						setSolverFrequency(PxReal);
+
+	PX_INLINE PxReal					getStiffnessFrequency() const;
+	PX_INLINE void						setStiffnessFrequency(PxReal);
+
+	PX_INLINE void						setStretchConfig(PxClothFabricPhaseType::Enum type, const PxClothStretchConfig& config);
+	PX_INLINE void						setTetherConfig(const PxClothTetherConfig& config);
+
+	PX_INLINE PxClothStretchConfig		getStretchConfig(PxClothFabricPhaseType::Enum type) const;
+	PX_INLINE PxClothTetherConfig		getTetherConfig() const;
+
+	PX_INLINE PxClothFlags				getClothFlags() const;
+	PX_INLINE void						setClothFlags(PxClothFlags flags);
+
+	PX_INLINE PxVec3					getWindVelocity() const;
+	PX_INLINE void						setWindVelocity(PxVec3);
+	PX_INLINE PxReal					getDragCoefficient() const;
+	PX_INLINE void						setDragCoefficient(PxReal);
+	PX_INLINE PxReal					getLiftCoefficient() const;
+	PX_INLINE void						setLiftCoefficient(PxReal);
+
+	PX_INLINE bool						isSleeping() const;
+	PX_INLINE PxReal					getSleepLinearVelocity() const;
+	PX_INLINE void						setSleepLinearVelocity(PxReal threshold);
+	PX_INLINE void						setWakeCounter(PxReal wakeCounterValue);
+	PX_INLINE PxReal					getWakeCounter() const;
+	PX_INLINE void						wakeUp();
+	PX_INLINE void						putToSleep();
+
+	PX_INLINE void						getParticleData(NpClothParticleData&);
+
+	PX_INLINE PxReal					getPreviousTimeStep() const;
+
+	PX_INLINE PxBounds3					getWorldBounds() const;
+
+	PX_INLINE void						setSimulationFilterData(const PxFilterData& data);
+	PX_INLINE PxFilterData				getSimulationFilterData() const;
+
+	PX_INLINE void						setContactOffset(PxReal);
+	PX_INLINE PxReal					getContactOffset() const;
+	PX_INLINE void						setRestOffset(PxReal);
+	PX_INLINE PxReal					getRestOffset() const;
+
+
+	//---------------------------------------------------------------------------------
+	// Data synchronization
+	//---------------------------------------------------------------------------------
+				
+	// Synchronously called with fetchResults.
+	void syncState();
+
+	//---------------------------------------------------------------------------------
+	// Miscellaneous
+	//---------------------------------------------------------------------------------
+	PX_FORCE_INLINE	const Sc::ClothCore&		getScCloth()		const	{ return mCloth; }  // Only use if you know what you're doing!
+	PX_FORCE_INLINE	Sc::ClothCore&				getScCloth()				{ return mCloth; }  // Only use if you know what you're doing!
+
+	static size_t getScOffset()
+	{ 
+		return reinterpret_cast<size_t>(&reinterpret_cast<Cloth*>(0)->mCloth);
+	}
+
+private:
+	Sc::ClothCore		mCloth;
+};
+
+
+PX_INLINE Sc::ClothFabricCore* Cloth::getFabric() const
+{
+	return mCloth.getFabric();
+}
+
+PX_INLINE void Cloth::resetFabric()
+{
+	return mCloth.resetFabric();
+}
+
+PX_INLINE void Cloth::setParticles(const PxClothParticle* currentParticles, const PxClothParticle* previousParticles)
+{
+	if (!isBuffering())
+		mCloth.setParticles(currentParticles, previousParticles);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setParticles() not allowed while simulation is running.");
+}
+
+PX_INLINE PxU32 Cloth::getNbParticles() const 
+{
+	return mCloth.getNbParticles();
+}
+
+PX_INLINE void Cloth::setMotionConstraints(const PxClothParticleMotionConstraint* motionConstraints)
+{
+	if (!isBuffering())
+		mCloth.setMotionConstraints(motionConstraints);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setMotionConstraints() not allowed while simulation is running.");
+}
+
+
+PX_INLINE bool Cloth::getMotionConstraints(PxClothParticleMotionConstraint* motionConstraintsBuffer) const
+{
+	if (!isBuffering())
+		return mCloth.getMotionConstraints(motionConstraintsBuffer);
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getMotionConstraints() not allowed while simulation is running.");
+		return false;
+	}
+}
+
+PX_INLINE PxU32 Cloth::getNbMotionConstraints() const
+{
+	return mCloth.getNbMotionConstraints();
+}
+
+PX_INLINE PxClothMotionConstraintConfig Cloth::getMotionConstraintConfig() const
+{
+	if (!isBuffering())
+		return mCloth.getMotionConstraintConfig();
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getMotionConstraintScaleBias() not allowed while simulation is running.");
+
+	return PxClothMotionConstraintConfig();
+}
+
+
+PX_INLINE void Cloth::setMotionConstraintConfig(const PxClothMotionConstraintConfig& config)
+{
+	if (!isBuffering())
+		mCloth.setMotionConstraintConfig(config);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setMotionConstraintConfig() not allowed while simulation is running.");
+}
+
+PX_INLINE void Cloth::setSeparationConstraints(const PxClothParticleSeparationConstraint* separationConstraints)
+{
+	if (!isBuffering())
+		mCloth.setSeparationConstraints(separationConstraints);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setSeparationConstraints() not allowed while simulation is running.");
+}
+
+
+PX_INLINE bool Cloth::getSeparationConstraints(PxClothParticleSeparationConstraint* separationConstraintsBuffer) const
+{
+	if (!isBuffering())
+		return mCloth.getSeparationConstraints(separationConstraintsBuffer);
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getSeparationConstraints() not allowed while simulation is running.");
+		return false;
+	}
+}
+
+PX_INLINE PxU32 Cloth::getNbSeparationConstraints() const
+{
+	return mCloth.getNbSeparationConstraints();
+}
+
+PX_INLINE void Cloth::clearInterpolation()
+{
+	return mCloth.clearInterpolation();
+}
+
+PX_INLINE void Cloth::setParticleAccelerations(const PxVec4* particleAccelerations)
+{
+	if (!isBuffering())
+		mCloth.setParticleAccelerations(particleAccelerations);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setParticleAccelerations() not allowed while simulation is running.");
+}
+
+
+PX_INLINE bool Cloth::getParticleAccelerations(PxVec4* particleAccelerationsBuffer) const
+{
+	if (!isBuffering())
+		return mCloth.getParticleAccelerations(particleAccelerationsBuffer);
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getParticleAccelerations() not allowed while simulation is running.");
+		return false;
+	}
+}
+
+PX_INLINE PxU32 Cloth::getNbParticleAccelerations() const
+{
+	return mCloth.getNbParticleAccelerations();
+}
+
+PX_INLINE void Cloth::addCollisionSphere(const PxClothCollisionSphere& sphere)
+{
+	if (!isBuffering())
+		mCloth.addCollisionSphere(sphere);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::addCollisionSphere() not allowed while simulation is running.");
+}
+PX_INLINE void Cloth::removeCollisionSphere(PxU32 index)
+{
+	if (!isBuffering())
+		mCloth.removeCollisionSphere(index);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::removeCollisionSphere() not allowed while simulation is running.");
+}
+PX_INLINE void Cloth::setCollisionSpheres(const PxClothCollisionSphere* spheresBuffer, PxU32 count)
+{
+	if (!isBuffering())
+		mCloth.setCollisionSpheres(spheresBuffer, count);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setCollisionSpheres() not allowed while simulation is running.");
+}
+PX_INLINE PxU32 Cloth::getNbCollisionSpheres() const
+{
+	if (!isBuffering())
+		return mCloth.getNbCollisionSpheres();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getNbCollisionSpheres() not allowed while simulation is running.");
+		return 0;
+	}
+}
+
+PX_INLINE void Cloth::getCollisionData( PxClothCollisionSphere* spheresBuffer, PxU32* capsulesBuffer, 
+									   PxClothCollisionPlane* planesBuffer, PxU32* convexesBuffer, PxClothCollisionTriangle* trianglesBuffer ) const
+{
+	if (!isBuffering())
+		mCloth.getCollisionData(spheresBuffer, capsulesBuffer, planesBuffer, convexesBuffer, trianglesBuffer);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getCollisionData() not allowed while simulation is running.");
+}
+
+
+PX_INLINE void Cloth::addCollisionCapsule(PxU32 first, PxU32 second)
+{
+	if (!isBuffering())
+		mCloth.addCollisionCapsule(first, second);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::addCollisionCapsule() not allowed while simulation is running.");
+}
+PX_INLINE void Cloth::removeCollisionCapsule(PxU32 index)
+{
+	if (!isBuffering())
+		mCloth.removeCollisionCapsule(index);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::removeCollisionCapsule() not allowed while simulation is running.");
+}
+PX_INLINE PxU32 Cloth::getNbCollisionCapsules() const
+{
+	if (!isBuffering())
+		return mCloth.getNbCollisionCapsules();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getNbCollisionCapsules() not allowed while simulation is running.");
+		return 0;
+	}
+}
+
+PX_INLINE void Cloth::addCollisionTriangle(const PxClothCollisionTriangle& triangle)
+{
+	if (!isBuffering())
+		mCloth.addCollisionTriangle(triangle);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::addCollisionTriangle() not allowed while simulation is running.");
+}
+PX_INLINE void Cloth::removeCollisionTriangle(PxU32 index)
+{
+	if (!isBuffering())
+		mCloth.removeCollisionTriangle(index);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::removeCollisionTriangle() not allowed while simulation is running.");
+}
+PX_INLINE void Cloth::setCollisionTriangles(const PxClothCollisionTriangle* trianglesBuffer, PxU32 count)
+{
+	if (!isBuffering())
+		mCloth.setCollisionTriangles(trianglesBuffer, count);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setCollisionTriangles() not allowed while simulation is running.");
+}
+PX_INLINE PxU32 Cloth::getNbCollisionTriangles() const
+{
+	if (!isBuffering())
+		return mCloth.getNbCollisionTriangles();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getNbCollisionTriangles() not allowed while simulation is running.");
+		return 0;
+	}
+}
+
+PX_INLINE void Cloth::addCollisionPlane(const PxClothCollisionPlane& plane)
+{
+	if (!isBuffering())
+		mCloth.addCollisionPlane(plane);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::addCollisionPlane() not allowed while simulation is running.");
+}
+PX_INLINE void Cloth::removeCollisionPlane(PxU32 index)
+{
+	if (!isBuffering())
+		mCloth.removeCollisionPlane(index);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::removeCollisionPlane() not allowed while simulation is running.");
+}
+PX_INLINE void Cloth::setCollisionPlanes(const PxClothCollisionPlane* planesBuffer, PxU32 count)
+{
+	if (!isBuffering())
+		mCloth.setCollisionPlanes(planesBuffer, count);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setCollisionPlanes() not allowed while simulation is running.");
+}
+PX_INLINE PxU32 Cloth::getNbCollisionPlanes() const
+{
+	if (!isBuffering())
+		return mCloth.getNbCollisionPlanes();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getNbCollisionPlanes() not allowed while simulation is running.");
+		return 0;
+	}
+}
+
+PX_INLINE void Cloth::addCollisionConvex(PxU32 mask)
+{
+	if (!isBuffering())
+		mCloth.addCollisionConvex(mask);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::addCollisionConvex() not allowed while simulation is running.");
+}
+PX_INLINE void Cloth::removeCollisionConvex(PxU32 index)
+{
+	if (!isBuffering())
+		mCloth.removeCollisionConvex(index);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::removeCollisionConvex() not allowed while simulation is running.");
+}
+PX_INLINE PxU32 Cloth::getNbCollisionConvexes() const
+{
+	if (!isBuffering())
+		return mCloth.getNbCollisionConvexes();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getNbCollisionConvexes() not allowed while simulation is running.");
+		return 0;
+	}
+}
+
+
+PX_INLINE void Cloth::setVirtualParticles(PxU32 numParticles, const PxU32* indices, PxU32 numWeights, const PxVec3* weights)
+{
+	if (!isBuffering())
+		mCloth.setVirtualParticles(numParticles, indices, numWeights, weights);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setVirtualParticles() not allowed while simulation is running.");
+}
+
+
+PX_INLINE PxU32 Cloth::getNbVirtualParticles() const
+{
+	if (!isBuffering())
+		return mCloth.getNbVirtualParticles();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getNbVirtualParticles() not allowed while simulation is running.");
+		return 0;
+	}
+}
+
+
+PX_INLINE void Cloth::getVirtualParticles(PxU32* indicesBuffer) const
+{
+	if (!isBuffering())
+		mCloth.getVirtualParticles(indicesBuffer);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getVirtualParticles() not allowed while simulation is running.");
+}
+
+
+PX_INLINE PxU32 Cloth::getNbVirtualParticleWeights() const
+{
+	if (!isBuffering())
+		return mCloth.getNbVirtualParticleWeights();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getNbVirtualParticleWeights() not allowed while simulation is running.");
+		return 0;
+	}
+}
+
+
+PX_INLINE void Cloth::getVirtualParticleWeights(PxVec3* weightsBuffer) const
+{
+	if (!isBuffering())
+		mCloth.getVirtualParticleWeights(weightsBuffer);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getVirtualParticleWeights() not allowed while simulation is running.");
+}
+
+
+PX_INLINE PxTransform Cloth::getGlobalPose() const
+{
+	if (!isBuffering())
+		return mCloth.getGlobalPose();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getGlobalPose() not allowed while simulation is running.");
+		return PxTransform(PxIdentity);
+	}
+}
+
+
+PX_INLINE void Cloth::setGlobalPose(const PxTransform& pose)
+{
+	if (!isBuffering())
+		mCloth.setGlobalPose(pose);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setGlobalPose() not allowed while simulation is running.");
+}
+
+
+PX_INLINE void Cloth::setTargetPose(const PxTransform& pose)
+{
+	if (!isBuffering())
+		mCloth.setTargetPose(pose);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setTargetPose() not allowed while simulation is running.");
+}
+
+
+PX_INLINE PxVec3 Cloth::getExternalAcceleration() const
+{
+	if (!isBuffering())
+		return mCloth.getExternalAcceleration();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getExternalAcceleration() not allowed while simulation is running.");
+		return PxVec3(0.0f);
+	}
+}
+
+
+PX_INLINE void Cloth::setExternalAcceleration(PxVec3 acceleration)
+{
+	if (!isBuffering())
+		mCloth.setExternalAcceleration(acceleration);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setExternalAcceleration() not allowed while simulation is running.");
+}
+
+PX_INLINE PxVec3 Cloth::getLinearInertiaScale() const
+{
+	if (!isBuffering())
+		return mCloth.getLinearInertiaScale();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getLinearInertiaScale() not allowed while simulation is running.");
+		return PxVec3(0.0f);
+	}
+}
+
+
+PX_INLINE void Cloth::setLinearInertiaScale(PxVec3 scale)
+{
+	if (!isBuffering())
+		mCloth.setLinearInertiaScale(scale);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setLinearInertiaScale() not allowed while simulation is running.");
+}
+
+PX_INLINE PxVec3 Cloth::getAngularInertiaScale() const
+{
+	if (!isBuffering())
+		return mCloth.getAngularInertiaScale();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getAngularInertiaScale() not allowed while simulation is running.");
+		return PxVec3(0.0f);
+	}
+}
+
+
+PX_INLINE void Cloth::setAngularInertiaScale(PxVec3 scale)
+{
+	if (!isBuffering())
+		mCloth.setAngularInertiaScale(scale);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setAngularInertiaScale() not allowed while simulation is running.");
+}
+
+PX_INLINE PxVec3 Cloth::getCentrifugalInertiaScale() const
+{
+	if (!isBuffering())
+		return mCloth.getCentrifugalInertiaScale();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getCentrifugalInertiaScale() not allowed while simulation is running.");
+		return PxVec3(0.0f);
+	}
+}
+
+
+PX_INLINE void Cloth::setCentrifugalInertiaScale(PxVec3 scale)
+{
+	if (!isBuffering())
+		mCloth.setCentrifugalInertiaScale(scale);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setCentrifugalInertiaScale() not allowed while simulation is running.");
+}
+
+PX_INLINE PxVec3 Cloth::getDampingCoefficient() const
+{
+	if (!isBuffering())
+		return mCloth.getDampingCoefficient();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getDampingCoefficient() not allowed while simulation is running.");
+		return PxVec3(0.0f);
+	}
+}
+
+
+PX_INLINE void Cloth::setDampingCoefficient(PxVec3 dampingCoefficient)
+{
+	if (!isBuffering())
+		mCloth.setDampingCoefficient(dampingCoefficient);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setDampingCoefficient() not allowed while simulation is running.");
+}
+
+PX_INLINE PxReal Cloth::getFrictionCoefficient() const
+{
+	if (!isBuffering())
+		return mCloth.getFrictionCoefficient();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getFrictionCoefficient() not allowed while simulation is running.");
+		return 0.0f;
+	}
+}
+
+
+PX_INLINE void Cloth::setFrictionCoefficient(PxReal frictionCoefficient)
+{
+	if (!isBuffering())
+		mCloth.setFrictionCoefficient(frictionCoefficient);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setFrictionCoefficient() not allowed while simulation is running.");
+}
+
+PX_INLINE PxVec3 Cloth::getLinearDragCoefficient() const
+{
+	if (!isBuffering())
+		return mCloth.getLinearDragCoefficient();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getLinearDragCoefficient() not allowed while simulation is running.");
+		return PxVec3(0.0f);
+	}
+}
+
+
+PX_INLINE void Cloth::setLinearDragCoefficient(PxVec3 dampingCoefficient)
+{
+	if (!isBuffering())
+		mCloth.setLinearDragCoefficient(dampingCoefficient);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setLinearDragCoefficient() not allowed while simulation is running.");
+}
+
+PX_INLINE PxVec3 Cloth::getAngularDragCoefficient() const
+{
+	if (!isBuffering())
+		return mCloth.getAngularDragCoefficient();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getAngularDragCoefficient() not allowed while simulation is running.");
+		return PxVec3(0.0f);
+	}
+}
+
+
+PX_INLINE void Cloth::setAngularDragCoefficient(PxVec3 dampingCoefficient)
+{
+	if (!isBuffering())
+		mCloth.setAngularDragCoefficient(dampingCoefficient);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setAngularDragCoefficient() not allowed while simulation is running.");
+}
+
+PX_INLINE PxReal Cloth::getCollisionMassScale() const
+{
+	if (!isBuffering())
+		return mCloth.getCollisionMassScale();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getCollisionMassScale() not allowed while simulation is running.");
+		return 0.0f;
+	}
+}
+PX_INLINE void Cloth::setCollisionMassScale(PxReal scalingCoefficient)
+{
+	if (!isBuffering())
+		mCloth.setCollisionMassScale(scalingCoefficient);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setCollisionMassScale() not allowed while simulation is running.");
+}
+
+PX_INLINE PxReal Cloth::getSelfCollisionDistance() const
+{
+	if (!isBuffering())
+		return mCloth.getSelfCollisionDistance();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getSelfCollisionDistance() not allowed while simulation is running.");
+		return 0.0f;
+	}
+}
+PX_INLINE void Cloth::setSelfCollisionDistance(PxReal distance)
+{
+	if (!isBuffering())
+		mCloth.setSelfCollisionDistance(distance);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setSelfCollisionDistance() not allowed while simulation is running.");
+}
+PX_INLINE PxReal Cloth::getSelfCollisionStiffness() const
+{
+	if (!isBuffering())
+		return mCloth.getSelfCollisionStiffness();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getSelfCollisionStiffness() not allowed while simulation is running.");
+		return 0.0f;
+	}
+}
+PX_INLINE void Cloth::setSelfCollisionStiffness(PxReal stiffness)
+{
+	if (!isBuffering())
+		mCloth.setSelfCollisionStiffness(stiffness);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setSelfCollisionStiffness() not allowed while simulation is running.");
+}
+
+PX_INLINE void Cloth::setSelfCollisionIndices(const PxU32* indices, PxU32 nbIndices)
+{
+	if (!isBuffering())
+		mCloth.setSelfCollisionIndices(indices, nbIndices);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setSelfCollisionIndices() not allowed while simulation is running.");
+}
+
+PX_INLINE bool Cloth::getSelfCollisionIndices(PxU32* indices) const
+{
+	if (!isBuffering())
+		return mCloth.getSelfCollisionIndices(indices);
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getSelfCollisionIndices() not allowed while simulation is running.");
+		return false;
+	}
+}
+
+PX_INLINE PxU32 Cloth::getNbSelfCollisionIndices() const
+{
+	return mCloth.getNbSelfCollisionIndices();
+}
+
+
+PX_INLINE void Cloth::setRestPositions(const PxVec4* restPositions)
+{
+	if (!isBuffering())
+		mCloth.setRestPositions(restPositions);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setRestPositions() not allowed while simulation is running.");
+}
+
+PX_INLINE bool Cloth::getRestPositions(PxVec4* restPositions) const
+{
+	if (!isBuffering())
+		return mCloth.getRestPositions(restPositions);
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getRestPositions() not allowed while simulation is running.");
+		return false;
+	}
+}
+
+PX_INLINE PxU32 Cloth::getNbRestPositions() const
+{
+	return mCloth.getNbRestPositions();
+}
+
+PX_INLINE PxReal Cloth::getSolverFrequency() const
+{
+	if (!isBuffering())
+		return mCloth.getSolverFrequency();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getSolverFrequency() not allowed while simulation is running.");
+		return 60.0f;
+	}
+}
+
+
+PX_INLINE void Cloth::setSolverFrequency(PxReal solverFreq)
+{
+	if (!isBuffering())
+		mCloth.setSolverFrequency(solverFreq);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setSolverFrequency() not allowed while simulation is running.");
+}
+
+PX_INLINE PxReal Cloth::getStiffnessFrequency() const
+{
+	if (!isBuffering())
+		return mCloth.getStiffnessFrequency();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getStiffnessFrequency() not allowed while simulation is running.");
+		return 60.0f;
+	}
+}
+
+
+PX_INLINE void Cloth::setStiffnessFrequency(PxReal solverFreq)
+{
+	if (!isBuffering())
+		mCloth.setStiffnessFrequency(solverFreq);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setStiffnessFrequency() not allowed while simulation is running.");
+}
+
+
+PX_INLINE void Cloth::setStretchConfig(PxClothFabricPhaseType::Enum type, const PxClothStretchConfig& config)
+{
+	if (!isBuffering())
+		mCloth.setStretchConfig(type, config);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setStretchConfig() not allowed while simulation is running.");
+}
+
+PX_INLINE void Cloth::setTetherConfig(const PxClothTetherConfig& config)
+{
+	if (!isBuffering())
+		mCloth.setTetherConfig(config);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setTetherConfig() not allowed while simulation is running.");
+}
+
+PX_INLINE PxClothStretchConfig Cloth::getStretchConfig(PxClothFabricPhaseType::Enum type) const
+{
+	if (!isBuffering())
+		return mCloth.getStretchConfig(type);
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getStretchConfig() not allowed while simulation is running.");		
+		return PxClothStretchConfig();
+	}
+}
+
+PX_INLINE PxClothTetherConfig Cloth::getTetherConfig() const
+{
+	if (!isBuffering())
+		return mCloth.getTetherConfig();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getTetherConfig() not allowed while simulation is running.");		
+		return PxClothTetherConfig();
+	}
+}
+
+PX_INLINE PxClothFlags Cloth::getClothFlags() const
+{
+	if (!isBuffering())
+		return mCloth.getClothFlags();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getClothFlags() not allowed while simulation is running.");
+		return PxClothFlags(0);
+	}
+}
+
+
+PX_INLINE void Cloth::setClothFlags(PxClothFlags flags)
+{
+	if (!isBuffering())
+		mCloth.setClothFlags(flags);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setClothFlag() not allowed while simulation is running.");
+}
+
+PX_INLINE PxVec3 Cloth::getWindVelocity() const
+{
+	if (!isBuffering())
+		return mCloth.getWindVelocity();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getWindVelocity() not allowed while simulation is running.");
+		return PxVec3(0.0f);
+	}
+}
+
+PX_INLINE void Cloth::setWindVelocity(PxVec3 wind)
+{
+	if (!isBuffering())
+		mCloth.setWindVelocity(wind);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setWindVelocity() not allowed while simulation is running.");
+}
+
+PX_INLINE PxReal Cloth::getDragCoefficient() const
+{
+	if (!isBuffering())
+		return mCloth.getDragCoefficient();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getDragCoefficient() not allowed while simulation is running.");
+		return 0.0f;
+	}
+}
+
+PX_INLINE void Cloth::setDragCoefficient(PxReal value)
+{
+	if (!isBuffering())
+		mCloth.setDragCoefficient(value);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setDragCoefficient() not allowed while simulation is running.");
+}
+
+PX_INLINE PxReal Cloth::getLiftCoefficient() const
+{
+	if (!isBuffering())
+		return mCloth.getLiftCoefficient();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getLiftCoefficient() not allowed while simulation is running.");
+		return 0.0f;
+	}
+}
+
+PX_INLINE void Cloth::setLiftCoefficient(PxReal value)
+{
+	if (!isBuffering())
+		mCloth.setLiftCoefficient(value);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setLiftCoefficient() not allowed while simulation is running.");
+}
+
+
+PX_INLINE bool Cloth::isSleeping() const
+{
+	if (!isBuffering())
+		return mCloth.isSleeping();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::isSleeping() not allowed while simulation is running.");
+		return false;
+	}
+}
+
+
+PX_INLINE PxReal Cloth::getSleepLinearVelocity() const
+{
+	if (!isBuffering())
+		return mCloth.getSleepLinearVelocity();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getSleepLinearVelocity() not allowed while simulation is running.");
+		return 0.0f;
+	}
+}
+
+
+PX_INLINE void Cloth::setSleepLinearVelocity(PxReal threshold)
+{
+	if (!isBuffering())
+		mCloth.setSleepLinearVelocity(threshold);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setSleepLinearVelocity() not allowed while simulation is running.");
+}
+
+
+PX_INLINE void Cloth::setWakeCounter(PxReal wakeCounterValue)
+{
+	if (!isBuffering())
+		mCloth.setWakeCounter(wakeCounterValue);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setWakeCounter() not allowed while simulation is running.");
+}
+
+
+PX_INLINE PxReal Cloth::getWakeCounter() const
+{
+	if (!isBuffering())
+		return mCloth.getWakeCounter();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getWakeCounter() not allowed while simulation is running.");
+		return 0.0f;
+	}
+}
+
+
+PX_INLINE void Cloth::wakeUp()
+{
+	Scene* scene = getScbScene();
+	PX_ASSERT(scene);  // only allowed for an object in a scene
+
+	if (!isBuffering())
+		mCloth.wakeUp(scene->getWakeCounterResetValue());
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::wakeUp() not allowed while simulation is running.");
+}
+
+
+PX_INLINE void Cloth::putToSleep()
+{
+	if (!isBuffering())
+		mCloth.putToSleep();
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::putToSleep() not allowed while simulation is running.");
+}
+
+
+PX_INLINE void Cloth::getParticleData(NpClothParticleData& particleData)
+{
+	if (!isBuffering())
+		return getScCloth().getParticleData(particleData);
+
+	Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, 
+		"Call to PxCloth::lockParticleData() not allowed while simulation is running.");
+
+	particleData.particles = 0;
+	particleData.previousParticles = 0;
+}
+
+
+PxReal Cloth::getPreviousTimeStep() const
+{
+	if (!isBuffering())
+		return mCloth.getPreviousTimeStep();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getPreviousTimeStep() not allowed while simulation is running.");
+		return 0.0f;
+	}
+}
+
+
+PX_INLINE PxBounds3 Cloth::getWorldBounds() const
+{
+	if (!isBuffering())
+		return mCloth.getWorldBounds();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getWorldBounds() not allowed while simulation is running.");
+		return PxBounds3::empty();
+	}
+}
+
+PX_INLINE void Cloth::setSimulationFilterData(const PxFilterData& data)
+{
+	if (!isBuffering())
+		mCloth.setSimulationFilterData(data);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setSimulationFilterData() not allowed while simulation is running.");
+}
+
+PX_INLINE PxFilterData Cloth::getSimulationFilterData() const
+{
+	if (!isBuffering())
+		return mCloth.getSimulationFilterData();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getSimulationFilterData() not allowed while simulation is running.");
+		return PxFilterData();
+	}
+}
+
+PX_INLINE void Cloth::setContactOffset(PxReal offset)
+{
+	if (!isBuffering())
+		mCloth.setContactOffset(offset);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setContactOffset() not allowed while simulation is running.");
+}
+
+PX_INLINE PxReal Cloth::getContactOffset() const
+{
+	if (!isBuffering())
+		return mCloth.getContactOffset();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getContactOffset() not allowed while simulation is running.");
+		return 0.0f;
+	}
+}
+
+PX_INLINE void Cloth::setRestOffset(PxReal offset)
+{
+	if (!isBuffering())
+		mCloth.setRestOffset(offset);
+	else
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::setRestOffset() not allowed while simulation is running.");
+}
+
+PX_INLINE PxReal Cloth::getRestOffset() const
+{
+	if (!isBuffering())
+		return mCloth.getRestOffset();
+	else
+	{
+		Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Call to PxCloth::getRestOffset() not allowed while simulation is running.");
+		return 0.0f;
+	}
+}
+
+}  // namespace Scb
+
+}
+
+#endif // PX_USE_CLOTH_API
+
+#endif