1 files changed, 90 insertions, 97 deletions

diff --git a/sdk/extensions/authoring/source/NvBlastExtAuthoring.cpp b/sdk/extensions/authoring/source/NvBlastExtAuthoring.cpp
index ef012d6..a0e6fc2 100755
--- a/sdk/extensions/authoring/source/NvBlastExtAuthoring.cpp
+++ b/sdk/extensions/authoring/source/NvBlastExtAuthoring.cpp
@@ -26,20 +26,21 @@
 // Copyright (c) 2016-2018 NVIDIA Corporation. All rights reserved.

 

 #include "NvBlastExtAuthoring.h"

-#include "NvBlastExtAuthoringMeshImpl.h"

-#include "NvBlastExtAuthoringMeshCleanerImpl.h"

-#include "NvBlastExtAuthoringFractureToolImpl.h"

-#include "NvBlastExtAuthoringCollisionBuilderImpl.h"

-#include "NvBlastExtAuthoringBondGeneratorImpl.h"

-#include "NvBlastExtAuthoringCutoutImpl.h"

 #include "NvBlastTypes.h"

 #include "NvBlastIndexFns.h"

 #include "NvBlast.h"

+#include "NvBlastAssert.h"

 #include "NvBlastGlobals.h"

-#include "NvBlastExtPxAsset.h"

 #include "NvBlastExtAssetUtils.h"

 #include "NvBlastExtAuthoringPatternGeneratorImpl.h"

 #include "NvBlastExtAuthoringAccelerator.h"

+#include "NvBlastExtAuthoringMeshImpl.h"

+#include "NvBlastExtAuthoringMeshCleanerImpl.h"

+#include "NvBlastExtAuthoringFractureToolImpl.h"

+#include "NvBlastExtAuthoringBondGeneratorImpl.h"

+#include "NvBlastExtAuthoringCollisionBuilderImpl.h"

+#include "NvBlastExtAuthoringCutoutImpl.h"

+#include "NvBlastPxSharedHelpers.h"

 

 #include <algorithm>

 #include <memory>

@@ -50,7 +51,7 @@ using namespace physx;
 #define SAFE_ARRAY_NEW(T, x) ((x) > 0) ? reinterpret_cast<T*>(NVBLAST_ALLOC(sizeof(T) * (x))) : nullptr;

 #define SAFE_ARRAY_DELETE(x) if (x != nullptr) {NVBLAST_FREE(x); x = nullptr;}

 

-Mesh* NvBlastExtAuthoringCreateMesh(const PxVec3* position, const PxVec3* normals, const PxVec2* uv, uint32_t verticesCount, const uint32_t* indices, uint32_t indicesCount)

+Mesh* NvBlastExtAuthoringCreateMesh(const NvcVec3* position, const NvcVec3* normals, const NvcVec2* uv, uint32_t verticesCount, const uint32_t* indices, uint32_t indicesCount)

 {

 	return new MeshImpl(position, normals, uv, verticesCount, indices, indicesCount);

 }

@@ -91,18 +92,28 @@ FractureTool* NvBlastExtAuthoringCreateFractureTool()
 	return new FractureToolImpl;

 }

 

-BlastBondGenerator* NvBlastExtAuthoringCreateBondGenerator(PxCooking* cooking, PxPhysicsInsertionCallback* insertionCallback)

+BlastBondGenerator* NvBlastExtAuthoringCreateBondGenerator(Nv::Blast::ConvexMeshBuilder* builder)

 {

-	return new BlastBondGeneratorImpl(cooking, insertionCallback);

+	return new BlastBondGeneratorImpl(builder);

 }

 

-ConvexMeshBuilder* NvBlastExtAuthoringCreateConvexMeshBuilder(PxCooking* cooking, PxPhysicsInsertionCallback* insertionCallback)

+int32_t NvBlastExtAuthoringBuildMeshConvexDecomposition(ConvexMeshBuilder* cmb, const Nv::Blast::Triangle* mesh,

+                                                                    uint32_t triangleCount,

+                                                                    const ConvexDecompositionParams& params,

+                                                                    CollisionHull**& convexes)

 {

-	return new ConvexMeshBuilderImpl(cooking, insertionCallback);

+	NVBLAST_ASSERT(cmb != nullptr);

+	return buildMeshConvexDecomposition(*cmb, mesh, triangleCount, params, convexes);

 }

 

 

-void NvBlastExtAuthoringTransformCollisionHullInPlace(CollisionHull* hull, const physx::PxVec3* scaling, const physx::PxQuat* rotation, const physx::PxVec3* translation)

+void NvBlastExtAuthoringTrimCollisionGeometry(ConvexMeshBuilder* cmb, uint32_t chunksCount,

+                                              Nv::Blast::CollisionHull** in, const uint32_t* chunkDepth)

+{

+	return trimCollisionGeometry(*cmb, chunksCount, in, chunkDepth);

+}

+

+void NvBlastExtAuthoringTransformCollisionHullInPlace(CollisionHull* hull, const NvcVec3* scaling, const NvcQuat* rotation, const NvcVec3* translation)

 {

 	// Local copies of scaling (S), rotation (R), and translation (T)

 	physx::PxVec3 S = { 1, 1, 1 };

@@ -114,12 +125,12 @@ void NvBlastExtAuthoringTransformCollisionHullInPlace(CollisionHull* hull, const
 	{

 		if (rotation)

 		{

-			R = *rotation;

+			R = *toPxShared(rotation);

 		}

 

 		if (scaling)

 		{

-			S = *scaling;

+			S       = *toPxShared(scaling);

 			cofS.x = S.y * S.z;

 			cofS.y = S.z * S.x;

 			cofS.z = S.x * S.y;

@@ -128,21 +139,21 @@ void NvBlastExtAuthoringTransformCollisionHullInPlace(CollisionHull* hull, const
 

 		if (translation)

 		{

-			T = *translation;

+			T = *toPxShared(translation);

 		}

 	}

 

 	const uint32_t pointCount = hull->pointsCount;

 	for (uint32_t pi = 0; pi < pointCount; pi++)

 	{

-		physx::PxVec3& p = hull->points[pi];

+		physx::PxVec3& p = toPxShared(hull->points[pi]);

 		p = (R.rotate(p.multiply(S)) + T);

 	}

 	

 	const uint32_t planeCount = hull->polygonDataCount;

 	for (uint32_t pi = 0; pi < planeCount; pi++)

 	{

-		float* plane = hull->polygonData[pi].mPlane;

+		float* plane = hull->polygonData[pi].plane;

 		physx::PxPlane pxPlane(plane[0], plane[1], plane[2], plane[3]);

 		PxVec3 transformedNormal = sgnDetS*R.rotate(pxPlane.n.multiply(cofS)).getNormalized();

 		PxVec3 transformedPt = R.rotate(pxPlane.pointInPlane().multiply(S)) + T;

@@ -156,14 +167,20 @@ void NvBlastExtAuthoringTransformCollisionHullInPlace(CollisionHull* hull, const
 }

 

 

-CollisionHull* NvBlastExtAuthoringTransformCollisionHull(const CollisionHull* hull, const physx::PxVec3* scaling, const physx::PxQuat* rotation, const physx::PxVec3* translation)

+CollisionHull* NvBlastExtAuthoringTransformCollisionHull(const CollisionHull* hull, const NvcVec3* scaling, const NvcQuat* rotation, const NvcVec3* translation)

 {

-	CollisionHullImpl* ret = new CollisionHullImpl(*hull);

+	CollisionHull* ret = new CollisionHull(*hull);

+	ret->points             = SAFE_ARRAY_NEW(NvcVec3, ret->pointsCount);

+	ret->indices       = SAFE_ARRAY_NEW(uint32_t, ret->indicesCount);

+	ret->polygonData        = SAFE_ARRAY_NEW(HullPolygon, ret->polygonDataCount);

+	memcpy(ret->points, hull->points, sizeof(ret->points[0]) * ret->pointsCount);

+	memcpy(ret->indices, hull->indices, sizeof(ret->indices[0]) * ret->indicesCount);

+	memcpy(ret->polygonData, hull->polygonData, sizeof(ret->polygonData[0]) * ret->polygonDataCount);

 	NvBlastExtAuthoringTransformCollisionHullInPlace(ret, scaling, rotation, translation);

 	return ret;

 }

 

-void buildPhysicsChunks(ConvexMeshBuilder& collisionBuilder, AuthoringResult& result, const CollisionParams& params, uint32_t chunksToProcessCount = 0, uint32_t* chunksToProcess = nullptr)

+void buildPhysicsChunks(ConvexMeshBuilder& collisionBuilder, AuthoringResult& result, const ConvexDecompositionParams& params, uint32_t chunksToProcessCount = 0, uint32_t* chunksToProcess = nullptr)

 {

 	uint32_t chunkCount = (uint32_t)result.chunkCount;

 	if (params.maximumNumberOfHulls == 1)

@@ -171,11 +188,9 @@ void buildPhysicsChunks(ConvexMeshBuilder& collisionBuilder, AuthoringResult& re
 		result.collisionHullOffset = SAFE_ARRAY_NEW(uint32_t, chunkCount + 1);

 		result.collisionHullOffset[0] = 0;

 		result.collisionHull = SAFE_ARRAY_NEW(CollisionHull*, chunkCount);

-		result.physicsSubchunks = SAFE_ARRAY_NEW(ExtPxSubchunk, chunkCount);

-		result.physicsChunks = SAFE_ARRAY_NEW(ExtPxChunk, chunkCount);

 		for (uint32_t i = 0; i < chunkCount; ++i)

 		{

-			std::vector<physx::PxVec3> vertices;

+			std::vector<NvcVec3> vertices;

 			for (uint32_t p = result.geometryOffset[i]; p < result.geometryOffset[i + 1]; ++p)

 			{

 				Nv::Blast::Triangle& tri = result.geometry[p];

@@ -185,13 +200,6 @@ void buildPhysicsChunks(ConvexMeshBuilder& collisionBuilder, AuthoringResult& re
 			}

 			result.collisionHullOffset[i + 1] = result.collisionHullOffset[i] + 1;

 			result.collisionHull[i] = collisionBuilder.buildCollisionGeometry((uint32_t)vertices.size(), vertices.data());

-			result.physicsSubchunks[i].transform = physx::PxTransform(physx::PxIdentity);

-			result.physicsSubchunks[i].geometry = physx::PxConvexMeshGeometry(collisionBuilder.buildConvexMesh(*result.collisionHull[i]));

-

-			result.physicsChunks[i].isStatic = false;

-			result.physicsChunks[i].subchunkCount = 1;

-			result.physicsChunks[i].firstSubchunkIndex = i;

-			//outPhysicsChunks.get()[i].subchunks = &outPhysicsSubchunks[i];

 		}

 	}

 	else

@@ -219,7 +227,8 @@ void buildPhysicsChunks(ConvexMeshBuilder& collisionBuilder, AuthoringResult& re
 

 			CollisionHull** tempHull;

 

-			int32_t newHulls = collisionBuilder.buildMeshConvexDecomposition(result.geometry + result.geometryOffset[i], 

+			int32_t newHulls =

+			    buildMeshConvexDecomposition(collisionBuilder, result.geometry + result.geometryOffset[i], 

 												result.geometryOffset[i + 1] - result.geometryOffset[i], params, tempHull);

 			totalHulls += newHulls;			

 			for (int32_t h = 0; h < newHulls; ++h)

@@ -232,10 +241,7 @@ void buildPhysicsChunks(ConvexMeshBuilder& collisionBuilder, AuthoringResult& re
 		result.collisionHullOffset = SAFE_ARRAY_NEW(uint32_t, chunkCount + 1);

 		result.collisionHullOffset[0] = 0;

 		result.collisionHull = SAFE_ARRAY_NEW(CollisionHull*, totalHulls);

-		result.physicsSubchunks = SAFE_ARRAY_NEW(ExtPxSubchunk, totalHulls);

-		result.physicsChunks = SAFE_ARRAY_NEW(ExtPxChunk, chunkCount);

 

-		int32_t firstSubchunk = 0;

 		for (uint32_t i = 0; i < chunkCount; ++i)

 		{

 			result.collisionHullOffset[i + 1] = result.collisionHullOffset[i] + hulls[i].size();

@@ -243,57 +249,42 @@ void buildPhysicsChunks(ConvexMeshBuilder& collisionBuilder, AuthoringResult& re
 			for (uint32_t subhull = 0; subhull < hulls[i].size(); ++subhull)

 			{

 				result.collisionHull[off + subhull] = hulls[i][subhull];

-				result.physicsSubchunks[firstSubchunk + subhull].transform = physx::PxTransform(physx::PxIdentity);

-				result.physicsSubchunks[firstSubchunk + subhull].geometry = physx::PxConvexMeshGeometry(collisionBuilder.buildConvexMesh(*hulls[i][subhull]));

 			}			

-			result.physicsChunks[i].isStatic = false;

-			result.physicsChunks[i].subchunkCount = static_cast<uint32_t>(hulls[i].size());

-			result.physicsChunks[i].firstSubchunkIndex = firstSubchunk;

-			firstSubchunk += result.physicsChunks[i].subchunkCount;

 		}

 	}

 }

 

 

-struct AuthoringResultImpl : public AuthoringResult

+void NvBlastExtAuthoringReleaseAuthoringResultCollision(Nv::Blast::ConvexMeshBuilder& collisionBuilder, Nv::Blast::AuthoringResult* ar)

 {

-	AuthoringResultImpl()

-	{

-		collisionHullOffset = nullptr;

-		collisionHull = nullptr;

-		physicsChunks = nullptr;

-		physicsSubchunks = nullptr;

-	}

-

-	void releaseCollisionHulls() override

+	if (ar->collisionHull != nullptr)

 	{

-		if (collisionHull != nullptr)

+		for (uint32_t ch = 0; ch < ar->collisionHullOffset[ar->chunkCount]; ch++)

 		{

-			for (uint32_t ch = 0; ch < collisionHullOffset[chunkCount]; ch++)

-			{

-				collisionHull[ch]->release();

-			}

-			SAFE_ARRAY_DELETE(collisionHullOffset);

-			SAFE_ARRAY_DELETE(collisionHull);

+			collisionBuilder.releaseCollisionHull(ar->collisionHull[ch]);

 		}

+		SAFE_ARRAY_DELETE(ar->collisionHullOffset);

+		SAFE_ARRAY_DELETE(ar->collisionHull);

 	}

+}

 

-	void release() override

+void NvBlastExtAuthoringReleaseAuthoringResult(Nv::Blast::ConvexMeshBuilder& collisionBuilder, Nv::Blast::AuthoringResult* ar)

+{

+	NvBlastExtAuthoringReleaseAuthoringResultCollision(collisionBuilder, ar);

+	if (ar->asset)

 	{

-		releaseCollisionHulls();

-		NVBLAST_FREE(asset);

-		SAFE_ARRAY_DELETE(assetToFractureChunkIdMap);

-		SAFE_ARRAY_DELETE(geometryOffset);

-		SAFE_ARRAY_DELETE(geometry);

-		SAFE_ARRAY_DELETE(chunkDescs);

-		SAFE_ARRAY_DELETE(bondDescs);

-		SAFE_ARRAY_DELETE(physicsChunks);

-		SAFE_ARRAY_DELETE(physicsSubchunks);

-		delete this;

+		NVBLAST_FREE(ar->asset);

+		ar->asset = nullptr;

 	}

-};

+	SAFE_ARRAY_DELETE(ar->assetToFractureChunkIdMap);

+	SAFE_ARRAY_DELETE(ar->geometryOffset);

+	SAFE_ARRAY_DELETE(ar->geometry);

+	SAFE_ARRAY_DELETE(ar->chunkDescs);

+	SAFE_ARRAY_DELETE(ar->bondDescs);

+	delete ar;

+}

 

-AuthoringResult* NvBlastExtAuthoringProcessFracture(FractureTool& fTool, BlastBondGenerator& bondGenerator, ConvexMeshBuilder& collisionBuilder, const CollisionParams& collisionParam, int32_t defaultSupportDepth)

+AuthoringResult* NvBlastExtAuthoringProcessFracture(FractureTool& fTool, BlastBondGenerator& bondGenerator, ConvexMeshBuilder& collisionBuilder, const ConvexDecompositionParams& collisionParam, int32_t defaultSupportDepth)

 {

 	fTool.finalizeFracturing();

 	const uint32_t chunkCount = fTool.getChunkCount();

@@ -301,7 +292,7 @@ AuthoringResult* NvBlastExtAuthoringProcessFracture(FractureTool& fTool, BlastBo
 	{

 		return nullptr;

 	}

-	AuthoringResultImpl* ret = new AuthoringResultImpl;

+	AuthoringResult* ret = new AuthoringResult;

 	if (ret == nullptr)

 	{

 		return nullptr;

@@ -390,21 +381,21 @@ AuthoringResult* NvBlastExtAuthoringProcessFracture(FractureTool& fTool, BlastBo
 	buildPhysicsChunks(collisionBuilder, aResult, collisionParam);

 

 	// set NvBlastChunk volume from Px geometry

-	for (uint32_t i = 0; i < chunkCount; i++)

-	{

-		float totalVolume = 0.f;

-		for (uint32_t k = 0; k < aResult.physicsChunks[i].subchunkCount; k++)

-		{

-			const auto& subChunk = aResult.physicsSubchunks[aResult.physicsChunks[i].firstSubchunkIndex + k];

-			physx::PxVec3 localCenterOfMass; physx::PxMat33 intertia; float mass;

-			subChunk.geometry.convexMesh->getMassInformation(mass, intertia, localCenterOfMass);

-			const physx::PxVec3 scale = subChunk.geometry.scale.scale;

-			mass *= scale.x * scale.y * scale.z;

-			totalVolume += mass / 1.0f; // unit density

-		}

-

-		aResult.chunkDescs[i].volume = totalVolume;

-	}

+	//for (uint32_t i = 0; i < chunkCount; i++)

+	//{

+	//	float totalVolume = 0.f;

+	//	for (uint32_t k = 0; k < aResult.physicsChunks[i].subchunkCount; k++)

+	//	{

+	//		const auto& subChunk = aResult.physicsSubchunks[aResult.physicsChunks[i].firstSubchunkIndex + k];

+	//		physx::PxVec3 localCenterOfMass; physx::PxMat33 intertia; float mass;

+	//		subChunk.geometry.convexMesh->getMassInformation(mass, intertia, localCenterOfMass);

+	//		const physx::PxVec3 scale = subChunk.geometry.scale.scale;

+	//		mass *= scale.x * scale.y * scale.z;

+	//		totalVolume += mass / 1.0f; // unit density

+	//	}

+

+	//	aResult.chunkDescs[i].volume = totalVolume;

+	//}

 

 	// build and serialize ExtPhysicsAsset

 	NvBlastAssetDesc	descriptor;

@@ -431,9 +422,9 @@ AuthoringResult* NvBlastExtAuthoringProcessFracture(FractureTool& fTool, BlastBo
 uint32_t NvBlastExtAuthoringFindAssetConnectingBonds

 (

 	const NvBlastAsset** components,

-	const physx::PxVec3* scales,

-	const physx::PxQuat* rotations,

-	const physx::PxVec3* translations,

+	const NvcVec3* scales,

+	const NvcQuat* rotations,

+	const NvcVec3* translations,

 	const uint32_t** convexHullOffsets,

 	const CollisionHull*** chunkHulls,

 	uint32_t componentCount,

@@ -442,7 +433,7 @@ uint32_t NvBlastExtAuthoringFindAssetConnectingBonds
 )

 {

 	//We don't need to use any of the cooking related parts of this

-	BlastBondGeneratorImpl bondGenerator(nullptr, nullptr);

+	BlastBondGeneratorImpl bondGenerator(nullptr);

 

 	std::vector<uint32_t> componentChunkOffsets;

 	componentChunkOffsets.reserve(componentCount + 1);

@@ -461,9 +452,9 @@ uint32_t NvBlastExtAuthoringFindAssetConnectingBonds
 	for (uint32_t c = 0; c < componentCount; c++)

 	{

 		const uint32_t chunkCount = NvBlastAssetGetChunkCount(components[c], &logLL);

-		const physx::PxVec3* scale = scales ? scales + c : nullptr;

-		const physx::PxQuat* rotation = rotations ? rotations + c : nullptr;

-		const physx::PxVec3* translation = translations ? translations + c : nullptr;

+		const NvcVec3* scale = scales ? scales + c : nullptr;

+		const NvcQuat* rotation          = rotations ? rotations + c : nullptr;

+		const NvcVec3* translation = translations ? translations + c : nullptr;

 

 		componentChunkOffsets.push_back(chunkCount + componentChunkOffsets.back());

 		for (uint32_t chunk = 0; chunk < chunkCount; chunk++)

@@ -472,7 +463,9 @@ uint32_t NvBlastExtAuthoringFindAssetConnectingBonds
 			const uint32_t hullsEnd = convexHullOffsets[c][chunk + 1];

 			for (uint32_t hull = hullsStart; hull < hullsEnd; hull++)

 			{

-				if ((scale != nullptr && *scale != identityScale) || (rotation != nullptr && !rotation->isIdentity()) || (translation != nullptr && !translation->isZero()))

+				if ((scale != nullptr && *toPxShared(scale) != identityScale) ||

+				    (rotation != nullptr && !toPxShared(rotation)->isIdentity()) ||

+				    (translation != nullptr && !toPxShared(translation)->isZero()))

 				{

 					hullsToRelease.emplace_back(NvBlastExtAuthoringTransformCollisionHull(chunkHulls[c][hull], scale, rotation, translation));

 					combinedConvexHulls.emplace_back(hullsToRelease.back());

@@ -523,7 +516,7 @@ uint32_t NvBlastExtAuthoringFindAssetConnectingBonds
 

 	for (CollisionHull* hull : hullsToRelease)

 	{

-		hull->release();

+		delete hull;

 	}

 

 	return newBoundCount;

@@ -540,7 +533,7 @@ void NvBlastExtAuthoringUpdateGraphicsMesh(Nv::Blast::FractureTool& fTool, Nv::B
 }

 

 void NvBlastExtAuthoringBuildCollisionMeshes(Nv::Blast::AuthoringResult& ares, Nv::Blast::ConvexMeshBuilder& collisionBuilder,

-	const Nv::Blast::CollisionParams& collisionParam, uint32_t chunksToProcessCount, uint32_t* chunksToProcess)

+	const Nv::Blast::ConvexDecompositionParams& collisionParam, uint32_t chunksToProcessCount, uint32_t* chunksToProcess)

 {

 	buildPhysicsChunks(collisionBuilder, ares, collisionParam, chunksToProcessCount, chunksToProcess);

 }