Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 507 insertions, 0 deletions

diff --git a/APEX_1.4/framework/include/ApexSDKImpl.h b/APEX_1.4/framework/include/ApexSDKImpl.h
new file mode 100644
index 00000000..ec977ae2
--- /dev/null
+++ b/APEX_1.4/framework/include/ApexSDKImpl.h
@@ -0,0 +1,507 @@
+/*
+ * 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 APEX_SDK_IMPL_H
+#define APEX_SDK_IMPL_H
+
+#include "Apex.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "ApexInterface.h"
+#include "ApexSDKHelpers.h"
+#include "ApexContext.h"
+#include "ApexPhysXObjectDesc.h"
+#include "FrameworkPerfScope.h"
+#include "ApexSDKIntl.h"
+#include "AuthorableObjectIntl.h"
+#include "SceneIntl.h"
+#include "RenderDebugInterface.h"
+#include "ApexRenderMeshAsset.h"
+#include "ApexAuthorableObject.h"
+#include "ModuleIntl.h"
+#include "DebugColorParamsEx.h"
+
+#include "ModuleCommonRegistration.h"
+#include "ModuleFrameworkRegistration.h"
+
+#include "ApexSDKCachedDataImpl.h"
+
+namespace physx
+{
+	class PxCudaContextManager;
+	class PxCudaContextManagerDesc;
+	
+	namespace pvdsdk
+	{
+		class PvdDataStream;
+		class ApexPvdClient;
+	}
+}
+
+#if APEX_CUDA_SUPPORT
+namespace nvidia
+{
+	class PhysXGpuIndicator;
+}
+#endif
+
+namespace nvidia
+{
+	namespace apex
+	{
+
+		class ApexResourceProvider;
+		class ApexScene;
+		class RenderMeshAsset;
+
+		typedef PxFileBuf* (CreateStreamFunc)(const char* filename, PxFileBuf::OpenMode mode);
+
+
+		// ApexAuthorableObject needs a "module", so we'll give it one that
+		// describes the APEX framework with regards to render mesh stuff
+		// needed: ModuleIntl, no methods implemented
+		class ModuleFramework : public ModuleIntl
+		{
+			void destroy() {}
+
+			ModuleSceneIntl* createInternalModuleScene(SceneIntl& apexScene, RenderDebugInterface* rd)
+			{
+				PX_UNUSED(apexScene);
+				PX_UNUSED(rd);
+				return NULL;
+			}
+
+			void           releaseModuleSceneIntl(ModuleSceneIntl& moduleScene)
+			{
+				PX_UNUSED(moduleScene);
+			}
+
+		public:
+
+			void init(NvParameterized::Traits* t);
+			void release(NvParameterized::Traits* t);
+		};
+
+
+		class ApexSDKImpl : public ApexSDKIntl, public ApexRWLockable, public UserAllocated
+		{
+		public:
+			APEX_RW_LOCKABLE_BOILERPLATE
+
+				ApexSDKImpl(ApexCreateError* errorCode, uint32_t APEXsdkVersion);
+			void					init(const ApexSDKDesc& desc);
+
+			/* ApexSDK */
+			Scene* 			createScene(const SceneDesc&);
+			void					releaseScene(Scene* scene);
+			AssetPreviewScene* createAssetPreviewScene();
+			void					releaseAssetPreviewScene(AssetPreviewScene* nxScene);
+
+			Module* 				createModule(const char* name, ApexCreateError* err);
+
+#if PX_PHYSICS_VERSION_MAJOR == 0
+			PxCpuDispatcher*	createCpuDispatcher(uint32_t numThreads);
+			PxCpuDispatcher*	getDefaultThreadPool();
+			void					releaseCpuDispatcher(PxCpuDispatcher& cd);
+#endif
+
+			/**
+			Creates/releases an ApexDebugRender interface
+			*/
+			virtual RenderDebugInterface* createApexRenderDebug(RENDER_DEBUG::RenderDebugInterface* iface, bool useRemoteDebugVisualization);
+			virtual void                releaseApexRenderDebug(RenderDebugInterface& debug);
+
+
+			/**
+			Create/release ApexShape interfaces
+			*/
+
+			virtual SphereShape* createApexSphereShape();
+			virtual CapsuleShape* createApexCapsuleShape();
+			virtual BoxShape* createApexBoxShape();
+			virtual HalfSpaceShape* createApexHalfSpaceShape();
+
+			virtual void releaseApexShape(Shape& shape);
+
+#if PX_PHYSICS_VERSION_MAJOR == 3
+			PhysXObjectDescIntl* 	createObjectDesc(const Actor*, const PxActor*);
+			PhysXObjectDescIntl* 	createObjectDesc(const Actor*, const PxShape*);
+			PhysXObjectDescIntl* 	createObjectDesc(const Actor*, const PxJoint*);
+			PhysXObjectDescIntl* 	createObjectDesc(const Actor*, const PxCloth*);
+			PhysXObjectDescIntl* 	createObjectDesc(const Actor*, const PxParticleSystem*);
+			PhysXObjectDescIntl* 	createObjectDesc(const Actor*, const PxParticleFluid*);
+			const PhysXObjectDesc* getPhysXObjectInfo(const PxActor*) const;
+			const PhysXObjectDesc* getPhysXObjectInfo(const PxShape*) const;
+			const PhysXObjectDesc* getPhysXObjectInfo(const PxJoint*) const;
+			const PhysXObjectDesc* getPhysXObjectInfo(const PxCloth*) const;
+			const PhysXObjectDesc* getPhysXObjectInfo(const PxParticleSystem*) const;
+			const PhysXObjectDesc* getPhysXObjectInfo(const PxParticleFluid*) const;
+			PxCooking* 	            getCookingInterface();
+			PxPhysics* 	    		getPhysXSDK();
+#endif // PX_PHYSICS_VERSION_MAJOR == 3
+
+			ApexActor*              getApexActor(Actor*) const;
+
+			// deprecated, use getErrorCallback()
+			PxErrorCallback* 		getOutputStream();
+			PxFoundation*			getFoundation() const;
+			PxErrorCallback* 		getErrorCallback() const;
+			PxAllocatorCallback* 	getAllocator() const;
+			ResourceProvider* 	getNamedResourceProvider();
+			ResourceProviderIntl* 	getInternalResourceProvider();
+			PxFileBuf* 		createStream(const char* filename, PxFileBuf::OpenMode mode);
+			PxFileBuf* 		createMemoryReadStream(const void* mem, uint32_t len);
+			PxFileBuf* 		createMemoryWriteStream(uint32_t alignment = 0);
+			const void* 			getMemoryWriteBuffer(PxFileBuf& stream, uint32_t& len);
+			void					releaseMemoryReadStream(PxFileBuf& stream);
+			void					releaseMemoryWriteStream(PxFileBuf& stream);
+
+			uint32_t			getNbModules();
+			Module**				getModules();
+			ModuleIntl**				getInternalModules();
+			void					releaseModule(Module* module);
+			ModuleIntl*				getInternalModuleByName(const char* name);
+
+			uint32_t			forceLoadAssets();
+
+			const char* 			checkAssetName(AuthorableObjectIntl& ao, const char* inName, ApexSimpleString& autoNameStorage);
+			AssetAuthoring*	createAssetAuthoring(const char* authorTypeName);
+			AssetAuthoring*	createAssetAuthoring(const char* authorTypeName, const char* name);
+			AssetAuthoring*	createAssetAuthoring(NvParameterized::Interface* params, const char* name);
+			Asset*			createAsset(AssetAuthoring&, const char*);
+			Asset* 			createAsset(NvParameterized::Interface* params, const char* name);
+			virtual Asset*	createAsset(const char* opaqueMeshName, UserOpaqueMesh* om);
+			void					releaseAsset(Asset& nxasset);
+			void					releaseAssetAuthoring(AssetAuthoring&);
+			/* ApexSDKIntl */
+			void					reportError(PxErrorCode::Enum code, const char* file, int line, const char* functionName, const char* message, ...);
+			void*					getTempMemory(uint32_t size);
+			void					releaseTempMemory(void* data);
+			NvParameterized::Traits* getParameterizedTraits()
+			{
+				return mParameterizedTraits;
+			}
+			uint32_t			getCookingVersion() const
+			{
+				return cookingVersion;
+			}
+			void					registerExternalModule(Module* nx, ModuleIntl* ni)
+			{
+				registerModule(nx, ni);
+			}
+
+			AuthObjTypeID			registerAuthObjType(const char*, ResID nsid);
+			AuthObjTypeID			registerAuthObjType(const char*, AuthorableObjectIntl* authObjPtr);
+			AuthObjTypeID			registerNvParamAuthType(const char*, AuthorableObjectIntl* authObjPtr);
+			void					unregisterAuthObjType(const char*);
+			void					unregisterNvParamAuthType(const char*);
+			AuthorableObjectIntl*	getAuthorableObject(const char*);
+			AuthorableObjectIntl*	getParamAuthObject(const char*);
+			bool					getAuthorableObjectNames(const char** authTypeNames, uint32_t& outCount, uint32_t inCount);
+			ResID					getMaterialNameSpace() const
+			{
+				return mMaterialNS;
+			}
+			ResID					getOpaqueMeshNameSpace() const
+			{
+				return mOpaqueMeshNS;
+			}
+			ResID					getCustomVBNameSpace() const
+			{
+				return mCustomVBNS;
+			}
+			ResID					getApexMeshNameSpace();
+			ResID					getCollisionGroupNameSpace() const
+			{
+				return mCollGroupNS;
+			}
+			ResID					getCollisionGroup128NameSpace() const
+			{
+				return mCollGroup128NS;
+			}
+			ResID					getCollisionGroup64NameSpace() const
+			{
+				return mCollGroup64NS;
+			}
+			ResID					getCollisionGroupMaskNameSpace() const
+			{
+				return mCollGroupMaskNS;
+			}
+			ResID					getPhysicalMaterialNameSpace() const
+			{
+				return mPhysMatNS;
+			}
+			ResID					getAuthorableTypesNameSpace() const
+			{
+				return mObjTypeNS;
+			}
+
+			void					releaseObjectDesc(void*);
+			UserRenderResourceManager* getUserRenderResourceManager() const
+			{
+				return renderResourceManagerWrapper ? renderResourceManagerWrapper : renderResourceManager;
+			}
+
+			const char* 			getWireframeMaterial();
+			const char* 			getSolidShadedMaterial();
+			virtual pvdsdk::ApexPvdClient* getApexPvdClient();
+			virtual profile::PxProfileZone * getProfileZone();
+			virtual profile::PxProfileZoneManager * getProfileZoneManager();
+
+			virtual void setEnableApexStats(bool enableApexStats)
+			{
+				mEnableApexStats = enableApexStats;
+			}
+
+			virtual void setEnableConcurrencyCheck(bool enableConcurrencyCheck)
+			{
+				mEnableConcurrencyCheck = enableConcurrencyCheck;
+			}
+
+			virtual bool isConcurrencyCheckEnabled()
+			{
+				return mEnableConcurrencyCheck;
+			}
+
+			bool isApexStatsEnabled() const
+			{
+				return mEnableApexStats;
+			}
+
+#if PX_WINDOWS_FAMILY
+			virtual const char*		getAppGuid();
+#endif
+
+#if APEX_CUDA_SUPPORT
+			virtual PhysXGpuIndicator* registerPhysXIndicatorGpuClient();
+			virtual void unregisterPhysXIndicatorGpuClient(PhysXGpuIndicator* gpuIndicator);
+#endif
+
+			ApexSDKCachedData&	getCachedData() const
+			{
+				return *mCachedData;
+			}
+
+			NvParameterized::Serializer* createSerializer(NvParameterized::Serializer::SerializeType type);
+			NvParameterized::Serializer* createSerializer(NvParameterized::Serializer::SerializeType type, NvParameterized::Traits* traits);
+
+			NvParameterized::Serializer::SerializeType getSerializeType(const void* data, uint32_t dlen);
+			NvParameterized::Serializer::SerializeType getSerializeType(PxFileBuf& stream);
+
+			NvParameterized::Serializer::ErrorType getSerializePlatform(const void* data, uint32_t dlen, NvParameterized::SerializePlatform& platform);
+			NvParameterized::Serializer::ErrorType getSerializePlatform(PxFileBuf& stream, NvParameterized::SerializePlatform& platform);
+			void getCurrentPlatform(NvParameterized::SerializePlatform& platform) const;
+			bool getPlatformFromString(const char* name, NvParameterized::SerializePlatform& platform) const;
+			const char* getPlatformName(const NvParameterized::SerializePlatform& platform) const;
+
+			NvParameterized::Interface* 	getDebugColorParams() const
+			{
+				return mDebugColorParams;
+			}
+			void					updateDebugColorParams(const char* color, uint32_t val);
+
+			bool					getRMALoadMaterialsLazily();
+
+			// applications can append strings to the APEX DLL filenames
+			const char* getCustomDllNamePostfix() const
+			{
+				return mCustomDllNamePostfix.c_str();
+			}
+
+			virtual ModuleIntl *getInternalModule(Module *module);
+			virtual Module *getModule(ModuleIntl *module);
+
+			virtual void enterURR();
+			virtual void leaveURR();
+			virtual void checkURR();
+
+		protected:
+			virtual ~ApexSDKImpl();
+			void					registerModule(Module*, ModuleIntl*);
+			void					release();
+
+		private:
+
+			void debugAsset(Asset* asset, const char* name);
+
+			ApexSimpleString                mDllLoadPath;
+			ApexSimpleString                mCustomDllNamePostfix;
+
+			ApexSimpleString                mWireframeMaterial;
+			ApexSimpleString                mSolidShadedMaterial;
+
+#if PX_WINDOWS_FAMILY
+			ApexSimpleString                mAppGuid;
+#endif
+
+			ResourceList* 				mAuthorableObjects;
+
+			physx::Array<Module*>			modules;
+			physx::Array<Module*>			moduleListForAPI;
+			physx::Array<ModuleIntl*>			imodules;
+			physx::Array<Scene*>		mScenes;
+
+			PhysXObjectDescIntl* 			createObjectDesc(const Actor*, const void*);
+			PhysXObjectDescIntl* 			getGenericPhysXObjectInfo(const void*) const;
+
+			enum { DescHashSize = 1024U * 32U };
+
+			uint32_t					mBatchSeedSize;
+
+			mutable nvidia::Mutex			mPhysXObjDescsLock;
+
+			physx::Array<ApexPhysXObjectDesc> mPhysXObjDescs;
+			uint32_t					mPhysXObjDescHash[DescHashSize];
+			uint32_t					mDescFreeList;
+			ResID                         mObjTypeNS;
+			ResID							mNxParamObjTypeNS;
+
+			char*							mErrorString;
+			//temp memories:
+			struct TempMemory
+			{
+				TempMemory() : memory(NULL), size(0), used(0) {}
+				void* memory;
+				uint32_t size;
+				uint32_t used;
+			};
+			physx::Array<TempMemory>		mTempMemories;
+			uint32_t						mNumTempMemoriesActive;	//temp memories are a LIFO, mNumTempMemoriesActive <= mTempMemories.size()
+			nvidia::Mutex					mTempMemoryLock;
+			nvidia::Mutex					mReportErrorLock;
+
+			PxFoundation*					foundation;
+
+#if PX_PHYSICS_VERSION_MAJOR == 0
+			PxCpuDispatcher*			mApexThreadPool;
+			physx::Array<PxCpuDispatcher*> mUserAllocThreadPools;
+#else
+			PxPhysics*	    				physXSDK;
+			PxCooking*	     			    cooking;
+#endif // PX_PHYSICS_VERSION_MAJOR == 0
+
+			UserRenderResourceManager*	renderResourceManager;
+			UserRenderResourceManager*	renderResourceManagerWrapper;
+			ApexResourceProvider*			apexResourceProvider;
+			uint32_t					physXsdkVersion;
+			uint32_t					cookingVersion;
+
+			NvParameterized::Traits*		mParameterizedTraits;
+
+			ResID							mMaterialNS;
+			ResID							mOpaqueMeshNS;
+			ResID							mCustomVBNS;
+			ResID							mCollGroupNS;
+			ResID							mCollGroup128NS;
+			ResID							mCollGroup64NS;
+			ResID							mCollGroupMaskNS;
+			ResID							mPhysMatNS;
+
+			ModuleFramework					frameworkModule;
+
+			ApexSDKCachedDataImpl*				mCachedData;
+
+			DebugColorParamsEx*				mDebugColorParams;
+
+			bool							mRMALoadMaterialsLazily;
+
+#ifdef PHYSX_PROFILE_SDK
+			pvdsdk::ApexPvdClient*				mApexPvdClient;
+			profile::PxProfileZone			*mProfileZone;
+#endif
+
+			uint32_t							mURRdepthTLSslot;
+
+			bool							mEnableApexStats;
+			bool							mEnableConcurrencyCheck;
+		};
+
+
+		///////////////////////////////////////////////////////////////////////////////
+		// ApexRenderMeshAssetAuthoring
+		///////////////////////////////////////////////////////////////////////////////
+		// Didn't use ApexAuthorableObject<> here because there were enough differences
+		// from a "normal" asset to make it difficult.  I could probably bend the will
+		// of the APEX render mesh to get it to comply, but it wasn't worth it at the time.
+		// -LRR
+
+		class RenderMeshAuthorableObject : public AuthorableObjectIntl
+		{
+		public:
+			RenderMeshAuthorableObject(ModuleIntl* m, ResourceList& list, const char* parameterizedName) :
+				AuthorableObjectIntl(m, list, ApexRenderMeshAsset::getClassName())
+			{
+				// Register the proper authorable object type in the NRP (override)
+				mAOResID = GetInternalApexSDK()->getInternalResourceProvider()->createNameSpace(mAOTypeName.c_str());
+				mAOPtrResID = GetInternalApexSDK()->registerAuthObjType(mAOTypeName.c_str(), this);
+
+				mParameterizedName = parameterizedName;
+
+				// Register the parameterized name in the NRP to point to this authorable object
+				GetInternalApexSDK()->registerNvParamAuthType(mParameterizedName.c_str(), this);
+			}
+
+			Asset* 			createAsset(AssetAuthoring& author, const char* name);
+			Asset* 			createAsset(NvParameterized::Interface* params, const char* name);
+
+			void					releaseAsset(Asset& nxasset);
+
+			AssetAuthoring* 	createAssetAuthoring();
+			AssetAuthoring* 	createAssetAuthoring(const char* name);
+			AssetAuthoring* 	createAssetAuthoring(NvParameterized::Interface* params, const char* name);
+			void					releaseAssetAuthoring(AssetAuthoring& nxauthor);
+
+			uint32_t					forceLoadAssets();
+			virtual uint32_t			getAssetCount()
+			{
+				return mAssets.getSize();
+			}
+			virtual bool			getAssetList(Asset** outAssets, uint32_t& outAssetCount, uint32_t inAssetCount)
+			{
+				PX_ASSERT(outAssets);
+				PX_ASSERT(inAssetCount >= mAssets.getSize());
+
+				if (!outAssets || inAssetCount < mAssets.getSize())
+				{
+					outAssetCount = 0;
+					return false;
+				}
+
+				outAssetCount = mAssets.getSize();
+				for (uint32_t i = 0; i < mAssets.getSize(); i++)
+				{
+					ApexRenderMeshAsset* asset = static_cast<ApexRenderMeshAsset*>(mAssets.getResource(i));
+					outAssets[i] = static_cast<Asset*>(asset);
+				}
+
+				return true;
+			}
+
+
+			ResID					getResID()
+			{
+				return mAOResID;
+			}
+
+			ApexSimpleString&		getName()
+			{
+				return mAOTypeName;
+			}
+
+			// Resource methods
+			void					release();
+			void					destroy();
+		};
+
+	}
+} // end namespace nvidia::apex
+
+
+#endif // APEX_SDK_IMPL_H