diff options
Diffstat (limited to 'NvBlast/test/src/unit/ActorTests.cpp')
| -rw-r--r-- | NvBlast/test/src/unit/ActorTests.cpp | 1059 |
1 files changed, 1059 insertions, 0 deletions
diff --git a/NvBlast/test/src/unit/ActorTests.cpp b/NvBlast/test/src/unit/ActorTests.cpp new file mode 100644 index 0000000..12dc19c --- /dev/null +++ b/NvBlast/test/src/unit/ActorTests.cpp @@ -0,0 +1,1059 @@ +#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) +} |