From 74b64a27f8e07b1b0b47b809b1a060518fa11a97 Mon Sep 17 00:00:00 2001 From: Bryan Galdrikian Date: Fri, 3 May 2019 00:25:46 -0700 Subject: Blast SDK 1.1.5 prerelease #1 --- samples/SampleBase/blast/BlastAssetModel.cpp | 59 ++++++----- samples/SampleBase/blast/BlastController.cpp | 141 ++++++++++++++++----------- samples/SampleBase/blast/BlastFamilyBoxes.h | 14 +-- samples/SampleBase/blast/BlastModel.cpp | 6 +- 4 files changed, 124 insertions(+), 96 deletions(-) (limited to 'samples/SampleBase') diff --git a/samples/SampleBase/blast/BlastAssetModel.cpp b/samples/SampleBase/blast/BlastAssetModel.cpp index 942820a..5d50642 100755 --- a/samples/SampleBase/blast/BlastAssetModel.cpp +++ b/samples/SampleBase/blast/BlastAssetModel.cpp @@ -45,10 +45,13 @@ #include "NvBlastExtTkSerialization.h" #include "NvBlastExtPxSerialization.h" #include "NvBlastExtAuthoring.h" -#include "NvBlastExtAuthoringCollisionBuilder.h" +#include "NvBlastExtPxManager.h" +#include "NvBlastExtPxCollisionBuilder.h" +#include "PxCooking.h" -BlastAssetModel::BlastAssetModel(TkFramework& framework, PxPhysics& physics, PxCooking& cooking, ExtSerialization& serialization, Renderer& renderer, const char* modelName) - : BlastAsset(renderer) +BlastAssetModel::BlastAssetModel(TkFramework& framework, PxPhysics& physics, PxCooking& cooking, + ExtSerialization& serialization, Renderer& renderer, const char* modelName) +: BlastAsset(renderer) { const float unitConversion = 1.f; @@ -60,16 +63,16 @@ BlastAssetModel::BlastAssetModel(TkFramework& framework, PxPhysics& physics, PxC // load obj file std::ostringstream objFileName; objFileName << modelName << ".obj"; - + if (resourceManager.findFile(objFileName.str(), path)) { m_model = BlastModel::loadFromFileTinyLoader(path.c_str()); if (!m_model) { ASSERT_PRINT(false, "obj load failed"); - } + } } - else // Obj is not found, try FBX + else // Obj is not found, try FBX { objFileName.clear(); objFileName.str(""); @@ -81,7 +84,6 @@ BlastAssetModel::BlastAssetModel(TkFramework& framework, PxPhysics& physics, PxC { ASSERT_PRINT(false, "fbx load failed"); } - } else { @@ -124,12 +126,11 @@ BlastAssetModel::BlastAssetModel(TkFramework& framework, PxPhysics& physics, PxC { ASSERT_PRINT(asset != nullptr, "can't load .blast file."); } - else - if (objectTypeID == Nv::Blast::ExtPxObjectTypeID::Asset) + else if (objectTypeID == Nv::Blast::ExtPxObjectTypeID::Asset) { - m_pxAsset = reinterpret_cast(asset); + m_pxAsset = reinterpret_cast(asset); const TkAsset& tkAsset = m_pxAsset->getTkAsset(); - NvBlastAsset* llasset = const_cast(tkAsset.getAssetLL()); + NvBlastAsset* llasset = const_cast(tkAsset.getAssetLL()); NvBlastExtAssetTransformInPlace(llasset, &inputScale, nullptr, nullptr); ExtPxSubchunk* subchunks = const_cast(m_pxAsset->getSubchunks()); for (uint32_t i = 0; i < m_pxAsset->getSubchunkCount(); ++i) @@ -142,12 +143,11 @@ BlastAssetModel::BlastAssetModel(TkFramework& framework, PxPhysics& physics, PxC TkAsset* tkAsset = nullptr; if (objectTypeID == Nv::Blast::TkObjectTypeID::Asset) { - tkAsset = reinterpret_cast(asset); + tkAsset = reinterpret_cast(asset); NvBlastAsset* llasset = const_cast(tkAsset->getAssetLL()); NvBlastExtAssetTransformInPlace(llasset, &inputScale, nullptr, nullptr); } - else - if (objectTypeID == Nv::Blast::LlObjectTypeID::Asset) + else if (objectTypeID == Nv::Blast::LlObjectTypeID::Asset) { NvBlastAsset* llasset = reinterpret_cast(asset); NvBlastExtAssetTransformInPlace(llasset, &inputScale, nullptr, nullptr); @@ -169,50 +169,49 @@ BlastAssetModel::BlastAssetModel(TkFramework& framework, PxPhysics& physics, PxC objFileName << modelName << ".fbx"; if (resourceManager.findFile(objFileName.str(), path)) { - std::shared_ptr rdr(NvBlastExtExporterCreateFbxFileReader(), [](IFbxFileReader* p) {p->release(); }); + std::shared_ptr rdr(NvBlastExtExporterCreateFbxFileReader(), + [](IFbxFileReader* p) { p->release(); }); rdr->loadFromFile(path.c_str()); if (rdr->isCollisionLoaded() == 0) { ASSERT_PRINT(false, "fbx doesn't contain collision geometry"); } uint32_t* hullsOffsets = nullptr; - CollisionHull** hulls = nullptr; - uint32_t meshCount = rdr->getCollision(hullsOffsets, hulls); - - /** - Create physics meshes; - */ - std::shared_ptr collisionBuilder( - NvBlastExtAuthoringCreateConvexMeshBuilder(&cooking, &physics.getPhysicsInsertionCallback()), - [](Nv::Blast::ConvexMeshBuilder* cmb) {cmb->release(); }); + CollisionHull** hulls = nullptr; + uint32_t meshCount = rdr->getCollision(hullsOffsets, hulls); physicsChunks.resize(meshCount); physicsSubchunks.resize(meshCount); + std::shared_ptr collisionBuilder( + ExtPxManager::createCollisionBuilder(physics, cooking), + [](Nv::Blast::ExtPxCollisionBuilder* cmb) { cmb->release(); }); + for (uint32_t i = 0; i < meshCount; ++i) { - for (uint32_t sbHulls = hullsOffsets[i]; sbHulls < hullsOffsets[i+1]; ++sbHulls) + for (uint32_t sbHulls = hullsOffsets[i]; sbHulls < hullsOffsets[i + 1]; ++sbHulls) { - PxConvexMeshGeometry temp = physx::PxConvexMeshGeometry(collisionBuilder.get()->buildConvexMesh(*hulls[sbHulls])); + PxConvexMeshGeometry temp = + physx::PxConvexMeshGeometry(collisionBuilder.get()->buildConvexMesh(*hulls[sbHulls])); if (temp.isValid()) { physicsSubchunks[i].push_back(ExtPxAssetDesc::SubchunkDesc()); - physicsSubchunks[i].back().geometry = temp; + physicsSubchunks[i].back().geometry = temp; physicsSubchunks[i].back().transform = physx::PxTransform(physx::PxIdentity); } } } for (uint32_t i = 0; i < meshCount; ++i) { - physicsChunks[i].isStatic = false; + physicsChunks[i].isStatic = false; physicsChunks[i].subchunkCount = (uint32_t)physicsSubchunks[i].size(); - physicsChunks[i].subchunks = physicsSubchunks[i].data(); + physicsChunks[i].subchunks = physicsSubchunks[i].data(); } if (hulls && hullsOffsets) { for (uint32_t h = 0; h < hullsOffsets[meshCount]; h++) { - hulls[h]->release(); + collisionBuilder->releaseCollisionHull(hulls[h]); } NVBLAST_FREE(hulls); NVBLAST_FREE(hullsOffsets); diff --git a/samples/SampleBase/blast/BlastController.cpp b/samples/SampleBase/blast/BlastController.cpp index a2cf5cd..d350a48 100755 --- a/samples/SampleBase/blast/BlastController.cpp +++ b/samples/SampleBase/blast/BlastController.cpp @@ -66,9 +66,9 @@ #include -#define SAFE_RELEASE_(p) \ +#define SAFE_RELEASE_(p) \ { \ - if(p) \ + if (p) \ { \ (p)->release(); \ (p) = NULL; \ @@ -80,9 +80,12 @@ // Joint creation /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -static physx::PxJoint* createPxJointCallback(ExtPxActor* actor0, const physx::PxTransform& localFrame0, ExtPxActor* actor1, const physx::PxTransform& localFrame1, physx::PxPhysics& physics, TkJoint& joint) +static physx::PxJoint* +createPxJointCallback(ExtPxActor* actor0, const physx::PxTransform& localFrame0, ExtPxActor* actor1, + const physx::PxTransform& localFrame1, physx::PxPhysics& physics, TkJoint& joint) { - PxDistanceJoint* pxJoint = PxDistanceJointCreate(physics, actor0 ? &actor0->getPhysXActor() : nullptr, localFrame0, actor1 ? &actor1->getPhysXActor() : nullptr, localFrame1); + PxDistanceJoint* pxJoint = PxDistanceJointCreate(physics, actor0 ? &actor0->getPhysXActor() : nullptr, localFrame0, + actor1 ? &actor1->getPhysXActor() : nullptr, localFrame1); pxJoint->setMaxDistance(1.0f); return pxJoint; } @@ -92,19 +95,26 @@ static physx::PxJoint* createPxJointCallback(ExtPxActor* actor0, const physx::Px // Controller /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -BlastController::BlastController() -: m_eventCallback(nullptr), debugRenderMode(BlastFamily::DEBUG_RENDER_DISABLED), m_impactDamageEnabled(true), -m_impactDamageToStressEnabled(false), m_rigidBodyLimitEnabled(true), m_rigidBodyLimit(40000), m_blastAssetsSize(0), debugRenderScale(0.01f), -m_taskManager(nullptr), m_extGroupTaskManager(nullptr), m_damageDescBuffer(64 * 1024), m_damageParamsBuffer(1024) +BlastController::BlastController() +: m_eventCallback(nullptr) +, debugRenderMode(BlastFamily::DEBUG_RENDER_DISABLED) +, m_impactDamageEnabled(true) +, m_impactDamageToStressEnabled(false) +, m_rigidBodyLimitEnabled(true) +, m_rigidBodyLimit(40000) +, m_blastAssetsSize(0) +, debugRenderScale(0.01f) +, m_taskManager(nullptr) +, m_extGroupTaskManager(nullptr) +, m_damageDescBuffer(64 * 1024) +, m_damageParamsBuffer(1024) { m_impactDamageToStressFactor = 0.01f; - m_draggingToStressFactor = 100.0f; + m_draggingToStressFactor = 100.0f; } -BlastController::~BlastController() -{ -} +BlastController::~BlastController() {} void BlastController::reinitialize() { @@ -118,16 +128,17 @@ void BlastController::onSampleStart() m_replay = new BlastReplay(); - m_taskManager = PxTaskManager::createTaskManager(NvBlastGetPxErrorCallback(), getPhysXController().getCPUDispatcher(), 0); + m_taskManager = + PxTaskManager::createTaskManager(NvBlastGetPxErrorCallback(), getPhysXController().getCPUDispatcher(), 0); TkGroupDesc gdesc; gdesc.workerCount = m_taskManager->getCpuDispatcher()->getWorkerCount(); - m_tkGroup = m_tkFramework->createGroup(gdesc); + m_tkGroup = m_tkFramework->createGroup(gdesc); m_extPxManager = ExtPxManager::create(getPhysXController().getPhysics(), *m_tkFramework, createPxJointCallback); m_extPxManager->setActorCountLimit(m_rigidBodyLimitEnabled ? m_rigidBodyLimit : 0); m_extImpactDamageManager = ExtImpactDamageManager::create(m_extPxManager, m_extImpactDamageManagerSettings); - m_eventCallback = new EventCallback(m_extImpactDamageManager); + m_eventCallback = new EventCallback(m_extImpactDamageManager); m_extGroupTaskManager = ExtGroupTaskManager::create(*m_taskManager); m_extGroupTaskManager->setGroup(m_tkGroup); @@ -138,7 +149,8 @@ void BlastController::onSampleStart() if (m_extSerialization != nullptr) { NvBlastExtTkSerializerLoadSet(*m_tkFramework, *m_extSerialization); - NvBlastExtPxSerializerLoadSet(*m_tkFramework, getPhysXController().getPhysics(), getPhysXController().getCooking(), *m_extSerialization); + NvBlastExtPxSerializerLoadSet(*m_tkFramework, getPhysXController().getPhysics(), + getPhysXController().getCooking(), *m_extSerialization); } } @@ -172,12 +184,14 @@ void BlastController::notifyPhysXControllerRelease() // Deffered/Immediate damage /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -void BlastController::deferDamage(ExtPxActor *actor, BlastFamily& family, const NvBlastDamageProgram& program, const void* damageDesc, uint32_t damageDescSize) +void BlastController::deferDamage(ExtPxActor* actor, BlastFamily& family, const NvBlastDamageProgram& program, + const void* damageDesc, uint32_t damageDescSize) { const void* bufferedDamageDesc = m_damageDescBuffer.push(damageDesc, damageDescSize); PX_ASSERT_WITH_MESSAGE(bufferedDamageDesc, "Damage desc buffer exhausted."); - NvBlastExtProgramParams programParams = { bufferedDamageDesc, &family.getMaterial(), actor->getFamily().getPxAsset().getAccelerator() }; + NvBlastExtProgramParams programParams = { bufferedDamageDesc, &family.getMaterial(), + actor->getFamily().getPxAsset().getAccelerator() }; const void* bufferedProgramParams = m_damageParamsBuffer.push(&programParams, sizeof(NvBlastExtProgramParams)); PX_ASSERT_WITH_MESSAGE(bufferedProgramParams, "Damage params buffer exhausted."); @@ -190,21 +204,29 @@ void BlastController::deferDamage(ExtPxActor *actor, BlastFamily& family, const NvBlastFractureBuffers& BlastController::getFractureBuffers(ExtPxActor* actor) { - const TkAsset* tkAsset = actor->getTkActor().getAsset(); + const TkAsset* tkAsset = actor->getTkActor().getAsset(); const uint32_t chunkCount = tkAsset->getChunkCount(); - const uint32_t bondCount = tkAsset->getBondCount(); + const uint32_t bondCount = tkAsset->getBondCount(); - m_fractureBuffers.bondFractureCount = bondCount; + m_fractureBuffers.bondFractureCount = bondCount; m_fractureBuffers.chunkFractureCount = chunkCount; - m_fractureData.resize((uint32_t)(m_fractureBuffers.bondFractureCount * sizeof(NvBlastBondFractureData) + m_fractureBuffers.chunkFractureCount * sizeof(NvBlastChunkFractureData))); // chunk count + bond count + m_fractureData.resize((uint32_t)(m_fractureBuffers.bondFractureCount * sizeof(NvBlastBondFractureData) + + m_fractureBuffers.chunkFractureCount * sizeof(NvBlastChunkFractureData))); // chunk + // count + // + + // bond + // count m_fractureBuffers.chunkFractures = reinterpret_cast(m_fractureData.data()); - m_fractureBuffers.bondFractures = reinterpret_cast(&m_fractureData.data()[m_fractureBuffers.chunkFractureCount * sizeof(NvBlastChunkFractureData)]); + m_fractureBuffers.bondFractures = reinterpret_cast( + &m_fractureData.data()[m_fractureBuffers.chunkFractureCount * sizeof(NvBlastChunkFractureData)]); return m_fractureBuffers; } -void BlastController::immediateDamage(ExtPxActor *actor, BlastFamily& family, const NvBlastDamageProgram& program, const void* damageDesc) +void BlastController::immediateDamage(ExtPxActor* actor, BlastFamily& family, const NvBlastDamageProgram& program, + const void* damageDesc) { - NvBlastExtProgramParams programParams = { damageDesc, &family.getMaterial(), actor->getFamily().getPxAsset().getAccelerator() }; + NvBlastExtProgramParams programParams = { damageDesc, &family.getMaterial(), + actor->getFamily().getPxAsset().getAccelerator() }; NvBlastFractureBuffers& fractureEvents = getFractureBuffers(actor); actor->getTkActor().generateFracture(&fractureEvents, program, &programParams); @@ -220,7 +242,8 @@ void BlastController::updateImpactDamage() { if (m_impactDamageUpdatePending) { - getPhysXController().getPhysXScene().setSimulationEventCallback(m_impactDamageEnabled ? m_eventCallback : nullptr); + getPhysXController().getPhysXScene().setSimulationEventCallback(m_impactDamageEnabled ? m_eventCallback : + nullptr); refreshImpactDamageSettings(); m_impactDamageUpdatePending = false; } @@ -230,17 +253,18 @@ void BlastController::setImpactDamageEnabled(bool enabled, bool forceUpdate) { if (m_impactDamageEnabled != enabled || forceUpdate) { - m_impactDamageEnabled = enabled; + m_impactDamageEnabled = enabled; m_impactDamageUpdatePending = true; } } -bool BlastController::customImpactDamageFunction(void* data, ExtPxActor* actor, physx::PxShape* shape, physx::PxVec3 position, physx::PxVec3 force) +bool BlastController::customImpactDamageFunction(void* data, ExtPxActor* actor, physx::PxShape* shape, + physx::PxVec3 position, physx::PxVec3 force) { return reinterpret_cast(data)->stressDamage(actor, position, force); } -bool BlastController::stressDamage(ExtPxActor *actor, physx::PxVec3 position, physx::PxVec3 force) +bool BlastController::stressDamage(ExtPxActor* actor, physx::PxVec3 position, physx::PxVec3 force) { if (actor->getTkActor().getGraphNodeCount() > 1) { @@ -248,7 +272,8 @@ bool BlastController::stressDamage(ExtPxActor *actor, physx::PxVec3 position, ph if (userData) { ExtPxStressSolver* solver = reinterpret_cast(userData); - solver->getSolver().addForce(*actor->getTkActor().getActorLL(), position, force * m_impactDamageToStressFactor); + solver->getSolver().addForce(*actor->getTkActor().getActorLL(), reinterpret_cast(position), + reinterpret_cast(force * m_impactDamageToStressFactor)); return true; } } @@ -258,7 +283,8 @@ bool BlastController::stressDamage(ExtPxActor *actor, physx::PxVec3 position, ph void BlastController::refreshImpactDamageSettings() { - m_extImpactDamageManagerSettings.damageFunction = m_impactDamageToStressEnabled ? customImpactDamageFunction : nullptr; + m_extImpactDamageManagerSettings.damageFunction = + m_impactDamageToStressEnabled ? customImpactDamageFunction : nullptr; m_extImpactDamageManagerSettings.damageFunctionData = this; m_extImpactDamageManager->setSettings(m_extImpactDamageManagerSettings); } @@ -271,20 +297,23 @@ void BlastController::refreshImpactDamageSettings() void BlastController::updateDraggingStress() { auto physxController = getPhysXController(); - auto actor = physxController.getDraggingActor(); + auto actor = physxController.getDraggingActor(); if (actor) { ExtPxActor* pxActor = m_extPxManager->getActorFromPhysXActor(*actor); - if (pxActor && pxActor->getTkActor().getGraphNodeCount() > 1 && pxActor->getPhysXActor().getRigidBodyFlags() & PxRigidBodyFlag::eKINEMATIC) + if (pxActor && pxActor->getTkActor().getGraphNodeCount() > 1 && + pxActor->getPhysXActor().getRigidBodyFlags() & PxRigidBodyFlag::eKINEMATIC) { void* userData = pxActor->getFamily().userData; if (userData) { ExtPxStressSolver* solver = reinterpret_cast(userData); PxTransform t(pxActor->getPhysXActor().getGlobalPose().getInverse()); - PxVec3 dragVector = t.rotate(physxController.getDragVector()); + PxVec3 dragVector = t.rotate(physxController.getDragVector()); const float factor = dragVector.magnitudeSquared() * m_draggingToStressFactor; - solver->getSolver().addForce(*pxActor->getTkActor().getActorLL(), physxController.getDragActorHookLocalPoint(), dragVector.getNormalized() * factor); + solver->getSolver().addForce(*pxActor->getTkActor().getActorLL(), + reinterpret_cast(physxController.getDragActorHookLocalPoint()), + reinterpret_cast(dragVector.getNormalized() * factor)); } } } @@ -297,26 +326,20 @@ void BlastController::updateDraggingStress() uint32_t BlastController::getActorCount() const { - return std::accumulate(m_families.begin(), m_families.end(), (uint32_t)0, [](uint32_t sum, const BlastFamilyPtr& a) - { - return sum += a->getActorCount(); - }); + return std::accumulate(m_families.begin(), m_families.end(), (uint32_t)0, + [](uint32_t sum, const BlastFamilyPtr& a) { return sum += a->getActorCount(); }); } uint32_t BlastController::getTotalVisibleChunkCount() const { - return std::accumulate(m_families.begin(), m_families.end(), (uint32_t)0, [](uint32_t sum, const BlastFamilyPtr& a) - { - return sum += a->getTotalVisibleChunkCount(); - }); + return std::accumulate(m_families.begin(), m_families.end(), (uint32_t)0, + [](uint32_t sum, const BlastFamilyPtr& a) { return sum += a->getTotalVisibleChunkCount(); }); } size_t BlastController::getFamilySize() const { - return std::accumulate(m_families.begin(), m_families.end(), (size_t)0, [](size_t sum, const BlastFamilyPtr& a) - { - return sum += a->getFamilySize(); - }); + return std::accumulate(m_families.begin(), m_families.end(), (size_t)0, + [](size_t sum, const BlastFamilyPtr& a) { return sum += a->getFamilySize(); }); } @@ -365,7 +388,7 @@ void BlastController::Animate(double dt) m_extGroupTaskManager->process(); m_extGroupTaskManager->wait(); -#else // process group on main thread +#else // process group on main thread m_tkGroup->process(); @@ -381,10 +404,10 @@ void BlastController::Animate(double dt) TkGroupStats gstats; m_tkGroup->getStats(gstats); - this->m_lastBlastTimers.blastDamageMaterial = NvBlastTicksToSeconds(gstats.timers.material); - this->m_lastBlastTimers.blastDamageFracture = NvBlastTicksToSeconds(gstats.timers.fracture); - this->m_lastBlastTimers.blastSplitIsland = NvBlastTicksToSeconds(gstats.timers.island); - this->m_lastBlastTimers.blastSplitPartition = NvBlastTicksToSeconds(gstats.timers.partition); + this->m_lastBlastTimers.blastDamageMaterial = NvBlastTicksToSeconds(gstats.timers.material); + this->m_lastBlastTimers.blastDamageFracture = NvBlastTicksToSeconds(gstats.timers.fracture); + this->m_lastBlastTimers.blastSplitIsland = NvBlastTicksToSeconds(gstats.timers.island); + this->m_lastBlastTimers.blastSplitPartition = NvBlastTicksToSeconds(gstats.timers.partition); this->m_lastBlastTimers.blastSplitVisibility = NvBlastTicksToSeconds(gstats.timers.visibility); for (uint32_t i = 0; i < m_families.size(); ++i) @@ -410,9 +433,12 @@ void BlastController::drawUI() refresh |= ImGui::Checkbox("Use Shear Damage", &m_extImpactDamageManagerSettings.shearDamage); refresh |= ImGui::DragFloat("Material Hardness", &m_extImpactDamageManagerSettings.hardness); refresh |= ImGui::DragFloat("Damage Radius (Max)", &m_extImpactDamageManagerSettings.damageRadiusMax); - refresh |= ImGui::DragFloat("Damage Threshold (Min)", &m_extImpactDamageManagerSettings.damageThresholdMin, 1.0f, 0.0f, 1.0f); - refresh |= ImGui::DragFloat("Damage Threshold (Max)", &m_extImpactDamageManagerSettings.damageThresholdMax, 1.0f, 0.0f, 1.0f); - refresh |= ImGui::DragFloat("Damage Falloff Radius Factor", &m_extImpactDamageManagerSettings.damageFalloffRadiusFactor, 1.0f, 0.0f, 32.0f); + refresh |= ImGui::DragFloat("Damage Threshold (Min)", &m_extImpactDamageManagerSettings.damageThresholdMin, + 1.0f, 0.0f, 1.0f); + refresh |= ImGui::DragFloat("Damage Threshold (Max)", &m_extImpactDamageManagerSettings.damageThresholdMax, + 1.0f, 0.0f, 1.0f); + refresh |= ImGui::DragFloat("Damage Falloff Radius Factor", + &m_extImpactDamageManagerSettings.damageFalloffRadiusFactor, 1.0f, 0.0f, 32.0f); refresh |= ImGui::Checkbox("Impact Damage To Stress Solver", &m_impactDamageToStressEnabled); if (refresh) @@ -438,7 +464,7 @@ void BlastController::drawUI() /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// BlastFamilyPtr BlastController::spawnFamily(BlastAsset* blastAsset, const BlastAsset::ActorDesc& desc) -{ +{ BlastFamilyPtr actor = blastAsset->createFamily(getPhysXController(), *m_extPxManager, desc); m_families.push_back(actor); recalculateAssetsSize(); @@ -477,7 +503,8 @@ void BlastController::recalculateAssetsSize() } } -bool BlastController::overlap(const PxGeometry& geometry, const PxTransform& pose, std::function hitCall) +bool BlastController::overlap(const PxGeometry& geometry, const PxTransform& pose, + std::function hitCall) { PROFILER_SCOPED_FUNCTION(); diff --git a/samples/SampleBase/blast/BlastFamilyBoxes.h b/samples/SampleBase/blast/BlastFamilyBoxes.h index 71df42c..f1e685d 100755 --- a/samples/SampleBase/blast/BlastFamilyBoxes.h +++ b/samples/SampleBase/blast/BlastFamilyBoxes.h @@ -30,6 +30,7 @@ #define BLAST_FAMILY_BOXES #include "BlastFamily.h" +#include class BlastAssetBoxes; class Renderable; @@ -37,19 +38,20 @@ class Renderable; class BlastFamilyBoxes : public BlastFamily { -public: - BlastFamilyBoxes(PhysXController& physXController, ExtPxManager& pxManager, Renderer& renderer, const BlastAssetBoxes& blastAsset, const BlastAsset::ActorDesc& desc); + public: + BlastFamilyBoxes(PhysXController& physXController, ExtPxManager& pxManager, Renderer& renderer, + const BlastAssetBoxes& blastAsset, const BlastAsset::ActorDesc& desc); virtual ~BlastFamilyBoxes(); -protected: + protected: virtual void onActorCreated(const ExtPxActor& actor); virtual void onActorUpdate(const ExtPxActor& actor); virtual void onActorDestroyed(const ExtPxActor& actor); -private: - Renderer& m_renderer; + private: + Renderer& m_renderer; std::vector m_chunkRenderables; }; -#endif //BLAST_FAMILY_BOXES \ No newline at end of file +#endif // BLAST_FAMILY_BOXES \ No newline at end of file diff --git a/samples/SampleBase/blast/BlastModel.cpp b/samples/SampleBase/blast/BlastModel.cpp index e23749c..ae9e0ca 100755 --- a/samples/SampleBase/blast/BlastModel.cpp +++ b/samples/SampleBase/blast/BlastModel.cpp @@ -74,9 +74,9 @@ BlastModelPtr BlastModel::loadFromFbxFile(const char* path) { indRemap[j] = (int32_t)cmesh.vertices.size(); cmesh.vertices.push_back(SimpleMesh::Vertex()); - cmesh.vertices.back().normal = normalsArray[j]; - cmesh.vertices.back().position = positionArray[j]; - cmesh.vertices.back().uv = uvArray[j]; + cmesh.vertices.back().normal = reinterpret_cast(normalsArray[j]); + cmesh.vertices.back().position = reinterpret_cast(positionArray[j]); + cmesh.vertices.back().uv = reinterpret_cast(uvArray[j]); } } const uint32_t indicesCount = rdr->getIndicesCount(); -- cgit v1.2.3