Blast SDK 1.1.5 prerelease #1v1.1.5_pre1

1 files changed, 260 insertions, 216 deletions

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 <NvBlastExtExporter.h>

 #include <PxConvexMesh.h>

 #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 <PxPhysicsAPI.h>

 

 #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<uint32_t>& chunkReorderInvMap,

-						const std::vector<uint32_t>& apexChunkFlags, std::vector<ExtPxAssetDesc::ChunkDesc>& physicsChunks,

-						std::vector<ExtPxAssetDesc::SubchunkDesc>& physicsSubchunks, std::vector<std::vector<CollisionHull*> >& hullsDesc)

+bool ApexImportTool::getCollisionGeometry(const NvParameterized::Interface* assetPrm, uint32_t chunkCount,

+                                          std::vector<uint32_t>& chunkReorderInvMap,

+                                          const std::vector<uint32_t>& apexChunkFlags,

+                                          std::vector<ExtPxAssetDesc::ChunkDesc>& physicsChunks,

+                                          std::vector<ExtPxAssetDesc::SubchunkDesc>& physicsSubchunks,

+                                          std::vector<std::vector<CollisionHull*> >& hullsDesc)

 {

 	physicsChunks.clear();

 	physicsChunks.resize(chunkCount);

 	// prepare physics asset desc (convexes, transforms)

-	std::shared_ptr<ConvexMeshBuilder> collisionBuilder(

-		NvBlastExtAuthoringCreateConvexMeshBuilder(m_Cooking, &m_PhysxSDK->getPhysicsInsertionCallback()),

-		[](ConvexMeshBuilder* cmb) { cmb->release(); });

 

 	const DestructibleAssetParameters* params = static_cast<const DestructibleAssetParameters*>(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<PxVec3> vertexData(verticesCount);

-					paramHandle.getParamVec3Array(vertexData.data(), verticesCount);

+					std::vector<NvcVec3> 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<uint32_t>& chunkToPartMp, const nvidia::apex::RenderMeshAssetParameters* rmAsset, std::vector<uint32_t>& chunkTrianglesOffsets, std::vector<Nv::Blast::Triangle>& chunkTriangles, int32_t posBufferIndex, float scale, PxVec3 offset )

+PxBounds3

+gatherChunkTriangles(std::vector<uint32_t>& chunkToPartMp, const nvidia::apex::RenderMeshAssetParameters* rmAsset,

+                     std::vector<uint32_t>& chunkTrianglesOffsets, std::vector<Nv::Blast::Triangle>& chunkTriangles,

+                     int32_t posBufferIndex, float scale, PxVec3 offset)

 {

 

 	PxBounds3 bnd;

@@ -293,16 +306,18 @@ PxBounds3 gatherChunkTriangles(std::vector<uint32_t>& 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<nvidia::apex::SubmeshParameters*>(rmAsset->submeshes.buf[submeshIndex]);

+			nvidia::apex::SubmeshParameters* submeshPrm =

+			    static_cast<nvidia::apex::SubmeshParameters*>(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<nvidia::apex::VertexBufferParameters*>(submeshPrm->vertexBuffer);

+			nvidia::apex::VertexBufferParameters* vbuf =

+			    static_cast<nvidia::apex::VertexBufferParameters*>(submeshPrm->vertexBuffer);

 

 			nvidia::apex::BufferF32x3* pbuf = static_cast<nvidia::apex::BufferF32x3*>(vbuf->buffers.buf[posBufferIndex]);

 

@@ -317,13 +332,10 @@ PxBounds3 gatherChunkTriangles(std::vector<uint32_t>& 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<uint32_t>& chunkToPartMp, const nvidi
 }

 

 bool ApexImportTool::importApexAsset(std::vector<uint32_t>& chunkReorderInvMap, NvParameterized::Interface* assetNvIfc,

-	std::vector<NvBlastChunkDesc>& chunkDescriptors, std::vector<NvBlastBondDesc>& bondDescriptors, std::vector<uint32_t>& apexChunkFlags)

+                                     std::vector<NvBlastChunkDesc>& chunkDescriptors,

+                                     std::vector<NvBlastBondDesc>& bondDescriptors, std::vector<uint32_t>& apexChunkFlags)

 {

 	ApexImporterConfig configDesc;

 	configDesc.setDefaults();

@@ -341,17 +354,20 @@ bool ApexImportTool::importApexAsset(std::vector<uint32_t>& chunkReorderInvMap,
 

 

 bool ApexImportTool::importApexAsset(std::vector<uint32_t>& chunkReorderInvMap, NvParameterized::Interface* assetNvIfc,

-	std::vector<NvBlastChunkDesc>& chunkDescriptors, std::vector<NvBlastBondDesc>& bondDescriptors, std::vector<uint32_t>& apexChunkFlags, const ApexImporterConfig& configDesc)

+                                     std::vector<NvBlastChunkDesc>& chunkDescriptors,

+                                     std::vector<NvBlastBondDesc>& bondDescriptors,

+                                     std::vector<uint32_t>& 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<uint32_t>& chunkReorderInvMap, NvParameterized::Interface* assetNvIfc,

-	std::vector<NvBlastChunkDesc>& chunkDescriptors, std::vector<NvBlastBondDesc>& bondsDescriptors, std::vector<uint32_t>& apexChunkFlags, const ApexImporterConfig& configDesc)

+bool ApexImportTool::importApexAssetInternal(std::vector<uint32_t>& chunkReorderInvMap,

+                                             NvParameterized::Interface* assetNvIfc,

+                                             std::vector<NvBlastChunkDesc>& chunkDescriptors,

+                                             std::vector<NvBlastBondDesc>& bondsDescriptors,

+                                             std::vector<uint32_t>& apexChunkFlags, const ApexImporterConfig& configDesc)

 {

 	if (!assetNvIfc)

 	{

@@ -360,14 +376,15 @@ bool ApexImportTool::importApexAssetInternal(std::vector<uint32_t>& chunkReorder
 	}

 	DestructibleAssetParameters* params = static_cast<nvidia::destructible::DestructibleAssetParameters*>(assetNvIfc);

 

-	int32_t apexChunkCount = params->chunks.arraySizes[0];

+	int32_t apexChunkCount  = params->chunks.arraySizes[0];

 	uint32_t rootChunkIndex = 0;

 

 	std::vector<uint32_t> chunkToPartMapping(apexChunkCount);

 

 	chunkDescriptors.resize(apexChunkCount);

 

-	nvidia::apex::RenderMeshAssetParameters* rmParam = static_cast<nvidia::apex::RenderMeshAssetParameters*>(params->renderMeshAsset);

+	nvidia::apex::RenderMeshAssetParameters* rmParam =

+	    static_cast<nvidia::apex::RenderMeshAssetParameters*>(params->renderMeshAsset);

 

 	std::vector<PxBounds3> perChunkBounds(apexChunkCount);

 	PxBounds3 allRmBound;

@@ -376,19 +393,21 @@ bool ApexImportTool::importApexAssetInternal(std::vector<uint32_t>& 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, &center.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<uint32_t>& 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<uint32_t>& 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<std::pair<uint32_t, uint32_t> > overlapsBuffer;

-	nvidia::destructible::CachedOverlaps* overlapsArray = static_cast<nvidia::destructible::CachedOverlaps*>(params->overlapsAtDepth.buf[maximumSupportDepth]);

+	nvidia::destructible::CachedOverlaps* overlapsArray =

+	    static_cast<nvidia::destructible::CachedOverlaps*>(params->overlapsAtDepth.buf[maximumSupportDepth]);

 	uint32_t overlapsCount = overlapsArray->overlaps.arraySizes[0];

 	if (overlapsCount != 0)

 	{

@@ -437,7 +457,7 @@ bool ApexImportTool::importApexAssetInternal(std::vector<uint32_t>& 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<uint32_t>& chunkReorder
 	bondsDescriptors.resize(overlapsBuffer.size());

 

 	std::shared_ptr<Nv::Blast::BlastBondGenerator> bondGenTool(

-		NvBlastExtAuthoringCreateBondGenerator(m_Cooking, &m_PhysxSDK->getPhysicsInsertionCallback()),

-		[](Nv::Blast::BlastBondGenerator* bg) {bg->release(); });

+	    NvBlastExtAuthoringCreateBondGenerator(m_collisionBuilder),

+	    [](Nv::Blast::BlastBondGenerator* bg) { bg->release(); });

 

 	std::vector<uint32_t> chunkTrianglesOffsets;

 	std::vector<Nv::Blast::Triangle> 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<uint32_t>& 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<uint32_t>& 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<uint32_t>& 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<uint32_t>& 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<uint32_t>& 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, &center.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<uint32_t>& chunkReorder
 	}

 

 	const uint32_t chunkCount = static_cast<uint32_t>(chunkDescriptors.size());

-	const uint32_t bondCount = static_cast<uint32_t>(bondsDescriptors.size());

+	const uint32_t bondCount  = static_cast<uint32_t>(bondsDescriptors.size());

 	std::vector<uint32_t> chunkReorderMap(chunkCount);

 	std::vector<NvBlastChunkDesc> 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<uint32_t>(chunkReorderMap.size()));

+	Nv::Blast::invertMap(chunkReorderInvMap.data(), chunkReorderMap.data(),

+	                     static_cast<uint32_t>(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<uint32_t>& chunkReorderInvMap, const NvParameterized::Interface* assetNvIfc, ExporterMeshData* outputData, const char* materialsDir)

+bool ApexImportTool::importRendermesh(const std::vector<uint32_t>& chunkReorderInvMap,

+                                      const NvParameterized::Interface* assetNvIfc, ExporterMeshData* outputData,

+                                      const char* materialsDir)

 {

-	const nvidia::destructible::DestructibleAssetParameters* dasset = static_cast<const nvidia::destructible::DestructibleAssetParameters*>(assetNvIfc);

-	const nvidia::apex::RenderMeshAssetParameters* rmAsset = static_cast<const nvidia::apex::RenderMeshAssetParameters*>(dasset->renderMeshAsset);

+	const nvidia::destructible::DestructibleAssetParameters* dasset =

+	    static_cast<const nvidia::destructible::DestructibleAssetParameters*>(assetNvIfc);

+	const nvidia::apex::RenderMeshAssetParameters* rmAsset =

+	    static_cast<const nvidia::apex::RenderMeshAssetParameters*>(dasset->renderMeshAsset);

 

 

 	outputData->submeshCount = rmAsset->submeshes.arraySizes[0];

-	outputData->submeshMats = new Material[outputData->submeshCount];

+	outputData->submeshMats  = new Material[outputData->submeshCount];

 	std::vector<Material> materialArray(outputData->submeshCount);

 	std::vector<std::string> materialPathes;

 	materialPathes.reserve(outputData->submeshCount);

@@ -680,19 +708,19 @@ bool ApexImportTool::importRendermesh(const std::vector<uint32_t>& 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<uint32_t>& 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<uint32_t>& 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<uint32_t>& 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<uint32_t>& chunkReorderI
 	{

 		for (uint32_t submeshIndex = 0; submeshIndex < outputData->submeshCount; ++submeshIndex)

 		{

-			nvidia::apex::SubmeshParameters* currentSubmesh = static_cast<nvidia::apex::SubmeshParameters*>(rmAsset->submeshes.buf[submeshIndex]);

-			nvidia::apex::VertexBufferParameters* vbuf = static_cast<nvidia::apex::VertexBufferParameters*>(currentSubmesh->vertexBuffer);

-			nvidia::apex::VertexFormatParameters* vbufFormat = static_cast<nvidia::apex::VertexFormatParameters*>(vbuf->vertexFormat);

+			nvidia::apex::SubmeshParameters* currentSubmesh =

+			    static_cast<nvidia::apex::SubmeshParameters*>(rmAsset->submeshes.buf[submeshIndex]);

+			nvidia::apex::VertexBufferParameters* vbuf =

+			    static_cast<nvidia::apex::VertexBufferParameters*>(currentSubmesh->vertexBuffer);

+			nvidia::apex::VertexFormatParameters* vbufFormat =

+			    static_cast<nvidia::apex::VertexFormatParameters*>(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<uint32_t>& chunkReorderI
 			}

 			if (vbufIds[0] != -1)

 			{

-				BufferF32x3* pbuf = static_cast<BufferF32x3*>(vbuf->buffers.buf[vbufIds[0]]);

+				BufferF32x3* pbuf        = static_cast<BufferF32x3*>(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<uint32_t>& 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<uint32_t>& chunkReorderI
 

 			if (vbufIds[1] != -1)

 			{

-				BufferF32x3* pbuf = static_cast<BufferF32x3*>(vbuf->buffers.buf[vbufIds[1]]);

+				BufferF32x3* pbuf     = static_cast<BufferF32x3*>(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<uint32_t>& chunkReorderI
 			}

 			if (vbufIds[2] != -1)

 			{

-				BufferF32x2* pbuf = static_cast<BufferF32x2*>(vbuf->buffers.buf[vbufIds[2]]);

+				BufferF32x2* pbuf      = static_cast<BufferF32x2*>(vbuf->buffers.buf[vbufIds[2]]);

 				const PxVec2* texCoord = reinterpret_cast<PxVec2*>(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<uint32_t>& 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<SubmeshParameters*>(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<SubmeshParameters*>(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<SubmeshParameters*>(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<SubmeshParameters*>(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<nvidia::apex::VertexBufferParameters*>(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<nvidia::apex::VertexBufferParameters*>(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