Changes for 1.1.1

See README.md

7 files changed, 340 insertions, 137 deletions

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();