Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 1132 insertions, 0 deletions

diff --git a/APEX_1.4/shared/external/src/TextRenderResourceManager.cpp b/APEX_1.4/shared/external/src/TextRenderResourceManager.cpp
new file mode 100644
index 00000000..f8f48b6a
--- /dev/null
+++ b/APEX_1.4/shared/external/src/TextRenderResourceManager.cpp
@@ -0,0 +1,1132 @@
+/*
+ * 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 "TextRenderResourceManager.h"
+
+#include "UserRenderResource.h"
+#include "UserRenderResourceDesc.h"
+
+#include "RenderContext.h"
+
+
+TextRenderResourceManager::TextRenderResourceManager() :
+mVerbosity(0),
+	mOutputFile(NULL),
+	mIO(NULL),
+	mVertexBufferCount(0),
+	mIndexBufferCount(0),
+	mBoneBufferCount(0),
+	mInstanceBufferCount(0),
+	mSpriteBufferCount(0),
+	mRenderResourceCount(0),
+	mSurfaceBufferCount(0)
+{
+}
+
+
+TextRenderResourceManager::TextRenderResourceManager(int verbosity, const char* outputFilename) :
+	mVerbosity(verbosity),
+	mOutputFile(NULL),
+	mVertexBufferCount(0),
+	mIndexBufferCount(0),
+	mBoneBufferCount(0),
+	mInstanceBufferCount(0),
+	mSpriteBufferCount(0),
+	mRenderResourceCount(0),
+	mSurfaceBufferCount(0)
+{
+	if (outputFilename != NULL)
+	{
+		mOutputFile = fopen(outputFilename, "w");
+	}
+	else
+	{
+		mOutputFile = stdout;
+	}
+	PX_ASSERT(mOutputFile != NULL);
+	
+	mIO = new Writer(mOutputFile);
+}
+
+
+TextRenderResourceManager::~TextRenderResourceManager()
+{
+	if (mOutputFile != NULL && mOutputFile != stdout)
+	{
+		fclose(mOutputFile);
+	}
+
+	if (mIO != NULL)
+	{
+		delete mIO;
+		mIO = NULL;
+	}
+}
+
+unsigned int TextRenderResourceManager::material2Id(void* material)
+{
+	std::map<void*, unsigned int>::iterator it = mMaterial2Id.find(material);
+	if (it != mMaterial2Id.end())
+	{
+		return it->second;
+	}
+
+	unsigned int result = (unsigned int)mMaterial2Id.size();
+	mMaterial2Id[material] = result;
+
+	return result;
+}
+
+bool TextRenderResourceManager::getSpriteLayoutData(uint32_t spriteCount, uint32_t spriteSemanticsBitmap, nvidia::apex::UserRenderSpriteBufferDesc* bufferDesc)
+{
+	PX_UNUSED(spriteCount);
+	PX_UNUSED(spriteSemanticsBitmap);
+	PX_UNUSED(bufferDesc);
+	return false;
+}
+
+bool TextRenderResourceManager::getInstanceLayoutData(uint32_t particleCount, uint32_t particleSemanticsBitmap, nvidia::apex::UserRenderInstanceBufferDesc* bufferDesc)
+{
+	PX_UNUSED(particleCount);
+	PX_UNUSED(particleSemanticsBitmap);
+	PX_UNUSED(bufferDesc);
+	return false;
+}
+
+
+
+Writer::Writer(FILE* outputFile) : mOutputFile(outputFile)
+{
+	mIsStdout = mOutputFile == stdout;
+}
+
+Writer::~Writer() {}
+
+void Writer::printAndScan(const char* format)
+{
+	fprintf(mOutputFile,"%s", format);
+}
+
+void Writer::printAndScan(const char* format, const char* arg)
+{
+	fprintf(mOutputFile, format, arg);
+}
+
+void Writer::printAndScan(const char* format, int arg)
+{
+	fprintf(mOutputFile, format, arg);
+}
+
+void Writer::printAndScan(float /*tol*/, nvidia::apex::RenderVertexSemantic::Enum /*s*/, const char* format, float arg)
+{
+	fprintf(mOutputFile, format, arg);
+}
+
+const char* Writer::semanticToString(nvidia::apex::RenderVertexSemantic::Enum semantic)
+{
+	const char* result = NULL;
+	switch (semantic)
+	{
+#define CASE(_SEMANTIC) case nvidia::apex::RenderVertexSemantic::_SEMANTIC: result = #_SEMANTIC; break
+		CASE(POSITION);
+		CASE(NORMAL);
+		CASE(TANGENT);
+		CASE(BINORMAL);
+		CASE(COLOR);
+		CASE(TEXCOORD0);
+		CASE(TEXCOORD1);
+		CASE(TEXCOORD2);
+		CASE(TEXCOORD3);
+		CASE(BONE_INDEX);
+		CASE(BONE_WEIGHT);
+#undef CASE
+
+	default:
+		PX_ALWAYS_ASSERT();
+	}
+
+	return result;
+}
+
+
+
+const char* Writer::semanticToString(nvidia::apex::RenderBoneSemantic::Enum semantic)
+{
+	const char* result = NULL;
+	switch (semantic)
+	{
+#define CASE(_SEMANTIC) case nvidia::apex::RenderBoneSemantic::_SEMANTIC: result = #_SEMANTIC; break
+		CASE(POSE);
+		CASE(PREVIOUS_POSE);
+#undef CASE
+
+	// if this assert is hit add/remove semantics above to match RenderBoneSemantic
+	PX_COMPILE_TIME_ASSERT(nvidia::apex::RenderBoneSemantic::NUM_SEMANTICS == 2);
+
+	default:
+		PX_ALWAYS_ASSERT();
+	}
+
+	return result;
+}
+
+
+
+void Writer::writeElem(const char* name, unsigned int val)
+{
+	const bool isStdout = mIsStdout;
+
+	if (isStdout)
+	{
+		printAndScan("\n  ");
+	}
+	printAndScan("%s=", name);
+	printAndScan("%d", (int)val);
+	if (!isStdout)
+	{
+		printAndScan(" ");
+	}
+}
+
+
+
+void Writer::writeArray(nvidia::apex::RenderDataFormat::Enum format, unsigned int stride, unsigned int numElements, const void* data, float tolerance, nvidia::apex::RenderVertexSemantic::Enum s)
+{
+	if (mIsStdout)
+	{
+		unsigned int maxNumElements = 1000000;
+
+		switch (format)
+		{
+		case nvidia::apex::RenderDataFormat::USHORT1:
+		case nvidia::apex::RenderDataFormat::UINT1:
+			maxNumElements = 10;
+			break;
+		case nvidia::apex::RenderDataFormat::FLOAT2:
+			maxNumElements = 3;
+			break;
+		case nvidia::apex::RenderDataFormat::FLOAT3:
+			maxNumElements = 2;
+			break;
+		case nvidia::apex::RenderDataFormat::FLOAT3x4:
+		case nvidia::apex::RenderDataFormat::FLOAT4x4:
+			maxNumElements = 1;
+			break;
+		default:
+			PX_ALWAYS_ASSERT();
+		}
+
+		if (maxNumElements < numElements)
+		{
+			numElements = maxNumElements;
+		}
+	}
+
+	for (unsigned int i = 0; i < numElements; i++)
+	{
+		const char* dataSample = ((const char*)data) + stride * i;
+
+		switch (format)
+		{
+		case nvidia::apex::RenderDataFormat::USHORT1:
+		{
+			const short* sh = (const short*)dataSample;
+			printAndScan("%d ", sh[0]);
+		}
+		break;
+		case nvidia::apex::RenderDataFormat::USHORT2:
+		{
+			const short* sh = (const short*)dataSample;
+			printAndScan("(%d ", sh[0]);
+			printAndScan("%d )", sh[1]);
+		}
+		break;
+		case nvidia::apex::RenderDataFormat::USHORT3:
+			{
+				const short* sh = (const short*)dataSample;
+				printAndScan("(%d ", sh[0]);
+				printAndScan("%d ", sh[2]);
+				printAndScan("%d )", sh[1]);
+			}
+			break;
+		case nvidia::apex::RenderDataFormat::USHORT4:
+		{
+			const short* sh = (const short*)dataSample;
+			printAndScan("(%d ", sh[0]);
+			printAndScan("%d ", sh[1]);
+			printAndScan("%d ", sh[2]);
+			printAndScan("%d )", sh[3]);
+		}
+		break;
+		case nvidia::apex::RenderDataFormat::UINT1:
+		{
+			const unsigned int* ui = (const unsigned int*)dataSample;
+			printAndScan("%d ", (int)ui[0]);
+		}
+		break;
+		case nvidia::apex::RenderDataFormat::FLOAT2:
+		{
+			const float* fl = (const float*)dataSample;
+			printAndScan(tolerance, s, "(%f ", fl[0]);
+			printAndScan(tolerance, s, "%f ) ", fl[1]);
+		}
+		break;
+		case nvidia::apex::RenderDataFormat::FLOAT3:
+		{
+			const physx::PxVec3* vec3 = (const physx::PxVec3*)dataSample;
+			printAndScan(tolerance, s, "(%f ", vec3->x);
+			printAndScan(tolerance, s, "%f ", vec3->y);
+			printAndScan(tolerance, s, "%f ) ", vec3->z);
+		}
+		break;
+		case nvidia::apex::RenderDataFormat::FLOAT4:
+		{
+			const physx::PxVec4* vec4 = (const physx::PxVec4*)dataSample;
+			printAndScan(tolerance, s, "(%f ", vec4->x);
+			printAndScan(tolerance, s, "%f ", vec4->y);
+			printAndScan(tolerance, s, "%f ", vec4->z);
+			printAndScan(tolerance, s, "%f ) ", vec4->w);
+		}
+		break;
+		case nvidia::apex::RenderDataFormat::FLOAT3x4:
+		{
+			const physx::PxVec3* vec3 = (const physx::PxVec3*)dataSample;
+			printAndScan("(");
+			for (unsigned int j = 0; j < 4; j++)
+			{
+				printAndScan(tolerance, s, "%f ", vec3[j].x);
+				printAndScan(tolerance, s, "%f ", vec3[j].y);
+				printAndScan(tolerance, s, "%f ", vec3[j].z);
+			}
+			printAndScan(") ");
+		}
+		break;
+		case nvidia::apex::RenderDataFormat::FLOAT4x4:
+			{
+				const physx::PxVec4* vec4 = (const physx::PxVec4*)dataSample;
+				printAndScan("(");
+				for (unsigned int j = 0; j < 4; j++)
+				{
+					printAndScan(tolerance, s, "%f ", vec4[j].x);
+					printAndScan(tolerance, s, "%f ", vec4[j].y);
+					printAndScan(tolerance, s, "%f ", vec4[j].z);
+					printAndScan(tolerance, s, "%f ", vec4[j].w);
+				}
+				printAndScan(") ");
+			}
+			break;
+		case nvidia::apex::RenderDataFormat::R8G8B8A8:
+		case nvidia::apex::RenderDataFormat::B8G8R8A8:
+			{
+				const unsigned int* ui = (const unsigned int*)dataSample;
+				printAndScan("0x%x ", (int)ui[0]);
+			}
+		break;
+		default:
+			PX_ALWAYS_ASSERT();
+		}
+	}
+}
+
+
+#define WRITE_ITEM(_A) mIO->writeElem(#_A, _A)
+#define WRITE_DESC_ELEM(_A) mIO->writeElem(#_A, (uint32_t)desc._A)
+#define WRITE_VREQUEST(_A) if (desc.buffersRequest[nvidia::apex::RenderVertexSemantic::_A] != nvidia::apex::RenderDataFormat::UNSPECIFIED) mIO->writeElem(#_A, desc.buffersRequest[nvidia::apex::RenderVertexSemantic::_A])
+#define WRITE_BREQUEST(_A) if (desc.buffersRequest[nvidia::apex::RenderBoneSemantic::_A] != nvidia::apex::RenderDataFormat::UNSPECIFIED) mIO->writeElem(#_A, desc.buffersRequest[nvidia::apex::RenderBoneSemantic::_A])
+
+
+
+
+
+
+
+
+
+
+
+class TextUserRenderVertexBuffer : public nvidia::apex::UserRenderVertexBuffer
+{
+public:
+	TextUserRenderVertexBuffer(const nvidia::apex::UserRenderVertexBufferDesc& desc, TextRenderResourceManager* manager, Writer* readerWriter, int bufferId) : mManager(manager), mIO(readerWriter), mWriteCalls(0), mDescriptor(desc)
+	{
+		mBufferId = bufferId;
+
+		if (mManager->getVerbosity() >= 1)
+		{
+			mIO->printAndScan("VertexBuffer[%d]::create(", mBufferId);
+
+			WRITE_DESC_ELEM(maxVerts);
+			WRITE_DESC_ELEM(hint);
+			WRITE_VREQUEST(POSITION);
+			WRITE_VREQUEST(NORMAL);
+			WRITE_VREQUEST(TANGENT);
+			WRITE_VREQUEST(BINORMAL);
+			WRITE_VREQUEST(COLOR);
+			WRITE_VREQUEST(TEXCOORD0);
+			WRITE_VREQUEST(TEXCOORD1);
+			WRITE_VREQUEST(TEXCOORD2);
+			WRITE_VREQUEST(TEXCOORD3);
+			WRITE_VREQUEST(BONE_INDEX);
+			WRITE_VREQUEST(BONE_WEIGHT);
+			// PH: not done on purpose (yet)
+			//WRITE_DESC_ELEM(numCustomBuffers);
+			//void** 						customBuffersIdents;
+			//RenderDataFormat::Enum*	customBuffersRequest;
+			WRITE_DESC_ELEM(moduleIdentifier);
+			WRITE_DESC_ELEM(uvOrigin);
+			WRITE_DESC_ELEM(canBeShared);
+
+			mIO->printAndScan(")\n");
+		}
+	}
+
+	~TextUserRenderVertexBuffer()
+	{
+		if (mManager->getVerbosity() >= 1)
+		{
+			mIO->printAndScan("VertexBuffer[%d]::destroy\n", mBufferId);
+		}
+	}
+
+	virtual void writeBuffer(const nvidia::RenderVertexBufferData& data, uint32_t firstVertex, uint32_t numVertices)
+	{
+		if (mManager->getVerbosity() >= 2)
+		{
+			mIO->printAndScan("VertexBuffer[%d]", mBufferId);
+			mIO->printAndScan("::writeBuffer#%d", (int)mWriteCalls);
+			mIO->printAndScan("(firstVertex=%d ", (int)firstVertex);
+			mIO->printAndScan("numVertices=%d)\n", (int)numVertices);
+
+			if (mManager->getVerbosity() >= 3)
+			{
+				for (unsigned int i = 0; i < nvidia::apex::RenderVertexSemantic::NUM_SEMANTICS; i++)
+				{
+					nvidia::apex::RenderVertexSemantic::Enum s = nvidia::apex::RenderVertexSemantic::Enum(i);
+					const nvidia::apex::RenderSemanticData& semanticData = data.getSemanticData(s);
+
+					if (semanticData.data != NULL)
+					{
+						mIO->printAndScan(" %s: ", mIO->semanticToString(s));
+						mIO->writeArray(semanticData.format, semanticData.stride, numVertices, semanticData.data, mManager->getVBTolerance(s), s);
+						mIO->printAndScan("\n");
+					}
+				}
+			}
+		}
+
+		mWriteCalls++;
+	}
+
+
+	unsigned int getId()
+	{
+		return (uint32_t)mBufferId;
+	}
+
+
+protected:
+	TextRenderResourceManager* mManager;
+	Writer* mIO;
+	int mBufferId;
+	unsigned int mWriteCalls;
+	nvidia::apex::UserRenderVertexBufferDesc mDescriptor;
+};
+
+
+
+
+nvidia::apex::UserRenderVertexBuffer* TextRenderResourceManager::createVertexBuffer(const nvidia::apex::UserRenderVertexBufferDesc& desc)
+{
+	nvidia::apex::UserRenderVertexBuffer* vb = new TextUserRenderVertexBuffer(desc, this, mIO, mVertexBufferCount++);
+	return vb;
+};
+
+
+
+void TextRenderResourceManager::releaseVertexBuffer(nvidia::apex::UserRenderVertexBuffer& buffer)
+{
+	delete &buffer;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class TextUserRenderIndexBuffer : public nvidia::apex::UserRenderIndexBuffer
+{
+public:
+	TextUserRenderIndexBuffer(const nvidia::apex::UserRenderIndexBufferDesc& desc, TextRenderResourceManager* manager, Writer* readerWriter, int bufferId) : mManager(manager), mIO(readerWriter), mWriteCalls(0), mDescriptor(desc)
+	{
+		mBufferId = bufferId;
+
+		if (mManager->getVerbosity() >= 1)
+		{
+			mIO->printAndScan("IndexBuffer[%d]::create(", mBufferId);
+
+			WRITE_DESC_ELEM(maxIndices);
+			WRITE_DESC_ELEM(hint);
+			WRITE_DESC_ELEM(format);
+			WRITE_DESC_ELEM(primitives);
+			WRITE_DESC_ELEM(registerInCUDA);
+
+			mIO->printAndScan(")\n");
+		}
+	}
+
+	~TextUserRenderIndexBuffer()
+	{
+		if (mManager->getVerbosity() >= 1)
+		{
+			mIO->printAndScan("IndexBuffer[%d]::destroy\n", mBufferId);
+		}
+	}
+
+	virtual void writeBuffer(const void* srcData, uint32_t srcStride, uint32_t firstDestElement, uint32_t numElements)
+	{
+		if (mManager->getVerbosity() >= 2)
+		{
+			mIO->printAndScan("IndexBuffer[%d]", mBufferId);
+			mIO->printAndScan("::writeBuffer#%d", (int)mWriteCalls);
+			mIO->printAndScan("(srcStride=%d ", (int)srcStride);
+			mIO->printAndScan("firstDestElement=%d ", (int)firstDestElement);
+			mIO->printAndScan("numElements=%d)\n ", (int)numElements);
+
+			mIO->writeArray(mDescriptor.format, srcStride, numElements, srcData, 0.0f, nvidia::apex::RenderVertexSemantic::CUSTOM);
+
+			mIO->printAndScan("\n");
+		}
+
+		mWriteCalls++;
+	}
+
+
+	unsigned int getId()
+	{
+		return (uint32_t)mBufferId;
+	}
+
+protected:
+	TextRenderResourceManager* mManager;
+	Writer* mIO;
+	int mBufferId;
+	unsigned int mWriteCalls;
+	nvidia::apex::UserRenderIndexBufferDesc mDescriptor;
+};
+
+
+
+nvidia::apex::UserRenderIndexBuffer* TextRenderResourceManager::createIndexBuffer(const nvidia::apex::UserRenderIndexBufferDesc& desc)
+{
+	nvidia::apex::UserRenderIndexBuffer* ib = new TextUserRenderIndexBuffer(desc, this, mIO, mIndexBufferCount++);
+	return ib;
+}
+
+
+
+void TextRenderResourceManager::releaseIndexBuffer(nvidia::apex::UserRenderIndexBuffer& buffer)
+{
+	delete &buffer;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class TextUserRenderBoneBuffer : public nvidia::apex::UserRenderBoneBuffer
+{
+public:
+	TextUserRenderBoneBuffer(const nvidia::apex::UserRenderBoneBufferDesc& desc, TextRenderResourceManager* manager, Writer* readerWriter, int bufferId) : mManager(manager), mIO(readerWriter), mWriteCalls(0), mDescriptor(desc)
+	{
+		mBufferId = bufferId;
+
+		if (mManager->getVerbosity() >= 1)
+		{
+			mIO->printAndScan("BoneBuffer[%d]::create(", mBufferId);
+			WRITE_DESC_ELEM(maxBones);
+			WRITE_DESC_ELEM(hint);
+			WRITE_BREQUEST(POSE);
+			mIO->printAndScan(")\n");
+		}
+	}
+
+	~TextUserRenderBoneBuffer()
+	{
+		if (mManager->getVerbosity() >= 1)
+		{
+			mIO->printAndScan("BoneBuffer[%d]::destroy\n", mBufferId);
+		}
+	}
+
+	virtual void writeBuffer(const nvidia::RenderBoneBufferData& data, uint32_t firstBone, uint32_t numBones)
+	{
+		if (mManager->getVerbosity() >= 2)
+		{
+			mIO->printAndScan("BoneBuffer[%d]", mBufferId);
+			mIO->printAndScan("::writeBuffer#%d", (int)mWriteCalls);
+			mIO->printAndScan("(firstBone=%d ", (int)firstBone);
+			mIO->printAndScan("numBones=%d)\n", (int)numBones);
+
+			for (unsigned int i = 0; i < nvidia::apex::RenderBoneSemantic::NUM_SEMANTICS; i++)
+			{
+				nvidia::apex::RenderBoneSemantic::Enum s = nvidia::apex::RenderBoneSemantic::Enum(i);
+				const nvidia::apex::RenderSemanticData& semanticData = data.getSemanticData(s);
+
+				if (semanticData.data != NULL)
+				{
+					mIO->printAndScan(" %s: ", mIO->semanticToString(s));
+					mIO->writeArray(semanticData.format, semanticData.stride, numBones, semanticData.data, mManager->getBonePoseTolerance(), nvidia::apex::RenderVertexSemantic::CUSTOM);
+					mIO->printAndScan("\n");
+				}
+			}
+		}
+
+		mWriteCalls++;
+	}
+
+
+	unsigned int getId()
+	{
+		return (uint32_t)mBufferId;
+	}
+
+protected:
+	TextRenderResourceManager* mManager;
+	Writer* mIO;
+	int mBufferId;
+	unsigned int mWriteCalls;
+	nvidia::apex::UserRenderBoneBufferDesc mDescriptor;
+};
+
+
+
+nvidia::apex::UserRenderBoneBuffer* TextRenderResourceManager::createBoneBuffer(const nvidia::apex::UserRenderBoneBufferDesc& desc)
+{
+	nvidia::apex::UserRenderBoneBuffer* bb = new TextUserRenderBoneBuffer(desc, this, mIO, mBoneBufferCount++);
+	return bb;
+}
+
+
+
+void TextRenderResourceManager::releaseBoneBuffer(nvidia::apex::UserRenderBoneBuffer& buffer)
+{
+	delete &buffer;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class TextUserRenderInstanceBuffer : public nvidia::apex::UserRenderInstanceBuffer
+{
+public:
+	TextUserRenderInstanceBuffer(const nvidia::apex::UserRenderInstanceBufferDesc& desc, TextRenderResourceManager* manager, Writer* readerWriter, int bufferId) : mManager(manager), mIO(readerWriter), mDescriptor(desc)
+	{
+		mBufferId = bufferId;
+
+		if (mManager->getVerbosity() >= 1)
+		{
+			mIO->printAndScan("InstanceBuffer[%d]::create\n", mBufferId);
+		}
+	}
+
+	~TextUserRenderInstanceBuffer()
+	{
+		if (mManager->getVerbosity() >= 1)
+		{
+			mIO->printAndScan("InstanceBuffer[%d]::destroy\n", mBufferId);
+		}
+	}
+
+	virtual void writeBuffer(const void* /*data*/, uint32_t /*firstInstance*/, uint32_t /*numInstances*/)
+	{
+		if (mManager->getVerbosity() >= 2)
+		{
+			mIO->printAndScan("InstanceBuffer[%d]::writeBuffer\n", mBufferId);
+
+		}
+	}
+
+	unsigned int getId()
+	{
+		return (uint32_t)mBufferId;
+	}
+
+protected:
+	TextRenderResourceManager* mManager;
+	Writer* mIO;
+	FILE* mOutputFile;
+	int mBufferId;
+	nvidia::apex::UserRenderInstanceBufferDesc mDescriptor;
+};
+
+
+
+nvidia::apex::UserRenderInstanceBuffer* TextRenderResourceManager::createInstanceBuffer(const nvidia::apex::UserRenderInstanceBufferDesc& desc)
+{
+	nvidia::apex::UserRenderInstanceBuffer* ib = new TextUserRenderInstanceBuffer(desc, this, mIO, mInstanceBufferCount++);
+	return ib;
+}
+
+
+
+void TextRenderResourceManager::releaseInstanceBuffer(nvidia::apex::UserRenderInstanceBuffer& buffer)
+{
+	delete &buffer;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class TextUserRenderSpriteBuffer : public nvidia::apex::UserRenderSpriteBuffer
+{
+public:
+	TextUserRenderSpriteBuffer(const nvidia::apex::UserRenderSpriteBufferDesc& desc, TextRenderResourceManager* manager, Writer* readerWriter, int bufferId) : mManager(manager), mIO(readerWriter), mDescriptor(desc)
+	{
+		mBufferId = bufferId;
+
+		if (mManager->getVerbosity() >= 1)
+		{
+			mIO->printAndScan("SpriteBuffer[%d]::create\n", mBufferId);
+		}
+	}
+
+	~TextUserRenderSpriteBuffer()
+	{
+		if (mManager->getVerbosity() >= 1)
+		{
+			mIO->printAndScan("SpriteBuffer[%d]::destroy\n", mBufferId);
+		}
+	}
+
+	virtual void writeBuffer(const void* /*data*/, uint32_t /*firstSprite*/, uint32_t /*numSprites*/)
+	{
+		if (mManager->getVerbosity() >= 2)
+		{
+			mIO->printAndScan("SpriteBuffer[%d]::writeBuffer\n", mBufferId);
+		}
+	}
+
+
+	unsigned int getId()
+	{
+		return (uint32_t)mBufferId;
+	}
+
+protected:
+	TextRenderResourceManager* mManager;
+	Writer* mIO;
+	FILE* mOutputFile;
+	int mBufferId;
+	nvidia::apex::UserRenderSpriteBufferDesc mDescriptor;
+};
+
+
+
+nvidia::apex::UserRenderSpriteBuffer* TextRenderResourceManager::createSpriteBuffer(const nvidia::apex::UserRenderSpriteBufferDesc& desc)
+{
+	nvidia::apex::UserRenderSpriteBuffer* sb = new TextUserRenderSpriteBuffer(desc, this, mIO, mSpriteBufferCount++);
+	return sb;
+}
+
+
+
+void TextRenderResourceManager::releaseSpriteBuffer(nvidia::apex::UserRenderSpriteBuffer& buffer)
+{
+	delete &buffer;
+}
+
+
+
+
+
+class TextUserRenderSurfaceBuffer : public nvidia::apex::UserRenderSurfaceBuffer
+{
+public:
+	TextUserRenderSurfaceBuffer(const nvidia::apex::UserRenderSurfaceBufferDesc& desc, TextRenderResourceManager* manager, Writer* readerWriter, int bufferId) : mManager(manager), mIO(readerWriter), mDescriptor(desc)
+	{
+		mBufferId = bufferId;
+
+		if (mManager->getVerbosity() >= 1)
+		{
+			mIO->printAndScan("SurfaceBuffer[%d]::create\n", mBufferId);
+		}
+	}
+
+	~TextUserRenderSurfaceBuffer()
+	{
+		if (mManager->getVerbosity() >= 1)
+		{
+			mIO->printAndScan("SurfaceBuffer[%d]::destroy\n", mBufferId);
+		}
+	}
+
+	virtual void writeBuffer(const void* /*srcData*/, uint32_t /*srcPitch*/, uint32_t /*srcHeight*/, uint32_t /*dstX*/, uint32_t /*dstY*/, uint32_t /*dstZ*/, uint32_t /*width*/, uint32_t /*height*/, uint32_t /*depth*/)
+	{
+		if (mManager->getVerbosity() >= 2)
+		{
+			mIO->printAndScan("SurfaceBuffer[%d]::writeBuffer\n", mBufferId);
+		}
+	}
+
+
+	unsigned int getId()
+	{
+		return (uint32_t)mBufferId;
+	}
+
+protected:
+	TextRenderResourceManager* mManager;
+	Writer* mIO;
+	FILE* mOutputFile;
+	int mBufferId;
+	nvidia::apex::UserRenderSurfaceBufferDesc mDescriptor;
+};
+
+
+nvidia::apex::UserRenderSurfaceBuffer*	 TextRenderResourceManager::createSurfaceBuffer( const nvidia::apex::UserRenderSurfaceBufferDesc &desc )
+{
+	nvidia::apex::UserRenderSurfaceBuffer* sb = new TextUserRenderSurfaceBuffer(desc, this, mIO, mSurfaceBufferCount++);
+	return sb;
+}
+
+
+
+void TextRenderResourceManager::releaseSurfaceBuffer( nvidia::apex::UserRenderSurfaceBuffer &buffer )
+{
+	delete &buffer;
+}
+
+
+
+
+
+
+
+
+
+
+
+class TextUserRenderResource : public nvidia::apex::UserRenderResource
+{
+public:
+	TextUserRenderResource(const nvidia::apex::UserRenderResourceDesc& desc, TextRenderResourceManager* manager, Writer* readerWriter, int bufferId) : mManager(manager), mIO(readerWriter), mRenderCount(0), mDescriptor(desc)
+	{
+		mBufferId = bufferId;
+
+		if (mManager->getVerbosity() >= 1)
+		{
+			mIO->printAndScan("RenderResource[%d]::create(", mBufferId);
+
+			for (unsigned int i = 0; i < mDescriptor.numVertexBuffers; i++)
+			{
+				TextUserRenderVertexBuffer* vb = static_cast<TextUserRenderVertexBuffer*>(mDescriptor.vertexBuffers[i]);
+				mIO->writeElem("VertexBuffer", vb->getId());
+			}
+
+			if (mDescriptor.indexBuffer != NULL)
+			{
+				TextUserRenderIndexBuffer* ib = static_cast<TextUserRenderIndexBuffer*>(mDescriptor.indexBuffer);
+				mIO->writeElem("IndexBuffer", ib->getId());
+			}
+
+			if (mDescriptor.boneBuffer != NULL)
+			{
+				TextUserRenderBoneBuffer* bb = static_cast<TextUserRenderBoneBuffer*>(mDescriptor.boneBuffer);
+				mIO->writeElem("BoneBuffer", bb->getId());
+			}
+
+			if (mDescriptor.instanceBuffer != NULL)
+			{
+				TextUserRenderInstanceBuffer* ib = static_cast<TextUserRenderInstanceBuffer*>(mDescriptor.instanceBuffer);
+				mIO->writeElem("InstanceBuffer", ib->getId());
+			}
+
+			if (mDescriptor.spriteBuffer != NULL)
+			{
+				TextUserRenderSpriteBuffer* sp = static_cast<TextUserRenderSpriteBuffer*>(mDescriptor.spriteBuffer);
+				mIO->writeElem("SpriteBuffer", sp->getId());
+			}
+
+			{
+				unsigned int materialId = manager->material2Id(mDescriptor.material);
+				mIO->writeElem("Material", materialId);
+			}
+
+			WRITE_DESC_ELEM(numVertexBuffers);
+			WRITE_DESC_ELEM(firstVertex);
+			WRITE_DESC_ELEM(numVerts);
+			WRITE_DESC_ELEM(firstIndex);
+			WRITE_DESC_ELEM(numIndices);
+			WRITE_DESC_ELEM(firstBone);
+			WRITE_DESC_ELEM(numBones);
+			WRITE_DESC_ELEM(firstInstance);
+			WRITE_DESC_ELEM(numInstances);
+			WRITE_DESC_ELEM(firstSprite);
+			WRITE_DESC_ELEM(numSprites);
+			WRITE_DESC_ELEM(submeshIndex);
+			WRITE_DESC_ELEM(cullMode);
+			WRITE_DESC_ELEM(primitives);
+
+			mIO->printAndScan(")\n");
+		}
+	}
+
+	~TextUserRenderResource()
+	{
+		if (mManager->getVerbosity() >= 1)
+		{
+			mIO->printAndScan("RenderResource[%d]::destroy\n", mBufferId);
+		}
+	}
+
+
+
+	void setVertexBufferRange(unsigned int firstVertex, unsigned int numVerts)
+	{
+		mDescriptor.firstVertex = firstVertex;
+		mDescriptor.numVerts = numVerts;
+
+		if (mManager->getVerbosity() >= 2)
+		{
+			mIO->printAndScan("RenderResource[%d]", mBufferId);
+			mIO->printAndScan("::setVertexBufferRange(firstVertex=%d", (int)firstVertex);
+			mIO->printAndScan(" numVerts=%d)\n", (int)numVerts);
+		}
+	}
+
+
+
+	void setIndexBufferRange(unsigned int firstIndex, unsigned int numIndices)
+	{
+		mDescriptor.firstIndex = firstIndex;
+		mDescriptor.numIndices = numIndices;
+
+		if (mManager->getVerbosity() >= 2)
+		{
+			mIO->printAndScan("RenderResource[%d]", mBufferId);
+			mIO->printAndScan("::setIndexBufferRange(firstIndex=%d ", (int)firstIndex);
+			mIO->printAndScan("numIndices=%d)\n", (int)numIndices);
+		}
+	}
+
+
+
+	void setBoneBufferRange(unsigned int firstBone, unsigned int numBones)
+	{
+		mDescriptor.firstBone = firstBone;
+		mDescriptor.numBones = numBones;
+
+		if (mManager->getVerbosity() >= 2)
+		{
+			mIO->printAndScan("RenderResource[%d]", mBufferId);
+			mIO->printAndScan("::setBoneBufferRange(firstBone=%d ", (int)firstBone);
+			mIO->printAndScan("numBones=%d)\n", (int)numBones);
+		}
+	}
+
+
+
+	void setInstanceBufferRange(unsigned int firstInstance, unsigned int numInstances)
+	{
+		mDescriptor.firstInstance = firstInstance;
+		mDescriptor.numInstances = numInstances;
+
+		if (mManager->getVerbosity() >= 2)
+		{
+			mIO->printAndScan("RenderResource[%d]", mBufferId);
+			mIO->printAndScan("::setInstanceBufferRange(firstInstance=%d ", (int)firstInstance);
+			mIO->printAndScan("numInstances=%d)\n", (int)numInstances);
+		}
+	}
+
+
+
+	void setSpriteBufferRange(unsigned int firstSprite, unsigned int numSprites)
+	{
+		mDescriptor.firstSprite = firstSprite;
+		mDescriptor.numSprites = numSprites;
+
+		if (mManager->getVerbosity() >= 2)
+		{
+			mIO->printAndScan("RenderResource[%d]", mBufferId);
+			mIO->printAndScan("(firstSprite=%d ", (int)firstSprite);
+			mIO->printAndScan("numSprites=%d)\n", (int)numSprites);
+		}
+	}
+
+
+
+	void setMaterial(void* material)
+	{
+		mDescriptor.material = material;
+
+		if (mManager->getVerbosity() >= 2 && material != mDescriptor.material)
+		{
+			mIO->printAndScan("RenderResource[%d]", mBufferId);
+			mIO->printAndScan("::setMaterial(material=%d)\n", (int)mManager->material2Id(material));
+		}
+	}
+
+
+
+	unsigned int getNbVertexBuffers() const
+	{
+		return mDescriptor.numVertexBuffers;
+	}
+
+
+
+	nvidia::apex::UserRenderVertexBuffer* getVertexBuffer(unsigned int index) const
+	{
+		return mDescriptor.vertexBuffers[index];
+	}
+
+
+
+	nvidia::apex::UserRenderIndexBuffer* getIndexBuffer() const
+	{
+		return mDescriptor.indexBuffer;
+	}
+
+
+
+
+	nvidia::apex::UserRenderBoneBuffer* getBoneBuffer()	const
+	{
+		return mDescriptor.boneBuffer;
+	}
+
+
+
+	nvidia::apex::UserRenderInstanceBuffer* getInstanceBuffer()	const
+	{
+		return mDescriptor.instanceBuffer;
+	}
+
+
+
+	nvidia::apex::UserRenderSpriteBuffer* getSpriteBuffer() const
+	{
+		return mDescriptor.spriteBuffer;
+	}
+
+
+
+	void render(const nvidia::apex::RenderContext& context)
+	{
+		if (mManager->getVerbosity() >= 2)
+		{
+			mIO->printAndScan("RenderResource[%d]", mBufferId);
+			mIO->printAndScan("::render#%d(", (int)mRenderCount);
+
+			for (int i = 0; i < 4; i++)
+			{
+				for (int j = 0; j < 4; j++)
+				{
+					mIO->printAndScan(mManager->getRenderPoseTolerance(), nvidia::apex::RenderVertexSemantic::CUSTOM, "%f ", context.local2world[i][j]);
+				}
+			}
+
+			mIO->printAndScan(")\n");
+		}
+
+		mRenderCount++;
+	}
+
+protected:
+	TextRenderResourceManager* mManager;
+	Writer* mIO;
+	int mBufferId;
+	unsigned int mRenderCount;
+	nvidia::apex::UserRenderResourceDesc mDescriptor;
+};
+
+
+
+nvidia::apex::UserRenderResource* TextRenderResourceManager::createResource(const nvidia::apex::UserRenderResourceDesc& desc)
+{
+	nvidia::apex::UserRenderResource* rr = new TextUserRenderResource(desc, this, mIO, mRenderResourceCount++);
+	return rr;
+}
+
+
+
+void TextRenderResourceManager::releaseResource(nvidia::apex::UserRenderResource& resource)
+{
+	delete &resource;
+}
+
+
+
+unsigned int TextRenderResourceManager::getMaxBonesForMaterial(void* /*material*/)
+{
+	return 0;
+}
+
+
+
+void TextUserRenderer::renderResource(const nvidia::apex::RenderContext& context)
+{
+	TextUserRenderResource* rr = static_cast<TextUserRenderResource*>(context.renderResource);
+	rr->render(context);
+}