diff --git a/Assets/CollisionTags.SHConfig b/Assets/CollisionTags.SHConfig new file mode 100644 index 00000000..18a339dd --- /dev/null +++ b/Assets/CollisionTags.SHConfig @@ -0,0 +1,20 @@ +0 1 +1 2 +2 3 +3 4 +4 5 +5 6 +6 7 +7 8 +8 9 +9 10 +10 11 +11 12 +12 13 +13 14 +14 15 +15 16 + +note: +All collision tags should follow the above format "indextag name". +If it fails to follow this, the default tag names will be used. \ No newline at end of file diff --git a/SHADE_Application/src/Application/SBApplication.cpp b/SHADE_Application/src/Application/SBApplication.cpp index a8871cd8..e80b247b 100644 --- a/SHADE_Application/src/Application/SBApplication.cpp +++ b/SHADE_Application/src/Application/SBApplication.cpp @@ -180,6 +180,7 @@ namespace Sandbox editor->PollPicking(); #endif + // TODO: Move into an Editor menu static bool drawColliders = false; if (SHInputManager::GetKeyDown(SHInputManager::SH_KEYCODE::F10)) { diff --git a/SHADE_Engine/src/Physics/Collision/SHCollisionTagMatrix.cpp b/SHADE_Engine/src/Physics/Collision/SHCollisionTagMatrix.cpp new file mode 100644 index 00000000..b687c6ca --- /dev/null +++ b/SHADE_Engine/src/Physics/Collision/SHCollisionTagMatrix.cpp @@ -0,0 +1,223 @@ +/**************************************************************************************** + * \file SHCollisionTagMatrix.cpp + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Implementation for Collision Tag Matrix for handling sets of Collision Tags. + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#include +#include + +// Primary Header +#include "SHCollisionTagMatrix.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Static Data Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + + SHCollisionTag SHCollisionTagMatrix::collisionTags[SHCollisionTag::NUM_LAYERS]; + + /*-----------------------------------------------------------------------------------*/ + /* Getter Function Definitions */ + /*-----------------------------------------------------------------------------------*/ + + const std::string& SHCollisionTagMatrix::GetTagName(int tagIndex) + { + if (tagIndex < 0 || tagIndex > SHCollisionTag::NUM_LAYERS) + throw std::invalid_argument("Index out of range!"); + + return collisionTags[tagIndex].GetName(); + } + + int SHCollisionTagMatrix::GetTagIndex(const std::string& tagName) noexcept + { + for (int i = 0; i < SHCollisionTag::NUM_LAYERS; ++i) + { + if (collisionTags[i].GetName() == tagName) + return i; + } + + SHLOGV_WARNING("Collision Tag {} cannot be found!", tagName) + return -1; + } + + SHCollisionTag* SHCollisionTagMatrix::GetTag(int tagIndex) + { + if (tagIndex < 0 || tagIndex > SHCollisionTag::NUM_LAYERS) + throw std::invalid_argument("Index out of range!"); + + return &collisionTags[tagIndex]; + } + + SHCollisionTag* SHCollisionTagMatrix::GetTag(const std::string& tagName) noexcept + { + for (int i = 0; i < SHCollisionTag::NUM_LAYERS; ++i) + { + if (collisionTags[i].GetName() == tagName) + return &collisionTags[i]; + } + + SHLOGV_WARNING("Collision Tag {} cannot be found!", tagName) + return nullptr; + } + + /*-----------------------------------------------------------------------------------*/ + /* Setter Function Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHCollisionTagMatrix::SetTagName(const std::string& oldTagName, const std::string& newTagName) noexcept + { + for (auto& collisionTag : collisionTags) + { + if (collisionTag.GetName() != oldTagName) + continue; + + collisionTag.SetName(newTagName); + return; + } + + SHLOGV_WARNING("Collision tag {} cannot be found!", oldTagName) + } + + void SHCollisionTagMatrix::SetTag(const std::string& tagName, const SHCollisionTag& newTag) noexcept + { + for (auto& collisionTag : collisionTags) + { + if (collisionTag.GetName() != tagName) + continue; + + collisionTag = newTag; + return; + } + + SHLOGV_WARNING("Collision tag {} cannot be found!", tagName) + } + + void SHCollisionTagMatrix::SetTag(const std::string& tagName, uint16_t mask) noexcept + { + for (auto& collisionTag : collisionTags) + { + if (collisionTag.GetName() != tagName) + continue; + + collisionTag.SetMask(mask); + return; + } + + SHLOGV_WARNING("Collision tag {} cannot be found!", tagName) + } + + void SHCollisionTagMatrix::SetTagName(int tagIndex, const std::string& newTagName) + { + if (tagIndex < 0 || tagIndex > SHCollisionTag::NUM_LAYERS) + throw std::invalid_argument("Index out of range!"); + + collisionTags[tagIndex].SetName(newTagName); + } + + void SHCollisionTagMatrix::SetTag(int tagIndex, const SHCollisionTag& newTag) + { + if (tagIndex < 0 || tagIndex > SHCollisionTag::NUM_LAYERS) + throw std::invalid_argument("Index out of range!"); + + collisionTags[tagIndex] = newTag; + } + + void SHCollisionTagMatrix::SetTag(int tagIndex, uint16_t mask) + { + if (tagIndex < 0 || tagIndex > SHCollisionTag::NUM_LAYERS) + throw std::invalid_argument("Index out of range!"); + + collisionTags[tagIndex].SetMask(mask); + } + + /*-----------------------------------------------------------------------------------*/ + /* Public Function Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHCollisionTagMatrix::Init(const std::filesystem::path& tagNameFilePath) noexcept + { + /** + * I HATE FILE IO + * + * Each line in the file should be "indextag name". + * If the line fails to follow this format, use the default tag name (index + 1) + */ + + // Populate tag names with default + for (int i = 0; i < SHCollisionTag::NUM_LAYERS; ++i) + collisionTags[i].SetName(std::to_string(i + 1)); + + std::ifstream collisionTagNamesFile { tagNameFilePath }; + + if (!collisionTagNamesFile.is_open()) + { + SHLOG_ERROR("Failed to open file for Collision Tag Names! Default tag names used!") + return; + } + + std::stringstream ss; + std::string line; + + int linesRead = 0; + while (std::getline(collisionTagNamesFile, line)) + { + // Do not read anything beyond the first 16 lines + if (linesRead >= 16) + break; + + ss << line; + ++linesRead; + + // First element is index. + int tagIndex; + ss >> tagIndex; + + // Next element is name of the tag + std::string tagName; + ss >> tagName; + + // If no tag name read, use default. + if (tagName.empty()) + { + SHLOG_ERROR + ( + "Collision tag file line {} does not match the required format of 'indextag name'. Default tag used for index {}" + , linesRead + 1 + , tagIndex + ) + + // Use default + collisionTags[tagIndex].SetName(std::to_string(tagIndex + 1)); + continue; + } + + collisionTags[tagIndex].SetName(tagName); + + ss.clear(); + } + + collisionTagNamesFile.close(); + } + + void SHCollisionTagMatrix::Exit(const std::filesystem::path& tagNameFilePath) noexcept + { + std::ofstream collisionTagNamesFile { tagNameFilePath }; + + if (!collisionTagNamesFile.is_open()) + { + SHLOG_ERROR("Failed to open file for Collision Tag Names! Tag names not saved!") + return; + } + + for (int i = 0; i < SHCollisionTag::NUM_LAYERS; ++i) + collisionTagNamesFile << i << " " << collisionTags[i].GetName() << std::endl; + + collisionTagNamesFile.close(); + } +} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/Collision/SHCollisionTagMatrix.h b/SHADE_Engine/src/Physics/Collision/SHCollisionTagMatrix.h new file mode 100644 index 00000000..90018fe4 --- /dev/null +++ b/SHADE_Engine/src/Physics/Collision/SHCollisionTagMatrix.h @@ -0,0 +1,67 @@ +/**************************************************************************************** + * \file SHCollisionTagMatrix.h + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Interface for Collision Tag Matrix for handling sets of Collision Tags. + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#pragma once + +#include + +// Project Includes +#include "SH_API.h" +#include "SHCollisionTags.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*-----------------------------------------------------------------------------------*/ + + class SH_API SHCollisionTagMatrix + { + public: + /*---------------------------------------------------------------------------------*/ + /* Getter Functions */ + /*---------------------------------------------------------------------------------*/ + + [[nodiscard]] static const std::string& GetTagName (int tagIndex); + [[nodiscard]] static int GetTagIndex (const std::string& tagName) noexcept; + + [[nodiscard]] static SHCollisionTag* GetTag (int tagIndex); + [[nodiscard]] static SHCollisionTag* GetTag (const std::string& tagName) noexcept; + + /*---------------------------------------------------------------------------------*/ + /* Setter Functions */ + /*---------------------------------------------------------------------------------*/ + + static void SetTagName (const std::string& oldTagName, const std::string& newTagName) noexcept; + static void SetTag (const std::string& tagName, const SHCollisionTag& newTag) noexcept; + static void SetTag (const std::string& tagName, uint16_t mask) noexcept; + + // Unsafe Setters: Can throw exceptions + + static void SetTagName (int tagIndex, const std::string& newTagName); + static void SetTag (int tagIndex, const SHCollisionTag& newTag); + static void SetTag (int tagIndex, uint16_t mask); + + + /*---------------------------------------------------------------------------------*/ + /* Function Members */ + /*---------------------------------------------------------------------------------*/ + + static void Init (const std::filesystem::path& tagNameFilePath) noexcept; + static void Exit (const std::filesystem::path& tagNameFilePath) noexcept; + + private: + /*---------------------------------------------------------------------------------*/ + /* Data Members */ + /*---------------------------------------------------------------------------------*/ + + static SHCollisionTag collisionTags[SHCollisionTag::NUM_LAYERS]; + }; +} \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/Collision/SHCollisionTags.cpp b/SHADE_Engine/src/Physics/Collision/SHCollisionTags.cpp new file mode 100644 index 00000000..b1d2d5fc --- /dev/null +++ b/SHADE_Engine/src/Physics/Collision/SHCollisionTags.cpp @@ -0,0 +1,116 @@ +/**************************************************************************************** + * \file SHCollisionTags.cpp + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Implementation for Collision Tags for filtering collisions. + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#include +#include + +// Primary Header +#include "SHCollisionTags.h" +// Project Headers +#include "Tools/Utilities/SHUtilities.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Constructors & Destructor Definitions */ + /*-----------------------------------------------------------------------------------*/ + + SHCollisionTag::SHCollisionTag() noexcept + : mask { SHUtilities::ConvertEnum(Layer::ALL) } + {} + + SHCollisionTag::SHCollisionTag(uint16_t _mask) noexcept + : mask { _mask } + {} + + SHCollisionTag::SHCollisionTag(Layer layer) noexcept + : mask { SHUtilities::ConvertEnum(layer) } + {} + + /*-----------------------------------------------------------------------------------*/ + /* Operator Overload Definitions */ + /*-----------------------------------------------------------------------------------*/ + + bool SHCollisionTag::operator==(const SHCollisionTag& rhs) const noexcept + { + return mask == rhs.mask; + } + + bool SHCollisionTag::operator!=(const SHCollisionTag& rhs) const noexcept + { + return mask != rhs.mask; + } + + SHCollisionTag::operator uint16_t() const noexcept + { + return mask; + } + + /*-----------------------------------------------------------------------------------*/ + /* Getter Function Definitions */ + /*-----------------------------------------------------------------------------------*/ + + uint16_t SHCollisionTag::GetMask() const noexcept + { + return mask; + } + + const std::string& SHCollisionTag::GetName() const noexcept + { + return name; + } + + bool SHCollisionTag::GetLayerState(Layer layer) const noexcept + { + return (mask & SHUtilities::ConvertEnum(layer)) > 0; + } + + bool SHCollisionTag::GetLayerState(int layerIndex) const + { + if (layerIndex < 0 || layerIndex > NUM_LAYERS) + throw std::invalid_argument("Index out of range!"); + + return (mask & (1U << layerIndex)) > 0; + } + + /*-----------------------------------------------------------------------------------*/ + /* Setter Function Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHCollisionTag::SetMask(uint16_t newMask) noexcept + { + mask = newMask; + } + + void SHCollisionTag::SetName(const std::string_view& newName) noexcept + { + name = newName; + } + + void SHCollisionTag::SetLayerState(Layer layer, bool state) noexcept + { + const auto VALUE = SHUtilities::ConvertEnum(layer); + state ? mask |= VALUE : mask &= ~(VALUE); + } + + void SHCollisionTag::SetLayerState(int layerIndex, bool state) + { + if (layerIndex < 0 || layerIndex > NUM_LAYERS) + throw std::invalid_argument("Index out of range!"); + + const auto VALUE = 1U << layerIndex; + state ? mask |= (VALUE) : mask &= ~(VALUE); + } +} // namespace SHADE + +SHADE::SHCollisionTag::Layer operator|(SHADE::SHCollisionTag::Layer lhs, SHADE::SHCollisionTag::Layer rhs) noexcept +{ + return static_cast(SHADE::SHUtilities::ConvertEnum(lhs) | SHADE::SHUtilities::ConvertEnum(rhs)); +} \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/Collision/SHCollisionTags.h b/SHADE_Engine/src/Physics/Collision/SHCollisionTags.h new file mode 100644 index 00000000..9c7b4364 --- /dev/null +++ b/SHADE_Engine/src/Physics/Collision/SHCollisionTags.h @@ -0,0 +1,112 @@ +/**************************************************************************************** + * \file SHCollisionTags.h + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Interface for Collision Tags for filtering collisions. + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#pragma once + +#include + +// Project Headers +#include "SH_API.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*-----------------------------------------------------------------------------------*/ + + class SH_API SHCollisionTag + { + public: + /*---------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*---------------------------------------------------------------------------------*/ + + enum class Layer : uint16_t + { + _1 = 0x0001 + , _2 = 0x0002 + , _3 = 0x0004 + , _4 = 0x0008 + , _5 = 0x0010 + , _6 = 0x0020 + , _7 = 0x0040 + , _8 = 0x0080 + , _9 = 0x0100 + , _10 = 0x0200 + , _11 = 0x0400 + , _12 = 0x0800 + , _13 = 0x1000 + , _14 = 0x2000 + , _15 = 0x4000 + , _16 = 0x8000 + , ALL = 0xFFFF + }; + + /*---------------------------------------------------------------------------------*/ + /* Data Members */ + /*---------------------------------------------------------------------------------*/ + static constexpr int NUM_LAYERS = 16; + + /*---------------------------------------------------------------------------------*/ + /* Constructors & Destructor */ + /*---------------------------------------------------------------------------------*/ + + SHCollisionTag () noexcept; + SHCollisionTag (uint16_t mask) noexcept; + SHCollisionTag (Layer layer) noexcept; + + SHCollisionTag (const SHCollisionTag&) noexcept = default; + SHCollisionTag (SHCollisionTag&&) noexcept = default; + ~SHCollisionTag () = default; + + /*---------------------------------------------------------------------------------*/ + /* Operator Overloads */ + /*---------------------------------------------------------------------------------*/ + + SHCollisionTag& operator=(const SHCollisionTag&) noexcept = default; + SHCollisionTag& operator=(SHCollisionTag&&) noexcept = default; + + [[nodiscard]] bool operator==(const SHCollisionTag& rhs) const noexcept; + [[nodiscard]] bool operator!=(const SHCollisionTag& rhs) const noexcept; + + operator uint16_t() const noexcept; + + /*---------------------------------------------------------------------------------*/ + /* Getter Functions */ + /*---------------------------------------------------------------------------------*/ + + [[nodiscard]] uint16_t GetMask () const noexcept; + [[nodiscard]] const std::string& GetName () const noexcept; + [[nodiscard]] bool GetLayerState (Layer layer) const noexcept; + [[nodiscard]] bool GetLayerState (int layerIndex) const; + + /*---------------------------------------------------------------------------------*/ + /* Setter Functions */ + /*---------------------------------------------------------------------------------*/ + + void SetMask (uint16_t newMask) noexcept; + void SetName (const std::string_view& newName) noexcept; + void SetLayerState (Layer layer, bool state) noexcept; + void SetLayerState (int layerIndex, bool state); + + private: + /*---------------------------------------------------------------------------------*/ + /* Data Members */ + /*---------------------------------------------------------------------------------*/ + + uint16_t mask; + std::string name; + }; + +} // namespace SHADE + +SHADE::SHCollisionTag::Layer SH_API operator|(SHADE::SHCollisionTag::Layer lhs, SHADE::SHCollisionTag::Layer rhs) noexcept; + + diff --git a/SHADE_Engine/src/Physics/Interface/SHCollisionShape.cpp b/SHADE_Engine/src/Physics/Interface/SHCollisionShape.cpp index 14743845..c8a082a5 100644 --- a/SHADE_Engine/src/Physics/Interface/SHCollisionShape.cpp +++ b/SHADE_Engine/src/Physics/Interface/SHCollisionShape.cpp @@ -16,6 +16,7 @@ #include "Math/Geometry/SHBox.h" #include "Math/Geometry/SHSphere.h" #include "Math/SHMathHelpers.h" +#include "Physics/Collision/SHCollisionTagMatrix.h" #include "Reflection/SHReflectionMetadata.h" #include "SHColliderComponent.h" @@ -26,12 +27,13 @@ namespace SHADE /*-----------------------------------------------------------------------------------*/ SHCollisionShape::SHCollisionShape(EntityID eid, Type colliderType, const SHPhysicsMaterial& physicsMaterial) - : type { colliderType } - , entityID { eid } - , isTrigger { false } - , dirty { true } - , shape { nullptr } - , material { physicsMaterial } + : type { colliderType } + , entityID { eid } + , isTrigger { false } + , dirty { true } + , shape { nullptr } + , material { physicsMaterial } + , collisionTag { SHCollisionTagMatrix::GetTag(0) } { switch (type) { @@ -57,6 +59,8 @@ namespace SHADE , shape { nullptr } , material { rhs.material } , positionOffset { rhs.positionOffset } + , rotationOffset { rhs.rotationOffset } + , collisionTag { rhs.collisionTag } { CopyShape(rhs.shape); } @@ -69,6 +73,8 @@ namespace SHADE , shape { nullptr } , material { rhs.material } , positionOffset { rhs.positionOffset } + , rotationOffset { rhs.rotationOffset } + , collisionTag { rhs.collisionTag } { CopyShape(rhs.shape); } @@ -93,6 +99,8 @@ namespace SHADE dirty = true; material = rhs.material; positionOffset = rhs.positionOffset; + rotationOffset = rhs.rotationOffset; + collisionTag = rhs.collisionTag; delete shape; CopyShape(rhs.shape); @@ -108,6 +116,8 @@ namespace SHADE dirty = true; material = rhs.material; positionOffset = rhs.positionOffset; + rotationOffset = rhs.rotationOffset; + collisionTag = rhs.collisionTag; delete shape; CopyShape(rhs.shape); @@ -134,6 +144,11 @@ namespace SHADE return type; } + const SHCollisionTag& SHCollisionShape::GetCollisionTag() const noexcept + { + return *collisionTag; + } + float SHCollisionShape::GetFriction() const noexcept { return material.GetFriction(); @@ -240,6 +255,12 @@ namespace SHADE isTrigger = trigger; } + void SHCollisionShape::SetCollisionTag(SHCollisionTag* newCollisionTag) noexcept + { + dirty = true; + collisionTag = newCollisionTag; + } + void SHCollisionShape::SetFriction(float friction) noexcept { dirty = true; diff --git a/SHADE_Engine/src/Physics/Interface/SHCollisionShape.h b/SHADE_Engine/src/Physics/Interface/SHCollisionShape.h index 526428fd..597814a6 100644 --- a/SHADE_Engine/src/Physics/Interface/SHCollisionShape.h +++ b/SHADE_Engine/src/Physics/Interface/SHCollisionShape.h @@ -17,6 +17,7 @@ #include "Math/Geometry/SHShape.h" #include "Math/SHQuaternion.h" #include "SHPhysicsMaterial.h" +#include "Physics/Collision/SHCollisionTags.h" namespace SHADE { @@ -74,6 +75,8 @@ namespace SHADE [[nodiscard]] Type GetType () const noexcept; + [[nodiscard]] const SHCollisionTag& GetCollisionTag () const noexcept; + [[nodiscard]] float GetFriction () const noexcept; [[nodiscard]] float GetBounciness () const noexcept; [[nodiscard]] float GetDensity () const noexcept; @@ -92,6 +95,7 @@ namespace SHADE void SetBoundingSphere (float radius); void SetIsTrigger (bool isTrigger) noexcept; + void SetCollisionTag (SHCollisionTag* newCollisionTag) noexcept; void SetFriction (float friction) noexcept; void SetBounciness (float bounciness) noexcept; void SetDensity (float density) noexcept; @@ -109,11 +113,15 @@ namespace SHADE EntityID entityID; // The entity this collider belongs to bool isTrigger; bool dirty; + SHShape* shape; SHPhysicsMaterial material; + SHVec3 positionOffset; SHVec3 rotationOffset; + SHCollisionTag* collisionTag; + /*---------------------------------------------------------------------------------*/ /* Function Members */ /*---------------------------------------------------------------------------------*/ diff --git a/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObject.cpp b/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObject.cpp index 3cfa3ec9..8de928f0 100644 --- a/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObject.cpp +++ b/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObject.cpp @@ -254,6 +254,10 @@ namespace SHADE } case 9: // Mass { + rp3dBody->setMass(component.mass); + rp3dBody->updateLocalCenterOfMassFromColliders(); + rp3dBody->updateLocalInertiaTensorFromColliders(); + //if (component.GetAutoMass()) //{ // rp3dBody->updateMassPropertiesFromColliders(); @@ -261,9 +265,9 @@ namespace SHADE //} //else //{ - rp3dBody->setMass(component.mass); - rp3dBody->updateLocalCenterOfMassFromColliders(); - rp3dBody->updateLocalInertiaTensorFromColliders(); + // rp3dBody->setMass(component.mass); + // rp3dBody->updateLocalCenterOfMassFromColliders(); + // rp3dBody->updateLocalInertiaTensorFromColliders(); //} break; @@ -309,7 +313,18 @@ namespace SHADE default: break; } - syncMaterial(i, collisionShape); + // Sync material + auto* rp3dCollider = rp3dBody->getCollider(i); + auto& rp3dMaterial = rp3dCollider->getMaterial(); + + rp3dMaterial.setFrictionCoefficient(collisionShape.GetFriction()); + rp3dMaterial.setBounciness(collisionShape.GetBounciness()); + rp3dMaterial.setMassDensity(collisionShape.GetDensity()); + + // Sync tags + const unsigned short MASK_BITS = collisionShape.GetCollisionTag(); + rp3dCollider->setCollisionCategoryBits(MASK_BITS); + rp3dCollider->setCollideWithMaskBits(MASK_BITS); collisionShape.dirty = false; } @@ -319,14 +334,6 @@ namespace SHADE /* Private Function Member Definitions */ /*-----------------------------------------------------------------------------------*/ - void SHPhysicsObject::syncMaterial(int colliderIndex, SHCollisionShape& collisionShape) const noexcept - { - auto& rp3dMaterial = rp3dBody->getCollider(colliderIndex)->getMaterial(); - rp3dMaterial.setFrictionCoefficient(collisionShape.GetFriction()); - rp3dMaterial.setBounciness(collisionShape.GetBounciness()); - rp3dMaterial.setMassDensity(collisionShape.GetDensity()); - } - void SHPhysicsObject::addBoxShape(SHCollisionShape& boxShape) const noexcept { const rp3d::Transform OFFSETS diff --git a/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObject.h b/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObject.h index 5a0e62ac..fefc983f 100644 --- a/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObject.h +++ b/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObject.h @@ -96,8 +96,6 @@ namespace SHADE /* Function Members */ /*---------------------------------------------------------------------------------*/ - void syncMaterial (int colliderIndex, SHCollisionShape& collisionShape) const noexcept; - // Box Shapes void addBoxShape (SHCollisionShape& boxShape) const noexcept; diff --git a/SHADE_Engine/src/Physics/System/SHPhysicsSystem.cpp b/SHADE_Engine/src/Physics/System/SHPhysicsSystem.cpp index f3513ffb..396edd93 100644 --- a/SHADE_Engine/src/Physics/System/SHPhysicsSystem.cpp +++ b/SHADE_Engine/src/Physics/System/SHPhysicsSystem.cpp @@ -14,10 +14,12 @@ #include "SHPhysicsSystem.h" // Project Headers +#include "Assets/SHAssetMacros.h" #include "ECS_Base/Managers/SHComponentManager.h" #include "ECS_Base/Managers/SHEntityManager.h" #include "ECS_Base/Managers/SHSystemManager.h" #include "Editor/SHEditor.h" +#include "Physics/Collision/SHCollisionTagMatrix.h" #include "Physics/SHPhysicsEvents.h" #include "Scene/SHSceneManager.h" #include "Scripting/SHScriptEngine.h" @@ -90,6 +92,11 @@ namespace SHADE void SHPhysicsSystem::Init() { + // Initialise collision tags + std::filesystem::path defaultCollisionTagNameFilePath { ASSET_ROOT }; + defaultCollisionTagNameFilePath.append("CollisionTags.SHConfig"); + SHCollisionTagMatrix::Init(defaultCollisionTagNameFilePath); + // Subscribe to component events const std::shared_ptr ADD_COMPONENT_RECEIVER { std::make_shared>(this, &SHPhysicsSystem::addPhysicsComponent) }; const ReceiverPtr ADD_COMPONENT_RECEIVER_PTR = std::dynamic_pointer_cast(ADD_COMPONENT_RECEIVER); @@ -122,6 +129,11 @@ namespace SHADE void SHPhysicsSystem::Exit() { worldState.DestroyWorld(factory); + + // Write collision tag names to file + std::filesystem::path defaultCollisionTagNameFilePath { ASSET_ROOT }; + defaultCollisionTagNameFilePath.append("CollisionTags.SHConfig"); + SHCollisionTagMatrix::Exit(defaultCollisionTagNameFilePath); } void SHPhysicsSystem::ForceUpdate()