Changes for 1.1.1

See README.md

13 files changed, 695 insertions, 202 deletions

diff --git a/test/src/BlastBaseTest.h b/test/src/BlastBaseTest.h
index 350cd88..55e3c6f 100644
--- a/test/src/BlastBaseTest.h
+++ b/test/src/BlastBaseTest.h
@@ -99,6 +99,7 @@ public:
 		case NvBlastMessage::Info:		failMask |= Nv::Blast::ErrorCode::eDEBUG_INFO;
 		case NvBlastMessage::Warning:	failMask |= Nv::Blast::ErrorCode::eDEBUG_WARNING;
 		case NvBlastMessage::Error:		failMask |= Nv::Blast::ErrorCode::eABORT | Nv::Blast::ErrorCode::eABORT | Nv::Blast::ErrorCode::eINTERNAL_ERROR | Nv::Blast::ErrorCode::eOUT_OF_MEMORY | Nv::Blast::ErrorCode::eINVALID_OPERATION | Nv::Blast::ErrorCode::eINVALID_PARAMETER;
+		default: break;
 		}
 
 		if (!(failMask & code) && Verbosity <= 0)
diff --git a/test/src/TkBaseTest.h b/test/src/TkBaseTest.h
index 2980601..7106647 100644
--- a/test/src/TkBaseTest.h
+++ b/test/src/TkBaseTest.h
@@ -167,34 +167,31 @@ struct CSParams
 	float coord;
 };
 
-static void CubeSlicer(NvBlastFractureBuffers* outbuf, const NvBlastGraphShaderActor* actor, const NvBlastProgramParams* params)
+static void CubeSlicer(NvBlastFractureBuffers* outbuf, const NvBlastGraphShaderActor* actor, const void* params)
 {
 	uint32_t bondFractureCount = 0;
 	uint32_t bondFractureCountMax = outbuf->bondFractureCount;
 
-	for (size_t i = 0; i < params->damageDescCount; ++i)
-	{
-		const CSParams& p = (reinterpret_cast<const CSParams*> (params->damageDescBuffer))[i];
+	const CSParams& p = *reinterpret_cast<const CSParams*> (reinterpret_cast<const NvBlastExtProgramParams*>(params)->damageDesc);
 
-		uint32_t currentNodeIndex = actor->firstGraphNodeIndex;
-		while (!Nv::Blast::isInvalidIndex(currentNodeIndex))
+	uint32_t currentNodeIndex = actor->firstGraphNodeIndex;
+	while (!Nv::Blast::isInvalidIndex(currentNodeIndex))
+	{
+		for (uint32_t adj = actor->adjacencyPartition[currentNodeIndex]; adj < actor->adjacencyPartition[currentNodeIndex + 1]; ++adj)
 		{
-			for (uint32_t adj = actor->adjacencyPartition[currentNodeIndex]; adj < actor->adjacencyPartition[currentNodeIndex + 1]; ++adj)
+			if (currentNodeIndex < actor->adjacentNodeIndices[adj])
 			{
-				if (currentNodeIndex < actor->adjacentNodeIndices[adj])
+				if (actor->assetBonds[actor->adjacentBondIndices[adj]].centroid[p.axis] == p.coord && bondFractureCount < bondFractureCountMax)
 				{
-					if (actor->assetBonds[actor->adjacentBondIndices[adj]].centroid[p.axis] == p.coord && bondFractureCount < bondFractureCountMax)
-					{
-						NvBlastBondFractureData& data = outbuf->bondFractures[bondFractureCount++];
-						data.userdata = 0;
-						data.nodeIndex0 = currentNodeIndex;
-						data.nodeIndex1 = actor->adjacentNodeIndices[adj];
-						data.health = 1.0f;
-					}
+					NvBlastBondFractureData& data = outbuf->bondFractures[bondFractureCount++];
+					data.userdata = 0;
+					data.nodeIndex0 = currentNodeIndex;
+					data.nodeIndex1 = actor->adjacentNodeIndices[adj];
+					data.health = 1.0f;
 				}
 			}
-			currentNodeIndex = actor->graphNodeIndexLinks[currentNodeIndex];
 		}
+		currentNodeIndex = actor->graphNodeIndexLinks[currentNodeIndex];
 	}
 
 	outbuf->bondFractureCount = bondFractureCount;
diff --git a/test/src/perf/DamagePerfTests.cpp b/test/src/perf/DamagePerfTests.cpp
new file mode 100644
index 0000000..df72b45
--- /dev/null
+++ b/test/src/perf/DamagePerfTests.cpp
@@ -0,0 +1,286 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2016-2017 NVIDIA Corporation. All rights reserved.
+
+
+#include "BlastBasePerfTest.h"
+#include "NvBlastExtDamageShaders.h"
+#include "NvBlastExtSerialization.h"
+#include "NvBlastTime.h"
+#include "PxVec3.h"
+#include "PxBounds3.h"
+#include <memory>
+#include <random>
+#include <cstdio>
+
+using namespace Nv::Blast;
+using namespace physx;
+
+static void blast
+(
+	std::set<NvBlastActor*>& actorsToDamage,
+	GeneratorAsset* testAsset,
+	NvBlastExtDamageAccelerator* accelerator,
+	GeneratorAsset::Vec3 localPos,
+	float minRadius, float maxRadius,
+	float compressiveDamage,
+	std::vector<uint32_t>& history,
+	NvBlastTimers& timers)
+{
+	std::vector<NvBlastChunkFractureData> chunkEvents; /* num lower-support chunks + bonds */
+	std::vector<NvBlastBondFractureData> bondEvents; /* num lower-support chunks + bonds */
+	chunkEvents.resize(testAsset->solverChunks.size());
+	bondEvents.resize(testAsset->solverBonds.size());
+
+	NvBlastExtRadialDamageDesc damage = {
+		compressiveDamage,
+		{ localPos.x, localPos.y, localPos.z },
+		minRadius,
+		maxRadius
+	};
+
+	NvBlastExtMaterial material;
+
+	NvBlastExtProgramParams programParams =
+	{
+		&damage,
+		&material,
+		accelerator
+	};
+
+	NvBlastDamageProgram program = {
+		NvBlastExtFalloffGraphShader,
+		nullptr
+	};
+
+	std::vector<char> splitScratch;
+	std::vector<NvBlastActor*> newActors(testAsset->solverChunks.size());
+
+	size_t totalNewActorsCount = 0;
+	for (std::set<NvBlastActor*>::iterator k = actorsToDamage.begin(); k != actorsToDamage.end();)
+	{
+		NvBlastActor* actor = *k;
+
+		NvBlastFractureBuffers events = { (uint32_t)bondEvents.size(), (uint32_t)chunkEvents.size(), bondEvents.data(), chunkEvents.data() };
+
+		NvBlastActorGenerateFracture(&events, actor, program, &programParams, nullptr, &timers);
+		NvBlastActorApplyFracture(nullptr, actor, &events, nullptr, &timers);
+
+		bool removeActor = false;
+
+		if (events.bondFractureCount + events.chunkFractureCount > 0)
+		{
+			history.push_back(events.bondFractureCount + events.chunkFractureCount);
+
+			splitScratch.resize((size_t)NvBlastActorGetRequiredScratchForSplit(actor, nullptr));
+			NvBlastActorSplitEvent result;
+			result.deletedActor = nullptr;
+			result.newActors = &newActors[totalNewActorsCount];
+			const size_t bufferSize = newActors.size() - totalNewActorsCount;
+			const size_t newActorsCount = NvBlastActorSplit(&result, actor, (uint32_t)bufferSize, splitScratch.data(), nullptr, &timers);
+			totalNewActorsCount += newActorsCount;
+			removeActor = newActorsCount > 0;
+		}
+
+		if (removeActor)
+		{
+			k = actorsToDamage.erase(k);
+		}
+		else
+		{
+			++k;
+		}
+	}
+
+	for (size_t i = 0; i < totalNewActorsCount; ++i)
+	{
+		actorsToDamage.insert(newActors[i]);
+	}
+}
+
+typedef BlastBasePerfTest<NvBlastMessage::Warning, 1> BlastBasePerfTestStrict;
+
+
+struct PerfResults
+{
+	int64_t totalTime;
+	int64_t createTime;
+};
+
+class PerfTest : public BlastBasePerfTestStrict
+{
+public:
+
+  NvBlastAsset* loadAsset(const char* path, ExtSerialization* ser)
+  {
+    std::ifstream infileStream(path, std::ios::binary);
+    if (!infileStream.is_open())
+    {
+      return nullptr;
+    }
+    const std::vector<char> inBuffer((std::istreambuf_iterator<char>(infileStream)), std::istreambuf_iterator<char>());
+    infileStream.close();
+
+    NvBlastAsset* asset = static_cast<NvBlastAsset*>(ser->deserializeFromBuffer(inBuffer.data(), inBuffer.size()));
+
+    return asset;
+  }
+
+	PerfResults damageLeafSupportActors(const char* testName, uint32_t assetCount, uint32_t familyCount, uint32_t damageCount, int accelType, std::vector<uint32_t>& history)
+	{
+		PerfResults results;
+		results.totalTime = 0;
+		results.createTime = 0;
+
+		const float compressiveDamage = 1.0f;
+		const uint32_t minChunkCount = 1000;
+		const uint32_t maxChunkCount = 100000;
+
+		srand(0);
+
+		for (uint32_t assetNum = 0; assetNum < assetCount; ++assetNum)
+		{
+			GeneratorAsset cube;
+			NvBlastAssetDesc desc;
+			generateRandomCube(cube, desc, minChunkCount, maxChunkCount);
+
+			{
+				std::vector<char> scratch;
+				physx::PxBounds3 bounds = physx::PxBounds3::empty();
+#if 1
+				scratch.resize((size_t)NvBlastGetRequiredScratchForCreateAsset(&desc, messageLog));
+				void* mem = alignedZeroedAlloc(NvBlastGetAssetMemorySize(&desc, messageLog));
+				NvBlastAsset* asset = NvBlastCreateAsset(mem, &desc, scratch.data(), messageLog);
+				EXPECT_TRUE(asset != nullptr);
+				bounds = physx::PxBounds3::centerExtents(physx::PxVec3(0, 0, 0), physx::PxVec3(cube.extents.x, cube.extents.y, cube.extents.z));
+#else
+				// load asset
+				NvBlastAsset* asset = nullptr;
+				ExtSerialization* ser = NvBlastExtSerializationCreate();
+				for (int s = 0; s < 5 && !asset; s++)
+				{
+					asset = loadAsset(&"../../../../../test/assets/table.blast"[s * 3], ser);
+				}
+				EXPECT_TRUE(asset != nullptr);
+				ser->release();
+				uint32_t bc = NvBlastAssetGetBondCount(asset, messageLog);
+				const NvBlastBond* bonds = NvBlastAssetGetBonds(asset, messageLog);
+				for (uint32_t i = 0; i < bc; i++)
+				{
+					bounds.include(reinterpret_cast<const physx::PxVec3&>(bonds[i].centroid));
+				}
+#endif
+
+				Nv::Blast::Time t;
+				NvBlastExtDamageAccelerator* accelerator = NvBlastExtDamageAcceleratorCreate(asset, accelType);
+				results.createTime += t.getElapsedTicks();
+
+				// Generate familes
+				for (uint32_t familyNum = 0; familyNum < familyCount; ++familyNum)
+				{
+					// create actor
+					NvBlastActorDesc actorDesc;
+					actorDesc.initialBondHealths = nullptr;
+					actorDesc.uniformInitialBondHealth = 1.0f;
+					actorDesc.initialSupportChunkHealths = nullptr;
+					actorDesc.uniformInitialLowerSupportChunkHealth = 1.0f;
+					void* mem = alignedZeroedAlloc(NvBlastAssetGetFamilyMemorySize(asset, messageLog));
+					NvBlastFamily* family = NvBlastAssetCreateFamily(mem, asset, messageLog);
+					scratch.resize((size_t)NvBlastFamilyGetRequiredScratchForCreateFirstActor(family, messageLog));
+					EXPECT_TRUE(family != nullptr);
+					NvBlastActor* actor = NvBlastFamilyCreateFirstActor(family, &actorDesc, scratch.data(), messageLog);
+					EXPECT_TRUE(actor != nullptr);
+
+					// Generate damage
+					std::set<NvBlastActor*> actors;
+					actors.insert(actor);
+					for (uint32_t damageNum = 0; damageNum < damageCount; ++damageNum)
+					{
+						GeneratorAsset::Vec3 localPos = GeneratorAsset::Vec3((float)rand() / RAND_MAX - 0.5f, (float)rand() / RAND_MAX - 0.5f, (float)rand() / RAND_MAX - 0.5f) * 2;
+						localPos.x *= bounds.getExtents().x;
+						localPos.y *= bounds.getExtents().y;
+						localPos.z *= bounds.getExtents().z;
+						const float relativeDamageRadius = (float)rand() / RAND_MAX * bounds.getExtents().maxElement();
+
+						NvBlastTimers timers;
+						NvBlastTimersReset(&timers);
+						blast(actors, &cube, accelerator, localPos, relativeDamageRadius, relativeDamageRadius*1.2f, compressiveDamage, history, timers);
+						const std::string timingName = std::string(testName) + " asset " + std::to_string(assetNum) + " family " + std::to_string(familyNum) + " damage " + std::to_string(damageNum) + " accel " + std::to_string(accelType);
+						BlastBasePerfTestStrict::reportData(timingName + " material", timers.material);
+						history.push_back((uint32_t)actors.size());
+						results.totalTime += timers.material;
+						history.push_back(0); // separator
+					}
+
+					// Release remaining actors
+					std::for_each(actors.begin(), actors.end(), [](NvBlastActor* a) { NvBlastActorDeactivate(a, messageLog); });
+					actors.clear();
+
+					alignedFree(family);
+				}
+
+				if (accelerator)
+					accelerator->release();
+
+				// Release asset data
+				alignedFree(asset);
+			}
+		}
+
+		return results;
+	}
+};
+
+
+// Tests
+TEST_F(PerfTest, DISABLED_DamageRadialSimple)
+{
+	const int trialCount = 10;
+	std::cout << "Trial (of " << trialCount << "): ";
+	for (int trial = 1; trial <= trialCount; ++trial)
+	{
+		if (trial % 100 == 0)
+		{
+			std::cout << trial << ".. ";
+			std::cout.flush();
+		}
+		std::vector<uint32_t> history1, history2;
+
+		uint32_t assetCount = 4;
+		uint32_t familyCount = 4;
+		uint32_t damageCount = 4;
+
+		PerfResults results0 = damageLeafSupportActors(test_info_->name(), assetCount, familyCount, damageCount, 0, history1);
+		BlastBasePerfTestStrict::reportData("DamageRadialSimple total0 " , results0.totalTime);
+		BlastBasePerfTestStrict::reportData("DamageRadialSimple create0 ", results0.createTime);
+		PerfResults results1 = damageLeafSupportActors(test_info_->name(), assetCount, familyCount, damageCount, 1, history2);
+		BlastBasePerfTestStrict::reportData("DamageRadialSimple total1 ", results1.totalTime);
+		BlastBasePerfTestStrict::reportData("DamageRadialSimple create1 ", results1.createTime);
+
+		EXPECT_TRUE(history1 == history2);
+	}
+	std::cout << "done." << std::endl;
+}
diff --git a/test/src/perf/SolverPerfTests.cpp b/test/src/perf/SolverPerfTests.cpp
index dfc5bc1..fa5187b 100644
--- a/test/src/perf/SolverPerfTests.cpp
+++ b/test/src/perf/SolverPerfTests.cpp
@@ -48,18 +48,15 @@ static void blast
 	bondEvents.resize(testAsset->solverBonds.size());
 
 	NvBlastExtRadialDamageDesc damage[] = {
-		{
-			compressiveDamage,
-			{ localPos.x, localPos.y, localPos.z },
-			minRadius,
-			maxRadius
-		}							
+		compressiveDamage,
+		{ localPos.x, localPos.y, localPos.z },
+		minRadius,
+		maxRadius
 	};
 
-	NvBlastProgramParams programParams =
+	NvBlastExtProgramParams programParams =
 	{
-		&damage,
-		1,
+		damage,
 		nullptr
 	};
 
@@ -127,43 +124,9 @@ public:
 
 		for (uint32_t assetNum = 0; assetNum < assetCount; ++assetNum)
 		{
-			CubeAssetGenerator::Settings settings;
-			settings.extents = GeneratorAsset::Vec3(1, 1, 1);
-			CubeAssetGenerator::DepthInfo depthInfo;
-			depthInfo.slicesPerAxis = GeneratorAsset::Vec3(1, 1, 1);
-			depthInfo.flag = NvBlastChunkDesc::Flags::NoFlags;
-			settings.depths.push_back(depthInfo);
-			uint32_t chunkCount = 1;
-			while (chunkCount < minChunkCount)
-			{
-				uint32_t chunkMul;
-				do
-				{
-					depthInfo.slicesPerAxis = GeneratorAsset::Vec3((float)(1 + rand() % 4), (float)(1 + rand() % 4), (float)(1 + rand() % 4));
-					chunkMul = (uint32_t)(depthInfo.slicesPerAxis.x * depthInfo.slicesPerAxis.y * depthInfo.slicesPerAxis.z);
-				} while (chunkMul == 1);
-				if (chunkCount*chunkMul > maxChunkCount)
-				{
-					break;
-				}
-				chunkCount *= chunkMul;
-				settings.depths.push_back(depthInfo);
-				settings.extents = settings.extents * depthInfo.slicesPerAxis;
-			}
-			settings.depths.back().flag = NvBlastChunkDesc::SupportFlag;	// Leaves are support
-
-			// Make largest direction unit size
-			settings.extents = settings.extents * (1.0f / std::max(settings.extents.x, std::max(settings.extents.y, settings.extents.z)));
-
-			// Create asset
-			GeneratorAsset testAsset;
-			CubeAssetGenerator::generate(testAsset, settings);
-
+			GeneratorAsset cube;
 			NvBlastAssetDesc desc;
-			desc.chunkDescs = testAsset.solverChunks.data();
-			desc.chunkCount = (uint32_t)testAsset.solverChunks.size();
-			desc.bondDescs = testAsset.solverBonds.data();
-			desc.bondCount = (uint32_t)testAsset.solverBonds.size();
+			generateRandomCube(cube, desc, minChunkCount, maxChunkCount);
 
 			{
 				std::vector<char> scratch;
@@ -193,11 +156,11 @@ public:
 					actors.insert(actor);
 					for (uint32_t damageNum = 0; damageNum < damageCount; ++damageNum)
 					{
-						GeneratorAsset::Vec3 localPos = settings.extents*GeneratorAsset::Vec3((float)rand() / RAND_MAX - 0.5f, (float)rand() / RAND_MAX - 0.5f, (float)rand() / RAND_MAX - 0.5f);
+						GeneratorAsset::Vec3 localPos = cube.extents*GeneratorAsset::Vec3((float)rand() / RAND_MAX - 0.5f, (float)rand() / RAND_MAX - 0.5f, (float)rand() / RAND_MAX - 0.5f);
 
 						NvBlastTimers timers;
 						NvBlastTimersReset(&timers);
-						blast(actors, &testAsset, localPos, relativeDamageRadius, relativeDamageRadius*1.2f, compressiveDamage, timers);
+						blast(actors, &cube, localPos, relativeDamageRadius, relativeDamageRadius*1.2f, compressiveDamage, timers);
 						const std::string timingName = std::string(testName) + " asset " + std::to_string(assetNum) + " family " + std::to_string(familyNum) + " damage " + std::to_string(damageNum);
 						BlastBasePerfTestStrict::reportData(timingName + " material", timers.material);
 						BlastBasePerfTestStrict::reportData(timingName + " fracture", timers.fracture);
@@ -220,7 +183,7 @@ public:
 	}
 };
 
-
+#if 0
 // Tests
 TEST_F(PerfTest, DamageLeafSupportActorsTestVisibility)
 {
@@ -237,3 +200,4 @@ TEST_F(PerfTest, DamageLeafSupportActorsTestVisibility)
 	}
 	std::cout << "done." << std::endl;
 }
+#endif
\ No newline at end of file
diff --git a/test/src/unit/APITests.cpp b/test/src/unit/APITests.cpp
index 5919450..22c9885 100644
--- a/test/src/unit/APITests.cpp
+++ b/test/src/unit/APITests.cpp
@@ -67,13 +67,11 @@ TEST_F(APITest, Basic)
 	NvBlastActor* actor = NvBlastFamilyCreateFirstActor(family, &actorDesc, scratch.data(), messageLog);
 	EXPECT_TRUE(actor != nullptr);
 
-	NvBlastExtRadialDamageDesc damage[] = {
-		{
-			10.0f,					// compressive
-			{ 0.0f, 0.0f, 0.0f },	// position
-			4.0f,					// min radius - maximum damage
-			6.0f					// max radius - zero damage
-		}							//				linear falloff
+	NvBlastExtRadialDamageDesc damage = {
+		10.0f,					// compressive
+		{ 0.0f, 0.0f, 0.0f },	// position
+		4.0f,					// min radius - maximum damage
+		6.0f					// max radius - zero damage
 	};
 
 	NvBlastBondFractureData outFracture[12]; /*num lower-support chunks + bonds?*/
@@ -84,9 +82,7 @@ TEST_F(APITest, Basic)
 	events.chunkFractureCount = 0;
 	events.chunkFractures = nullptr;
 
-	NvBlastProgramParams programParams;
-	programParams.damageDescCount = 1;
-	programParams.damageDescBuffer = &damage;
+	NvBlastExtProgramParams programParams = { &damage, nullptr };
 
 	NvBlastDamageProgram program = {
 		NvBlastExtFalloffGraphShader,
@@ -187,9 +183,7 @@ TEST_F(APITest, DamageBondsCompressive)
 		6, 0, outCommands, nullptr
 	};
 
-	NvBlastProgramParams programParams;
-	programParams.damageDescCount = 1;
-	programParams.damageDescBuffer = &damage;
+	NvBlastExtProgramParams programParams = { &damage, nullptr };
 
 	NvBlastDamageProgram program = {
 		NvBlastExtFalloffGraphShader,
@@ -1203,13 +1197,11 @@ TEST_F(APITest, FractureWithBondDuplicates)
 	// split in 2
 	std::vector<NvBlastActor*> actors;
 	{
-		NvBlastExtRadialDamageDesc damage[] = {
-			{
-				10.0f,					// compressive
-				{ 0.0f, 0.0f, 0.0f },	// position
-				100.0f,					// min radius - maximum damage
-				100.0f					// max radius - zero damage
-			}							//				linear falloff
+		NvBlastExtRadialDamageDesc damage = {
+			10.0f,					// compressive
+			{ 0.0f, 0.0f, 0.0f },	// position
+			100.0f,					// min radius - maximum damage
+			100.0f					// max radius - zero damage
 		};
 
 		NvBlastBondFractureData outBondFracture[bondCount];
@@ -1221,9 +1213,7 @@ TEST_F(APITest, FractureWithBondDuplicates)
 		events.chunkFractureCount = 2;
 		events.chunkFractures = outChunkFracture;
 
-		NvBlastProgramParams programParams;
-		programParams.damageDescCount = 1;
-		programParams.damageDescBuffer = &damage;
+		NvBlastExtProgramParams programParams = { &damage, nullptr };
 
 		NvBlastDamageProgram program = {
 			NvBlastExtFalloffGraphShader,
@@ -1366,13 +1356,11 @@ TEST_F(APITest, NoBondsSausage)
 	}
 
 	// damage
-	NvBlastExtRadialDamageDesc damage[] = {
-		{
-			10.0f,					// compressive
-			{ 0.0f, 0.0f, 0.0f },	// position
-			4.0f,					// min radius - maximum damage
-			6.0f					// max radius - zero damage
-		}							//				linear falloff
+	NvBlastExtRadialDamageDesc damage = {
+		10.0f,					// compressive
+		{ 0.0f, 0.0f, 0.0f },	// position
+		4.0f,					// min radius - maximum damage
+		6.0f					// max radius - zero damage
 	};
 
 	NvBlastBondFractureData outBondFracture[2];
@@ -1384,9 +1372,7 @@ TEST_F(APITest, NoBondsSausage)
 	events.chunkFractureCount = 2;
 	events.chunkFractures = outChunkFracture;
 
-	NvBlastProgramParams programParams;
-	programParams.damageDescCount = 1;
-	programParams.damageDescBuffer = &damage;
+	NvBlastExtProgramParams programParams = { &damage, nullptr };
 
 	NvBlastDamageProgram program = {
 		NvBlastExtFalloffGraphShader,
diff --git a/test/src/unit/ActorTests.cpp b/test/src/unit/ActorTests.cpp
index 522d230..1dc23dc 100644
--- a/test/src/unit/ActorTests.cpp
+++ b/test/src/unit/ActorTests.cpp
@@ -109,19 +109,16 @@ static void blast(std::set<NvBlastActor*>& actorsToDamage, GeneratorAsset* testA
 	std::vector<char> splitScratch;
 	std::vector<NvBlastActor*> newActorsBuffer(testAsset->solverChunks.size());
 
-	NvBlastExtRadialDamageDesc damage[] = {
-		{
-			compressiveDamage,
-			{ localPos.x, localPos.y, localPos.z },
-			minRadius,
-			maxRadius
-		}
+	NvBlastExtRadialDamageDesc damage = {
+		compressiveDamage,
+		{ localPos.x, localPos.y, localPos.z },
+		minRadius,
+		maxRadius
 	};
 
-	NvBlastProgramParams programParams =
+	NvBlastExtProgramParams programParams =
 	{
 		&damage,
-		1,
 		nullptr
 	};
 
diff --git a/test/src/unit/AssetTests.cpp b/test/src/unit/AssetTests.cpp
index 3b1ca7b..6963843 100644
--- a/test/src/unit/AssetTests.cpp
+++ b/test/src/unit/AssetTests.cpp
@@ -50,6 +50,8 @@
 #include "NvBlastExtSerializationInternal.h"
 #endif
 
+#include "NvBlastExtAssetUtils.h"
+
 #pragma warning( pop )
 
 #include <fstream>
@@ -373,8 +375,149 @@ public:
 			EXPECT_FALSE(isIdentity);
 		}
 	}
+
+	void mergeAssetTest(const NvBlastAssetDesc& desc, bool fail)
+	{
+		std::vector<char> scratch;
+
+		scratch.resize((size_t)NvBlastGetRequiredScratchForCreateAsset(&desc, messageLog));
+		void* mem = NVBLAST_ALLOC(NvBlastGetAssetMemorySize(&desc, messageLog));
+		NvBlastAsset* asset = NvBlastCreateAsset(mem, &desc, scratch.data(), messageLog);
+		EXPECT_TRUE(asset != nullptr);
+		if (asset == nullptr)
+		{
+			free(mem);
+			return;
+		}
+
+		// Merge two copies of this asset together
+		const NvBlastAsset* components[2] = { asset, asset };
+		const NvcVec3 translations[2] = { { 0, 0, 0 },{ 2, 0, 0 } };
+
+		const NvBlastBond bond = { { 1.0f, 0.0f, 0.0f }, 1.0f,{ 1.0f, 0.0f, 0.0f }, 0 };
+
+		NvBlastExtAssetUtilsBondDesc newBondDescs[4];
+		for (int i = 0; i < 4; ++i)
+		{
+			newBondDescs[i].bond = bond;
+			newBondDescs[i].chunkIndices[0] = 2 * (i + 1);
+			newBondDescs[i].chunkIndices[1] = 2 * i + 1;
+			newBondDescs[i].componentIndices[0] = 0;
+			newBondDescs[i].componentIndices[1] = 1;
+		}
+
+		// Create a merged descriptor
+		std::vector<uint32_t> chunkIndexOffsets(2);
+		std::vector<uint32_t> chunkReorderMap(2 * desc.chunkCount);
+
+		NvBlastAssetDesc mergedDesc = NvBlastExtAssetUtilsMergeAssets(components, nullptr, nullptr, translations, 2, newBondDescs, 4, chunkIndexOffsets.data(), chunkReorderMap.data(), 2 * desc.chunkCount);
+		EXPECT_EQ(2 * desc.bondCount + 4, mergedDesc.bondCount);
+		EXPECT_EQ(2 * desc.chunkCount, mergedDesc.chunkCount);
+		for (uint32_t i = 0; i < 2 * desc.chunkCount; ++i)
+		{
+			EXPECT_LT(chunkReorderMap[i], 2 * desc.chunkCount);
+		}
+		EXPECT_EQ(0, chunkIndexOffsets[0]);
+		EXPECT_EQ(desc.chunkCount, chunkIndexOffsets[1]);
+
+		scratch.resize((size_t)NvBlastGetRequiredScratchForCreateAsset(&mergedDesc, messageLog));
+		mem = NVBLAST_ALLOC(NvBlastGetAssetMemorySize(&mergedDesc, messageLog));
+		NvBlastAsset* mergedAsset = NvBlastCreateAsset(mem, &mergedDesc, scratch.data(), messageLog);
+		EXPECT_TRUE(mergedAsset != nullptr);
+		if (mergedAsset == nullptr)
+		{
+			free(mem);
+			return;
+		}
+
+		NVBLAST_FREE(const_cast<NvBlastBondDesc*>(mergedDesc.bondDescs));
+		NVBLAST_FREE(const_cast<NvBlastChunkDesc*>(mergedDesc.chunkDescs));
+		NVBLAST_FREE(mergedAsset);
+
+		if (!fail)
+		{
+			mergedDesc = NvBlastExtAssetUtilsMergeAssets(components, nullptr, nullptr, translations, 2, newBondDescs, 4, nullptr, chunkReorderMap.data(), 2 * desc.chunkCount);
+			EXPECT_EQ(2 * desc.bondCount + 4, mergedDesc.bondCount);
+			EXPECT_EQ(2 * desc.chunkCount, mergedDesc.chunkCount);
+			for (uint32_t i = 0; i < 2 * desc.chunkCount; ++i)
+			{
+				EXPECT_LT(chunkReorderMap[i], 2 * desc.chunkCount);
+			}
+			scratch.resize((size_t)NvBlastGetRequiredScratchForCreateAsset(&mergedDesc, messageLog));
+			mem = NVBLAST_ALLOC(NvBlastGetAssetMemorySize(&mergedDesc, messageLog));
+			mergedAsset = NvBlastCreateAsset(mem, &mergedDesc, scratch.data(), messageLog);
+			EXPECT_TRUE(mergedAsset != nullptr);
+			free(mem);
+			NVBLAST_FREE(const_cast<NvBlastBondDesc*>(mergedDesc.bondDescs));
+			NVBLAST_FREE(const_cast<NvBlastChunkDesc*>(mergedDesc.chunkDescs));
+		}
+		else
+		{
+			// We don't pass in a valid chunkReorderMap so asset creation should fail
+			mergedDesc = NvBlastExtAssetUtilsMergeAssets(components, nullptr, nullptr, translations, 2, newBondDescs, 4, chunkIndexOffsets.data(), nullptr, 0);
+			EXPECT_EQ(2 * desc.bondCount + 4, mergedDesc.bondCount);
+			EXPECT_EQ(2 * desc.chunkCount, mergedDesc.chunkCount);
+			EXPECT_EQ(0, chunkIndexOffsets[0]);
+			EXPECT_EQ(desc.chunkCount, chunkIndexOffsets[1]);
+			scratch.resize((size_t)NvBlastGetRequiredScratchForCreateAsset(&mergedDesc, messageLog));
+			mem = NVBLAST_ALLOC(NvBlastGetAssetMemorySize(&mergedDesc, messageLog));
+			mergedAsset = NvBlastCreateAsset(mem, &mergedDesc, scratch.data(), messageLog);
+			EXPECT_TRUE(mergedAsset == nullptr);
+			free(mem);
+			NVBLAST_FREE(const_cast<NvBlastBondDesc*>(mergedDesc.bondDescs));
+			NVBLAST_FREE(const_cast<NvBlastChunkDesc*>(mergedDesc.chunkDescs));
+
+			mergedDesc = NvBlastExtAssetUtilsMergeAssets(components, nullptr, nullptr, translations, 2, newBondDescs, 4, nullptr, nullptr, 0);
+			EXPECT_EQ(2 * desc.bondCount + 4, mergedDesc.bondCount);
+			EXPECT_EQ(2 * desc.chunkCount, mergedDesc.chunkCount);
+			scratch.resize((size_t)NvBlastGetRequiredScratchForCreateAsset(&mergedDesc, messageLog));
+			mem = NVBLAST_ALLOC(NvBlastGetAssetMemorySize(&mergedDesc, messageLog));
+			mergedAsset = NvBlastCreateAsset(mem, &mergedDesc, scratch.data(), messageLog);
+			EXPECT_TRUE(mergedAsset == nullptr);
+			free(mem);
+			NVBLAST_FREE(const_cast<NvBlastBondDesc*>(mergedDesc.bondDescs));
+			NVBLAST_FREE(const_cast<NvBlastChunkDesc*>(mergedDesc.chunkDescs));
+
+			// We lie and say the chunkReorderMap is not large enough.  It should be filled with 0xFFFFFFFF up to the size we gave
+			mergedDesc = NvBlastExtAssetUtilsMergeAssets(components, nullptr, nullptr, translations, 2, newBondDescs, 4, nullptr, chunkReorderMap.data(), desc.chunkCount);
+			EXPECT_EQ(2 * desc.bondCount + 4, mergedDesc.bondCount);
+			EXPECT_EQ(2 * desc.chunkCount, mergedDesc.chunkCount);
+			for (uint32_t i = 0; i < desc.chunkCount; ++i)
+			{
+				EXPECT_TRUE(Nv::Blast::isInvalidIndex(chunkReorderMap[i]));
+			}
+			scratch.resize((size_t)NvBlastGetRequiredScratchForCreateAsset(&mergedDesc, messageLog));
+			mem = NVBLAST_ALLOC(NvBlastGetAssetMemorySize(&mergedDesc, messageLog));
+			mergedAsset = NvBlastCreateAsset(mem, &mergedDesc, scratch.data(), messageLog);
+			EXPECT_TRUE(mergedAsset == nullptr);
+			free(mem);
+			NVBLAST_FREE(const_cast<NvBlastBondDesc*>(mergedDesc.bondDescs));
+			NVBLAST_FREE(const_cast<NvBlastChunkDesc*>(mergedDesc.chunkDescs));
+
+			mergedDesc = NvBlastExtAssetUtilsMergeAssets(components, nullptr, nullptr, translations, 2, newBondDescs, 4, chunkIndexOffsets.data(), chunkReorderMap.data(), desc.chunkCount);
+			EXPECT_EQ(2 * desc.bondCount + 4, mergedDesc.bondCount);
+			EXPECT_EQ(2 * desc.chunkCount, mergedDesc.chunkCount);
+			for (uint32_t i = 0; i < desc.chunkCount; ++i)
+			{
+				EXPECT_TRUE(Nv::Blast::isInvalidIndex(chunkReorderMap[i]));
+			}
+			EXPECT_EQ(0, chunkIndexOffsets[0]);
+			EXPECT_EQ(desc.chunkCount, chunkIndexOffsets[1]);
+			scratch.resize((size_t)NvBlastGetRequiredScratchForCreateAsset(&mergedDesc, messageLog));
+			mem = NVBLAST_ALLOC(NvBlastGetAssetMemorySize(&mergedDesc, messageLog));
+			mergedAsset = NvBlastCreateAsset(mem, &mergedDesc, scratch.data(), messageLog);
+			EXPECT_TRUE(mergedAsset == nullptr);
+			free(mem);
+			NVBLAST_FREE(const_cast<NvBlastBondDesc*>(mergedDesc.bondDescs));
+			NVBLAST_FREE(const_cast<NvBlastChunkDesc*>(mergedDesc.chunkDescs));
+		}
+
+		// Finally free the original asset
+		NVBLAST_FREE(asset);
+	}
 };
 
+typedef AssetTest<-1, 0> AssetTestAllowErrorsSilently;
 typedef AssetTest<NvBlastMessage::Error, 0> AssetTestAllowWarningsSilently;
 typedef AssetTest<NvBlastMessage::Error, 1> AssetTestAllowWarnings;
 typedef AssetTest<NvBlastMessage::Warning, 1> AssetTestStrict;
@@ -673,3 +816,43 @@ TEST_F(AssetTestAllowWarningsSilently, BuildAssetsShufflingChunkDescriptorsUsing
 		buildAssetShufflingDescriptors(&g_assetDescsMissingCoverage[i], g_assetsFromMissingCoverageExpectedValues[i], 10, true);
 	}
 }
+
+TEST_F(AssetTestStrict, MergeAssetsUpperSupportOnly)
+{
+	mergeAssetTest(g_assetDescs[0], false);
+}
+
+TEST_F(AssetTestStrict, MergeAssetsWithSubsupport)
+{
+	mergeAssetTest(g_assetDescs[1], false);
+}
+
+TEST_F(AssetTestStrict, MergeAssetsWithWorldBondsUpperSupportOnly)
+{
+	mergeAssetTest(g_assetDescs[3], false);
+}
+
+TEST_F(AssetTestStrict, MergeAssetsWithWorldBondsWithSubsupport)
+{
+	mergeAssetTest(g_assetDescs[4], false);
+}
+
+TEST_F(AssetTestAllowErrorsSilently, MergeAssetsUpperSupportOnlyExpectFail)
+{
+	mergeAssetTest(g_assetDescs[0], true);
+}
+
+TEST_F(AssetTestAllowErrorsSilently, MergeAssetsWithSubsupportExpectFail)
+{
+	mergeAssetTest(g_assetDescs[1], true);
+}
+
+TEST_F(AssetTestAllowErrorsSilently, MergeAssetsWithWorldBondsUpperSupportOnlyExpectFail)
+{
+	mergeAssetTest(g_assetDescs[3], true);
+}
+
+TEST_F(AssetTestAllowErrorsSilently, MergeAssetsWithWorldBondsWithSubsupportExpectFail)
+{
+	mergeAssetTest(g_assetDescs[4], true);
+}
diff --git a/test/src/unit/MultithreadingTests.cpp b/test/src/unit/MultithreadingTests.cpp
index 708f153..da07f98 100644
--- a/test/src/unit/MultithreadingTests.cpp
+++ b/test/src/unit/MultithreadingTests.cpp
@@ -59,19 +59,16 @@ static void blast(std::set<NvBlastActor*>& actorsToDamage, GeneratorAsset* testA
 	std::vector<char> splitScratch;
 	std::vector<NvBlastActor*> newActorsBuffer(testAsset->solverChunks.size());
 
-	NvBlastExtRadialDamageDesc damage[] = {
-		{
-			compressiveDamage,
-			{ localPos.x, localPos.y, localPos.z },
-			minRadius,
-			maxRadius
-		}
+	NvBlastExtRadialDamageDesc damage = {
+		compressiveDamage,
+		{ localPos.x, localPos.y, localPos.z },
+		minRadius,
+		maxRadius
 	};
 
-	NvBlastProgramParams programParams =
+	NvBlastExtProgramParams programParams =
 	{
 		&damage,
-		1,
 		nullptr
 	};
 
diff --git a/test/src/unit/SyncTests.cpp b/test/src/unit/SyncTests.cpp
index 4ac79ac..fba07a9 100644
--- a/test/src/unit/SyncTests.cpp
+++ b/test/src/unit/SyncTests.cpp
@@ -141,12 +141,19 @@ protected:
 		// add sync as listener to family #1
 		families[1]->addListener(*sync);
 
+		// damage params
+		CSParams cs0(1, 0.0f);
+		NvBlastExtProgramParams csParams0 = { &cs0, nullptr };
+		NvBlastExtRadialDamageDesc radialDamage0 = m_test->getRadialDamageDesc(0, 0, 0);
+		NvBlastExtProgramParams radialParams0 = { &radialDamage0, nullptr };
+		NvBlastExtRadialDamageDesc radialDamage1 = m_test->getRadialDamageDesc(0, 0, 0, 10.0f, 10.0f, 0.1f);
+		NvBlastExtProgramParams radialParams1 = { &radialDamage1, nullptr };
+
 		// damage family #0 (make it split)
 		{
 			TkActor* actor;
 			families[0]->getActors(&actor, 1);
-			CSParams p(1, 0.0f);
-			actor->damage(m_test->getCubeSlicerProgram(), &p, sizeof(p), m_test->getDefaultMaterial());
+			actor->damage(m_test->getCubeSlicerProgram(), &csParams0);
 		}
 
 		// process
@@ -164,8 +171,7 @@ protected:
 		{
 			TkActor* actor;
 			families[0]->getActors(&actor, 1, 1);
-			NvBlastExtRadialDamageDesc radialDamage = m_test->getRadialDamageDesc(0, 0, 0);
-			actor->damage(m_test->getFalloffProgram(), &radialDamage, sizeof(radialDamage), m_test->getDefaultMaterial());
+			actor->damage(m_test->getFalloffProgram(), &radialParams0);
 		}
 
 
@@ -174,7 +180,7 @@ protected:
 			TkActor* actor;
 			families[1]->getActors(&actor, 1);
 			NvBlastExtRadialDamageDesc radialDamage = m_test->getRadialDamageDesc(0, 0, 0, 10.0f, 10.0f, 0.1f);
-			actor->damage(m_test->getFalloffProgram(), &radialDamage, sizeof(radialDamage), m_test->getDefaultMaterial());
+			actor->damage(m_test->getFalloffProgram(), &radialParams1);
 		}
 
 		// process
diff --git a/test/src/unit/TkCompositeTests.cpp b/test/src/unit/TkCompositeTests.cpp
index 37dad1b..280b07e 100644
--- a/test/src/unit/TkCompositeTests.cpp
+++ b/test/src/unit/TkCompositeTests.cpp
@@ -327,8 +327,9 @@ public:
 
 		group->addActor(*actor1);
 
-		CSParams p(2, 0.0f);
-		actor1->damage(getCubeSlicerProgram(), &p, sizeof(p), getDefaultMaterial());
+		CSParams cs2(2, 0.0f);
+		NvBlastExtProgramParams csParams2 = { &cs2, nullptr };
+		actor1->damage(getCubeSlicerProgram(), &csParams2);
 
 		EXPECT_EQ((size_t)0, tracker.joints.size());
 
@@ -363,9 +364,10 @@ public:
 		}
 
 		NvBlastExtRadialDamageDesc radialDamage = getRadialDamageDesc(0, 0, 0);
+		NvBlastExtProgramParams radialParams = { &radialDamage, nullptr };
 		for (TkActor* actor : actors)
 		{
-			actor->damage(getFalloffProgram(), &radialDamage, sizeof(radialDamage), getDefaultMaterial());
+			actor->damage(getFalloffProgram(), &radialParams);
 		}
 
 		m_groupTM->process();
@@ -464,11 +466,13 @@ public:
 
 		EXPECT_EQ(compJointCount, tracker.joints.size());
 
+		CSParams cs2(2, 0.0f);
+		NvBlastExtProgramParams csParams2 = { &cs2, nullptr };
+
 		size_t totalActorCount = 0;
 		for (uint32_t i = 0; i < 4; ++i)
 		{
-			CSParams p(2, 0.0f);
-			actors[i]->damage(getCubeSlicerProgram(), &p, sizeof(p), getDefaultMaterial());
+			actors[i]->damage(getCubeSlicerProgram(), &csParams2);
 
 			m_groupTM->process();
 			m_groupTM->wait();
@@ -515,9 +519,10 @@ public:
 		}
 
 		NvBlastExtRadialDamageDesc radialDamage = getRadialDamageDesc(0, 0, 0);
+		NvBlastExtProgramParams radialParams = { &radialDamage, nullptr };
 		for (TkActor* actor : actors)
 		{
-			actor->damage(getFalloffProgram(), &radialDamage, sizeof(radialDamage), getDefaultMaterial());
+			actor->damage(getFalloffProgram(), &radialParams);
 		}
 
 		m_groupTM->process();
@@ -625,9 +630,11 @@ public:
 		tracker.joints.insert(joint);
 
 		NvBlastExtRadialDamageDesc radialDamage1 = getRadialDamageDesc(0, 1, 0, 2, 2);
-		actor1->damage(getFalloffProgram(), &radialDamage1, sizeof(radialDamage1), getDefaultMaterial());
+		NvBlastExtProgramParams radialParams1 = { &radialDamage1, nullptr };
+		actor1->damage(getFalloffProgram(), &radialParams1);
 		NvBlastExtRadialDamageDesc radialDamage2 = getRadialDamageDesc(0, -1, 0, 2, 2);
-		actor2->damage(getFalloffProgram(), &radialDamage2, sizeof(radialDamage2), getDefaultMaterial());
+		NvBlastExtProgramParams radialParams2 = { &radialDamage2, nullptr };
+		actor2->damage(getFalloffProgram(), &radialParams2);
 
 		m_groupTM->process();
 		m_groupTM->wait();
diff --git a/test/src/unit/TkTests.cpp b/test/src/unit/TkTests.cpp
index 3df536a..feee2a1 100644
--- a/test/src/unit/TkTests.cpp
+++ b/test/src/unit/TkTests.cpp
@@ -174,7 +174,17 @@ TEST_F(TkTestStrict, ActorDamageGroup)
 	m_groupTM->setGroup(group);
 
 	NvBlastExtRadialDamageDesc radialDamage = getRadialDamageDesc(0, 0, 0);
+	NvBlastExtProgramParams radialDamageParams = { &radialDamage, nullptr };
+
 	NvBlastExtShearDamageDesc shearDamage = getShearDamageDesc(0, 0, 0);
+	NvBlastExtProgramParams shearDamageParams = { &shearDamage, nullptr };
+
+	CSParams csDamage0(0, 0.0f);
+	NvBlastExtProgramParams csDamageParams0 = { &csDamage0, nullptr };
+	CSParams csDamage1(1, 0.0f);
+	NvBlastExtProgramParams csDamageParams1 = { &csDamage1, nullptr };
+	CSParams csDamage2(2, 0.0f);
+	NvBlastExtProgramParams csDamageParams2 = { &csDamage2, nullptr };
 
 	std::vector<TkFamily*> families;
 	TkFamily* trackedFamily;
@@ -212,8 +222,6 @@ TEST_F(TkTestStrict, ActorDamageGroup)
 		TkActor* cubeActor2 = fwk->createActor(cubeAD);
 		EXPECT_TRUE(cubeActor2 != nullptr);
 
-		CSParams p(0, 0.0f);
-
 		expectedVisibleChunks[&cubeActor1->getFamily()] = ExpectedVisibleChunks(2, 4); // split in 2, 4 chunks each
 		expectedVisibleChunks[&cubeActor2->getFamily()] = ExpectedVisibleChunks(1, 1); // not split
 
@@ -234,8 +242,8 @@ TEST_F(TkTestStrict, ActorDamageGroup)
 		families.push_back(&actor1->getFamily());
 		families.push_back(&actor2->getFamily());
 
-		cubeActor1->damage(getCubeSlicerProgram(), &p, sizeof(p), getDefaultMaterial());
-		actor1->damage(getFalloffProgram(), &radialDamage, sizeof(radialDamage), getDefaultMaterial());
+		cubeActor1->damage(getCubeSlicerProgram(), &csDamageParams0);
+		actor1->damage(getFalloffProgram(), &radialDamageParams);
 	}
 
 	EXPECT_FALSE(group->endProcess());
@@ -251,8 +259,7 @@ TEST_F(TkTestStrict, ActorDamageGroup)
 		trackedFamily->getActors(actors.data(), static_cast<uint32_t>(actors.size()));
 		for (TkActor* actor : actors)
 		{
-			CSParams p(1, 0.0f);
-			actor->damage(getCubeSlicerProgram(), &p, sizeof(p), getDefaultMaterial());
+			actor->damage(getCubeSlicerProgram(), &csDamageParams1);
 		}
 	}
 	expectedVisibleChunks[trackedFamily] = ExpectedVisibleChunks(4, 2);
@@ -268,8 +275,7 @@ TEST_F(TkTestStrict, ActorDamageGroup)
 		trackedFamily->getActors(actors.data(), static_cast<uint32_t>(actors.size()));
 		for (TkActor* actor : actors)
 		{
-			CSParams p(2, 0.0f);
-			actor->damage(getCubeSlicerProgram(), &p, sizeof(p), getDefaultMaterial());
+			actor->damage(getCubeSlicerProgram(), &csDamageParams2);
 		}
 	}
 
@@ -287,7 +293,7 @@ TEST_F(TkTestStrict, ActorDamageGroup)
 		TEST_ZONE_BEGIN("damage");
 		for (TkActor* actor : actors)
 		{
-			actor->damage(getFalloffProgram(), &radialDamage, sizeof(radialDamage), getDefaultMaterial());
+			actor->damage(getFalloffProgram(), &radialDamageParams);
 		}
 		TEST_ZONE_END("damage");
 	}
@@ -306,7 +312,7 @@ TEST_F(TkTestStrict, ActorDamageGroup)
 		TEST_ZONE_BEGIN("damage");
 		for (TkActor* actor : actors)
 		{
-			actor->damage(getShearProgram(), &shearDamage, sizeof(shearDamage), getDefaultMaterial());
+			actor->damage(getShearProgram(), &shearDamageParams);
 		}
 		TEST_ZONE_END("damage");
 	}
@@ -322,7 +328,7 @@ TEST_F(TkTestStrict, ActorDamageGroup)
 		TEST_ZONE_BEGIN("damage");
 		for (TkActor* actor : actors)
 		{
-			actor->damage(getShearProgram(), &shearDamage, sizeof(shearDamage), getDefaultMaterial());
+			actor->damage(getShearProgram(), &shearDamageParams);
 		}
 		TEST_ZONE_END("damage");
 	}
@@ -365,6 +371,13 @@ TEST_F(TkTestStrict, ActorDamageMultiGroup)
 	std::vector<TkFamily*> families(2);
 	std::map<TkFamily*, ExpectedVisibleChunks> expectedVisibleChunks;
 
+	CSParams csDamage0(0, 0.0f);
+	NvBlastExtProgramParams csDamageParams0 = { &csDamage0, nullptr };
+	CSParams csDamage1(1, 0.0f);
+	NvBlastExtProgramParams csDamageParams1 = { &csDamage1, nullptr };
+	CSParams csDamage2(2, 0.0f);
+	NvBlastExtProgramParams csDamageParams2 = { &csDamage2, nullptr };
+
 	// prepare 2 equal actors/families and damage
 	{
 		GeneratorAsset cube;
@@ -395,12 +408,10 @@ TEST_F(TkTestStrict, ActorDamageMultiGroup)
 		families[1] = (&cubeActor1->getFamily());
 
 		{
-			CSParams p0(0, 0.0f);
-			CSParams p1(1, 0.0f);
-			cubeActor0->damage(getCubeSlicerProgram(), &p0, sizeof(p0), getDefaultMaterial());
-			cubeActor0->damage(getCubeSlicerProgram(), &p1, sizeof(p1), getDefaultMaterial());
+			cubeActor0->damage(getCubeSlicerProgram(), &csDamageParams0);
+			cubeActor0->damage(getCubeSlicerProgram(), &csDamageParams1);
 
-			cubeActor1->damage(getCubeSlicerProgram(), &p0, sizeof(p0), getDefaultMaterial());
+			cubeActor1->damage(getCubeSlicerProgram(), &csDamageParams0);
 		}
 
 		expectedVisibleChunks[families[0]] = ExpectedVisibleChunks(4, 2); // split in 4, 2 chunks each
@@ -466,11 +477,9 @@ TEST_F(TkTestStrict, ActorDamageMultiGroup)
 			combinations.emplace(pair(actor->getGroup(), &actor->getFamily()));
 			if (actor->getVisibleChunkCount() == 4)
 			{
-				CSParams p1(1, 0.0f);
-				actor->damage(getCubeSlicerProgram(), &p1, sizeof(p1), getDefaultMaterial());
+				actor->damage(getCubeSlicerProgram(), &csDamageParams1);
 			}
-			CSParams p2(2, 0.0f);
-			actor->damage(getCubeSlicerProgram(), &p2, sizeof(p2), getDefaultMaterial());
+			actor->damage(getCubeSlicerProgram(), &csDamageParams2);
 		}
 		EXPECT_EQ(combinations.size(), 4);
 
@@ -505,7 +514,9 @@ TEST_F(TkTestStrict, ActorDamageMultiGroup)
 	std::default_random_engine re;
 	{
 		NvBlastExtRadialDamageDesc radialDamage = getRadialDamageDesc(0, 0, 0);
+		NvBlastExtProgramParams radialDamageParams = { &radialDamage, nullptr };
 		NvBlastExtShearDamageDesc shearDamage = getShearDamageDesc(0, 0, 0);
+		NvBlastExtProgramParams shearDamageParams = { &shearDamage, nullptr };
 
 		std::vector<TkActor*> actors;
 		while (1)
@@ -529,11 +540,11 @@ TEST_F(TkTestStrict, ActorDamageMultiGroup)
 
 				if (actor->getGraphNodeCount() > 1)
 				{
-					actor->damage(getFalloffProgram(), &radialDamage, sizeof(radialDamage), getDefaultMaterial());
+					actor->damage(getFalloffProgram(), &radialDamageParams);
 				}
 				else
 				{
-					actor->damage(getShearProgram(), &shearDamage, sizeof(shearDamage), getDefaultMaterial());
+					actor->damage(getShearProgram(), &shearDamageParams);
 				}
 
 				if (re() % 1000 < 500)
@@ -632,36 +643,34 @@ TEST_F(TkTestStrict, ActorDamageBufferedDamage)
 
 		// 2 of damage types would be through user's NvBlastDamageProgram, this pointer must live till group->sync()
 		NvBlastExtRadialDamageDesc userR0 = getRadialDamageDesc(P, P, 0, R, R);
-		NvBlastProgramParams userProgramParams0 =
-		{
-			&userR0,	// damageDescBuffer
-			1,			// damageDescCount
-			nullptr,	// material
-		};
+		NvBlastExtProgramParams userProgramParams0 = { &userR0,	nullptr	};
 
 		NvBlastExtRadialDamageDesc userR1 = getRadialDamageDesc(-P, P, 0, R, R);
-		NvBlastProgramParams userProgramParams1 =
-		{
-			&userR1,	// damageDescBuffer
-			1,			// damageDescCount
-			nullptr,	// material
-		};
+		NvBlastExtProgramParams userProgramParams1 = { &userR1, nullptr	};
+
+		CSParams csDamage0(0, 0.0f);
+		NvBlastExtProgramParams csDamageParams0 = { &csDamage0, nullptr };
+		CSParams csDamage1(1, 0.0f);
+		NvBlastExtProgramParams csDamageParams1 = { &csDamage1, nullptr };
+		CSParams csDamage2(2, 0.0f);
+		NvBlastExtProgramParams csDamageParams2 = { &csDamage2, nullptr };
+
+		NvBlastExtRadialDamageDesc r0 = getRadialDamageDesc(P, -P, 0, R, R);
+		NvBlastExtProgramParams rDamageParams0 = { &r0, nullptr };
+		NvBlastExtRadialDamageDesc r1 = getRadialDamageDesc(-P, -P, 0, R, R);
+		NvBlastExtProgramParams rDamageParams1 = { &r1, nullptr };
+
 
 		// fill damage functions, shuffle and apply
 		{
-			CSParams p0(0, 0.0f);
-			CSParams p1(1, 0.0f);
-			CSParams p2(2, 0.0f);
-			NvBlastExtRadialDamageDesc r0 = getRadialDamageDesc(P, -P, 0, R, R);
-			NvBlastExtRadialDamageDesc r1 = getRadialDamageDesc(-P, -P, 0, R, R);
 
 			const uint32_t damageCount = 7;
 			std::vector<std::function<void(void)>> damageFns(damageCount);
-			damageFns[0] = [&]() { actor->damage(getCubeSlicerProgram(), &p0, sizeof(p0), getDefaultMaterial()); };
-			damageFns[1] = [&]() { actor->damage(getCubeSlicerProgram(), &p1, sizeof(p1), getDefaultMaterial()); };
-			damageFns[2] = [&]() { actor->damage(getCubeSlicerProgram(), &p2, sizeof(p2), getDefaultMaterial()); };
-			damageFns[3] = [&]() { actor->damage(getFalloffProgram(), &r0, sizeof(r0), getDefaultMaterial()); };
-			damageFns[4] = [&]() { actor->damage(getFalloffProgram(), &r1, sizeof(r1), getDefaultMaterial()); };
+			damageFns[0] = [&]() { actor->damage(getCubeSlicerProgram(), &csDamageParams0); };
+			damageFns[1] = [&]() { actor->damage(getCubeSlicerProgram(), &csDamageParams1); };
+			damageFns[2] = [&]() { actor->damage(getCubeSlicerProgram(), &csDamageParams2); };
+			damageFns[3] = [&]() { actor->damage(getFalloffProgram(), &rDamageParams0); };
+			damageFns[4] = [&]() { actor->damage(getFalloffProgram(), &rDamageParams1); };
 			damageFns[5] = [&]() { actor->damage(getFalloffProgram(), &userProgramParams0); };
 			damageFns[6] = [&]() { actor->damage(getFalloffProgram(), &userProgramParams1); };
 
@@ -858,9 +867,12 @@ TEST_F(TkTestAllowWarnings, DISABLED_FamilySerialization)
 		uint32_t expectedActorCount = 16;
 
 		// cube slicer params
-		CSParams p0(0, 0.0f);
-		CSParams p1(1, 0.0f);
-		CSParams p2(2, 0.0f);
+		CSParams csDamage0(0, 0.0f);
+		NvBlastExtProgramParams csDamageParams0 = { &csDamage0, nullptr };
+		CSParams csDamage1(1, 0.0f);
+		NvBlastExtProgramParams csDamageParams1 = { &csDamage1, nullptr };
+		CSParams csDamage2(2, 0.0f);
+		NvBlastExtProgramParams csDamageParams2 = { &csDamage2, nullptr };
 
 		// fallof params
 		const float P = 0.5f;
@@ -869,16 +881,20 @@ TEST_F(TkTestAllowWarnings, DISABLED_FamilySerialization)
 		NvBlastExtRadialDamageDesc r1 = getRadialDamageDesc(-P, P, 0, R, R);
 		NvBlastExtRadialDamageDesc r2 = getRadialDamageDesc(P, -P, 0, R, R);
 		NvBlastExtRadialDamageDesc r3 = getRadialDamageDesc(-P, -P, 0, R, R);
+		NvBlastExtProgramParams r0p = { &r0, nullptr };
+		NvBlastExtProgramParams r1p = { &r1, nullptr };
+		NvBlastExtProgramParams r2p = { &r2, nullptr };
+		NvBlastExtProgramParams r3p = { &r3, nullptr };
 
 		const uint32_t damageCount = 7;
 		std::vector<std::function<void(TkActor* a)>> damageFns(damageCount);
-		damageFns[0] = [&](TkActor* a) { a->damage(getCubeSlicerProgram(), &p0, sizeof(p0), getDefaultMaterial()); };
-		damageFns[1] = [&](TkActor* a) { a->damage(getCubeSlicerProgram(), &p1, sizeof(p1), getDefaultMaterial()); };
-		damageFns[2] = [&](TkActor* a) { a->damage(getCubeSlicerProgram(), &p2, sizeof(p2), getDefaultMaterial()); };
-		damageFns[3] = [&](TkActor* a) { a->damage(getFalloffProgram(), &r0, sizeof(r0), getDefaultMaterial()); };
-		damageFns[4] = [&](TkActor* a) { a->damage(getFalloffProgram(), &r1, sizeof(r1), getDefaultMaterial()); };
-		damageFns[5] = [&](TkActor* a) { a->damage(getFalloffProgram(), &r2, sizeof(r2), getDefaultMaterial()); };
-		damageFns[6] = [&](TkActor* a) { a->damage(getFalloffProgram(), &r3, sizeof(r3), getDefaultMaterial()); };
+		damageFns[0] = [&](TkActor* a) { a->damage(getCubeSlicerProgram(), &csDamageParams0); };
+		damageFns[1] = [&](TkActor* a) { a->damage(getCubeSlicerProgram(), &csDamageParams1); };
+		damageFns[2] = [&](TkActor* a) { a->damage(getCubeSlicerProgram(), &csDamageParams2); };
+		damageFns[3] = [&](TkActor* a) { a->damage(getFalloffProgram(), &r0p); };
+		damageFns[4] = [&](TkActor* a) { a->damage(getFalloffProgram(), &r1p); };
+		damageFns[5] = [&](TkActor* a) { a->damage(getFalloffProgram(), &r2p); };
+		damageFns[6] = [&](TkActor* a) { a->damage(getFalloffProgram(), &r3p); };
 
 		std::vector<TkActor*> actors(64);
 
@@ -939,10 +955,11 @@ TEST_F(TkTestStrict, GroupStats)
 	group->addActor(*cubeActor4);
 
 	NvBlastExtRadialDamageDesc r0 = getRadialDamageDesc(0.0f, 0.0f, 0.0f);
-	cubeActor1->damage(getFalloffProgram(), &r0, sizeof(r0));
-	cubeActor2->damage(getFalloffProgram(), &r0, sizeof(r0));
-	cubeActor3->damage(getFalloffProgram(), &r0, sizeof(r0));
-	cubeActor4->damage(getFalloffProgram(), &r0, sizeof(r0));
+	NvBlastExtProgramParams radialDamageParams = { &r0, nullptr };
+	cubeActor1->damage(getFalloffProgram(), &radialDamageParams);
+	cubeActor2->damage(getFalloffProgram(), &radialDamageParams);
+	cubeActor3->damage(getFalloffProgram(), &radialDamageParams);
+	cubeActor4->damage(getFalloffProgram(), &radialDamageParams);
 
 	Nv::Blast::Time time;
 	m_groupTM->process();
@@ -1077,7 +1094,8 @@ TEST_F(TkTestStrict, FractureReportSupport)
 
 	// this will trigger hierarchical chunk fracture
 	NvBlastExtRadialDamageDesc radialDamage = getRadialDamageDesc(0, 0, 0);
-	actor->damage(getFalloffProgram(), &radialDamage, sizeof(NvBlastExtRadialDamageDesc), getDefaultMaterial());
+	NvBlastExtProgramParams radialDamageParams = { &radialDamage, nullptr };
+	actor->damage(getFalloffProgram(), &radialDamageParams);
 
 	m_groupTM->process();
 	m_groupTM->wait();
@@ -1219,7 +1237,8 @@ TEST_F(TkTestStrict, FractureReportGraph)
 
 	// this will trigger one bond to break
 	NvBlastExtRadialDamageDesc radialDamage = getRadialDamageDesc(0, 0, 0, 0.5f, 0.5f);
-	rootActor->damage(getFalloffProgram(), &radialDamage, sizeof(NvBlastExtRadialDamageDesc), getDefaultMaterial());
+	NvBlastExtProgramParams radialDamageParams = { &radialDamage, nullptr };
+	rootActor->damage(getFalloffProgram(), &radialDamageParams);
 
 	m_groupTM->process();
 	m_groupTM->wait();
@@ -1266,7 +1285,8 @@ TEST_F(TkTestStrict, SplitWarning) // GWD-167
 	group->addActor(*actor);
 
 	NvBlastExtRadialDamageDesc radialDamage = getRadialDamageDesc(0, 0, 0);
-	actor->damage(getFalloffProgram(), &radialDamage, sizeof(NvBlastExtRadialDamageDesc), getDefaultMaterial());
+	NvBlastExtProgramParams radialDamageParams = { &radialDamage, nullptr };
+	actor->damage(getFalloffProgram(), &radialDamageParams);
 
 	m_groupTM->process();
 	m_groupTM->wait();
@@ -1362,10 +1382,11 @@ TEST_F(TkTestAllowWarnings, ChangeThreadCountToZero)
 	group->addActor(*actor4);
 
 	NvBlastExtRadialDamageDesc radialDamage = getRadialDamageDesc(0, 0, 0);
-	actor1->damage(getFalloffProgram(), &radialDamage, sizeof(NvBlastExtRadialDamageDesc), getDefaultMaterial());
-	actor2->damage(getFalloffProgram(), &radialDamage, sizeof(NvBlastExtRadialDamageDesc), getDefaultMaterial());
-	actor3->damage(getFalloffProgram(), &radialDamage, sizeof(NvBlastExtRadialDamageDesc), getDefaultMaterial());
-	actor4->damage(getFalloffProgram(), &radialDamage, sizeof(NvBlastExtRadialDamageDesc), getDefaultMaterial());
+	NvBlastExtProgramParams radialDamageParams = { &radialDamage, nullptr };
+	actor1->damage(getFalloffProgram(), &radialDamageParams);
+	actor2->damage(getFalloffProgram(), &radialDamageParams);
+	actor3->damage(getFalloffProgram(), &radialDamageParams);
+	actor4->damage(getFalloffProgram(), &radialDamageParams);
 
 	m_groupTM->process();
 	m_groupTM->wait();
@@ -1463,10 +1484,11 @@ TEST_F(TkTestStrict, ChangeThreadCountUp)
 	group->addActor(*actor4);
 
 	NvBlastExtRadialDamageDesc radialDamage = getRadialDamageDesc(0, 0, 0);
-	actor1->damage(getFalloffProgram(), &radialDamage, sizeof(NvBlastExtRadialDamageDesc), getDefaultMaterial());
-	actor2->damage(getFalloffProgram(), &radialDamage, sizeof(NvBlastExtRadialDamageDesc), getDefaultMaterial());
-	actor3->damage(getFalloffProgram(), &radialDamage, sizeof(NvBlastExtRadialDamageDesc), getDefaultMaterial());
-	actor4->damage(getFalloffProgram(), &radialDamage, sizeof(NvBlastExtRadialDamageDesc), getDefaultMaterial());
+	NvBlastExtProgramParams radialDamageParams = { &radialDamage, nullptr };
+	actor1->damage(getFalloffProgram(), &radialDamageParams);
+	actor2->damage(getFalloffProgram(), &radialDamageParams);
+	actor3->damage(getFalloffProgram(), &radialDamageParams);
+	actor4->damage(getFalloffProgram(), &radialDamageParams);
 
 	m_taskman->setCpuDispatcher(*disp4);
 	//group->setWorkerCount(m_taskman->getCpuDispatcher()->getWorkerCount());
@@ -1562,10 +1584,15 @@ TEST_F(TkTestAllowWarnings, GroupNoWorkers)
 	group->addActor(*actor4);
 
 	NvBlastExtRadialDamageDesc radialDamage = getRadialDamageDesc(0, 0, 0);
-	actor1->damage(getFalloffProgram(), &radialDamage, sizeof(NvBlastExtRadialDamageDesc), getDefaultMaterial());
-	actor2->damage(getFalloffProgram(), &radialDamage, sizeof(NvBlastExtRadialDamageDesc), getDefaultMaterial());
-	actor3->damage(getFalloffProgram(), &radialDamage, sizeof(NvBlastExtRadialDamageDesc), getDefaultMaterial());
-	actor4->damage(getFalloffProgram(), &radialDamage, sizeof(NvBlastExtRadialDamageDesc), getDefaultMaterial());
+	NvBlastExtProgramParams programParams = {
+		&radialDamage,
+		getDefaultMaterial()
+	};
+
+	actor1->damage(getFalloffProgram(), &programParams);
+	actor2->damage(getFalloffProgram(), &programParams);
+	actor3->damage(getFalloffProgram(), &programParams);
+	actor4->damage(getFalloffProgram(), &programParams);
 
 	m_groupTM->process();
 	m_groupTM->wait();
diff --git a/test/src/utils/TestAssets.cpp b/test/src/utils/TestAssets.cpp
index 34dd5b5..5668d3e 100644
--- a/test/src/utils/TestAssets.cpp
+++ b/test/src/utils/TestAssets.cpp
@@ -28,6 +28,7 @@
 
 #include "TestAssets.h"
 #include "AssetGenerator.h"
+#include <algorithm>
 
 const NvBlastChunkDesc g_cube1ChunkDescs[9] =
 {
@@ -378,3 +379,42 @@ void generateCube(GeneratorAsset& cubeAsset, NvBlastAssetDesc& assetDesc, size_t
 	assetDesc.chunkCount = (uint32_t)cubeAsset.chunks.size();
 	assetDesc.chunkDescs = cubeAsset.solverChunks.data();
 }
+
+void generateRandomCube(GeneratorAsset& cubeAsset, NvBlastAssetDesc& desc, uint32_t minChunkCount, uint32_t maxChunkCount)
+{
+	CubeAssetGenerator::Settings settings;
+	settings.extents = GeneratorAsset::Vec3(1, 1, 1);
+	CubeAssetGenerator::DepthInfo depthInfo;
+	depthInfo.slicesPerAxis = GeneratorAsset::Vec3(1, 1, 1);
+	depthInfo.flag = NvBlastChunkDesc::Flags::NoFlags;
+	settings.depths.push_back(depthInfo);
+	uint32_t chunkCount = 1;
+	while (chunkCount < minChunkCount)
+	{
+		uint32_t chunkMul;
+		do
+		{
+			depthInfo.slicesPerAxis = GeneratorAsset::Vec3((float)(1 + rand() % 4), (float)(1 + rand() % 4), (float)(1 + rand() % 4));
+			chunkMul = (uint32_t)(depthInfo.slicesPerAxis.x * depthInfo.slicesPerAxis.y * depthInfo.slicesPerAxis.z);
+		} while (chunkMul == 1);
+		if (chunkCount*chunkMul > maxChunkCount)
+		{
+			break;
+		}
+		chunkCount *= chunkMul;
+		settings.depths.push_back(depthInfo);
+		settings.extents = settings.extents * depthInfo.slicesPerAxis;
+	}
+	settings.depths.back().flag = NvBlastChunkDesc::SupportFlag;	// Leaves are support
+
+																	// Make largest direction unit size
+	settings.extents = settings.extents * (1.0f / std::max(settings.extents.x, std::max(settings.extents.y, settings.extents.z)));
+
+	// Create asset
+	CubeAssetGenerator::generate(cubeAsset, settings);
+
+	desc.chunkDescs = cubeAsset.solverChunks.data();
+	desc.chunkCount = (uint32_t)cubeAsset.solverChunks.size();
+	desc.bondDescs = cubeAsset.solverBonds.data();
+	desc.bondCount = (uint32_t)cubeAsset.solverBonds.size();
+}
\ No newline at end of file
diff --git a/test/src/utils/TestAssets.h b/test/src/utils/TestAssets.h
index 5fd7741..6d034bc 100644
--- a/test/src/utils/TestAssets.h
+++ b/test/src/utils/TestAssets.h
@@ -65,4 +65,6 @@ inline uint32_t getAssetDescMissingCoverageCount()
 void generateCube(GeneratorAsset& cubeAsset, NvBlastAssetDesc& assetDesc, size_t maxDepth, size_t width, 
 	int32_t supportDepth = -1, CubeAssetGenerator::BondFlags bondFlags = CubeAssetGenerator::ALL_INTERNAL_BONDS);
 
+void generateRandomCube(GeneratorAsset& cubeAsset, NvBlastAssetDesc& assetDesc, uint32_t minChunkCount, uint32_t maxChunkCount);
+
 #endif // #ifdef TESTASSETS_H