Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 686 insertions, 0 deletions

diff --git a/APEX_1.4/include/Scene.h b/APEX_1.4/include/Scene.h
new file mode 100644
index 00000000..1cc11325
--- /dev/null
+++ b/APEX_1.4/include/Scene.h
@@ -0,0 +1,686 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, 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.
+ */
+
+
+#ifndef SCENE_H
+#define SCENE_H
+
+/*!
+\file
+\brief classes Scene, SceneStats, SceneDesc
+*/
+
+#include "ApexDesc.h"
+#include "Renderable.h"
+#include "RenderDebugInterface.h"
+#include "Context.h"
+#include "foundation/PxVec3.h"
+#include <ApexDefs.h>
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+#include "PxFiltering.h"
+#endif
+#include "MirrorScene.h"
+
+namespace NvParameterized
+{
+class Interface;
+}
+
+namespace physx
+{
+	class PxBaseTask;
+	class PxTaskManager;
+	class PxCpuDispatcher;
+	class PxGpuDispatcher;
+}
+
+namespace nvidia
+{
+namespace apex
+{
+// Forward declaration for the PhysX3Interface::setContactReportFlags() callback
+class DestructibleActor;
+
+PX_PUSH_PACK_DEFAULT
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+/**
+\brief Interface used to call setter function for PhysX 3.0
+*/
+class PhysX3Interface
+{
+public:
+	/**
+	\brief Set the current contact report pair flags any time the Destructible module creates a PhysX 3.x shape
+
+	User can set the report pair flags to specified actor
+	*/
+	virtual void setContactReportFlags(PxShape* shape, physx::PxPairFlags flags, DestructibleActor* actor, uint16_t actorChunkIndex) = 0;
+
+	/**
+	\brief Get the current contact report pair flags
+
+	*/
+	virtual physx::PxPairFlags getContactReportFlags(const physx::PxShape* shape) const = 0;
+};
+#endif
+
+/**
+\brief Data used to initialize a new Scene
+*/
+class SceneDesc : public ApexDesc
+{
+public:
+
+	PX_INLINE SceneDesc() : ApexDesc()
+	{
+		init();
+	}
+
+	PX_INLINE void setToDefault()
+	{
+		ApexDesc::setToDefault();
+		init();
+	}
+
+
+	/** \brief Give this ApexScene an existing PxScene
+
+	The ApexScene will use the same CpuDispatcher and GpuDispatcher that were
+	provided to the PxScene when it was created.  There is no need to provide
+	these pointers in the ApexScene descriptor.
+	*/
+	PxScene* scene;
+
+	/** \brief Give this ApexScene an existing RenderDebugInterface
+	*/
+	RenderDebugInterface* debugInterface;
+
+#if PX_PHYSICS_VERSION_MAJOR == 0
+
+	/**
+	\brief Give this ApexScene a user defined CpuDispatcher
+
+	If cpuDispatcher is NULL, the APEX SDK will create and use a default
+	thread pool.
+	*/
+	PxCpuDispatcher* cpuDispatcher;
+
+	/**
+	\brief Give this ApexScene a user defined GpuDispatcher
+
+	If gpuDispatcher is NULL, this APEX scene will not use any GPU accelerated
+	features.
+	*/
+	PxGpuDispatcher* gpuDispatcher;
+
+#elif PX_PHYSICS_VERSION_MAJOR == 3
+
+	/** \brief Give this ApexScene a user defined interface to the PhysX 3.*
+	*/
+	PhysX3Interface* physX3Interface;
+
+#endif
+
+	/**
+	\brief Toggle the use of a legacy DebugRenderable for PhysX 2.8.x or PxRenderBuffer for 3.x
+
+	If true, then debug rendering will happen through the legacy DebugRenderable interface.
+	If false (the default value) it will render through the UserRenderResources interface.
+	*/
+	bool	useDebugRenderable;
+
+	/**
+	\brief Transmits debug rendering to PVD2 as well
+	*/
+	bool	debugVisualizeRemotely;
+
+	/**
+	\brief If 'debugVisualizeLocally' is true, then debug visualization which is being transmitted remotely will also be shown locally as well.
+	*/
+	bool	debugVisualizeLocally;
+
+	/**
+	\brief Switch for particles (BasicIOS, ParticleIOS, FieldSampler) which defines whether to use CUDA or not.
+	*/
+	bool 	useCuda;
+
+private:
+	PX_INLINE void init()
+	{
+#if PX_PHYSICS_VERSION_MAJOR == 0
+		cpuDispatcher = 0;
+		gpuDispatcher = 0;
+#elif PX_PHYSICS_VERSION_MAJOR == 3
+		physX3Interface	= 0;
+#endif
+		scene = 0;
+		debugInterface = 0;
+		useDebugRenderable = false;
+		debugVisualizeRemotely = false;
+		debugVisualizeLocally = true;
+#if APEX_CUDA_SUPPORT
+		useCuda = true;
+#else
+		useCuda = false;
+#endif
+	}
+};
+
+
+/**
+\brief APEX stat struct that contains the type enums
+*/
+struct StatDataType
+{
+	/**
+	\brief Enum of the APEX stat types
+	*/
+	enum Enum
+	{
+		INVALID = 0,
+		STRING  = 1,
+		INT     = 2,
+		FLOAT   = 3,
+		ENUM    = 4,
+		BOOL    = 5,
+	};
+};
+
+/**
+\brief data value definitions for stats (derived from openautomate)
+*/
+typedef struct oaValueStruct
+{
+	union
+	{
+		char*			String;
+		int32_t			Int;
+		float			Float;
+		char*			Enum;
+		bool			Bool;
+	};
+} StatValue;
+
+/**
+\brief data value definitions for stats
+*/
+typedef struct
+{
+	///name
+	const char*			StatName;
+
+	///type
+	StatDataType::Enum	StatType;
+
+	///current value
+	StatValue			StatCurrentValue;
+} StatsInfo;
+
+/**
+\brief Per scene statistics
+*/
+struct SceneStats
+{
+	/**\brief The number of ApexStats structures stored.
+	*/
+	uint32_t			numApexStats;
+	/**\brief Array of StatsInfo structures.
+	*/
+	StatsInfo*			ApexStatsInfoPtr;
+};
+
+/**
+\brief Types of view matrices handled by APEX
+
+USER_CUSTOMIZED : APEX simply uses the view matrix given. Need to setViewParams()
+LOOK_AT_RH: APEX gets the eye direction and eye position based on this kind of matrix.
+LOOK_AT_LH: APEX gets the eye direction and eye position based on this kind of matrix.
+
+*/
+struct ViewMatrixType
+{
+	/**
+	\brief Enum of the view matrices types
+	*/
+	enum Enum
+	{
+		USER_CUSTOMIZED = 0,
+		LOOK_AT_RH,
+		LOOK_AT_LH,
+	};
+};
+
+/**
+\brief Types of projection matrices handled by APEX
+
+USER_CUSTOMIZED : APEX simply uses the projection matrix given. Need to setProjParams()
+
+*/
+struct ProjMatrixType
+{
+	/**
+	\brief Enum of the projection matrices types
+	*/
+	enum Enum
+	{
+		USER_CUSTOMIZED = 0,
+	};
+};
+
+/**
+\brief Enum of the bounding box types
+*/
+struct UserBoundingBoxFlags
+{
+	/**
+	\brief Enum of the bounding box types
+	*/
+	enum Enum
+	{
+		NONE    = 1 << 0,
+		ENTER   = 1 << 1,
+		LEAVE   = 1 << 2
+	};
+};
+
+/**
+\brief An APEX wrapper for an PxScene
+*/
+class Scene : public Renderable, public Context, public ApexInterface
+{
+public:
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	/**
+	\brief Associate an PxScene with this Scene.
+
+	All Actors in the Scene will be added to the PxScene.
+	The PxScene pointer can be NULL, which will cause all APEX actors to be removed
+	from the previously specified PxScene.  This must be done before the PxScene
+	can be released.
+	*/
+	virtual void setPhysXScene(PxScene* s) = 0;
+
+	/**
+	\brief Retrieve the PxScene associated with this Scene
+	*/
+	virtual PxScene* getPhysXScene() const = 0;
+
+#endif
+
+	/**
+	\brief Retrieve scene statistics
+	*/
+	virtual const SceneStats* getStats(void) const = 0;
+
+	/**
+	\brief Start simulation of the APEX (and PhysX) scene
+
+	Start simulation of the Actors and the PxScene associated with this Scene.
+	No Actors should be added, deleted, or modified until fetchResults() is called.
+
+	Calls to simulate() should pair with calls to fetchResults():
+ 	Each fetchResults() invocation corresponds to exactly one simulate()
+ 	invocation; calling simulate() twice without an intervening fetchResults()
+ 	or fetchResults() twice without an intervening simulate() causes an error
+ 	condition.
+ 
+	\param[in] elapsedTime Amount of time to advance simulation by. <b>Range:</b> (0,inf)
+
+	\param[in] finalStep should be left as true, unless your application is manually sub stepping APEX
+	(and PhysX) and you do not intend to try to render the output of intermediate steps.
+
+	\param[in] completionTask if non-NULL, this task will have its refcount incremented in simulate(), then
+	decremented when the scene is ready to have fetchResults called. So the task will not run until the
+	application also calls removeReference() after calling simulate.
+
+	\param[in] scratchMemBlock a memory region for physx to use for temporary data during simulation. This block may be reused by the application
+	after fetchResults returns. Must be aligned on a 16-byte boundary
+
+	\param[in] scratchMemBlockSize the size of the scratch memory block. Must be a multiple of 16K.
+	*/
+	virtual void simulate(float elapsedTime, 
+						  bool finalStep = true, 
+						  PxBaseTask *completionTask = NULL,
+						  void* scratchMemBlock = 0, 
+						  uint32_t scratchMemBlockSize = 0) = 0;
+
+	/**
+	\brief Checks, and optionally blocks, for simulation completion.  Updates scene state.
+
+	Checks if Scene has completed simulating (optionally blocking for completion).  Updates
+	new state of Actors and the PxScene.  Returns true if simulation is complete.
+
+	\param block [in] - block until simulation is complete
+	\param errorState [out] - error value is written to this address, if not NULL
+	*/
+	virtual bool fetchResults(bool block, uint32_t* errorState) = 0;
+
+	/**
+	\brief Returns an DebugRenderable object that contains the data for debug rendering of this scene
+	*/
+	virtual const PxRenderBuffer* getRenderBuffer() const = 0;
+
+	/**
+	\brief Returns an DebugRenderable object that contains the data for debug rendering of this scene, in screenspace
+	*/
+	virtual const PxRenderBuffer* getRenderBufferScreenSpace() const = 0;
+
+	/**
+	\brief Checks, and optionally blocks, for simulation completion.
+
+	Performs same function as fetchResults(), but does not update scene state.  fetchResults()
+	must still be called before the next simulation step can begin.
+	*/
+	virtual bool checkResults(bool block) const = 0;
+
+	/**
+	\brief Allocate a view matrix. Returns a viewID that identifies this view matrix
+		   for future calls to setViewMatrix(). The matrix is de-allocated automatically
+		   when the scene is released.
+
+	Each call of this function allocates space for one view matrix. Since many features in
+	APEX require a projection matrix it is _required_ that the application call this method.
+	Max calls restricted to 1 for now.
+	If ViewMatrixType is USER_CUSTOMIZED, setViewParams() as well using this viewID.
+	If connected to PVD, PVD camera is set up.
+	@see ViewMatrixType
+	@see setViewParams()
+	*/
+	virtual uint32_t allocViewMatrix(ViewMatrixType::Enum) = 0;
+
+	/**
+	\brief Allocate a projection matrix. Returns a projID that identifies this projection matrix
+	       for future calls to setProjMatrix(). The matrix is de-allocated automatically
+		   when the scene is released.
+
+	Each call of this function allocates space for one projection matrix.  Since many features in
+	APEX require a projection matrix it is _required_ that the application call this method.
+	Max calls restricted to 1 for now.
+	If ProjMatrixType is USER_CUSTOMIZED, setProjParams() as well using this projID
+	@see ProjMatrixType
+	@see setProjParams()
+	*/
+	virtual uint32_t allocProjMatrix(ProjMatrixType::Enum) = 0;
+
+	/**
+	\brief Returns the number of view matrices allocated.
+	*/
+	virtual uint32_t getNumViewMatrices() const = 0;
+
+	/**
+	\brief Returns the number of projection matrices allocated.
+	*/
+	virtual uint32_t getNumProjMatrices() const = 0;
+
+	/**
+	\brief Sets the view matrix for the given viewID. Should be called whenever the view matrix needs to be updated.
+
+	If the given viewID's matrix type is identifiable as indicated in ViewMatrixType, eye position and eye direction are set as well, using values from this matrix.
+	Otherwise, make a call to setViewParams().
+	If connected to PVD, PVD camera is updated.
+	*/
+	virtual void setViewMatrix(const PxMat44& viewTransform, const uint32_t viewID = 0) = 0;
+
+	/**
+	\brief Returns the view matrix set by the user for the given viewID.
+
+	@see setViewMatrix()
+	*/
+	virtual PxMat44	getViewMatrix(const uint32_t viewID = 0) const = 0;
+
+	/**
+	\brief Sets the projection matrix for the given projID. Should be called whenever the projection matrix needs to be updated.
+
+	Make a call to setProjParams().
+	@see setProjParams()
+	*/
+	virtual void setProjMatrix(const PxMat44& projTransform, const uint32_t projID = 0) = 0;
+
+	/**
+	\brief Returns the projection matrix set by the user for the given projID.
+
+	@see setProjMatrix()
+	*/
+	virtual PxMat44	getProjMatrix(const uint32_t projID = 0) const = 0;
+
+	/**
+	\brief Sets the use of the view matrix and projection matrix as identified by their IDs. Should be called whenever either matrices needs to be updated.
+	*/
+	virtual void setUseViewProjMatrix(const uint32_t viewID = 0, const uint32_t projID = 0) = 0;
+
+	/**
+	\brief Sets the necessary information for the view matrix as identified by its viewID. Should be called whenever any of the listed parameters needs to be updated.
+
+	@see ViewMatrixType
+	*/
+	virtual void setViewParams(const PxVec3& eyePosition, const PxVec3& eyeDirection, const PxVec3& worldUpDirection = PxVec3(0, 1, 0), const uint32_t viewID = 0) = 0;
+
+	/**
+	\brief Sets the necessary information for the projection matrix as identified by its projID. Should be called whenever any of the listed parameters needs to be updated.
+
+	@see ProjMatrixType
+	*/
+	virtual void setProjParams(float nearPlaneDistance, float farPlaneDistance, float fieldOfViewDegree, uint32_t viewportWidth, uint32_t viewportHeight, const uint32_t projID = 0) = 0;
+
+	/**
+	\brief Returns the world space eye position.
+
+	@see ViewMatrixType
+	@see setViewMatrix()
+	*/
+	virtual PxVec3 getEyePosition(const uint32_t viewID = 0) const = 0;
+
+	/**
+	\brief Returns the world space eye direction.
+
+	@see ViewMatrixType
+	@see setViewMatrix()
+	*/
+	virtual PxVec3 getEyeDirection(const uint32_t viewID = 0) const = 0;
+
+	/**
+	\brief Returns the APEX scene's task manager
+	*/
+	virtual PxTaskManager* getTaskManager() const = 0;
+
+	/**
+	\brief Toggle the use of a debug renderable
+	*/
+	virtual void setUseDebugRenderable(bool state) = 0;
+
+	/**
+	\brief Gets debug rendering parameters from NvParameterized
+	*/
+	virtual ::NvParameterized::Interface* getDebugRenderParams() const = 0;
+
+	/**
+	\brief Gets module debug rendering parameters from NvParameterized
+	*/
+	virtual ::NvParameterized::Interface* getModuleDebugRenderParams(const char* name) const = 0;
+
+	/**
+	\brief Gets gravity value from PhysX or Apex scene for non PhysX configuration
+	*/
+	virtual PxVec3 getGravity() const = 0;
+
+	/**
+	\brief Sets gravity for PhysX or Apex scene for non PhysX configuration
+	*/
+	virtual void setGravity(const PxVec3& gravity) = 0;
+
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+	/**
+	\brief Acquire the PhysX scene lock for read access.
+	
+	The PhysX 3.2.2 SDK (and higher) provides a multiple-reader single writer mutex lock to coordinate	
+	access to the PhysX SDK API from multiple concurrent threads.  This method will in turn invoke the
+	lockRead call on the PhysX Scene.  The source code fileName and line number a provided for debugging
+	purposes.
+	*/
+	virtual void lockRead(const char *fileName,uint32_t lineo) = 0;
+
+	/**
+	\brief Acquire the PhysX scene lock for write access.
+	
+	The PhysX 3.2.2 SDK (and higher) provides a multiple-reader single writer mutex lock to coordinate	
+	access to the PhysX SDK API from multiple concurrent threads.  This method will in turn invoke the
+	lockWrite call on the PhysX Scene.  The source code fileName and line number a provided for debugging
+	purposes.
+	*/
+	virtual void lockWrite(const char *fileName,uint32_t lineno) = 0;
+
+	/**
+	\brief Release the PhysX scene read lock
+	*/
+	virtual void unlockRead() = 0;
+
+	/**
+	\brief Release the PhysX scene write lock
+	*/
+	virtual void unlockWrite() = 0;
+
+	/**
+	\brief Allows the application to specify a pair of PhysX actors for the purposes of collision filtering.
+
+	The set of methods addActorPair/removeActorPair and findActorPair can be used to implement collision filtering.
+	This is a feature typically required to implement ragdoll systems to prevent nearby bodies from generating 
+	contacts which create jitter in the simulation; causing artifacts and preventing a ragdoll from coming to rest.
+	
+	These methods are not required but are helper methods available if needed by the application.
+
+	\param actor0 The first actor in the actor pair to consider
+	\param actor1 The second actor in the actor pair to consider for filtering
+	*/
+	virtual void addActorPair(PxActor *actor0,PxActor *actor1) = 0;
+
+	/**
+	\brief Removes a previously specified pair of actors from the actor-pair filter table
+
+	\param actor0 The first actor in the actor pair to remove
+	\param actor1 The second actor in the actor pair to remove
+	*/
+	virtual void removeActorPair(PxActor *actor0,PxActor *actor1) = 0;
+
+	/**
+	\brief This method is used to determine if two actor pairs match.
+
+	If actor0 and actor1 were previously added to the actor-pair filter table, then this method will return true.  
+	Order is not important, actor0+actor1 will return the same result as actor1+actor0
+
+	\param actor0 The first actor to consider
+	\param actor1 The second actor to consider
+
+	\return Returns true if the two actors match false if they have not been previously defined.
+	*/
+	virtual bool findActorPair(PxActor *actor0,PxActor *actor1) const = 0;
+
+
+	/**
+	\brief Returns an MirrorScene helper class which keeps a primary APEX scene mirrored into a secondary scene.
+
+
+	\param mirrorScene [in] - The APEX scene that this scene will be mirrored into.
+	\param mirrorFilter [in] - The application provided callback interface to filter which actors/shapes get mirrored.
+	\param mirrorStaticDistance [in] - The distance to mirror static objects from the primary scene into the mirrored scene.
+	\param mirrorDynamicDistance [in] - The distance to mirror dynamic objects from the primary scene into the mirrored scene.
+	\param mirrorRefreshDistance [in] - The distance the camera should have moved before revising the trigger shapes controlling which actors get mirrored.
+	*/
+	virtual MirrorScene *createMirrorScene(nvidia::apex::Scene &mirrorScene,
+		MirrorScene::MirrorFilter &mirrorFilter,
+		float mirrorStaticDistance,
+		float mirrorDynamicDistance,
+		float mirrorRefreshDistance) = 0;
+#endif
+
+
+	/**
+	\brief Adds user-defined bounding box into the scene. Each module can use these bounding boxes in a module-specific way. See documentation on each module.
+	Some modules might use it as a valid volume of simulation, deleting actors or parts of actors upon leaving a BB.
+
+
+	\param bounds [in] - The bounding box in world coordinates.
+	\param flags [in] - The flag for supplied bounding box.
+	*/
+	virtual void addBoundingBox(const PxBounds3& bounds, UserBoundingBoxFlags::Enum flags) = 0;
+
+	/**
+	\brief Returns user-defined bounding box added previously. In case there is no bounding box for the given index, zero sized PxBounds3 is returned.
+
+
+	\param index [in] - Index of the bounding box. User could acquire total number of bounding boxes using getBoundingBoxCount.
+	*/
+	virtual const PxBounds3 getBoundingBox(const uint32_t index) const = 0;
+
+	/**
+	\brief Returns user-defined bounding box flags. In case there is no bounding box (and its flags) for the given index, UserBoundingBoxFlags::NONE is returned.
+
+
+	\param index [in] - Index of the bounding box. User could acquire total number of bounding boxes using getBoundingBoxCount.
+	*/
+	virtual UserBoundingBoxFlags::Enum getBoundingBoxFlags(const uint32_t index) const = 0;
+
+	/**
+	\brief Returns user-defined bounding box count.
+	*/
+	virtual uint32_t getBoundingBoxCount() const = 0;
+
+	/**
+	\brief Removes user-defined bounding box at index. In case index is invalid (there is no bounding box for this index) nothing is happenning.
+
+	\param index [in] - Index of the bounding box. User could acquire total number of bounding boxes using getBoundingBoxCount.
+	*/
+	virtual void  removeBoundingBox(const uint32_t index) = 0;
+
+	/**
+	\brief Removed all of the user-specified bounding boxes.
+	*/
+	virtual void  removeAllBoundingBoxes() = 0;
+
+	/**
+	\brief Returns CUDA test manager. For distribution builds return NULL
+	*/
+	virtual void* getCudaTestManager() const = 0;
+	
+	/**
+	\brief Returns CUDA profile manager. For distribution builds return NULL
+	*/
+	virtual void* getCudaProfileManager() const = 0;
+
+	/**
+	\brief Enables/disables CUDA error check after each kernel launch. 
+	
+	Use ONLY for DEBUG purposes, when enabled could dramatically slowdown performance!
+	*/
+	virtual void setCudaKernelCheckEnabled(bool enabled) = 0;
+	
+	/**
+	\brief Returns whether CUDA error check enabled
+	*/
+	virtual bool getCudaKernelCheckEnabled() const = 0;
+
+#if APEX_UE4
+	/**
+	\brief Update gravity
+	*/
+	virtual void updateGravity() = 0;
+#endif
+};
+
+
+PX_POP_PACK
+
+}
+} // end namespace nvidia::apex
+
+#endif // SCENE_H