Merge pull request #233 from SHADE-DP/SP3-2-Physics

Added Collision Tags

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 "index<space>tag name". 
+If it fails to follow this, the default tag names will be used.

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))
       {

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 <SHpch.h>
+#include <fstream>
+
+// 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 "index<space>tag 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 'index<space>tag 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

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 <filesystem>
+
+// 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];
+  };
+}

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 <SHpch.h>
+#include <fstream>
+
+// 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::SHCollisionTag::Layer>(SHADE::SHUtilities::ConvertEnum(lhs) | SHADE::SHUtilities::ConvertEnum(rhs));
+}

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 <string>
+
+// 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;
+
+

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 }
+  : type          { colliderType }
-  , entityID  { eid }
+  , entityID      { eid }
-  , isTrigger { false }
+  , isTrigger     { false }
-  , dirty     { true }
+  , dirty         { true }
-  , shape     { nullptr }
+  , shape         { nullptr }
-  , material  { physicsMaterial }
+  , 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;

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                                                                */
     /*---------------------------------------------------------------------------------*/

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->setMass(component.mass);
-              rp3dBody->updateLocalCenterOfMassFromColliders();
+            //  rp3dBody->updateLocalCenterOfMassFromColliders();
-              rp3dBody->updateLocalInertiaTensorFromColliders();
+            //  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

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;

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<SHEventReceiverSpec<SHPhysicsSystem>>(this, &SHPhysicsSystem::addPhysicsComponent) };
     const ReceiverPtr ADD_COMPONENT_RECEIVER_PTR = std::dynamic_pointer_cast<SHEventReceiver>(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()