Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 342 insertions, 0 deletions

diff --git a/APEX_1.4/samples_v2/SampleBase/ApexResourceCallback.cpp b/APEX_1.4/samples_v2/SampleBase/ApexResourceCallback.cpp
new file mode 100644
index 00000000..690c65ad
--- /dev/null
+++ b/APEX_1.4/samples_v2/SampleBase/ApexResourceCallback.cpp
@@ -0,0 +1,342 @@
+/*
+* 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.
+*/
+
+#include "ApexResourceCallback.h"
+
+#include "DestructibleAsset.h"
+#include "ClothingAsset.h"
+#include "EffectPackageAsset.h"
+
+#include "EmitterAsset.h"
+#include "ImpactEmitterAsset.h"
+#include "IofxAsset.h"
+#include "BasicIosAsset.h"
+#include "RenderMeshAsset.h"
+#include "ParticleIosAsset.h"
+
+#include <windows.h>
+#include "Utils.h"
+
+#include "UserOpaqueMesh.h"
+
+#include "ApexRenderMaterial.h"
+
+#include "PsString.h"
+
+using namespace physx;
+using namespace nvidia;
+
+#define PATH_MAX_LEN 512
+
+
+ApexResourceCallback::ApexResourceCallback()
+{
+	// search for root folder by default
+	addSearchDir(".");
+}
+
+void* ApexResourceCallback::requestResource(const char* nameSpace, const char* name)
+{
+	Asset* asset = 0;
+
+	if(!shdfnd::strcmp(nameSpace, DESTRUCTIBLE_AUTHORING_TYPE_NAME)
+		|| !shdfnd::strcmp(nameSpace, CLOTHING_AUTHORING_TYPE_NAME)
+		|| !shdfnd::strcmp(nameSpace, EMITTER_AUTHORING_TYPE_NAME)
+		|| !shdfnd::strcmp(nameSpace, IMPACT_EMITTER_AUTHORING_TYPE_NAME)
+		|| !shdfnd::strcmp(nameSpace, IOFX_AUTHORING_TYPE_NAME)
+		|| !shdfnd::strcmp(nameSpace, BASIC_IOS_AUTHORING_TYPE_NAME)
+		|| !shdfnd::strcmp(nameSpace, PARTICLE_IOS_AUTHORING_TYPE_NAME)
+		|| !shdfnd::strcmp(nameSpace, RENDER_MESH_AUTHORING_TYPE_NAME))
+	{
+		NvParameterized::Interface* params = deserializeFromFile(name);
+		if (params != NULL)
+		{
+			asset = mApexSDK->createAsset(params, name);
+			PX_ASSERT(asset && "ERROR Creating NvParameterized Asset");
+		}
+	}
+	else if (!shdfnd::strcmp(nameSpace, APEX_OPAQUE_MESH_NAME_SPACE))
+	{
+		NvParameterized::Interface* params = deserializeFromFile("woodChunkMesh");
+		if (params != NULL)
+		{
+			asset = mApexSDK->createAsset(params, "woodChunkMesh");
+			PX_ASSERT(asset && "ERROR Creating NvParameterized Asset");
+		}
+	}
+	else if(!shdfnd::strcmp(nameSpace, APEX_MATERIALS_NAME_SPACE))
+	{
+		// try load as GraphicMaterial first
+		if (mModuleParticles)
+		{
+			const NvParameterized::Interface *graphicMaterialData = mModuleParticles->locateGraphicsMaterialData(name);
+			if (graphicMaterialData)
+			{
+				ApexRenderMaterial* material = new ApexRenderMaterial(this, graphicMaterialData);
+				return material;
+			}
+		}
+
+		// try load from xml file then
+		char path[PATH_MAX_LEN];
+		const char* exts[] = { "xml" };
+		if (findFile(name, std::vector<const char*>(exts, exts + sizeof(exts) / sizeof(exts[0])), path))
+		{
+			ApexRenderMaterial* material = new ApexRenderMaterial(this, path);
+			return material;
+		}
+	}
+	else if (!shdfnd::strcmp(nameSpace, APEX_COLLISION_GROUP_128_NAME_SPACE))
+	{
+		return NULL;
+	}
+	else if (!shdfnd::strcmp(nameSpace, APEX_CUSTOM_VB_NAME_SPACE))
+	{
+		return NULL;
+	}
+
+	// try load from particles DB
+	if (asset == NULL && mModuleParticles)
+	{
+		// mModuleParticles
+		NvParameterized::Interface *iface = mModuleParticles->locateResource(name, nameSpace);
+		if (iface)
+		{
+			NvParameterized::Interface *copyInterface = NULL;
+			iface->clone(copyInterface);	// Create a copy of the parameterize data.
+			PX_ASSERT(copyInterface);
+			if (copyInterface)
+			{
+				asset = mApexSDK->createAsset(copyInterface, name);	// Create the asset using this NvParameterized::Inteface data
+				PX_ASSERT(asset);
+			}
+		}
+	}
+
+	PX_ASSERT_WITH_MESSAGE(asset, name);
+	return asset;
+}
+
+NvParameterized::Interface* ApexResourceCallback::deserializeFromFile(const char* name)
+{
+	NvParameterized::Interface* params = NULL;
+
+	char path[PATH_MAX_LEN];
+	const char* exts[] = { "apb", "apx" };
+	if (findFile(name, std::vector<const char*>(exts, exts + sizeof(exts) / sizeof(exts[0])), path))
+	{
+		PxFileBuf* stream = mApexSDK->createStream(path, PxFileBuf::OPEN_READ_ONLY);
+
+		if (stream)
+		{
+			NvParameterized::Serializer::SerializeType serType = mApexSDK->getSerializeType(*stream);
+			NvParameterized::Serializer::ErrorType serError;
+			NvParameterized::Serializer* ser = mApexSDK->createSerializer(serType);
+			PX_ASSERT(ser);
+
+			NvParameterized::Serializer::DeserializedData data;
+			serError = ser->deserialize(*stream, data);
+
+			if (serError == NvParameterized::Serializer::ERROR_NONE && data.size() == 1)
+			{
+				params = data[0];
+			}
+			else
+			{
+				PX_ASSERT(0 && "ERROR Deserializing NvParameterized Asset");
+			}
+
+			stream->release();
+			ser->release();
+		}
+	}
+
+	return params;
+}
+
+
+void ApexResourceCallback::releaseResource(const char* nameSpace, const char*, void* resource)
+{
+	if (!shdfnd::strcmp(nameSpace, DESTRUCTIBLE_AUTHORING_TYPE_NAME) ||
+		!shdfnd::strcmp(nameSpace, CLOTHING_AUTHORING_TYPE_NAME))
+	{
+		Asset* asset = (Asset*)resource;
+		mApexSDK->releaseAsset(*asset);
+	}
+	else if (!shdfnd::strcmp(nameSpace, APEX_MATERIALS_NAME_SPACE))
+	{
+		delete (ApexRenderMaterial*)resource;
+	}
+}
+
+void* ApexResourceCallback::requestResourceCustom(CustomResourceNameSpace customNameSpace, const char* name)
+{
+	std::pair<CustomResourceNameSpace, std::string> key(customNameSpace, name);
+	if (mCustomResources.find(key) == mCustomResources.end())
+	{
+		void *resource = NULL;
+		if (customNameSpace == eSHADER_FILE_PATH)
+		{
+			char* path = new char[PATH_MAX_LEN];
+			const char* exts[] = { "hlsl" };
+			if (findFile(name, std::vector<const char*>(exts, exts + sizeof(exts) / sizeof(exts[0])), path))
+			{
+				resource = path;
+			}
+			else
+			{
+				PX_ALWAYS_ASSERT_MESSAGE(name);
+				delete[] path;
+			}
+		}
+		else if (customNameSpace == eTEXTURE_RESOURCE)
+		{
+			char path[PATH_MAX_LEN];
+			const char* exts[] = { "dds", "tga" };
+			if (findFile(name, std::vector<const char*>(exts, exts + sizeof(exts) / sizeof(exts[0])), path))
+			{
+				TextureResource* textureResource = new TextureResource();
+				WCHAR wPath[MAX_PATH];
+				MultiByteToWideChar(CP_ACP, 0, path, -1, wPath, MAX_PATH);
+				wPath[MAX_PATH - 1] = 0;
+
+				const char* ext = strext(path);
+				if (::strcmp(ext, "dds") == 0)
+				{
+					V(DirectX::LoadFromDDSFile(wPath, DirectX::DDS_FLAGS_NONE, &textureResource->metaData,
+						textureResource->image));
+				}
+				else if (::strcmp(ext, "tga") == 0)
+				{
+					V(DirectX::LoadFromTGAFile(wPath, &textureResource->metaData,
+						textureResource->image));
+				}
+				else
+				{
+					PX_ALWAYS_ASSERT_MESSAGE("Unsupported texture extension");
+				}
+				resource = textureResource;
+			}
+		}
+
+		if (resource != NULL)
+		{
+			mCustomResources.emplace(key, resource);
+		}
+		else
+		{
+			PX_ALWAYS_ASSERT_MESSAGE(name);
+		}
+	}
+	return mCustomResources.at(key);
+}
+
+void ApexResourceCallback::addSearchDir(const char* dir, bool recursive)
+{
+	uint32_t len = dir && *dir ? (uint32_t)strlen(dir) : 0;
+	if(len)
+	{
+		len++;
+		char* searchPath = new char[len];
+		shdfnd::strlcpy(searchPath, len, dir);
+		SearchDir searcDir = { searchPath, recursive };
+		mSearchDirs.push_back(searcDir);
+	}
+}
+
+ApexResourceCallback::~ApexResourceCallback()
+{
+	// release search dirs
+	for(size_t i = 0; i < mSearchDirs.size(); i++)
+	{
+		delete[] mSearchDirs[i].path;
+	}
+	mSearchDirs.clear();
+
+	// release custom resources map
+	for (std::map<std::pair<CustomResourceNameSpace, std::string>, void*>::iterator it = mCustomResources.begin(); it != mCustomResources.end(); it++)
+	{
+		switch ((*it).first.first)
+		{
+		case eSHADER_FILE_PATH:
+			delete (char*)((*it).second);
+			break;
+		case eTEXTURE_RESOURCE:
+			delete (TextureResource*)((*it).second);
+			break;
+		default:
+			PX_ALWAYS_ASSERT();
+			break;
+		}
+	}
+	mCustomResources.clear();
+}
+
+bool ApexResourceCallback::findFileInDir(const char* fileNameFull, const char* path, bool recursive, char* foundPath)
+{
+	WIN32_FIND_DATA ffd;
+	char tmp[PATH_MAX_LEN];
+	shdfnd::snprintf(tmp, sizeof(tmp), "%s\\*", path);
+	HANDLE hFind = FindFirstFile(tmp, &ffd);
+
+	if(INVALID_HANDLE_VALUE == hFind)
+	{
+		return NULL;
+	}
+
+	do
+	{
+		if(0 == nvidia::strcmp(".", ffd.cFileName) || 0 == nvidia::strcmp("..", ffd.cFileName))
+			continue;
+
+		if(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+		{
+			char tmp[PATH_MAX_LEN];
+			shdfnd::snprintf(tmp, sizeof(tmp), "%s\\%s", path, ffd.cFileName);
+			if(findFileInDir(fileNameFull, tmp, recursive, foundPath))
+				return true;
+		}
+		else if(nvidia::stricmp(ffd.cFileName, fileNameFull) == 0)
+		{
+			shdfnd::snprintf(foundPath, PATH_MAX_LEN, "%s\\%s", path, ffd.cFileName);
+			return true;
+		}
+	} while(FindNextFile(hFind, &ffd) != 0);
+
+	return false;
+}
+
+bool ApexResourceCallback::findFile(const char* fileName, std::vector<const char*> exts, char* foundPath)
+{
+	std::string fileNameOnly = fileName;
+	size_t ind = fileNameOnly.find_last_of('/');
+	if (ind > 0)
+		fileNameOnly = fileNameOnly.substr(ind + 1);
+
+	for(size_t i = 0; i < mSearchDirs.size(); i++)
+	{
+		const SearchDir& searchDir = mSearchDirs[i];
+
+		for(size_t j = 0; j < exts.size(); j++)
+		{
+			const char* ext = exts[j];
+			const uint32_t fileMaxLen = 128;
+			char fileNameFull[fileMaxLen] = { 0 };
+
+			nvidia::shdfnd::snprintf(fileNameFull, fileMaxLen, "%s.%s", fileNameOnly.c_str(), ext);
+			if(findFileInDir(fileNameFull, searchDir.path, searchDir.recursive, foundPath))
+				return true;
+		}
+
+		if (findFileInDir(fileNameOnly.c_str(), searchDir.path, searchDir.recursive, foundPath))
+			return true;
+	}
+	return false;
+}