Updating to [email protected] and [email protected] with a new directory structure.

NvBlast folder is gone, files have been moved to top level directory.  README is changed to reflect this.

1 files changed, 0 insertions, 1059 deletions

diff --git a/NvBlast/test/src/unit/ActorTests.cpp b/NvBlast/test/src/unit/ActorTests.cpp
deleted file mode 100644
index 12dc19c..0000000
--- a/NvBlast/test/src/unit/ActorTests.cpp
+++ /dev/null
@@ -1,1059 +0,0 @@
-#include "BlastBaseTest.h"
-#include "AssetGenerator.h"
-
-#include <map>
-#include <algorithm>
-
-#include "NvBlastActor.h"
-#include "NvBlastExtDamageShaders.h"
-
-
-static bool chooseRandomGraphNodes(uint32_t* g, uint32_t count, const Nv::Blast::Actor& actor)
-{
-	const uint32_t graphNodeCount = actor.getGraphNodeCount();
-
-	if (graphNodeCount < count)
-	{
-		return false;
-	}
-
-	std::vector<uint32_t> graphNodeIndices(graphNodeCount);
-	uint32_t* index = graphNodeIndices.data();
-	for (Nv::Blast::Actor::GraphNodeIt i = actor; (bool)i ; ++i)
-	{
-		*index++ = (uint32_t)i;
-	}
-	struct UserDataSorter
-	{
-		UserDataSorter(const Nv::Blast::Actor& actor) : m_asset(*actor.getAsset()) {}
-
-		bool	operator () (uint32_t i0, uint32_t i1) const
-		{
-			const uint32_t c0 = m_asset.m_graph.getChunkIndices()[i0];
-			const uint32_t c1 = m_asset.m_graph.getChunkIndices()[i1];
-			return m_asset.getChunks()[c0].userData < m_asset.getChunks()[c1].userData;
-		}
-
-		const Nv::Blast::Asset& m_asset;
-	} userDataSorter(actor);
-	std::sort(graphNodeIndices.data(), graphNodeIndices.data() + graphNodeCount, userDataSorter);
-
-#if 0
-	std::vector<uint32_t> descUserData(graphNodeCount);
-	for (uint32_t i = 0; i < graphNodeCount; ++i)
-	{
-		descUserData[i] = actor.getAsset()->m_chunks[actor.getAsset()->m_graph.m_chunkIndices[graphNodeIndices[i]]].userData;
-	}
-#endif
-
-	uint32_t t = 0;
-	uint32_t m = 0;
-	for (uint32_t i = 0; i < graphNodeCount && m < count; ++i, ++t)
-	{
-		NVBLAST_ASSERT(t < graphNodeCount);
-		if (t >= graphNodeCount)
-		{
-			break;
-		}
-		const float U = (float)rand()/RAND_MAX;	// U is uniform random number in [0,1)
-		if ((graphNodeCount - t)*U < count - m)
-		{
-			g[m++] = graphNodeIndices[i];
-		}
-	}
-
-	return m == count;
-}
-
-
-static void blast(std::set<NvBlastActor*>& actorsToDamage, GeneratorAsset* testAsset, GeneratorAsset::Vec3 localPos, float minRadius, float maxRadius, float compressiveDamage)
-{
-	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());
-
-
-	std::vector<char> splitScratch;
-	std::vector<NvBlastActor*> newActorsBuffer(testAsset->solverChunks.size());
-
-	NvBlastExtRadialDamageDesc damage[] = {
-		{
-			compressiveDamage,
-			{ localPos.x, localPos.y, localPos.z },
-			minRadius,
-			maxRadius
-		}
-	};
-
-	NvBlastProgramParams programParams =
-	{
-		&damage,
-		1,
-		nullptr
-	};
-
-	NvBlastDamageProgram program = {
-		NvBlastExtFalloffGraphShader,
-		nullptr
-	};
-
-	size_t totalNewActorsCount = 0;
-	for (std::set<NvBlastActor*>::iterator k = actorsToDamage.begin(); k != actorsToDamage.end();)
-	{
-		NvBlastActor* actor = *k;
-		NvBlastFractureBuffers events = { static_cast<uint32_t>(bondEvents.size()), static_cast<uint32_t>(chunkEvents.size()), bondEvents.data(), chunkEvents.data() };
-
-		NvBlastActorGenerateFracture(&events, actor, program, &programParams, nullptr, nullptr);
-		NvBlastActorApplyFracture(&events, actor, &events, nullptr, nullptr);
-		bool removeActor = false;
-
-		if (events.bondFractureCount + events.chunkFractureCount > 0)
-		{
-			NvBlastActorSplitEvent splitEvent;
-			splitEvent.newActors = &newActorsBuffer.data()[totalNewActorsCount];
-			uint32_t newActorSize = (uint32_t)(newActorsBuffer.size() - totalNewActorsCount);
-
-			splitScratch.resize((size_t)NvBlastActorGetRequiredScratchForSplit(actor, nullptr));
-			const size_t newActorsCount = NvBlastActorSplit(&splitEvent, actor, newActorSize, splitScratch.data(), nullptr, nullptr);
-			totalNewActorsCount += newActorsCount;
-			removeActor = splitEvent.deletedActor != NULL;
-		}
-
-		if (removeActor)
-		{
-			k = actorsToDamage.erase(k);
-		}
-		else
-		{
-			++k;
-		}
-	}
-
-	for (size_t i = 0; i < totalNewActorsCount; ++i)
-	{
-		actorsToDamage.insert(newActorsBuffer[i]);
-	}
-}
-
-
-template<int FailLevel, int Verbosity>
-class ActorTest : public BlastBaseTest<FailLevel, Verbosity>
-{
-public:
-	ActorTest()
-	{
-
-	}
-
-	static void messageLog(int type, const char* msg, const char* file, int line)
-	{
-		BlastBaseTest<FailLevel, Verbosity>::messageLog(type, msg, file, line);
-	}
-
-	static void* alloc(size_t size)
-	{
-		return BlastBaseTest<FailLevel, Verbosity>::alloc(size);
-	}
-
-	static void free(void* mem)
-	{
-		BlastBaseTest<FailLevel, Verbosity>::free(mem);
-	}
-
-	NvBlastAsset* buildAsset(const NvBlastAssetDesc& desc)
-	{
-		// fix desc if wrong order or missing coverage first
-		NvBlastAssetDesc fixedDesc = desc;
-		std::vector<NvBlastChunkDesc> chunkDescs(desc.chunkDescs, desc.chunkDescs + desc.chunkCount);
-		std::vector<NvBlastBondDesc> bondDescs(desc.bondDescs, desc.bondDescs + desc.bondCount);
-		std::vector<uint32_t> chunkReorderMap(desc.chunkCount);
-		std::vector<char> scratch(desc.chunkCount * sizeof(NvBlastChunkDesc));
-		NvBlastEnsureAssetExactSupportCoverage(chunkDescs.data(), fixedDesc.chunkCount, scratch.data(), messageLog);
-		NvBlastReorderAssetDescChunks(chunkDescs.data(), fixedDesc.chunkCount, bondDescs.data(), fixedDesc.bondCount, chunkReorderMap.data(), scratch.data(), messageLog);
-		fixedDesc.chunkDescs = chunkDescs.data();
-		fixedDesc.bondDescs = bondDescs.empty() ? nullptr : bondDescs.data();
-
-		// create asset
-		m_scratch.resize((size_t)NvBlastGetRequiredScratchForCreateAsset(&fixedDesc, messageLog));
-		void* mem = alloc(NvBlastGetAssetMemorySize(&fixedDesc, messageLog));
-		NvBlastAsset* asset = NvBlastCreateAsset(mem, &fixedDesc, &m_scratch[0], messageLog);
-		EXPECT_TRUE(asset != nullptr);
-		return asset;
-	}
-
-	void buildAssets()
-	{
-		m_assets.resize(getAssetDescCount());
-		for (uint32_t i = 0; i < m_assets.size(); ++i)
-		{
-			m_assets[i] = buildAsset(g_assetDescs[i]);
-		}
-	}
-
-	NvBlastActor* instanceActor(const NvBlastAsset& asset)
-	{
-		NvBlastActorDesc actorDesc;
-		actorDesc.initialBondHealths = actorDesc.initialSupportChunkHealths = nullptr;
-		actorDesc.uniformInitialBondHealth = actorDesc.uniformInitialLowerSupportChunkHealth = 1.0f;
-		void* fmem = alloc(NvBlastAssetGetFamilyMemorySize(&asset, nullptr));
-		NvBlastFamily* family = NvBlastAssetCreateFamily(fmem, &asset, nullptr);
-		std::vector<char> scratch((size_t)NvBlastFamilyGetRequiredScratchForCreateFirstActor(family, messageLog));
-		NvBlastActor* actor = NvBlastFamilyCreateFirstActor(family, &actorDesc, &scratch[0], messageLog);
-		EXPECT_TRUE(actor != nullptr);
-		return actor;
-	}
-
-	void instanceActors()
-	{
-		m_actors.resize(m_assets.size());
-		for (uint32_t i = 0; i < m_actors.size(); ++i)
-		{
-			m_actors[i] = instanceActor(*m_assets[i]);
-		}
-	}
-
-	void releaseActors()
-	{
-		for (uint32_t i = 0; i < m_actors.size(); ++i)
-		{
-			NvBlastFamily* family = NvBlastActorGetFamily(m_actors[i], messageLog);
-
-			const bool actorReleaseResult = NvBlastActorDeactivate(m_actors[i], messageLog);
-			EXPECT_TRUE(actorReleaseResult);
-
-			free(family);
-		}
-	}
-
-	void destroyAssets()
-	{
-		for (uint32_t i = 0; i < m_assets.size(); ++i)
-		{
-			free(m_assets[i]);
-		}
-	}
-
-	void instanceAndPartitionRecursively
-	(
-		const NvBlastAsset& asset,
-		bool partitionToSubsupport,
-		void (*preSplitTest)(const Nv::Blast::Actor&, NvBlastLog),
-		void (*postSplitTest)(const std::vector<Nv::Blast::Actor*>&, uint32_t, uint32_t, bool)
-	)
-	{
-		const Nv::Blast::Asset& solverAsset = *static_cast<const Nv::Blast::Asset*>(&asset);
-
-		std::vector<Nv::Blast::Actor*> actors;
-		std::vector<Nv::Blast::Actor*> buffer(NvBlastAssetGetChunkCount(&asset, messageLog));
-
-		// Instance the first actor from the asset
-		actors.push_back(static_cast<Nv::Blast::Actor*>(instanceActor(asset)));
-
-		NvBlastFamily* family = NvBlastActorGetFamily(actors[0], messageLog);
-
-		const uint32_t supportChunkCount = actors[0]->getAsset()->m_graph.m_nodeCount;
-		const uint32_t leafChunkCount = actors[0]->getAsset()->m_leafChunkCount;
-
-		// Now randomly partition the actors in the array, and keep going until we're down to single support chunks
-		bool canFracture = true;
-
-		while (canFracture)
-		{
-			canFracture = false;
-
-			for (uint32_t actorToPartition = 0; actorToPartition < actors.size(); ++actorToPartition)
-			{
-				Nv::Blast::Actor* a = (Nv::Blast::Actor*)actors[actorToPartition];
-				if (a == nullptr)
-				{
-					continue;
-				}
-
-				m_scratch.reserve((size_t)NvBlastActorGetRequiredScratchForSplit(a, messageLog));
-
-				if (preSplitTest)
-				{
-					preSplitTest(*a, nullptr);
-				}
-
-				const bool singleLowerSupportChunk = a->getGraphNodeCount() <= 1;
-				uint32_t newActorCount = 0;
-
-				for (int damageNum = 0; newActorCount < 2 && damageNum < 100; ++damageNum)	// Avoid infinite loops
-				{
-					if (!singleLowerSupportChunk)
-					{
-						uint32_t g[2];
-						chooseRandomGraphNodes(g, 2, *a);
-						const uint32_t bondIndex = solverAsset.m_graph.findBond(g[0], g[1]);
-						if (bondIndex != Nv::Blast::invalidIndex<uint32_t>())
-						{
-							a->damageBond(g[0], g[1], bondIndex, 100.0f);
-							a->findIslands(&m_scratch[0]);
-						}
-					}
-					else
-					if (!partitionToSubsupport)
-					{
-						continue;
-					}
-
-					// Split actor
-					newActorCount = a->partition((Nv::Blast::Actor**)&buffer[0], (uint32_t)buffer.size(), messageLog);
-
-					if (newActorCount >= 2)
-					{
-						actors[actorToPartition] = nullptr;
-					}
-				}
-
-				if (newActorCount > 1)
-				{
-					canFracture = true;
-				}
-
-				for (uint32_t i = 0; i < newActorCount; ++i)
-				{
-					actors.push_back(buffer[i]);
-					buffer[i]->updateVisibleChunksFromGraphNodes();
-				}
-			}
-		}
-		
-		if (postSplitTest)
-		{
-			postSplitTest(actors, leafChunkCount, supportChunkCount, partitionToSubsupport);
-		}
-
-		for (auto actor : actors)
-		{
-			if (actor)
-				actor->release();
-		}
-
-		free(family);
-	}
-
-	static void recursivePartitionPostSplitTestCounts(const std::vector<Nv::Blast::Actor*>& actors, uint32_t leafChunkCount, uint32_t supportChunkCount, bool partitionToSubsupport)
-	{
-		// Test to see that all actors are split down to single support chunks
-		uint32_t remainingActorCount = 0;
-		for (uint32_t i = 0; i < actors.size(); ++i)
-		{
-			Nv::Blast::Actor* a = (Nv::Blast::Actor*)actors[i];
-			if (a == nullptr)
-			{
-				continue;
-			}
-
-			++remainingActorCount;
-
-			NVBLAST_ASSERT(1 == a->getVisibleChunkCount());
-			EXPECT_EQ(1, a->getVisibleChunkCount());
-			if (!partitionToSubsupport)
-			{
-				EXPECT_EQ(1, a->getGraphNodeCount());
-			}
-
-			const bool actorReleaseResult = NvBlastActorDeactivate(actors[i], nullptr);
-			EXPECT_TRUE(actorReleaseResult);
-		}
-
-		if (partitionToSubsupport)
-		{
-			EXPECT_EQ(leafChunkCount, remainingActorCount);
-		}
-		else
-		{
-			EXPECT_EQ(supportChunkCount, remainingActorCount);
-		}
-	}
-
-	static void testActorVisibleChunks(const Nv::Blast::Actor& actor, NvBlastLog)
-	{
-		const Nv::Blast::Asset& asset = *actor.getAsset();
-		const NvBlastChunk* chunks = asset.getChunks();
-
-		if (actor.isSubSupportChunk())
-		{
-			EXPECT_EQ(1, actor.getVisibleChunkCount());
-
-			const uint32_t firstVisibleChunkIndex = (uint32_t)Nv::Blast::Actor::VisibleChunkIt(actor);
-
-			EXPECT_EQ(actor.getIndex() - asset.m_graph.m_nodeCount, firstVisibleChunkIndex - asset.m_firstSubsupportChunkIndex);
-
-			// Make sure the visible chunk is subsupport
-			// Array of support flags
-			std::vector<bool> isSupport(asset.m_chunkCount, false);
-			for (uint32_t i = 0; i < asset.m_graph.m_nodeCount; ++i)
-			{
-				isSupport[asset.m_graph.getChunkIndices()[i]] = true;
-			}
-
-			// Climb hierarchy to find support chunk
-			uint32_t chunkIndex = firstVisibleChunkIndex;
-			while (chunkIndex != Nv::Blast::invalidIndex<uint32_t>())
-			{
-				if (isSupport[chunkIndex])
-				{
-					break;
-				}
-				chunkIndex = chunks[chunkIndex].parentChunkIndex;
-			}
-
-			EXPECT_FALSE(Nv::Blast::isInvalidIndex(chunkIndex));
-		}
-		else
-		{
-			// Array of visibility flags
-			std::vector<bool> isVisible(asset.m_chunkCount, false);
-			for (Nv::Blast::Actor::VisibleChunkIt i = actor; (bool)i; ++i)
-			{
-				isVisible[(uint32_t)i] = true;
-			}
-
-			// Mark visible nodes representing graph chunks
-			std::vector<bool> visibleChunkFound(asset.m_chunkCount, false);
-
-			// Make sure every graph chunk is represented by a visible chunk
-			for (Nv::Blast::Actor::GraphNodeIt i = actor; (bool)i; ++i)
-			{
-				const uint32_t graphNodeIndex = (uint32_t)i;
-				uint32_t chunkIndex = asset.m_graph.getChunkIndices()[graphNodeIndex];
-				// Climb hierarchy to find visible chunk
-				while (chunkIndex != Nv::Blast::invalidIndex<uint32_t>())
-				{
-					// Check that chunk owners are accurate
-					EXPECT_EQ(actor.getIndex(), actor.getFamilyHeader()->getChunkActorIndices()[chunkIndex]);
-					if (isVisible[chunkIndex])
-					{
-						visibleChunkFound[chunkIndex] = true;
-						break;
-					}
-					chunkIndex = chunks[chunkIndex].parentChunkIndex;
-				}
-				EXPECT_FALSE(Nv::Blast::isInvalidIndex(chunkIndex));
-			}
-
-			// Check that all visible chunks are accounted for
-			for (uint32_t i = 0; i < asset.m_chunkCount; ++i)
-			{
-				EXPECT_EQ(visibleChunkFound[i], isVisible[i]);
-			}
-
-			// Make sure that, if all siblings are intact, they are invisible
-			for (uint32_t i = 0; i < asset.m_chunkCount; ++i)
-			{
-				bool allIntact = true;
-				bool noneVisible = true;
-				if (chunks[i].firstChildIndex < asset.getUpperSupportChunkCount()) // Do not check subsupport
-				{
-					for (uint32_t j = chunks[i].firstChildIndex; j < chunks[i].childIndexStop; ++j)
-					{
-						allIntact = allIntact && actor.getFamilyHeader()->getChunkActorIndices()[j] == actor.getIndex();
-						noneVisible = noneVisible && !isVisible[j];
-					}
-					EXPECT_TRUE(!allIntact || noneVisible);
-				}
-			}
-		}
-	}
-
-	static void recursivePartitionPostSplitTestVisibleChunks(const std::vector<Nv::Blast::Actor*>& actors, uint32_t leafChunkCount, uint32_t supportChunkCount, bool partitionToSubsupport)
-	{
-		for (uint32_t i = 0; i < actors.size(); ++i)
-		{
-			Nv::Blast::Actor* a = (Nv::Blast::Actor*)actors[i];
-			if (a == nullptr)
-			{
-				continue;
-			}
-
-			testActorVisibleChunks(*a, nullptr);
-		}
-	}
-
-	void partitionActorsToSupportChunks
-	(
-		uint32_t assetDescCount,
-		const NvBlastAssetDesc* assetDescs,
-		void(*preSplitTest)(const Nv::Blast::Actor&, NvBlastLog),
-		void(*postSplitTest)(const std::vector<Nv::Blast::Actor*>&, uint32_t, uint32_t, bool),
-		bool partitionToSubsupport
-	)
-	{
-		srand(0);
-
-		for (uint32_t i = 0; i < assetDescCount; ++i)
-		{
-			// Create an asset
-			NvBlastAsset* asset = buildAsset(assetDescs[i]);
-
-			// Perform repeated partitioning
-			instanceAndPartitionRecursively(*asset, partitionToSubsupport, preSplitTest, postSplitTest);
-
-			// Free the asset
-			free(asset);
-		}
-	}
-
-	static void compareFamilies(const NvBlastFamily* family1, const NvBlastFamily* family2, size_t size, NvBlastLog logFn)
-	{
-		const char* block1 = reinterpret_cast<const char*>(family1);
-		const char* block2 = reinterpret_cast<const char*>(family2);
-#if 0
-		EXPECT_EQ(0, memcmp(block1, block2, size));
-#else
-		bool diffFound = false;
-		size_t startDiff = 0;
-		for (size_t i = 0; i < size; ++i)
-		{
-			if (block1[i] != block2[i])
-			{
-				diffFound = true;
-				startDiff = i;
-				break;
-			}
-		}
-		if (!diffFound)
-		{
-			return;
-		}
-		size_t endDiff = startDiff;
-		for (size_t i = size; i--;)
-		{
-			if (block1[i] != block2[i])
-			{
-				endDiff = i;
-				break;
-			}
-		}
-		std::ostringstream msg;
-		msg << "Block deserialization does not match current block in position range [" << startDiff << ", " << endDiff << "].";
-		logFn(NvBlastMessage::Error, msg.str().c_str(), __FILE__, __LINE__);
-#endif
-	}
-
-	static void testActorBlockSerialize(std::vector<NvBlastActor*>& actors, NvBlastLog logFn)
-	{
-		if (actors.size())
-		{
-			const NvBlastFamily* family = NvBlastActorGetFamily(actors[0], logFn);
-			const uint32_t size = NvBlastFamilyGetSize(family, logFn);
-			s_storage.insert(s_storage.end(), (char*)family, (char*)family + size);
-		}
-	}
-
-	static void testActorBlockDeserialize(std::vector<NvBlastActor*>& actors, NvBlastLog logFn)
-	{
-		if (actors.size())
-		{
-			EXPECT_LT(s_curr, s_storage.size());
-			const NvBlastFamily* family = reinterpret_cast<NvBlastFamily*>(&s_storage[s_curr]);
-			const uint32_t size = NvBlastFamilyGetSize(family, logFn);
-			EXPECT_LE(s_curr + size, s_storage.size());
-			s_curr += size;
-			const NvBlastFamily* actorFamily = NvBlastActorGetFamily(actors[0], logFn);
-			// Family may contain different assets pointers, copy into new family block and set the same asset before comparing
-			Nv::Blast::Actor& a = *static_cast<Nv::Blast::Actor*>(actors[0]);
-			const Nv::Blast::Asset* solverAsset = a.getAsset();
-			std::vector<char> storageFamilyCopy((char*)family, (char*)family + size);
-			NvBlastFamily* storageFamily = reinterpret_cast<NvBlastFamily*>(storageFamilyCopy.data());
-			NvBlastFamilySetAsset(storageFamily, solverAsset, logFn);
-			{
-				const uint32_t actorCountExpected = NvBlastFamilyGetActorCount(storageFamily, logFn);
-				std::vector<NvBlastActor*> blockActors(actorCountExpected);
-				const uint32_t actorCountReturned = NvBlastFamilyGetActors(&blockActors[0], actorCountExpected, storageFamily, logFn);
-				EXPECT_EQ(actorCountExpected, actorCountReturned);
-			}
-			compareFamilies(storageFamily, actorFamily, size, logFn);
-		}
-	}
-
-	// Serialize all actors and then deserialize back into a new family in a random order, and compare with the original family
-	static void testActorSerializationNewFamily(std::vector<NvBlastActor*>& actors, NvBlastLog logFn)
-	{
-		if (actors.size() == 0)
-		{
-			return;
-		}
-
-		Nv::Blast::Actor& a = *static_cast<Nv::Blast::Actor*>(actors[0]);
-		const Nv::Blast::Asset* solverAsset = a.getAsset();
-
-		const uint32_t serSizeBound = NvBlastAssetGetActorSerializationSizeUpperBound(solverAsset, logFn);
-			
-		std::vector< std::vector<char> > streams(actors.size());
-		for (size_t i = 0; i < actors.size(); ++i)
-		{
-			const uint32_t serSize = NvBlastActorGetSerializationSize(actors[i], logFn);
-			EXPECT_GE(serSizeBound, serSize);
-			std::vector<char>& stream = streams[i];
-			stream.resize(serSize);
-			const uint32_t bytesWritten = NvBlastActorSerialize(&stream[0], serSize, actors[i], logFn);
-			EXPECT_EQ(serSize, bytesWritten);
-		}
-
-		void* fmem = alloc(NvBlastAssetGetFamilyMemorySize(solverAsset, logFn));
-		NvBlastFamily* newFamily = NvBlastAssetCreateFamily(fmem, solverAsset, logFn);
-
-		std::vector<size_t> order(actors.size());
-		for (size_t i = 0; i < order.size(); ++i)
-		{
-			order[i] = i;
-		}
-		std::random_shuffle(order.begin(), order.end());
-
-		for (size_t i = 0; i < actors.size(); ++i)
-		{
-			NvBlastActor* newActor = NvBlastFamilyDeserializeActor(newFamily, &streams[order[i]][0], logFn);
-			EXPECT_TRUE(newActor != nullptr);
-		}
-
-		const NvBlastFamily* oldFamily = NvBlastActorGetFamily(&a, logFn);
-		compareFamilies(oldFamily, newFamily, NvBlastFamilyGetSize(oldFamily, logFn), logFn);
-
-		free(newFamily);
-	}
-
-	// Copy the family and then serialize some subset of actors, deleting them afterwards.
-	// Then, deserialize back into the block and compare the original and new families.
-	static void testActorSerializationPartialBlock(std::vector<NvBlastActor*>& actors, NvBlastLog logFn)
-	{
-		if (actors.size() <= 1)
-		{
-			return;
-		}
-
-		Nv::Blast::Actor& a = *static_cast<Nv::Blast::Actor*>(actors[0]);
-		const Nv::Blast::Asset* solverAsset = a.getAsset();
-
-		const NvBlastFamily* oldFamily = NvBlastActorGetFamily(&a, logFn);
-		const uint32_t size = NvBlastFamilyGetSize(oldFamily, logFn);
-		std::vector<char> buffer((char*)oldFamily, (char*)oldFamily + size);
-		NvBlastFamily* familyCopy = reinterpret_cast<NvBlastFamily*>(&buffer[0]);
-
-		const uint32_t serCount = 1 + (rand() % actors.size() - 1);
-
-		const uint32_t actorCount = NvBlastFamilyGetActorCount(familyCopy, logFn);
-		std::vector<NvBlastActor*> actorsRemaining(actorCount);
-		const uint32_t actorsInFamily = NvBlastFamilyGetActors(&actorsRemaining[0], actorCount, familyCopy, logFn);
-		EXPECT_EQ(actorCount, actorsInFamily);
-
-		const uint32_t serSizeBound = NvBlastAssetGetActorSerializationSizeUpperBound(solverAsset, logFn);
-
-		std::vector< std::vector<char> > streams(serCount);
-		for (uint32_t i = 0; i < serCount; ++i)
-		{
-			std::vector<char>& stream = streams[i];
-			const uint32_t indexToStream = rand() % actorsRemaining.size();
-			NvBlastActor* actorToStream = actorsRemaining[indexToStream];
-			std::swap(actorsRemaining[indexToStream], actorsRemaining[actorsRemaining.size() - 1]);
-			actorsRemaining.pop_back();
-			const uint32_t serSize = NvBlastActorGetSerializationSize(actorToStream, logFn);
-			EXPECT_GE(serSizeBound, serSize);
-			stream.resize(serSize);
-			const uint32_t bytesWritten = NvBlastActorSerialize(&stream[0], serSize, actorToStream, logFn);
-			EXPECT_EQ(serSize, bytesWritten);
-			NvBlastActorDeactivate(actorToStream, logFn);
-		}
-
-		for (uint32_t i = 0; i < serCount; ++i)
-		{
-			NvBlastActor* newActor = NvBlastFamilyDeserializeActor(familyCopy, &streams[i][0], logFn);
-			EXPECT_TRUE(newActor != nullptr);
-		}
-
-		compareFamilies(oldFamily, familyCopy, size, logFn);
-	}
-
-	void damageLeafSupportActors
-	(
-	uint32_t assetCount,
-	uint32_t familyCount,
-	uint32_t damageCount,
-	bool simple,
-	void (*actorTest)(const Nv::Blast::Actor&, NvBlastLog),
-	void (*postDamageTest)(std::vector<NvBlastActor*>&, NvBlastLog),
-	CubeAssetGenerator::BondFlags bondFlags = CubeAssetGenerator::BondFlags::ALL_BONDS
-	)
-	{
-		const float relativeDamageRadius = simple ? 0.75f : 0.2f;
-		const float compressiveDamage = 1.0f;
-		const uint32_t minChunkCount = simple ? 9 : 100;
-		const uint32_t maxChunkCount = simple ? 9 : 10000;
-		const bool printActorCount = false;
-
-		srand(0);
-
-		std::cout << "Asset # (out of " << assetCount << "): ";
-		for (uint32_t assetNum = 0; assetNum < assetCount; ++assetNum)
-		{
-			std::cout << assetNum + 1 << ".. ";
-			CubeAssetGenerator::Settings settings;
-			settings.extents = GeneratorAsset::Vec3(1, 1, 1);
-			settings.bondFlags = bondFlags;
-			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 = simple ? GeneratorAsset::Vec3(2, 2, 2) : 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);
-
-			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();
-
-			NvBlastAsset* asset = buildAsset(desc);
-			NvBlastID assetID = NvBlastAssetGetID(asset, messageLog);
-
-			// copy asset (for setAsset testing)
-			const char* data = (const char*)asset;
-			const uint32_t dataSize = NvBlastAssetGetSize(asset, messageLog);
-			char* duplicateData = (char*)alloc(dataSize);
-			memcpy(duplicateData, data, dataSize);
-			NvBlastAsset* assetDuplicate = (NvBlastAsset*)duplicateData;
-
-			// Generate families
-			for (uint32_t familyNum = 0; familyNum < familyCount; ++familyNum)
-			{
-				// family
-				void* fmem = alloc(NvBlastAssetGetFamilyMemorySize(asset, messageLog));
-				NvBlastFamily* family = NvBlastAssetCreateFamily(fmem, asset, messageLog);	// Using zeroingAlloc in case actorTest compares memory blocks
-				NvBlastID id = NvBlastFamilyGetAssetID(family, messageLog);
-				EXPECT_TRUE(!memcmp(&assetID, &id, sizeof(NvBlastID)));
-				if (rand() % 2 == 0)
-				{
-					// replace asset with duplicate in half of cases to test setAsset
-					NvBlastFamilySetAsset(family, assetDuplicate, messageLog);
-					NvBlastID id2 = NvBlastFamilyGetAssetID(family, messageLog);
-					EXPECT_TRUE(!memcmp(&assetID, &id2, sizeof(NvBlastID)));
-				}
-
-				// actor
-				NvBlastActorDesc actorDesc;
-				actorDesc.initialBondHealths = actorDesc.initialSupportChunkHealths = nullptr;
-				actorDesc.uniformInitialBondHealth = actorDesc.uniformInitialLowerSupportChunkHealth = 1.0f;
-				m_scratch.resize((size_t)NvBlastFamilyGetRequiredScratchForCreateFirstActor(family, messageLog));
-				NvBlastActor* actor = NvBlastFamilyCreateFirstActor(family, &actorDesc, m_scratch.data(), messageLog);
-				EXPECT_TRUE(actor != nullptr);
-
-				// Generate damage
-				std::set<NvBlastActor*> actors;
-				actors.insert(actor);
-				if (printActorCount) std::cout << "Actors: 1.. ";
-				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);
-					blast(actors, &testAsset, localPos, relativeDamageRadius, relativeDamageRadius*1.2f, compressiveDamage);
-					if (printActorCount) std::cout << actors.size() << ".. ";
-					if (actors.size() > 0)
-					{
-						const NvBlastFamily* family = NvBlastActorGetFamily(*actors.begin(), messageLog);
-						const uint32_t actorCount = NvBlastFamilyGetActorCount(family, messageLog);
-						EXPECT_EQ((uint32_t)actors.size(), actorCount);
-						if ((uint32_t)actors.size() == actorCount)
-						{
-							std::vector<NvBlastActor*> buffer1(actorCount);
-							const uint32_t actorsWritten = NvBlastFamilyGetActors(&buffer1[0], actorCount, family, messageLog);
-							EXPECT_EQ(actorsWritten, actorCount);
-							std::vector<NvBlastActor*> buffer2(actors.begin(), actors.end());
-							EXPECT_EQ(0, memcmp(&buffer1[0], &buffer2[0], actorCount*sizeof(NvBlastActor*)));
-						}
-					}
-					// Test individual actors
-					if (actorTest != nullptr)
-					{
-						for (std::set<NvBlastActor*>::iterator k = actors.begin(); k != actors.end(); ++k)
-						{
-							actorTest(*static_cast<Nv::Blast::Actor*>(*k), messageLog);
-						}
-					}
-				}
-				if (printActorCount) std::cout << "\n";
-
-				// Test fractured actor set
-				if (postDamageTest)
-				{
-					std::vector<NvBlastActor*> actorArray(actors.begin(), actors.end());
-					postDamageTest(actorArray, messageLog);
-				}
-
-				// Release remaining actors
-				for (std::set<NvBlastActor*>::iterator k = actors.begin(); k != actors.end(); ++k)
-				{
-					NvBlastActorDeactivate(*k, messageLog);
-				}
-				actors.clear();
-
-				free(family);
-			}
-
-			// Release asset data
-			free(asset);
-			free(assetDuplicate);
-		}
-		std::cout << "done.\n";
-	}
-
-	std::vector<NvBlastAsset*>		m_assets;
-	std::vector<NvBlastActor*>		m_actors;
-	std::vector<char>				m_scratch;
-	static std::vector<char>		s_storage;
-
-	static size_t					s_curr;
-};
-
-// Static values
-template<int FailLevel, int Verbosity>
-std::vector<char>	ActorTest<FailLevel, Verbosity>::s_storage;
-
-template<int FailLevel, int Verbosity>
-size_t					ActorTest<FailLevel, Verbosity>::s_curr;
-
-// Specializations
-typedef ActorTest<NvBlastMessage::Error, 1> ActorTestAllowWarnings;
-typedef ActorTest<NvBlastMessage::Warning, 1> ActorTestStrict;
-
-// Tests
-TEST_F(ActorTestStrict, InstanceActors)
-{
-	// Build assets and instance actors
-	buildAssets();
-	instanceActors();
-
-	// Release actors and destroy assets
-	releaseActors();
-	destroyAssets();
-}
-
-TEST_F(ActorTestAllowWarnings, ActorHealthInitialization)
-{
-	// Test all assets
-	std::vector<NvBlastAssetDesc> assetDescs;
-	assetDescs.insert(assetDescs.end(), g_assetDescs, g_assetDescs + getAssetDescCount());
-	assetDescs.insert(assetDescs.end(), g_assetDescsMissingCoverage, g_assetDescsMissingCoverage + getAssetDescMissingCoverageCount());
-
-	struct TestMode
-	{
-		enum Enum
-		{
-			Uniform,
-			Nonuniform,
-
-			Count
-		};
-	};
-
-	for (auto assetDesc : assetDescs)
-	{
-		NvBlastAsset* asset = buildAsset(assetDesc);
-		EXPECT_TRUE(asset != nullptr);
-
-		Nv::Blast::Asset& assetInt = static_cast<Nv::Blast::Asset&>(*asset);
-
-		NvBlastSupportGraph graph = NvBlastAssetGetSupportGraph(asset, nullptr);
-
-		std::vector<float> supportChunkHealths(graph.nodeCount);
-		for (size_t i = 0; i < supportChunkHealths.size(); ++i)
-		{
-			supportChunkHealths[i] = 1.0f + (float)i;
-		}
-
-		std::vector<float> bondHealths(assetInt.getBondCount());
-		for (size_t i = 0; i < bondHealths.size(); ++i)
-		{
-			bondHealths[i] = 1.5f + (float)i;
-		}
-
-		for (int chunkTestMode = 0; chunkTestMode < TestMode::Count; ++chunkTestMode)
-		{
-			for (int bondTestMode = 0; bondTestMode < TestMode::Count; ++bondTestMode)
-			{
-				NvBlastActorDesc actorDesc;
-
-				switch (chunkTestMode)
-				{
-				default:
-				case TestMode::Uniform:
-					actorDesc.initialSupportChunkHealths = nullptr;
-					actorDesc.uniformInitialLowerSupportChunkHealth = 1.0f;
-					break;
-				case TestMode::Nonuniform:
-					actorDesc.initialSupportChunkHealths = supportChunkHealths.data();
-					break;
-				}
-
-				switch (bondTestMode)
-				{
-				default:
-				case TestMode::Uniform:
-					actorDesc.initialBondHealths = nullptr;
-					actorDesc.uniformInitialBondHealth = 2.0f;
-					break;
-				case TestMode::Nonuniform:
-					actorDesc.initialBondHealths = bondHealths.data();
-					break;
-				}
-
-				void* fmem = alloc(NvBlastAssetGetFamilyMemorySize(asset, messageLog));
-				NvBlastFamily* family = NvBlastAssetCreateFamily(fmem, asset, nullptr);
-				std::vector<char> scratch((size_t)NvBlastFamilyGetRequiredScratchForCreateFirstActor(family, messageLog));
-				NvBlastActor* actor = NvBlastFamilyCreateFirstActor(family, &actorDesc, &scratch[0], messageLog);
-				EXPECT_TRUE(actor != nullptr);
-
-				Nv::Blast::Actor& actorInt = static_cast<Nv::Blast::Actor&>(*actor);
-				Nv::Blast::FamilyHeader* header = actorInt.getFamilyHeader();
-
-
-				for (uint32_t i = 0; i < graph.nodeCount; ++i)
-				{
-					const uint32_t supportChunkIndex = graph.chunkIndices[i];
-					for (Nv::Blast::Asset::DepthFirstIt it(assetInt, supportChunkIndex); (bool)it; ++it)
-					{
-						const uint32_t chunkIndex = (uint32_t)it;
-						const uint32_t lowerSupportIndex = assetInt.getContiguousLowerSupportIndex(chunkIndex);
-						NVBLAST_ASSERT(lowerSupportIndex < assetInt.getLowerSupportChunkCount());
-						const float health = header->getLowerSupportChunkHealths()[lowerSupportIndex];
-						switch (chunkTestMode)
-						{
-						default:
-						case TestMode::Uniform:
-							EXPECT_EQ(1.0f, health);
-							break;
-						case TestMode::Nonuniform:
-							EXPECT_EQ(supportChunkHealths[i], health);
-							break;
-						}
-					}
-				}
-
-				for (uint32_t i = 0; i < assetInt.getBondCount(); ++i)
-				{
-					switch (bondTestMode)
-					{
-					default:
-					case TestMode::Uniform:
-						EXPECT_EQ(2.0f, header->getBondHealths()[i]);
-						break;
-					case TestMode::Nonuniform:
-						EXPECT_EQ(bondHealths[i], header->getBondHealths()[i]);
-						break;
-					}
-				}
-
-				NvBlastActorDeactivate(actor, messageLog);
-				free(family);
-			}
-		}
-
-		free(asset);
-	}
-}
-
-TEST_F(ActorTestStrict, PartitionActorsToSupportChunksTestCounts)
-{
-	partitionActorsToSupportChunks(getAssetDescCount(), g_assetDescs, nullptr, recursivePartitionPostSplitTestCounts, false);
-}
-
-TEST_F(ActorTestAllowWarnings, PartitionActorsFromBadDescriptorsToSupportChunksTestCounts)
-{
-	partitionActorsToSupportChunks(getAssetDescMissingCoverageCount(), g_assetDescsMissingCoverage, nullptr, recursivePartitionPostSplitTestCounts, false);
-}
-
-TEST_F(ActorTestStrict, PartitionActorsToLeafChunksTestCounts)
-{
-	partitionActorsToSupportChunks(getAssetDescCount(), g_assetDescs, nullptr, recursivePartitionPostSplitTestCounts, true);
-}
-
-TEST_F(ActorTestAllowWarnings, PartitionActorsFromBadDescriptorsToLeafChunksTestCounts)
-{
-	partitionActorsToSupportChunks(getAssetDescMissingCoverageCount(), g_assetDescsMissingCoverage, nullptr, recursivePartitionPostSplitTestCounts, true);
-}
-
-TEST_F(ActorTestStrict, PartitionActorsToSupportChunksTestVisibility)
-{
-	partitionActorsToSupportChunks(getAssetDescCount(), g_assetDescs, testActorVisibleChunks, recursivePartitionPostSplitTestVisibleChunks, false);
-}
-
-TEST_F(ActorTestAllowWarnings, PartitionActorsFromBadDescriptorsToSupportChunksTestVisibility)
-{
-	partitionActorsToSupportChunks(getAssetDescMissingCoverageCount(), g_assetDescsMissingCoverage, testActorVisibleChunks, recursivePartitionPostSplitTestVisibleChunks, false);
-}
-
-TEST_F(ActorTestStrict, PartitionActorsToLeafChunksTestVisibility)
-{
-	partitionActorsToSupportChunks(getAssetDescCount(), g_assetDescs, testActorVisibleChunks, recursivePartitionPostSplitTestVisibleChunks, true);
-}
-
-TEST_F(ActorTestAllowWarnings, PartitionActorsFromBadDescriptorsToLeafChunksTestVisibility)
-{
-	partitionActorsToSupportChunks(getAssetDescMissingCoverageCount(), g_assetDescsMissingCoverage, testActorVisibleChunks, recursivePartitionPostSplitTestVisibleChunks, true);
-}
-
-TEST_F(ActorTestStrict, DamageLeafSupportActorsTestVisibility)
-{
-	damageLeafSupportActors(4, 4, 5, false, testActorVisibleChunks, nullptr);
-}
-
-TEST_F(ActorTestStrict, DamageLeafSupportActorTestBlockSerialization)
-{
-	s_storage.resize(0);
-	damageLeafSupportActors(4, 4, 5, false, nullptr, testActorBlockSerialize);
-	s_curr = 0;
-	damageLeafSupportActors(4, 4, 5, false, nullptr, testActorBlockDeserialize);
-	s_storage.resize(0);
-}
-
-TEST_F(ActorTestStrict, DamageSimpleLeafSupportActorTestActorSerializationNewFamily)
-{
-	damageLeafSupportActors(1, 1, 4, true, nullptr, testActorSerializationNewFamily);
-}
-
-TEST_F(ActorTestStrict, DamageSimpleLeafSupportActorTestActorSerializationPartialBlock)
-{
-	damageLeafSupportActors(1, 1, 4, true, nullptr, testActorSerializationPartialBlock);
-}
-
-TEST_F(ActorTestStrict, DamageLeafSupportActorTestActorSerializationNewFamily)
-{
-	damageLeafSupportActors(4, 4, 4, false, nullptr, testActorSerializationNewFamily);
-}
-
-TEST_F(ActorTestStrict, DamageLeafSupportActorTestActorSerializationPartialBlock)
-{
-	damageLeafSupportActors(4, 4, 4, false, nullptr, testActorSerializationPartialBlock);
-}
-
-TEST_F(ActorTestStrict, DamageMultipleIslandLeafSupportActorsTestVisibility)
-{
-	damageLeafSupportActors(4, 4, 5, false, testActorVisibleChunks, nullptr, CubeAssetGenerator::BondFlags::Y_BONDS | CubeAssetGenerator::BondFlags::Z_BONDS);	// Only connect y-z plane islands
-	damageLeafSupportActors(4, 4, 5, false, testActorVisibleChunks, nullptr, CubeAssetGenerator::BondFlags::Z_BONDS);	// Only connect z-direction islands
-	damageLeafSupportActors(4, 4, 5, false, testActorVisibleChunks, nullptr, CubeAssetGenerator::BondFlags::NO_BONDS);	// All support chunks disconnected (single-chunk islands)
-}