diff options
Diffstat (limited to 'APEX_1.4/shared/external/src/TextRenderResourceManager.cpp')
| -rw-r--r-- | APEX_1.4/shared/external/src/TextRenderResourceManager.cpp | 1132 |
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); +} |