From 74b64a27f8e07b1b0b47b809b1a060518fa11a97 Mon Sep 17 00:00:00 2001 From: Bryan Galdrikian Date: Fri, 3 May 2019 00:25:46 -0700 Subject: Blast SDK 1.1.5 prerelease #1 --- .../import/source/NvBlastExtApexImportTool.cpp | 476 +++++++++++---------- 1 file changed, 260 insertions(+), 216 deletions(-) (limited to 'sdk/extensions/import/source') diff --git a/sdk/extensions/import/source/NvBlastExtApexImportTool.cpp b/sdk/extensions/import/source/NvBlastExtApexImportTool.cpp index fad9ade..44566f5 100755 --- a/sdk/extensions/import/source/NvBlastExtApexImportTool.cpp +++ b/sdk/extensions/import/source/NvBlastExtApexImportTool.cpp @@ -30,7 +30,7 @@ #if NV_VC #pragma warning(push) -#pragma warning(disable: 4996) // 'fopen' unsafe warning, from NxFileBuffer.h +#pragma warning(disable : 4996) // 'fopen' unsafe warning, from NxFileBuffer.h #endif #include "PxFoundation.h" @@ -40,7 +40,9 @@ #include #include #include "PxPhysics.h" -#include "NvBlastExtAuthoringCollisionBuilder.h" +#include "NvBlastExtAuthoringConvexMeshBuilder.h" +#include "NvBlastExtPxManager.h" +#include "NvBlastExtPxCollisionBuilder.h" #include "NvBlastExtPxAsset.h" #include "NvBlastExtAuthoring.h" #include "NvBlastExtAuthoringBondGenerator.h" @@ -74,6 +76,7 @@ #include #include "NvBlastPxCallbacks.h" +#include "NvBlastPxSharedHelpers.h" using namespace nvidia; using namespace physx; @@ -88,26 +91,26 @@ namespace Blast namespace ApexImporter { - /** - Should be consistent with IntPair in APEX - */ - struct IntPair +/** + Should be consistent with IntPair in APEX +*/ +struct IntPair +{ + void set(int32_t _i0, int32_t _i1) { - void set(int32_t _i0, int32_t _i1) - { - i0 = _i0; - i1 = _i1; - } + i0 = _i0; + i1 = _i1; + } - int32_t i0, i1; + int32_t i0, i1; + + static int compare(const void* a, const void* b) + { + const int32_t diff0 = ((IntPair*)a)->i0 - ((IntPair*)b)->i0; + return diff0 ? diff0 : (((IntPair*)a)->i1 - ((IntPair*)b)->i1); + } +}; - static int compare(const void* a, const void* b) - { - const int32_t diff0 = ((IntPair*)a)->i0 - ((IntPair*)b)->i0; - return diff0 ? diff0 : (((IntPair*)a)->i1 - ((IntPair*)b)->i1); - } - }; - bool ApexImportTool::loadAssetFromFile(physx::PxFileBuf* stream, NvParameterized::Serializer::DeserializedData& data) { if (stream && stream->isOpen()) @@ -115,7 +118,8 @@ bool ApexImportTool::loadAssetFromFile(physx::PxFileBuf* stream, NvParameterized NvParameterized::Serializer::SerializeType serType = NvParameterized::Serializer::peekSerializeType(*stream); NvParameterized::Serializer::ErrorType serError; - NvParameterized::Traits* traits = new NvParameterized::DefaultTraits(NvParameterized::DefaultTraits::BehaviourFlags::DEFAULT_POLICY); + NvParameterized::Traits* traits = + new NvParameterized::DefaultTraits(NvParameterized::DefaultTraits::BehaviourFlags::DEFAULT_POLICY); nvidia::destructible::ModuleDestructibleRegistration::invokeRegistration(traits); ModuleDestructibleLegacyRegistration::invokeRegistration(traits); @@ -157,25 +161,27 @@ bool ApexImportTool::isValid() enum ChunkFlags { - SupportChunk = (1 << 0), - UnfracturableChunk = (1 << 1), + SupportChunk = (1 << 0), + UnfracturableChunk = (1 << 1), DescendantUnfractureable = (1 << 2), - UndamageableChunk = (1 << 3), - UncrumbleableChunk = (1 << 4), - RuntimeFracturableChunk = (1 << 5), - Instanced = (1 << 8), + UndamageableChunk = (1 << 3), + UncrumbleableChunk = (1 << 4), + RuntimeFracturableChunk = (1 << 5), + Instanced = (1 << 8), }; uint32_t getPartIndex(const DestructibleAssetParameters* prm, uint32_t id) { auto& sch = prm->chunks.buf[id]; - return (sch.flags & ChunkFlags::Instanced) == 0 ? sch.meshPartIndex : prm->chunkInstanceInfo.buf[sch.meshPartIndex].partIndex; + return (sch.flags & ChunkFlags::Instanced) == 0 ? sch.meshPartIndex : + prm->chunkInstanceInfo.buf[sch.meshPartIndex].partIndex; } ApexImportTool::ApexImportTool() { - m_Foundation = PxCreateFoundation(PX_FOUNDATION_VERSION, NvBlastGetPxAllocatorCallback(), NvBlastGetPxErrorCallback()); + m_Foundation = + PxCreateFoundation(PX_FOUNDATION_VERSION, NvBlastGetPxAllocatorCallback(), NvBlastGetPxErrorCallback()); if (!m_Foundation) { NVBLAST_LOG_ERROR("Error: failed to create Foundation\n"); @@ -186,46 +192,47 @@ ApexImportTool::ApexImportTool() if (!m_PhysxSDK) { NVBLAST_LOG_ERROR("Error: failed to create PhysX\n"); - + return; } - + physx::PxCookingParams cookingParams(scale); cookingParams.buildGPUData = true; - m_Cooking = PxCreateCooking(PX_PHYSICS_VERSION, m_PhysxSDK->getFoundation(), cookingParams); + m_Cooking = PxCreateCooking(PX_PHYSICS_VERSION, m_PhysxSDK->getFoundation(), cookingParams); if (!m_Cooking) { NVBLAST_LOG_ERROR("Error: failed to create PhysX Cooking\n"); return; } - + m_collisionBuilder = ExtPxManager::createCollisionBuilder(*m_PhysxSDK, *m_Cooking); } -bool ApexImportTool::getCollisionGeometry(const NvParameterized::Interface* assetPrm, uint32_t chunkCount, std::vector& chunkReorderInvMap, - const std::vector& apexChunkFlags, std::vector& physicsChunks, - std::vector& physicsSubchunks, std::vector >& hullsDesc) +bool ApexImportTool::getCollisionGeometry(const NvParameterized::Interface* assetPrm, uint32_t chunkCount, + std::vector& chunkReorderInvMap, + const std::vector& apexChunkFlags, + std::vector& physicsChunks, + std::vector& physicsSubchunks, + std::vector >& hullsDesc) { physicsChunks.clear(); physicsChunks.resize(chunkCount); // prepare physics asset desc (convexes, transforms) - std::shared_ptr collisionBuilder( - NvBlastExtAuthoringCreateConvexMeshBuilder(m_Cooking, &m_PhysxSDK->getPhysicsInsertionCallback()), - [](ConvexMeshBuilder* cmb) { cmb->release(); }); const DestructibleAssetParameters* params = static_cast(assetPrm); - int32_t apexHullCount = 0; + int32_t apexHullCount = 0; const uint32_t apexChunkCount = params->chunks.arraySizes[0]; - + for (uint32_t chunkIndex = 0; chunkIndex < chunkCount; ++chunkIndex) { uint32_t apexChunkIndex = chunkReorderInvMap[chunkIndex]; if (apexChunkIndex < apexChunkCount) { - uint32_t partIndex = getPartIndex(params, apexChunkIndex); - uint32_t partConvexHullCount = params->chunkConvexHullStartIndices.buf[partIndex + 1] - params->chunkConvexHullStartIndices.buf[partIndex]; + uint32_t partIndex = getPartIndex(params, apexChunkIndex); + uint32_t partConvexHullCount = params->chunkConvexHullStartIndices.buf[partIndex + 1] - + params->chunkConvexHullStartIndices.buf[partIndex]; apexHullCount += partConvexHullCount; } } @@ -238,9 +245,11 @@ bool ApexImportTool::getCollisionGeometry(const NvParameterized::Interface* asse uint32_t apexChunkIndex = chunkReorderInvMap[chunkIndex]; if (apexChunkIndex < apexChunkCount) { - uint32_t partIndex = getPartIndex(params, apexChunkIndex); - uint32_t partConvexHullCount = params->chunkConvexHullStartIndices.buf[partIndex + 1] - params->chunkConvexHullStartIndices.buf[partIndex]; - NvParameterized::Interface** cxInterfaceArray = params->chunkConvexHulls.buf + params->chunkConvexHullStartIndices.buf[partIndex]; + uint32_t partIndex = getPartIndex(params, apexChunkIndex); + uint32_t partConvexHullCount = params->chunkConvexHullStartIndices.buf[partIndex + 1] - + params->chunkConvexHullStartIndices.buf[partIndex]; + NvParameterized::Interface** cxInterfaceArray = + params->chunkConvexHulls.buf + params->chunkConvexHullStartIndices.buf[partIndex]; physicsChunks[chunkIndex].subchunkCount = partConvexHullCount; for (uint32_t hull = 0; hull < partConvexHullCount; ++hull) { @@ -248,20 +257,21 @@ bool ApexImportTool::getCollisionGeometry(const NvParameterized::Interface* asse int32_t verticesCount = 0; paramHandle.getParameter("vertices"); paramHandle.getArraySize(verticesCount); - std::vector vertexData(verticesCount); - paramHandle.getParamVec3Array(vertexData.data(), verticesCount); + std::vector vertexData(verticesCount); + paramHandle.getParamVec3Array(toPxShared(vertexData.data()), verticesCount); hullsDesc[chunkIndex].push_back(nullptr); - hullsDesc[chunkIndex].back() = collisionBuilder.get()->buildCollisionGeometry(verticesCount, vertexData.data()); - PxConvexMesh* convexMesh = collisionBuilder.get()->buildConvexMesh(verticesCount, vertexData.data()); - - const ExtPxAssetDesc::SubchunkDesc subchunk = - { - PxTransform(PxIdentity), - PxConvexMeshGeometry(convexMesh) - }; + hullsDesc[chunkIndex].back() = + m_collisionBuilder->buildCollisionGeometry(verticesCount, vertexData.data()); + auto collisionHull = m_collisionBuilder->buildCollisionGeometry(verticesCount, vertexData.data()); + auto convexMesh = m_collisionBuilder->buildConvexMesh(*collisionHull); + m_collisionBuilder->releaseCollisionHull(collisionHull); + + const ExtPxAssetDesc::SubchunkDesc subchunk = { PxTransform(PxIdentity), + PxConvexMeshGeometry(convexMesh) }; physicsSubchunks.push_back(subchunk); } - physicsChunks[chunkIndex].subchunks = partConvexHullCount ? (&physicsSubchunks.back() + 1 - partConvexHullCount) : nullptr; + physicsChunks[chunkIndex].subchunks = + partConvexHullCount ? (&physicsSubchunks.back() + 1 - partConvexHullCount) : nullptr; // static flag set physicsChunks[chunkIndex].isStatic = (apexChunkFlags[apexChunkIndex] & (1 << 1)) != 0; @@ -282,7 +292,10 @@ bool ApexImportTool::getCollisionGeometry(const NvParameterized::Interface* asse return true; } -PxBounds3 gatherChunkTriangles(std::vector& chunkToPartMp, const nvidia::apex::RenderMeshAssetParameters* rmAsset, std::vector& chunkTrianglesOffsets, std::vector& chunkTriangles, int32_t posBufferIndex, float scale, PxVec3 offset ) +PxBounds3 +gatherChunkTriangles(std::vector& chunkToPartMp, const nvidia::apex::RenderMeshAssetParameters* rmAsset, + std::vector& chunkTrianglesOffsets, std::vector& chunkTriangles, + int32_t posBufferIndex, float scale, PxVec3 offset) { PxBounds3 bnd; @@ -293,16 +306,18 @@ PxBounds3 gatherChunkTriangles(std::vector& chunkToPartMp, const nvidi chunkTrianglesOffsets[0] = 0; for (uint32_t chunkIndex = 0; chunkIndex < chunkCount; ++chunkIndex) { - uint32_t part = chunkToPartMp[chunkIndex]; + uint32_t part = chunkToPartMp[chunkIndex]; uint32_t submeshCount = rmAsset->submeshes.arraySizes[0]; for (uint32_t submeshIndex = 0; submeshIndex < submeshCount; ++submeshIndex) { - nvidia::apex::SubmeshParameters* submeshPrm = static_cast(rmAsset->submeshes.buf[submeshIndex]); + nvidia::apex::SubmeshParameters* submeshPrm = + static_cast(rmAsset->submeshes.buf[submeshIndex]); const uint32_t* indexArray = submeshPrm->indexBuffer.buf + submeshPrm->indexPartition.buf[part]; uint32_t indexCount = submeshPrm->indexPartition.buf[part + 1] - submeshPrm->indexPartition.buf[part]; - nvidia::apex::VertexBufferParameters* vbuf = static_cast(submeshPrm->vertexBuffer); + nvidia::apex::VertexBufferParameters* vbuf = + static_cast(submeshPrm->vertexBuffer); nvidia::apex::BufferF32x3* pbuf = static_cast(vbuf->buffers.buf[posBufferIndex]); @@ -317,13 +332,10 @@ PxBounds3 gatherChunkTriangles(std::vector& chunkToPartMp, const nvidi bnd.include(positions[indexArray[i + 1]]); bnd.include(positions[indexArray[i + 2]]); - a.p = positions[indexArray[i]] - offset; - b.p = positions[indexArray[i + 1]] - offset; - c.p = positions[indexArray[i + 2]] - offset; - a.p *= scale; - b.p *= scale; - c.p *= scale; - chunkTriangles.push_back(Nv::Blast::Triangle(a, b, c)); + a.p = fromPxShared(positions[indexArray[i]] - offset) * scale; + b.p = fromPxShared(positions[indexArray[i + 1]] - offset) * scale; + c.p = fromPxShared(positions[indexArray[i + 2]] - offset) * scale; + chunkTriangles.push_back({a, b, c}); } } chunkTrianglesOffsets[chunkIndex + 1] = chunkTriangles.size(); @@ -332,7 +344,8 @@ PxBounds3 gatherChunkTriangles(std::vector& chunkToPartMp, const nvidi } bool ApexImportTool::importApexAsset(std::vector& chunkReorderInvMap, NvParameterized::Interface* assetNvIfc, - std::vector& chunkDescriptors, std::vector& bondDescriptors, std::vector& apexChunkFlags) + std::vector& chunkDescriptors, + std::vector& bondDescriptors, std::vector& apexChunkFlags) { ApexImporterConfig configDesc; configDesc.setDefaults(); @@ -341,17 +354,20 @@ bool ApexImportTool::importApexAsset(std::vector& chunkReorderInvMap, bool ApexImportTool::importApexAsset(std::vector& chunkReorderInvMap, NvParameterized::Interface* assetNvIfc, - std::vector& chunkDescriptors, std::vector& bondDescriptors, std::vector& apexChunkFlags, const ApexImporterConfig& configDesc) + std::vector& chunkDescriptors, + std::vector& bondDescriptors, + std::vector& apexChunkFlags, const ApexImporterConfig& configDesc) { - return importApexAssetInternal(chunkReorderInvMap, assetNvIfc, chunkDescriptors, bondDescriptors, apexChunkFlags, configDesc); + return importApexAssetInternal(chunkReorderInvMap, assetNvIfc, chunkDescriptors, bondDescriptors, apexChunkFlags, + configDesc); } - - - -bool ApexImportTool::importApexAssetInternal(std::vector& chunkReorderInvMap, NvParameterized::Interface* assetNvIfc, - std::vector& chunkDescriptors, std::vector& bondsDescriptors, std::vector& apexChunkFlags, const ApexImporterConfig& configDesc) +bool ApexImportTool::importApexAssetInternal(std::vector& chunkReorderInvMap, + NvParameterized::Interface* assetNvIfc, + std::vector& chunkDescriptors, + std::vector& bondsDescriptors, + std::vector& apexChunkFlags, const ApexImporterConfig& configDesc) { if (!assetNvIfc) { @@ -360,14 +376,15 @@ bool ApexImportTool::importApexAssetInternal(std::vector& chunkReorder } DestructibleAssetParameters* params = static_cast(assetNvIfc); - int32_t apexChunkCount = params->chunks.arraySizes[0]; + int32_t apexChunkCount = params->chunks.arraySizes[0]; uint32_t rootChunkIndex = 0; std::vector chunkToPartMapping(apexChunkCount); chunkDescriptors.resize(apexChunkCount); - nvidia::apex::RenderMeshAssetParameters* rmParam = static_cast(params->renderMeshAsset); + nvidia::apex::RenderMeshAssetParameters* rmParam = + static_cast(params->renderMeshAsset); std::vector perChunkBounds(apexChunkCount); PxBounds3 allRmBound; @@ -376,19 +393,21 @@ bool ApexImportTool::importApexAssetInternal(std::vector& chunkReorder for (uint32_t i = 0; i < (uint32_t)apexChunkCount; ++i) { // Use bounds center for centroid - uint32_t partIndex = getPartIndex(params, i); - chunkToPartMapping[i] = partIndex; + uint32_t partIndex = getPartIndex(params, i); + chunkToPartMapping[i] = partIndex; const PxBounds3 bounds = rmParam->partBounds.buf[partIndex]; perChunkBounds[i] = bounds; allRmBound.include(bounds); - + const PxVec3 center = bounds.getCenter(); memcpy(chunkDescriptors[i].centroid, ¢er.x, 3 * sizeof(float)); // Find chunk volume - uint32_t partConvexHullCount = params->chunkConvexHullStartIndices.buf[partIndex + 1] - params->chunkConvexHullStartIndices.buf[partIndex]; - NvParameterized::Interface** cxInterfaceArray = params->chunkConvexHulls.buf + params->chunkConvexHullStartIndices.buf[partIndex]; + uint32_t partConvexHullCount = + params->chunkConvexHullStartIndices.buf[partIndex + 1] - params->chunkConvexHullStartIndices.buf[partIndex]; + NvParameterized::Interface** cxInterfaceArray = + params->chunkConvexHulls.buf + params->chunkConvexHullStartIndices.buf[partIndex]; chunkDescriptors[i].volume = 0.0f; for (uint32_t hull = 0; hull < partConvexHullCount; ++hull) { @@ -402,7 +421,7 @@ bool ApexImportTool::importApexAssetInternal(std::vector& chunkReorder int16_t parent = params->chunks.buf[i].parentIndex; if (parent == -1) { - rootChunkIndex = i; + rootChunkIndex = i; chunkDescriptors[i].parentChunkIndex = UINT32_MAX; } else @@ -410,19 +429,20 @@ bool ApexImportTool::importApexAssetInternal(std::vector& chunkReorder chunkDescriptors[i].parentChunkIndex = parent; } - chunkDescriptors[i].flags = 0; + chunkDescriptors[i].flags = 0; chunkDescriptors[i].userData = i; } // Get support graph data from Apex asset // const NvParameterized::Interface* assetParameterized = assetNvIfc; - uint32_t maximumSupportDepth = 0; + uint32_t maximumSupportDepth = 0; NvParameterized::Handle parameterHandle(*assetParameterized); parameterHandle.getParameter("supportDepth"); parameterHandle.getParamU32(maximumSupportDepth); std::vector > overlapsBuffer; - nvidia::destructible::CachedOverlaps* overlapsArray = static_cast(params->overlapsAtDepth.buf[maximumSupportDepth]); + nvidia::destructible::CachedOverlaps* overlapsArray = + static_cast(params->overlapsAtDepth.buf[maximumSupportDepth]); uint32_t overlapsCount = overlapsArray->overlaps.arraySizes[0]; if (overlapsCount != 0) { @@ -437,7 +457,7 @@ bool ApexImportTool::importApexAssetInternal(std::vector& chunkReorder } } - // Format all connections as (chunk with lower index) -> (chunk with higher index) // + // Format all connections as (chunk with lower index) -> (chunk with higher index) // for (uint32_t i = 0; i < overlapsBuffer.size(); ++i) { @@ -456,14 +476,14 @@ bool ApexImportTool::importApexAssetInternal(std::vector& chunkReorder bondsDescriptors.resize(overlapsBuffer.size()); std::shared_ptr bondGenTool( - NvBlastExtAuthoringCreateBondGenerator(m_Cooking, &m_PhysxSDK->getPhysicsInsertionCallback()), - [](Nv::Blast::BlastBondGenerator* bg) {bg->release(); }); + NvBlastExtAuthoringCreateBondGenerator(m_collisionBuilder), + [](Nv::Blast::BlastBondGenerator* bg) { bg->release(); }); std::vector chunkTrianglesOffsets; std::vector chunkTriangles; - + PxBounds3 bnds = allRmBound; - PxVec3 offset = bnds.getCenter(); + PxVec3 offset = bnds.getCenter(); float scale = 1.0f / PxMax(PxAbs(bnds.getExtents(0)), PxMax(PxAbs(bnds.getExtents(1)), PxAbs(bnds.getExtents(2)))); bnds = gatherChunkTriangles(chunkToPartMapping, rmParam, chunkTrianglesOffsets, chunkTriangles, 0, scale, offset); @@ -482,8 +502,9 @@ bool ApexImportTool::importApexAssetInternal(std::vector& chunkReorder overlapsA.push_back(it.first); overlapsB.push_back(it.second); } - bondGenTool.get()->createBondBetweenMeshes(chunkTrianglesOffsets.size() - 1, chunkTrianglesOffsets.data(), chunkTriangles.data(), - overlapsBuffer.size(), overlapsA.data(), overlapsB.data(), bondsDesc, cf); + bondGenTool.get()->createBondBetweenMeshes(chunkTrianglesOffsets.size() - 1, chunkTrianglesOffsets.data(), + chunkTriangles.data(), overlapsBuffer.size(), overlapsA.data(), + overlapsB.data(), bondsDesc, cf); memcpy(bondsDescriptors.data(), bondsDesc, sizeof(NvBlastBondDesc) * bondsDescriptors.size()); NVBLAST_FREE(bondsDesc); @@ -499,9 +520,8 @@ bool ApexImportTool::importApexAssetInternal(std::vector& chunkReorder bondsDescriptors[i].bond.centroid[0] += offset.x; bondsDescriptors[i].bond.centroid[1] += offset.y; bondsDescriptors[i].bond.centroid[2] += offset.z; - } - + /// Delete all bonds with zero area /// for (uint32_t i = 0; i < bondsDescriptors.size(); ++i) { @@ -509,7 +529,7 @@ bool ApexImportTool::importApexAssetInternal(std::vector& chunkReorder { bondsDescriptors[i].chunkIndices[0] = bondsDescriptors.back().chunkIndices[0]; bondsDescriptors[i].chunkIndices[1] = bondsDescriptors.back().chunkIndices[1]; - bondsDescriptors[i].bond = bondsDescriptors.back().bond; + bondsDescriptors[i].bond = bondsDescriptors.back().bond; bondsDescriptors.pop_back(); --i; } @@ -521,7 +541,7 @@ bool ApexImportTool::importApexAssetInternal(std::vector& chunkReorder { for (uint32_t i = 0; i < chunkDescriptors.size(); i++) { - uint32_t chunkID = i; + uint32_t chunkID = i; const NvParameterized::Interface* assetInterface = assetNvIfc; NvParameterized::Handle chunksHandle(*assetInterface, "chunks"); chunksHandle.set(chunkID); @@ -537,9 +557,9 @@ bool ApexImportTool::importApexAssetInternal(std::vector& chunkReorder { NvBlastBondDesc bond; bond.chunkIndices[0] = i; - bond.chunkIndices[1] = UINT32_MAX; // invalid index for "world" - bond.bond.area = 0.1f; // ??? - PxVec3 center = perChunkBounds[i].getCenter(); + bond.chunkIndices[1] = UINT32_MAX; // invalid index for "world" + bond.bond.area = 0.1f; // ??? + PxVec3 center = perChunkBounds[i].getCenter(); memcpy(&bond.bond.centroid, ¢er.x, sizeof(PxVec3)); PxVec3 normal = PxVec3(0, 0, 1); memcpy(&bond.bond.normal, &normal.x, sizeof(PxVec3)); @@ -549,14 +569,17 @@ bool ApexImportTool::importApexAssetInternal(std::vector& chunkReorder } const uint32_t chunkCount = static_cast(chunkDescriptors.size()); - const uint32_t bondCount = static_cast(bondsDescriptors.size()); + const uint32_t bondCount = static_cast(bondsDescriptors.size()); std::vector chunkReorderMap(chunkCount); std::vector scratch(chunkCount); NvBlastEnsureAssetExactSupportCoverage(chunkDescriptors.data(), chunkCount, scratch.data(), logLL); - NvBlastBuildAssetDescChunkReorderMap(chunkReorderMap.data(), chunkDescriptors.data(), chunkCount, scratch.data(), logLL); - NvBlastApplyAssetDescChunkReorderMapInPlace(chunkDescriptors.data(), chunkCount, bondsDescriptors.data(), bondCount, chunkReorderMap.data(), true, scratch.data(), logLL); + NvBlastBuildAssetDescChunkReorderMap(chunkReorderMap.data(), chunkDescriptors.data(), chunkCount, scratch.data(), + logLL); + NvBlastApplyAssetDescChunkReorderMapInPlace(chunkDescriptors.data(), chunkCount, bondsDescriptors.data(), bondCount, + chunkReorderMap.data(), true, scratch.data(), logLL); chunkReorderInvMap.resize(chunkReorderMap.size()); - Nv::Blast::invertMap(chunkReorderInvMap.data(), chunkReorderMap.data(), static_cast(chunkReorderMap.size())); + Nv::Blast::invertMap(chunkReorderInvMap.data(), chunkReorderMap.data(), + static_cast(chunkReorderMap.size())); return true; } @@ -564,10 +587,10 @@ const float VEC_EPS = 1e-4f; class MaterialXmlParser : public physx::shdfnd::FastXml::Callback { -public: + public: std::string textureFile; -protected: + protected: // encountered a comment in the XML virtual bool processComment(const char* /*comment*/) { @@ -580,10 +603,11 @@ protected: } // return true to continue processing the XML document, false to skip. - virtual bool processElement(const char* elementName, // name of the element - const char* elementData, // element data, null if none - const physx::shdfnd::FastXml::AttributePairs& attr, - int /*lineno*/) // line number in the source XML file + virtual bool processElement(const char* elementName, // name of the element + const char* elementData, // element data, null if none + const physx::shdfnd::FastXml::AttributePairs& attr, int /*lineno*/) // line number in + // the source XML + // file { PX_UNUSED(attr); if (::strcmp(elementName, "sampler2D") == 0) @@ -610,21 +634,21 @@ protected: class PxInputDataFromPxFileBuf : public physx::PxInputData { -public: + public: PxInputDataFromPxFileBuf(physx::PxFileBuf& fileBuf) : mFileBuf(fileBuf) {} // physx::PxInputData interface - virtual uint32_t getLength() const + virtual uint32_t getLength() const { return mFileBuf.getFileLength(); } - virtual void seek(uint32_t offset) + virtual void seek(uint32_t offset) { mFileBuf.seekRead(offset); } - virtual uint32_t tell() const + virtual uint32_t tell() const { return mFileBuf.tellRead(); } @@ -636,7 +660,7 @@ public: } PX_NOCOPY(PxInputDataFromPxFileBuf) -private: + private: physx::PxFileBuf& mFileBuf; }; @@ -659,14 +683,18 @@ std::string getTextureFromMaterial(const char* materialPath) #define MAX_PATH_LEN 260 -bool ApexImportTool::importRendermesh(const std::vector& chunkReorderInvMap, const NvParameterized::Interface* assetNvIfc, ExporterMeshData* outputData, const char* materialsDir) +bool ApexImportTool::importRendermesh(const std::vector& chunkReorderInvMap, + const NvParameterized::Interface* assetNvIfc, ExporterMeshData* outputData, + const char* materialsDir) { - const nvidia::destructible::DestructibleAssetParameters* dasset = static_cast(assetNvIfc); - const nvidia::apex::RenderMeshAssetParameters* rmAsset = static_cast(dasset->renderMeshAsset); + const nvidia::destructible::DestructibleAssetParameters* dasset = + static_cast(assetNvIfc); + const nvidia::apex::RenderMeshAssetParameters* rmAsset = + static_cast(dasset->renderMeshAsset); outputData->submeshCount = rmAsset->submeshes.arraySizes[0]; - outputData->submeshMats = new Material[outputData->submeshCount]; + outputData->submeshMats = new Material[outputData->submeshCount]; std::vector materialArray(outputData->submeshCount); std::vector materialPathes; materialPathes.reserve(outputData->submeshCount); @@ -680,19 +708,19 @@ bool ApexImportTool::importRendermesh(const std::vector& chunkReorderI std::ostringstream materialPath; materialPath << materialsDir << "\\" << materialName; std::string texturePath = getTextureFromMaterial(materialPath.str().c_str()); - int32_t bfs = texturePath.length(); - char* texPath = new char[bfs + 1]; - char* matName = new char[bfs + 1]; + int32_t bfs = texturePath.length(); + char* texPath = new char[bfs + 1]; + char* matName = new char[bfs + 1]; memset(texPath, 0, sizeof(char) * (bfs + 1)); memset(matName, 0, sizeof(char) * (bfs + 1)); memcpy(texPath, texturePath.data(), sizeof(char) * bfs); - memcpy(matName, texturePath.data(), sizeof(char) * bfs); + memcpy(matName, texturePath.data(), sizeof(char) * bfs); outputData->submeshMats[submeshIndex].diffuse_tex = texPath; - outputData->submeshMats[submeshIndex].name = matName; + outputData->submeshMats[submeshIndex].name = matName; } else { - int32_t bfs = strnlen(materialName, MAX_PATH_LEN); + int32_t bfs = strnlen(materialName, MAX_PATH_LEN); char* texPath = new char[bfs]; char* matName = new char[bfs]; memset(texPath, 0, sizeof(char) * (bfs + 1)); @@ -700,7 +728,7 @@ bool ApexImportTool::importRendermesh(const std::vector& chunkReorderI memcpy(texPath, materialName, sizeof(char) * bfs); memcpy(matName, materialName, sizeof(char) * bfs); outputData->submeshMats[submeshIndex].diffuse_tex = texPath; - outputData->submeshMats[submeshIndex].name = matName; + outputData->submeshMats[submeshIndex].name = matName; } } } @@ -708,11 +736,16 @@ bool ApexImportTool::importRendermesh(const std::vector& chunkReorderI { bool operator()(const PxVec3& a, const PxVec3& b) const { - if (a.x + VEC_EPS < b.x) return true; - if (a.x - VEC_EPS > b.x) return false; - if (a.y + VEC_EPS < b.y) return true; - if (a.y - VEC_EPS > b.y) return false; - if (a.z + VEC_EPS < b.z) return true; + if (a.x + VEC_EPS < b.x) + return true; + if (a.x - VEC_EPS > b.x) + return false; + if (a.y + VEC_EPS < b.y) + return true; + if (a.y - VEC_EPS > b.y) + return false; + if (a.z + VEC_EPS < b.z) + return true; return false; } }; @@ -720,9 +753,12 @@ bool ApexImportTool::importRendermesh(const std::vector& chunkReorderI { bool operator()(const PxVec2& a, const PxVec2& b) const { - if (a.x + VEC_EPS < b.x) return true; - if (a.x - VEC_EPS > b.x) return false; - if (a.y + VEC_EPS < b.y) return true; + if (a.x + VEC_EPS < b.x) + return true; + if (a.x - VEC_EPS > b.x) + return false; + if (a.y + VEC_EPS < b.y) + return true; return false; } }; @@ -744,12 +780,15 @@ bool ApexImportTool::importRendermesh(const std::vector& chunkReorderI { for (uint32_t submeshIndex = 0; submeshIndex < outputData->submeshCount; ++submeshIndex) { - nvidia::apex::SubmeshParameters* currentSubmesh = static_cast(rmAsset->submeshes.buf[submeshIndex]); - nvidia::apex::VertexBufferParameters* vbuf = static_cast(currentSubmesh->vertexBuffer); - nvidia::apex::VertexFormatParameters* vbufFormat = static_cast(vbuf->vertexFormat); + nvidia::apex::SubmeshParameters* currentSubmesh = + static_cast(rmAsset->submeshes.buf[submeshIndex]); + nvidia::apex::VertexBufferParameters* vbuf = + static_cast(currentSubmesh->vertexBuffer); + nvidia::apex::VertexFormatParameters* vbufFormat = + static_cast(vbuf->vertexFormat); uint32_t indexCount = vbuf->vertexCount; // Find position buffer index - int32_t vbufIds[3]; // 0 - pos, 1 - normals, 2 - t-coord + int32_t vbufIds[3]; // 0 - pos, 1 - normals, 2 - t-coord vbufIds[0] = vbufIds[1] = vbufIds[2] = -1; { for (int32_t bid = 0; bid < vbufFormat->bufferFormats.arraySizes[0]; ++bid) @@ -770,9 +809,9 @@ bool ApexImportTool::importRendermesh(const std::vector& chunkReorderI } if (vbufIds[0] != -1) { - BufferF32x3* pbuf = static_cast(vbuf->buffers.buf[vbufIds[0]]); + BufferF32x3* pbuf = static_cast(vbuf->buffers.buf[vbufIds[0]]); const PxVec3* posistions = pbuf->data.buf; - uint32_t oldSize = (uint32_t)positionsMapping.size(); + uint32_t oldSize = (uint32_t)positionsMapping.size(); positionsMapping.resize(oldSize + indexCount); for (uint32_t i = 0; i < indexCount; ++i) @@ -780,7 +819,7 @@ bool ApexImportTool::importRendermesh(const std::vector& chunkReorderI auto it = posMap.find(posistions[i]); if (it == posMap.end()) { - posMap[posistions[i]] = (uint32_t)compressedPositions.size(); + posMap[posistions[i]] = (uint32_t)compressedPositions.size(); positionsMapping[oldSize + i] = (uint32_t)compressedPositions.size(); compressedPositions.push_back(posistions[i]); } @@ -793,16 +832,16 @@ bool ApexImportTool::importRendermesh(const std::vector& chunkReorderI if (vbufIds[1] != -1) { - BufferF32x3* pbuf = static_cast(vbuf->buffers.buf[vbufIds[1]]); + BufferF32x3* pbuf = static_cast(vbuf->buffers.buf[vbufIds[1]]); const PxVec3* normals = pbuf->data.buf; - uint32_t oldSize = (uint32_t)normalsMapping.size(); + uint32_t oldSize = (uint32_t)normalsMapping.size(); normalsMapping.resize(oldSize + indexCount); for (uint32_t i = 0; i < indexCount; ++i) { auto it = normMap.find(normals[i]); if (it == normMap.end()) { - normMap[normals[i]] = (uint32_t)compressedNormals.size(); + normMap[normals[i]] = (uint32_t)compressedNormals.size(); normalsMapping[oldSize + i] = (uint32_t)compressedNormals.size(); compressedNormals.push_back(normals[i]); } @@ -814,16 +853,16 @@ bool ApexImportTool::importRendermesh(const std::vector& chunkReorderI } if (vbufIds[2] != -1) { - BufferF32x2* pbuf = static_cast(vbuf->buffers.buf[vbufIds[2]]); + BufferF32x2* pbuf = static_cast(vbuf->buffers.buf[vbufIds[2]]); const PxVec2* texCoord = reinterpret_cast(pbuf->data.buf); - uint32_t oldSize = (uint32_t)texturesMapping.size(); + uint32_t oldSize = (uint32_t)texturesMapping.size(); texturesMapping.resize(oldSize + indexCount); for (uint32_t i = 0; i < indexCount; ++i) { auto it = texMap.find(texCoord[i]); if (it == texMap.end()) { - texMap[texCoord[i]] = (uint32_t)compressedTextures.size(); + texMap[texCoord[i]] = (uint32_t)compressedTextures.size(); texturesMapping[oldSize + i] = (uint32_t)compressedTextures.size(); compressedTextures.push_back(texCoord[i]); } @@ -835,84 +874,84 @@ bool ApexImportTool::importRendermesh(const std::vector& chunkReorderI } } } - for (uint32_t i = 0; i < compressedTextures.size(); ++i) + for (uint32_t i = 0; i < compressedTextures.size(); ++i) + { + std::swap(compressedTextures[i].x, compressedTextures[i].y); + } + + outputData->positionsCount = (uint32_t)compressedPositions.size(); + // meshData.positions = compressedPositions.data(); + outputData->positions = new NvcVec3[outputData->positionsCount]; + memcpy(outputData->positions, compressedPositions.data(), sizeof(NvcVec3) * outputData->positionsCount); + outputData->normalsCount = (uint32_t)compressedNormals.size(); + // meshData.normals = compressedNormals.data(); + outputData->normals = new NvcVec3[outputData->normalsCount]; + memcpy(outputData->normals, compressedNormals.data(), sizeof(NvcVec3) * outputData->normalsCount); + outputData->uvsCount = (uint32_t)compressedTextures.size(); + // meshData.uvs = compressedTextures.data(); + outputData->uvs = new NvcVec2[outputData->uvsCount]; + memcpy(outputData->uvs, compressedTextures.data(), sizeof(NvcVec2) * outputData->uvsCount); + + uint32_t apexChunkCount = dasset->chunks.arraySizes[0]; + outputData->meshCount = (uint32_t)chunkReorderInvMap.size(); + outputData->submeshOffsets = new uint32_t[outputData->meshCount * outputData->submeshCount + 1]{ 0 }; + + // count total number of indices + for (uint32_t chunkIndex = 0; chunkIndex < apexChunkCount; ++chunkIndex) + { + uint32_t apexChunkIndex = chunkReorderInvMap[chunkIndex]; + if (apexChunkIndex >= apexChunkCount) { - std::swap(compressedTextures[i].x, compressedTextures[i].y); + PX_ALWAYS_ASSERT(); + continue; } + uint32_t part = getPartIndex(dasset, chunkIndex); + for (uint32_t submeshIndex = 0; submeshIndex < outputData->submeshCount; ++submeshIndex) + { + SubmeshParameters* sm = static_cast(rmAsset->submeshes.buf[submeshIndex]); - outputData->positionsCount = (uint32_t)compressedPositions.size(); - //meshData.positions = compressedPositions.data(); - outputData->positions = new PxVec3[outputData->positionsCount]; - memcpy(outputData->positions, compressedPositions.data(), sizeof(PxVec3) * outputData->positionsCount); - outputData->normalsCount = (uint32_t)compressedNormals.size(); - //meshData.normals = compressedNormals.data(); - outputData->normals = new PxVec3[outputData->normalsCount]; - memcpy(outputData->normals, compressedNormals.data(), sizeof(PxVec3) * outputData->normalsCount); - outputData->uvsCount = (uint32_t)compressedTextures.size(); - //meshData.uvs = compressedTextures.data(); - outputData->uvs = new PxVec2[outputData->uvsCount]; - memcpy(outputData->uvs, compressedTextures.data(), sizeof(PxVec2) * outputData->uvsCount); - - uint32_t apexChunkCount = dasset->chunks.arraySizes[0]; - outputData->meshCount = (uint32_t)chunkReorderInvMap.size(); - outputData->submeshOffsets = new uint32_t[outputData->meshCount * outputData->submeshCount + 1]{ 0 }; - - //count total number of indices - for (uint32_t chunkIndex = 0; chunkIndex < apexChunkCount; ++chunkIndex) + uint32_t indexCount = sm->indexPartition.buf[part + 1] - sm->indexPartition.buf[part]; + uint32_t* firstIdx = outputData->submeshOffsets + chunkIndex * outputData->submeshCount + submeshIndex; + *(firstIdx + 1) = *firstIdx + indexCount; + } + } + outputData->posIndex = new uint32_t[outputData->submeshOffsets[outputData->meshCount * outputData->submeshCount]]; + outputData->normIndex = new uint32_t[outputData->submeshOffsets[outputData->meshCount * outputData->submeshCount]]; + outputData->texIndex = new uint32_t[outputData->submeshOffsets[outputData->meshCount * outputData->submeshCount]]; + // copy indices + for (uint32_t chunkIndex = 0; chunkIndex < outputData->meshCount; ++chunkIndex) + { + uint32_t apexChunkIndex = chunkReorderInvMap[chunkIndex]; + if (apexChunkIndex >= apexChunkCount) { - uint32_t apexChunkIndex = chunkReorderInvMap[chunkIndex]; - if (apexChunkIndex >= apexChunkCount) - { - PX_ALWAYS_ASSERT(); - continue; - } - uint32_t part = getPartIndex(dasset, chunkIndex); - for (uint32_t submeshIndex = 0; submeshIndex < outputData->submeshCount; ++submeshIndex) - { - SubmeshParameters* sm = static_cast(rmAsset->submeshes.buf[submeshIndex]); - - uint32_t indexCount = sm->indexPartition.buf[part + 1] - sm->indexPartition.buf[part]; - uint32_t* firstIdx = outputData->submeshOffsets + chunkIndex * outputData->submeshCount + submeshIndex; - *(firstIdx + 1) = *firstIdx + indexCount; - } + PX_ALWAYS_ASSERT(); + continue; } - outputData->posIndex = new uint32_t[outputData->submeshOffsets[outputData->meshCount * outputData->submeshCount]]; - outputData->normIndex = new uint32_t[outputData->submeshOffsets[outputData->meshCount * outputData->submeshCount]]; - outputData->texIndex = new uint32_t[outputData->submeshOffsets[outputData->meshCount * outputData->submeshCount]]; - //copy indices - for (uint32_t chunkIndex = 0; chunkIndex < outputData->meshCount; ++chunkIndex) + uint32_t part = getPartIndex(dasset, chunkIndex); + uint32_t offset = 0; + for (uint32_t submeshIndex = 0; submeshIndex < outputData->submeshCount; ++submeshIndex) { - uint32_t apexChunkIndex = chunkReorderInvMap[chunkIndex]; - if (apexChunkIndex >= apexChunkCount) - { - PX_ALWAYS_ASSERT(); - continue; - } - uint32_t part = getPartIndex(dasset, chunkIndex); - uint32_t offset = 0; - for (uint32_t submeshIndex = 0; submeshIndex < outputData->submeshCount; ++submeshIndex) - { - SubmeshParameters* sm = static_cast(rmAsset->submeshes.buf[submeshIndex]); - const uint32_t* indexArray = sm->indexBuffer.buf + sm->indexPartition.buf[part]; - uint32_t indexCount = sm->indexPartition.buf[part + 1] - sm->indexPartition.buf[part]; + SubmeshParameters* sm = static_cast(rmAsset->submeshes.buf[submeshIndex]); + const uint32_t* indexArray = sm->indexBuffer.buf + sm->indexPartition.buf[part]; + uint32_t indexCount = sm->indexPartition.buf[part + 1] - sm->indexPartition.buf[part]; - uint32_t firstIdx = outputData->submeshOffsets[chunkIndex * outputData->submeshCount + submeshIndex]; + uint32_t firstIdx = outputData->submeshOffsets[chunkIndex * outputData->submeshCount + submeshIndex]; - for (uint32_t i = 0; i < indexCount; ++i) - { - outputData->posIndex[firstIdx + i] = positionsMapping[indexArray[i] + offset]; - outputData->normIndex[firstIdx + i] = normalsMapping[indexArray[i] + offset]; - outputData->texIndex[firstIdx + i] = texturesMapping[indexArray[i] + offset]; - } - nvidia::apex::VertexBufferParameters* vbuf = static_cast(sm->vertexBuffer); - offset += vbuf->vertexCount; + for (uint32_t i = 0; i < indexCount; ++i) + { + outputData->posIndex[firstIdx + i] = positionsMapping[indexArray[i] + offset]; + outputData->normIndex[firstIdx + i] = normalsMapping[indexArray[i] + offset]; + outputData->texIndex[firstIdx + i] = texturesMapping[indexArray[i] + offset]; } + nvidia::apex::VertexBufferParameters* vbuf = + static_cast(sm->vertexBuffer); + offset += vbuf->vertexCount; } - return true; + } + return true; } - bool ApexImportTool::saveAsset(const NvBlastAsset* asset, PxFileBuf* stream) { if (!asset) @@ -925,7 +964,7 @@ bool ApexImportTool::saveAsset(const NvBlastAsset* asset, PxFileBuf* stream) NVBLAST_LOG_ERROR("Error: bad output stream."); return false; } - const void* assetData = asset; + const void* assetData = asset; uint32_t assetDataSize = NvBlastAssetGetSize(asset, logLL); stream->write(assetData, assetDataSize); stream->close(); @@ -936,9 +975,14 @@ bool ApexImportTool::saveAsset(const NvBlastAsset* asset, PxFileBuf* stream) ApexImportTool::~ApexImportTool() { + m_collisionBuilder->release(); + m_Cooking->release(); + m_PhysxSDK->release(); + m_Foundation->release(); + } -} // namespace ApexImporter +} // namespace ApexImporter -} // namespace Blast -} // namespace Nv +} // namespace Blast +} // namespace Nv -- cgit v1.2.3