Init

physx/samples/samplecctsharedcode/KinematicPlatform.h

@@ -0,0 +1,132 @@
+//
+// 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-2021 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 KINEMATIC_PLATFORM_H
+#define KINEMATIC_PLATFORM_H
+
+#include "common/PxPhysXCommonConfig.h"
+#include "foundation/PxTransform.h"
+#include "SampleAllocator.h"
+#include "SampleAllocatorSDKClasses.h"
+#include "characterkinematic/PxControllerObstacles.h"
+#include <vector>
+
+namespace physx
+{
+	class PxRigidDynamic;
+}
+
+	// PT: Captures the state of the platform. We decouple this data from the platform itself so that the
+	// same platform path (const data) can be used by several platform instances.
+	struct PlatformState
+	{
+					PlatformState();
+
+		PxTransform	mPrevPose;
+		PxReal		mCurrentTime;
+		PxReal		mCurrentRotationTime;
+		bool		mFlip;
+	};
+
+	enum LoopMode
+	{
+		LOOP_FLIP,
+		LOOP_WRAP,
+	};
+
+	class KinematicPlatform : public SampleAllocateable
+	{
+		public:
+												KinematicPlatform();
+												~KinematicPlatform();
+
+						void					release();
+						void					init(PxU32 nbPts, const PxVec3* pts, const PxTransform& globalPose, const PxQuat& localRot, PxRigidDynamic* actor, PxReal travelTime, PxReal rotationSpeed, LoopMode mode=LOOP_FLIP);
+						void					setBoxObstacle(ObstacleHandle handle, const PxBoxObstacle* boxObstacle);
+						PxU32					getNbSegments()								const;
+						PxReal					computeLength()								const;
+						bool					getPoint(PxVec3& p, PxU32 seg, PxReal t)	const;
+						bool					getPoint(PxVec3& p, PxReal t)				const;
+						void					resync();
+
+		PX_FORCE_INLINE	void					updatePhysics(PxReal dtime)										{ updateState(mPhysicsState, NULL, dtime, true);			}
+		PX_FORCE_INLINE	void					updateRender(PxReal dtime, PxObstacleContext* obstacleContext)	{ updateState(mRenderState, obstacleContext, dtime, false);	}
+
+		PX_FORCE_INLINE	PxReal					getTravelTime()			const	{ return mTravelTime;						}
+		PX_FORCE_INLINE	void					setTravelTime(PxReal t)			{ mTravelTime = t;							}
+						void					setT(PxF32 t);
+
+		PX_FORCE_INLINE	const PxTransform&		getPhysicsPose()		const	{ return mPhysicsState.mPrevPose;			}
+		PX_FORCE_INLINE	const PxTransform&		getRenderPose()			const	{ return mRenderState.mPrevPose;			}
+
+		PX_FORCE_INLINE	PxRigidDynamic*			getPhysicsActor()				{ return mActor;							}
+
+		PX_FORCE_INLINE	PxReal					getRotationSpeed()		const	{ return mRotationSpeed;					}
+		PX_FORCE_INLINE	void					setRotationSpeed(PxReal s)		{ mRotationSpeed = s;						}
+
+		protected:
+						PxQuat					mLocalRot;		// Local rotation (const data)
+						PxU32					mNbPts;
+						PxVec3Alloc*			mPts;
+						PxRigidDynamic*			mActor;			// Physics
+						const PxBoxObstacle*	mBoxObstacle;
+						ObstacleHandle			mObstacle;		// Render
+						PxReal					mTravelTime;
+						PxReal					mRotationSpeed;
+						LoopMode				mMode;
+
+						PlatformState			mPhysicsState;
+						PlatformState			mRenderState;
+						void					updateState(PlatformState& state, PxObstacleContext* obstacleContext, PxReal dtime, bool updateActor)	const;
+	};
+
+	class KinematicPlatformManager : public SampleAllocateable
+	{
+		public:
+															KinematicPlatformManager();
+															~KinematicPlatformManager();
+
+						void								release();
+						KinematicPlatform*					createPlatform(PxU32 nbPts, const PxVec3* pts, const PxTransform& pose, const PxQuat& localRot, PxRigidDynamic* actor, PxReal platformSpeed, PxReal rotationSpeed, LoopMode mode=LOOP_FLIP);
+
+		PX_FORCE_INLINE	PxU32								getNbPlatforms()			{ return (PxU32)mPlatforms.size();	}
+		PX_FORCE_INLINE	KinematicPlatform**					getPlatforms()				{ return &mPlatforms[0];			}
+		PX_FORCE_INLINE	PxF32								getElapsedTime()			{ return mElapsedPlatformTime;		}
+		PX_FORCE_INLINE	void								syncElapsedTime(float time)	{ mElapsedPlatformTime = time;		}
+
+						void								updatePhysicsPlatforms(float dtime);
+
+		protected:
+						std::vector<KinematicPlatform*>		mPlatforms;
+						PxF32								mElapsedPlatformTime;
+	};
+
+
+#endif