SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorComponentView.hpp

@@ -290,6 +290,7 @@ namespace SHADE
         {
           SHEditorWidgets::DragVec3("Force", { "X", "Y", "Z" }, [component] {return component->GetForce(); }, [](SHVec3 const& value) {}, false, "Force", 0.1f, "%.3f", 0.0f, 0.0f, ImGuiSliderFlags_ReadOnly);
           SHEditorWidgets::DragVec3("Torque", { "X", "Y", "Z" }, [component] {return component->GetTorque(); }, [](SHVec3 const& value) {}, false, "Torque", 0.1f, "%.3f", 0.0f, 0.0f, ImGuiSliderFlags_ReadOnly);
+          SHEditorWidgets::CheckBox("Is Asleep", [component] {return component->GetIsSleeping(); }, [](bool value) {}, "If the Rigid Body is asleep");
         } 
       }
 

SHADE_Engine/src/Math/Geometry/SHBox.cpp

@@ -1,5 +1,5 @@
 /****************************************************************************************
- * \file      SHBoundingBox.cpp
+ * \file      SHBox.cpp
  * \author    Diren D Bharwani, diren.dbharwani, 390002520
  * \brief     Implementation for a 3-Dimensional Axis Aligned Bounding Box
  *

SHADE_Engine/src/Math/Geometry/SHBox.h

@@ -1,5 +1,5 @@
 /****************************************************************************************
- * \file      SHBoundingBox.h
+ * \file      SHBox.h
  * \author    Diren D Bharwani, diren.dbharwani, 390002520
  * \brief     Interface for a 3-Dimensional Axis Aligned Bounding Box
  *

SHADE_Engine/src/Physics/Collision/SHCollisionListener.cpp

@@ -16,6 +16,7 @@
 // Project Headers
 #include "Physics/PhysicsObject/SHPhysicsObject.h"
 #include "Physics/System/SHPhysicsSystem.h"
+#include "Scene/SHSceneManager.h"
 
 /*-------------------------------------------------------------------------------------*/
 /* Local Helper Functions                                                              */
@@ -80,10 +81,15 @@ namespace SHADE
     {
       for (auto eventIter = container.begin(); eventIter != container.end();)
       {
-        const bool CLEAR_EVENT =  eventIter->GetCollisionState() == SHCollisionInfo::State::EXIT
+        const SHCollisionInfo& C_INFO = *eventIter;
-                              ||  eventIter->GetCollisionState() == SHCollisionInfo::State::INVALID;
 
-        if (CLEAR_EVENT)
+        const bool CLEAR_EVENT =  C_INFO.GetCollisionState() == SHCollisionInfo::State::EXIT
+                              ||  C_INFO.GetCollisionState() == SHCollisionInfo::State::INVALID;
+
+        const bool INACTIVE_OBJECT =  !SHSceneManager::CheckNodeAndComponentsActive<SHColliderComponent>(C_INFO.GetEntityA())
+                                  ||  !SHSceneManager::CheckNodeAndComponentsActive<SHColliderComponent>(C_INFO.GetEntityB());
+
+        if (CLEAR_EVENT || INACTIVE_OBJECT)
           eventIter = container.erase(eventIter);
         else
           ++eventIter;

SHADE_Engine/src/Physics/Interface/SHCollisionShape.cpp

@@ -304,6 +304,9 @@ namespace SHADE
         const auto* RHS_BOX = reinterpret_cast<const SHBox*>(rhs);
 
         shape = new SHBox{ positionOffset, RHS_BOX->GetWorldExtents() };
+        auto* lhsBox = reinterpret_cast<SHBox*>(shape);
+        lhsBox->SetRelativeExtents(RHS_BOX->GetRelativeExtents());
+
         break;
       }
       case Type::SPHERE:
@@ -311,6 +314,9 @@ namespace SHADE
         const  auto* RHS_SPHERE = reinterpret_cast<const SHSphere*>(rhs);
 
         shape = new SHSphere{ positionOffset, RHS_SPHERE->GetWorldRadius() };
+        auto* lhsSphere = reinterpret_cast<SHSphere*>(shape);
+        lhsSphere->SetRelativeRadius(RHS_SPHERE->GetRelativeRadius());
+
         break;
       }
       default: break;

SHADE_Engine/src/Physics/Interface/SHRigidBodyComponent.cpp

@@ -29,7 +29,6 @@ namespace SHADE
 
   SHRigidBodyComponent::SHRigidBodyComponent() noexcept
   : type        { Type::DYNAMIC }
-  , interpolate { true }
   , flags       { 0 }
   , dirtyFlags  { std::numeric_limits<uint16_t>::max() }
   , mass        { 1.0f }
@@ -40,6 +39,7 @@ namespace SHADE
     // Initialise default flags
     flags |= 1U << 0; // Gravity set to true
     flags |= 1U << 1; // Sleeping allowed
+    flags |= 1U << 8; // Interpolate by default
   }
 
   /*-----------------------------------------------------------------------------------*/
@@ -60,7 +60,16 @@ namespace SHADE
 
   bool SHRigidBodyComponent::IsInterpolating() const noexcept
   {
-    return interpolate;
+    static constexpr int FLAG_POS = 8;
+    return flags & (1U << FLAG_POS);
+  }
+
+  bool SHRigidBodyComponent::GetIsSleeping() const noexcept
+  {
+    if (auto* physicsObject = system->GetPhysicsObject(GetEID()); physicsObject)
+      return physicsObject->GetRigidBody()->isSleeping();
+
+    return false;
   }
 
   SHRigidBodyComponent::Type SHRigidBodyComponent::GetType() const noexcept
@@ -68,21 +77,6 @@ namespace SHADE
     return type;
   }
 
-  float SHRigidBodyComponent::GetMass() const noexcept
-  {
-    return mass;
-  }
-
-  float SHRigidBodyComponent::GetDrag() const noexcept
-  {
-    return drag;
-  }
-
-  float SHRigidBodyComponent::GetAngularDrag() const noexcept
-  {
-    return angularDrag;
-  }
-
   bool SHRigidBodyComponent::GetFreezePositionX() const noexcept
   {
     static constexpr int FLAG_POS = 2;
@@ -119,6 +113,27 @@ namespace SHADE
     return flags & (1U << FLAG_POS);
   }
 
+  //bool SHRigidBodyComponent::GetAutoMass() const noexcept
+  //{
+  //  static constexpr int FLAG_POS = 9;
+  //  return flags & (1U << FLAG_POS);
+  //}
+
+   float SHRigidBodyComponent::GetMass() const noexcept
+  {
+    return mass;
+  }
+
+  float SHRigidBodyComponent::GetDrag() const noexcept
+  {
+    return drag;
+  }
+
+  float SHRigidBodyComponent::GetAngularDrag() const noexcept
+  {
+    return angularDrag;
+  }
+
   SHVec3 SHRigidBodyComponent::GetForce() const noexcept
   {
     if (auto* physicsObject = system->GetPhysicsObject(GetEID()); physicsObject)
@@ -295,9 +310,18 @@ namespace SHADE
 
   void SHRigidBodyComponent::SetInterpolate(bool allowInterpolation) noexcept
   {
-    interpolate = allowInterpolation;
+    static constexpr int FLAG_POS = 8;
+    allowInterpolation ? flags |= 1U << FLAG_POS : flags &= ~(1U << FLAG_POS);
   }
 
+  //void SHRigidBodyComponent::SetAutoMass(bool autoMass) noexcept
+  //{
+  //  static constexpr int FLAG_POS = 9;
+  //  autoMass ? flags |= 1U << FLAG_POS : flags &= ~(1U << FLAG_POS);
+
+  //  dirtyFlags |= 1U << FLAG_POS;
+  //}
+
   void SHRigidBodyComponent::SetMass(float newMass) noexcept
   {
     static constexpr int FLAG_POS = 9;
@@ -313,6 +337,9 @@ namespace SHADE
 
     dirtyFlags |= 1U << FLAG_POS;
     mass = newMass;
+
+    // Turn off automass
+    flags &= ~(1U << FLAG_POS);
   }
 
   void SHRigidBodyComponent::SetDrag(float newDrag) noexcept
@@ -467,6 +494,8 @@ RTTR_REGISTRATION
     .property("Angular Drag"      , &SHRigidBodyComponent::GetAngularDrag     , &SHRigidBodyComponent::SetAngularDrag     )
     .property("Use Gravity"       , &SHRigidBodyComponent::IsGravityEnabled   , &SHRigidBodyComponent::SetGravityEnabled  )
     .property("Interpolate"       , &SHRigidBodyComponent::IsInterpolating    , &SHRigidBodyComponent::SetInterpolate     )
+    .property("Sleeping Enabled"  , &SHRigidBodyComponent::IsAllowedToSleep   , &SHRigidBodyComponent::SetIsAllowedToSleep)
+    //.property("Auto Mass"         , &SHRigidBodyComponent::GetAutoMass        , &SHRigidBodyComponent::SetAutoMass        )
     .property("Freeze Position X" , &SHRigidBodyComponent::GetFreezePositionX , &SHRigidBodyComponent::SetFreezePositionX )
     .property("Freeze Position Y" , &SHRigidBodyComponent::GetFreezePositionY , &SHRigidBodyComponent::SetFreezePositionY )
     .property("Freeze Position Z" , &SHRigidBodyComponent::GetFreezePositionZ , &SHRigidBodyComponent::SetFreezePositionZ )

SHADE_Engine/src/Physics/Interface/SHRigidBodyComponent.h

@@ -71,19 +71,23 @@ namespace SHADE
     [[nodiscard]] bool                IsAllowedToSleep    ()  const noexcept;
     [[nodiscard]] bool                IsInterpolating     ()  const noexcept;
 
+    [[nodiscard]] bool                GetIsSleeping       ()  const noexcept;
+
     [[nodiscard]] Type                GetType             ()  const noexcept;
-    [[nodiscard]] float               GetMass             ()  const noexcept;
-    [[nodiscard]] float               GetDrag             ()  const noexcept;
-    [[nodiscard]] float               GetAngularDrag      ()  const noexcept;
 
     [[nodiscard]] bool                GetFreezePositionX  ()  const noexcept;
     [[nodiscard]] bool                GetFreezePositionY  ()  const noexcept;
     [[nodiscard]] bool                GetFreezePositionZ  ()  const noexcept;
-
     [[nodiscard]] bool                GetFreezeRotationX  ()  const noexcept;
     [[nodiscard]] bool                GetFreezeRotationY  ()  const noexcept;
     [[nodiscard]] bool                GetFreezeRotationZ  ()  const noexcept;
 
+    //[[nodiscard]] bool                GetAutoMass         ()  const noexcept;
+
+    [[nodiscard]] float               GetMass             ()  const noexcept;
+    [[nodiscard]] float               GetDrag             ()  const noexcept;
+    [[nodiscard]] float               GetAngularDrag      ()  const noexcept;
+
     [[nodiscard]] SHVec3              GetForce            ()  const noexcept;
     [[nodiscard]] SHVec3              GetTorque           ()  const noexcept;
     [[nodiscard]] SHVec3              GetLinearVelocity   ()  const noexcept;
@@ -108,6 +112,7 @@ namespace SHADE
     void SetFreezeRotationY   (bool freezeRotationY)              noexcept;
     void SetFreezeRotationZ   (bool freezeRotationZ)              noexcept;
     void SetInterpolate       (bool allowInterpolation)           noexcept;
+    //void SetAutoMass          (bool autoMass)                     noexcept;
 
     void SetMass              (float newMass)                     noexcept;
     void SetDrag              (float newDrag)                     noexcept;
@@ -144,8 +149,7 @@ namespace SHADE
 
     Type              type;
 
-    bool              interpolate;
+    uint16_t          flags;          // 0 0 0 0 0 0 am ip aZ aY aX lZ lY lX slp g
-    uint8_t           flags;          // aZ aY aX lZ lY lX slp g
     uint16_t          dirtyFlags;     // 0 0 0 0 aD d m t aZ aY aX lZ lY lX slp g
 
     float             mass;

SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObject.cpp

@@ -109,8 +109,17 @@ namespace SHADE
     {
       // TODO(Diren): Add more collider shapes
 
-      case SHCollisionShape::Type::BOX:     addBoxShape(collisionShape);    break;
+      case SHCollisionShape::Type::BOX:
-      case SHCollisionShape::Type::SPHERE:  addSphereShape(collisionShape); break;
+      {
+        addBoxShape(collisionShape);
+        break;
+      }
+      
+      case SHCollisionShape::Type::SPHERE:
+      {
+        addSphereShape(collisionShape);
+        break;
+      }
       default: break;
     }
 
@@ -245,9 +254,17 @@ namespace SHADE
           }
           case 9:   // Mass
           {
+            //if (component.GetAutoMass())
+            //{
+            //  rp3dBody->updateMassPropertiesFromColliders();
+            //  component.mass = rp3dBody->getMass();
+            //}
+            //else
+            //{
               rp3dBody->setMass(component.mass);
               rp3dBody->updateLocalCenterOfMassFromColliders();
               rp3dBody->updateLocalInertiaTensorFromColliders();
+            //}
 
             break;
           }

SHADE_Engine/src/Physics/SHPhysicsWorld.h

@@ -38,8 +38,8 @@ namespace SHADE
       /*-------------------------------------------------------------------------------*/
 
       SHVec3    gravity                     = SHVec3{ 0.0f, -9.81f, 0.0f };
-      uint16_t  numVelocitySolverIterations = 15;
+      uint16_t  numVelocitySolverIterations = 10;
-      uint16_t  numPositionSolverIterations = 8;
+      uint16_t  numPositionSolverIterations = 5;
       bool      sleepingEnabled             = true;
     };
 

SHADE_Engine/src/Physics/System/SHPhysicsDebugDrawSystem.cpp

@@ -24,7 +24,7 @@ namespace SHADE
   /* Static Data Member Definitions                                                    */
   /*-----------------------------------------------------------------------------------*/
 
-  const SHPhysicsDebugDrawSystem::DebugDrawFunction SHPhysicsDebugDrawSystem::drawFunctions[SHPhysicsDebugDrawSystem::NUM_FLAGS] =
+  const SHPhysicsDebugDrawSystem::DebugDrawFunction SHPhysicsDebugDrawSystem::drawFunctions[NUM_FLAGS] =
   {
     SHPhysicsDebugDrawSystem::drawColliders
   , SHPhysicsDebugDrawSystem::drawColliderAABBs
@@ -33,6 +33,8 @@ namespace SHADE
   , SHPhysicsDebugDrawSystem::drawContactNormals
   };
 
+  SHVec3 SHPhysicsDebugDrawSystem::boxVertices[NUM_BOX_VERTICES];
+
   /*-----------------------------------------------------------------------------------*/
   /* Constructors & Destructor Definitions                                             */
   /*-----------------------------------------------------------------------------------*/
@@ -42,7 +44,7 @@ namespace SHADE
   , physicsSystem     { nullptr }
   , rp3dDebugRenderer { nullptr }
   {
-    debugColours[SHUtilities::ConvertEnum(DebugDrawFlags::COLLIDER)]          = 
+    debugColours[SHUtilities::ConvertEnum(DebugDrawFlags::COLLIDER)]          = SHColour::GREEN;
     debugColours[SHUtilities::ConvertEnum(DebugDrawFlags::COLLIDER_AABB)]     = SHColour::YELLOW;
     debugColours[SHUtilities::ConvertEnum(DebugDrawFlags::BROAD_PHASE_AABB)]  = SHColour::CYAN;
     debugColours[SHUtilities::ConvertEnum(DebugDrawFlags::CONTACT_POINTS)]    = SHColour::RED;
@@ -95,6 +97,9 @@ namespace SHADE
 
     SHASSERT(physicsSystem == nullptr, "Non-existent physics system attached to the physics debug draw system!")
     physicsSystem = SHSystemManager::GetSystem<SHPhysicsSystem>();
+
+    // Generate shapes
+    generateBox();
   }
 
   void SHPhysicsDebugDrawSystem::Exit()
@@ -159,21 +164,20 @@ namespace SHADE
     
   }
 
+  void SHPhysicsDebugDrawSystem::generateBox() noexcept
+  {
+    boxVertices[0] = {  0.5f,  0.5f, -0.5f  }; // TOP_RIGHT_BACK
+    boxVertices[1] = { -0.5f,  0.5f, -0.5f  }; // TOP_LEFT_BACK
+    boxVertices[2] = {  0.5f, -0.5f, -0.5f  }; // BTM_RIGHT_BACK
+    boxVertices[3] = { -0.5f, -0.5f, -0.5f  }; // BTM_LEFT_BACK
+    boxVertices[4] = {  0.5f,  0.5f,  0.5f  }; // TOP_RIGHT_FRONT
+    boxVertices[5] = { -0.5f,  0.5f,  0.5f  }; // TOP_LEFT_FRONT
+    boxVertices[6] = {  0.5f, -0.5f,  0.5f  }; // BTM_RIGHT_FRONT
+    boxVertices[7] = { -0.5f, -0.5f,  0.5f  }; // BTM_LEFT_FRONT
+  }
+
   void SHPhysicsDebugDrawSystem::debugDrawBox(const SHColliderComponent& colliderComponent, const SHCollisionShape& collisionShape) noexcept
   {
-    static constexpr uint32_t NUM_BOX_VERTICES = 8;
-    static const SHVec3 boxVertices[NUM_BOX_VERTICES]
-    {
-      {  0.5f,  0.5f, -0.5f  } // TOP_RIGHT_BACK
-    , { -0.5f,  0.5f, -0.5f  } // TOP_LEFT_BACK
-    , {  0.5f, -0.5f, -0.5f  } // BTM_RIGHT_BACK
-    , { -0.5f, -0.5f, -0.5f  } // BTM_LEFT_BACK
-    , {  0.5f,  0.5f,  0.5f  } // TOP_RIGHT_FRONT
-    , { -0.5f,  0.5f,  0.5f  } // TOP_LEFT_FRONT
-    , {  0.5f, -0.5f,  0.5f  } // BTM_RIGHT_FRONT
-    , { -0.5f, -0.5f,  0.5f  } // BTM_LEFT_FRONT
-    };
-
     auto* debugDrawSystem = SHSystemManager::GetSystem<SHDebugDrawSystem>();
     if (debugDrawSystem == nullptr)
     {
@@ -184,10 +188,16 @@ namespace SHADE
     auto* BOX = reinterpret_cast<const SHBox*>(collisionShape.GetShape());
 
     // Calculate final position & orientation
-    const SHVec3        FINAL_POS = colliderComponent.GetPosition() + collisionShape.GetPositionOffset();
+    const SHVec3        COLLIDER_POS  = colliderComponent.GetPosition();
-    const SHQuaternion  FINAL_ROT = colliderComponent.GetOrientation() * SHQuaternion::FromEuler(collisionShape.GetRotationOffset());
+    const SHVec3        BOX_POS       = collisionShape.GetPositionOffset();
+    const SHQuaternion  COLLIDER_ROT  = colliderComponent.GetOrientation();
+    const SHQuaternion  BOX_ROT       = SHQuaternion::FromEuler(collisionShape.GetRotationOffset());
 
-    const SHMatrix BOX_TRS = SHMatrix::Scale(BOX->GetWorldExtents() * 2.0f) * SHMatrix::Rotate(FINAL_ROT) * SHMatrix::Translate(FINAL_POS);
+
+    const SHMatrix COLLIDER_TR  = SHMatrix::Rotate(COLLIDER_ROT) * SHMatrix::Translate(COLLIDER_POS);
+    const SHMatrix BOX_TRS      = SHMatrix::Scale(BOX->GetWorldExtents() * 2.0f) * SHMatrix::Rotate(BOX_ROT) * SHMatrix::Translate(BOX_POS);
+
+    const SHMatrix FINAL_TRS = BOX_TRS * COLLIDER_TR;
 
     const SHColour COLLIDER_COLOUR = collisionShape.IsTrigger() ? SHColour::PURPLE : SHColour::GREEN;
 
@@ -197,8 +207,8 @@ namespace SHADE
       const uint32_t IDX1 = i;
       const uint32_t IDX2 = i + NUM_BOX_VERTICES / 2;
 
-      transformedVertices[IDX1] = SHVec3::Transform(boxVertices[IDX1], BOX_TRS);
+      transformedVertices[IDX1] = SHVec3::Transform(boxVertices[IDX1], FINAL_TRS);
-      transformedVertices[IDX2] = SHVec3::Transform(boxVertices[IDX2], BOX_TRS);
+      transformedVertices[IDX2] = SHVec3::Transform(boxVertices[IDX2], FINAL_TRS);
 
       // Draw 4 line to connect the quads
       debugDrawSystem->DrawLine(COLLIDER_COLOUR, transformedVertices[IDX1], transformedVertices[IDX2]);
@@ -207,6 +217,7 @@ namespace SHADE
     // A, B, C, D
     std::array backQuad { transformedVertices[0], transformedVertices[1], transformedVertices[3], transformedVertices[2] };
     debugDrawSystem->DrawPoly(COLLIDER_COLOUR, backQuad.begin(), backQuad.end());
+
     // E, F, G, H
     std::array frontQuad { transformedVertices[4], transformedVertices[5], transformedVertices[7], transformedVertices[6] };
     debugDrawSystem->DrawPoly(COLLIDER_COLOUR, frontQuad.begin(), frontQuad.end());
@@ -226,8 +237,10 @@ namespace SHADE
     const SHColour COLLIDER_COLOUR = collisionShape.IsTrigger() ? SHColour::PURPLE : SHColour::GREEN;
 
     // Calculate final position & orientation
-    const SHVec3 FINAL_POS = colliderComponent.GetPosition() + collisionShape.GetPositionOffset();
+    const SHQuaternion  FINAL_ROT = colliderComponent.GetOrientation() * SHQuaternion::FromEuler(collisionShape.GetRotationOffset());
-    debugDrawSystem->DrawSphere(COLLIDER_COLOUR, FINAL_POS, SPHERE->GetWorldRadius());
+    const SHMatrix      TR = SHMatrix::Rotate(FINAL_ROT) * SHMatrix::Translate(colliderComponent.GetPosition());
+
+    debugDrawSystem->DrawSphere(COLLIDER_COLOUR, SHVec3::Transform(collisionShape.GetPositionOffset(), TR), SPHERE->GetWorldRadius());
   }
 
 } // namespace SHADE

SHADE_Engine/src/Physics/System/SHPhysicsDebugDrawSystem.h

@@ -98,9 +98,14 @@ namespace SHADE
     /*---------------------------------------------------------------------------------*/
 
     static constexpr int NUM_FLAGS = SHUtilities::ConvertEnum(DebugDrawFlags::NUM_FLAGS);
-
     static const DebugDrawFunction  drawFunctions[NUM_FLAGS];
 
+    // SHAPES INFO
+
+    static constexpr size_t NUM_BOX_VERTICES    = 8;
+    static SHVec3 boxVertices[NUM_BOX_VERTICES];
+    
+
     uint8_t                 debugDrawFlags;
     SHPhysicsSystem*        physicsSystem;
     rp3d::DebugRenderer*    rp3dDebugRenderer;
@@ -110,12 +115,20 @@ namespace SHADE
     /* Function Members                                                                */
     /*---------------------------------------------------------------------------------*/
 
+    // Generic Draw Functions
+
     static void drawColliders       (rp3d::DebugRenderer* debugRenderer) noexcept;
     static void drawColliderAABBs   (rp3d::DebugRenderer* debugRenderer) noexcept;
     static void drawBroadPhaseAABBs (rp3d::DebugRenderer* debugRenderer) noexcept;
     static void drawContactPoints   (rp3d::DebugRenderer* debugRenderer) noexcept;
     static void drawContactNormals  (rp3d::DebugRenderer* debugRenderer) noexcept;
 
+    // Shape Generation Functions
+
+    static void generateBox         () noexcept;
+
+    // Shape Draw Functions
+
     static void debugDrawBox        (const SHColliderComponent& colliderComponent, const SHCollisionShape& collisionShape) noexcept;
     static void debugDrawSphere     (const SHColliderComponent& colliderComponent, const SHCollisionShape& collisionShape) noexcept;
   };

SHADE_Engine/src/Physics/System/SHPhysicsSystem.cpp

@@ -154,14 +154,32 @@ namespace SHADE
       auto* rigidBodyComponent = SHComponentManager::GetComponent_s<SHRigidBodyComponent>(entityID);
       auto* colliderComponent = SHComponentManager::GetComponent_s<SHColliderComponent>(entityID);
 
-      postUpdateSyncTransforms
+      const auto& CURRENT_TF = physicsObject.GetRigidBody()->getTransform();
-      (
+      const auto& RENDER_POS = CURRENT_TF.getPosition();
-        physicsObject
+      const auto& RENDER_ROT = CURRENT_TF.getOrientation();
-      , transformComponent
+
-      , rigidBodyComponent
+      // Cache transform
-      , colliderComponent
+      physicsObject.prevTransform = CURRENT_TF;
-      , 1.0   // We use 1.0 here to avoid any interpolation
+
-      );
+      // Sync with physics components
+      if (rigidBodyComponent && SHSceneManager::CheckNodeAndComponentsActive<SHRigidBodyComponent>(entityID))
+      {
+        rigidBodyComponent->position    = RENDER_POS;
+        rigidBodyComponent->orientation = RENDER_ROT;
+      }
+
+      if (colliderComponent && SHSceneManager::CheckNodeAndComponentsActive<SHColliderComponent>(entityID))
+      {
+        colliderComponent->position    = RENDER_POS;
+        colliderComponent->orientation = RENDER_ROT;
+      }
+
+      // Set transform for rendering
+      if (transformComponent)
+      {
+        transformComponent->SetWorldPosition(RENDER_POS);
+        transformComponent->SetWorldOrientation(RENDER_ROT);
+      }
     }
   }
 
@@ -337,93 +355,4 @@ namespace SHADE
     return onStopEvent->handle;
   }
 
-  void SHPhysicsSystem::preUpdateSyncTransform
-  (
-    SHPhysicsObject&      physicsObject
-  , SHTransformComponent* transformComponent
-  , SHRigidBodyComponent* rigidBodyComponent
-  , SHColliderComponent*  colliderComponent
-  ) noexcept
-  {
-    if (!transformComponent)
-      return;
-
-    const SHVec3&       WORLD_POS = transformComponent->GetWorldPosition();
-    const SHQuaternion& WORLD_ROT = transformComponent->GetWorldOrientation();
-    const SHVec3&       WORLD_SCL = transformComponent->GetWorldScale();
-
-    const rp3d::Transform RP3D_TRANSFORM { WORLD_POS, WORLD_ROT };
-    physicsObject.GetRigidBody()->setTransform(RP3D_TRANSFORM);
-
-    if (rigidBodyComponent && SHSceneManager::CheckNodeAndComponentsActive<SHRigidBodyComponent>(physicsObject.entityID))
-    {
-      rigidBodyComponent->position    = WORLD_POS;
-      rigidBodyComponent->orientation = WORLD_ROT;
-    }
-
-    if (colliderComponent && SHSceneManager::CheckNodeAndComponentsActive<SHColliderComponent>(physicsObject.entityID))
-    {
-      colliderComponent->position     = WORLD_POS;
-      colliderComponent->orientation  = WORLD_ROT;
-      colliderComponent->scale        = WORLD_SCL;
-
-      colliderComponent->RecomputeCollisionShapes();
-    }
-  }
-
-  void SHPhysicsSystem::postUpdateSyncTransforms
-  (
-    SHPhysicsObject&      physicsObject 
-  , SHTransformComponent* transformComponent
-  , SHRigidBodyComponent* rigidBodyComponent
-  , SHColliderComponent*  colliderComponent
-  , double                interpolationFactor
-  ) noexcept
-  {
-    const rp3d::Transform& CURRENT_TF = physicsObject.GetRigidBody()->getTransform();
-    auto  renderPos = CURRENT_TF.getPosition();
-    auto  renderRot = CURRENT_TF.getOrientation();
-
-    // Cache transforms
-    if (physicsObject.GetRigidBody()->isActive())
-      physicsObject.prevTransform = CURRENT_TF;
-
-    // Sync with rigid bodies
-    if (rigidBodyComponent && SHSceneManager::CheckNodeAndComponentsActive<SHRigidBodyComponent>(physicsObject.entityID))
-    {
-      // Skip static bodies
-      if (rigidBodyComponent->GetType() == SHRigidBodyComponent::Type::STATIC)
-        return;
-
-      // Check if transform should be interpolated
-      if (rigidBodyComponent->IsInterpolating())
-      {
-        // Interpolate transforms between current and predicted next transform
-
-        const rp3d::Transform PREV_TF         = physicsObject.prevTransform;
-        const rp3d::Transform INTERPOLATED_TF = rp3d::Transform::interpolateTransforms(PREV_TF, CURRENT_TF, static_cast<rp3d::decimal>(interpolationFactor));
-
-        renderPos = INTERPOLATED_TF.getPosition();
-        renderRot = INTERPOLATED_TF.getOrientation();
-      }
-
-      rigidBodyComponent->position     = CURRENT_TF.getPosition();
-      rigidBodyComponent->orientation  = CURRENT_TF.getOrientation();
-    }
-
-    // Sync with colliders
-    if (colliderComponent && SHSceneManager::CheckNodeAndComponentsActive<SHColliderComponent>(physicsObject.entityID))
-    {
-      colliderComponent->position     = CURRENT_TF.getPosition();
-      colliderComponent->orientation  = CURRENT_TF.getOrientation();
-    }
-
-    // Set transform for rendering
-    if (transformComponent)
-    {
-      transformComponent->SetWorldPosition(renderPos);
-      transformComponent->SetWorldOrientation(renderRot);
-    }
-  }
-
 } // namespace SHADE

SHADE_Engine/src/Physics/System/SHPhysicsSystem.h

@@ -113,6 +113,14 @@ namespace SHADE
       void        syncRigidBodyActive (EntityID eid, SHPhysicsObject& physicsObject)  const noexcept;
       void        syncColliderActive  (EntityID eid, SHPhysicsObject& physicsObject)  const noexcept;
       static void syncOnPlay          (EntityID eid, SHPhysicsObject& physicsObject)  noexcept;
+
+      static void preUpdateSyncTransform
+      (
+        SHPhysicsObject&      physicsObject 
+      , SHTransformComponent* transformComponent
+      , SHRigidBodyComponent* rigidBodyComponent
+      , SHColliderComponent*  colliderComponent
+      ) noexcept;
     };
 
     class SH_API PhysicsFixedUpdate final : public SHFixedSystemRoutine
@@ -145,6 +153,21 @@ namespace SHADE
       /*-------------------------------------------------------------------------------*/
 
       void Execute(double dt) noexcept override;
+
+    private:
+
+      /*-------------------------------------------------------------------------------*/
+      /* Function Members                                                              */
+      /*-------------------------------------------------------------------------------*/
+
+      static void postUpdateSyncTransforms
+      (
+        SHPhysicsObject&      physicsObject 
+      , SHTransformComponent* transformComponent
+      , SHRigidBodyComponent* rigidBodyComponent
+      , SHColliderComponent*  colliderComponent
+      , double                interpolationFactor
+      ) noexcept;
     };
 
   private:
@@ -178,24 +201,5 @@ namespace SHADE
     SHEventHandle     onPlay                  (SHEventPtr onPlayEvent);
     SHEventHandle     onStop                  (SHEventPtr onStopEvent);
 
-    
-
-    static void preUpdateSyncTransform
-    (
-      SHPhysicsObject&      physicsObject 
-    , SHTransformComponent* transformComponent
-    , SHRigidBodyComponent* rigidBodyComponent
-    , SHColliderComponent*  colliderComponent
-    ) noexcept;
-
-    static void postUpdateSyncTransforms
-    (
-      SHPhysicsObject&      physicsObject 
-    , SHTransformComponent* transformComponent
-    , SHRigidBodyComponent* rigidBodyComponent
-    , SHColliderComponent*  colliderComponent
-    , double                interpolationFactor
-    ) noexcept;
-
   };
 } // namespace SHADE

SHADE_Engine/src/Physics/System/SHPhysicsSystemRoutines.cpp

@@ -262,4 +262,94 @@ namespace SHADE
     if (colliderComponent)
       physicsObject.SyncColliders(*colliderComponent);
   }
+
+  void SHPhysicsSystem::PhysicsPreUpdate::preUpdateSyncTransform
+  (
+    SHPhysicsObject&      physicsObject
+  , SHTransformComponent* transformComponent
+  , SHRigidBodyComponent* rigidBodyComponent
+  , SHColliderComponent*  colliderComponent
+  ) noexcept
+  {
+    if (!transformComponent)
+      return;
+
+    const SHVec3&       WORLD_POS = transformComponent->GetWorldPosition();
+    const SHQuaternion& WORLD_ROT = transformComponent->GetWorldOrientation();
+    const SHVec3&       WORLD_SCL = transformComponent->GetWorldScale();
+
+    const rp3d::Transform RP3D_TRANSFORM { WORLD_POS, WORLD_ROT };
+    physicsObject.GetRigidBody()->setTransform(RP3D_TRANSFORM);
+    physicsObject.prevTransform = RP3D_TRANSFORM;
+
+    if (rigidBodyComponent && SHSceneManager::CheckNodeAndComponentsActive<SHRigidBodyComponent>(physicsObject.entityID))
+    {
+      rigidBodyComponent->position    = WORLD_POS;
+      rigidBodyComponent->orientation = WORLD_ROT;
+    }
+
+    if (colliderComponent && SHSceneManager::CheckNodeAndComponentsActive<SHColliderComponent>(physicsObject.entityID))
+    {
+      colliderComponent->position     = WORLD_POS;
+      colliderComponent->orientation  = WORLD_ROT;
+      colliderComponent->scale        = WORLD_SCL;
+
+      colliderComponent->RecomputeCollisionShapes();
+    }
+  }
+
+  void SHPhysicsSystem::PhysicsPostUpdate::postUpdateSyncTransforms
+  (
+    SHPhysicsObject&      physicsObject 
+  , SHTransformComponent* transformComponent
+  , SHRigidBodyComponent* rigidBodyComponent
+  , SHColliderComponent*  colliderComponent
+  , double                interpolationFactor
+  ) noexcept
+  {
+    const rp3d::Transform& CURRENT_TF = physicsObject.GetRigidBody()->getTransform();
+    auto  renderPos = CURRENT_TF.getPosition();
+    auto  renderRot = CURRENT_TF.getOrientation();
+
+    // Cache transforms
+    if (physicsObject.GetRigidBody()->isActive())
+      physicsObject.prevTransform = CURRENT_TF;
+
+    // Sync with rigid bodies
+    if (rigidBodyComponent && SHSceneManager::CheckNodeAndComponentsActive<SHRigidBodyComponent>(physicsObject.entityID))
+    {
+      // Skip static bodies
+      if (rigidBodyComponent->GetType() == SHRigidBodyComponent::Type::STATIC)
+        return;
+
+      // Check if transform should be interpolated
+      if (rigidBodyComponent->IsInterpolating())
+      {
+        // Interpolate transforms between current and predicted next transform
+
+        const rp3d::Transform PREV_TF         = physicsObject.prevTransform;
+        const rp3d::Transform INTERPOLATED_TF = rp3d::Transform::interpolateTransforms(PREV_TF, CURRENT_TF, static_cast<rp3d::decimal>(interpolationFactor));
+
+        renderPos = INTERPOLATED_TF.getPosition();
+        renderRot = INTERPOLATED_TF.getOrientation();
+      }
+
+      rigidBodyComponent->position     = CURRENT_TF.getPosition();
+      rigidBodyComponent->orientation  = CURRENT_TF.getOrientation();
+    }
+
+    // Sync with colliders
+    if (colliderComponent && SHSceneManager::CheckNodeAndComponentsActive<SHColliderComponent>(physicsObject.entityID))
+    {
+      colliderComponent->position     = CURRENT_TF.getPosition();
+      colliderComponent->orientation  = CURRENT_TF.getOrientation();
+    }
+
+    // Set transform for rendering
+    if (transformComponent)
+    {
+      transformComponent->SetWorldPosition(renderPos);
+      transformComponent->SetWorldOrientation(renderRot);
+    }
+  }
 } // namespace SHADE

SHADE_Managed/src/Components/Collider.cxx

@@ -20,7 +20,7 @@ of DigiPen Institute of Technology is prohibited.
 namespace SHADE
 {
     /*---------------------------------------------------------------------------------*/
-    /* ColliderBound - Constructors                                                    */
+    /* CollisionShape - Constructors                                                   */
     /*---------------------------------------------------------------------------------*/
     CollisionShape::CollisionShape(int arrayIdx, Entity attachedEntity)
     : arrayIndex { arrayIdx }
@@ -28,102 +28,183 @@ namespace SHADE
     {}
 
     /*---------------------------------------------------------------------------------*/
-    /* ColliderBound - Setter Functions                                                */
+    /* CollisionShape - Properties                                                     */
+    /*---------------------------------------------------------------------------------*/
+
+    bool CollisionShape::IsTrigger::get()
+    {
+       return getNativeCollisionShape().IsTrigger();
+    }
+
+    void CollisionShape::IsTrigger::set(bool value)
+    {
+      getNativeCollisionShape().SetIsTrigger(value);
+    }
+
+    Vector3 CollisionShape::PositionOffset::get()
+    {
+      return Convert::ToCLI(getNativeCollisionShape().GetPositionOffset());
+    }
+
+    void CollisionShape::PositionOffset::set(Vector3 value)
+    {
+      getNativeCollisionShape().SetPositionOffset(Convert::ToNative(value));
+    }
+
+    Vector3 CollisionShape::RotationOffset::get()
+    {
+      return Convert::ToCLI(getNativeCollisionShape().GetRotationOffset());
+    }
+
+    void CollisionShape::RotationOffset::set(Vector3 value)
+    {
+      getNativeCollisionShape().SetRotationOffset(Convert::ToNative(value));
+    }
+
+    float CollisionShape::Friction::get()
+    {
+      return getNativeCollisionShape().GetFriction();
+    }
+
+    void CollisionShape::Friction::set(float value)
+    {
+      getNativeCollisionShape().SetFriction(value);
+    }
+
+    float CollisionShape::Bounciness::get()
+    {
+      return getNativeCollisionShape().GetBounciness();
+    }
+
+    void CollisionShape::Bounciness::set(float value)
+    {
+      getNativeCollisionShape().SetBounciness(value);
+    }
+
+    float CollisionShape::Density::get()
+    {
+      return getNativeCollisionShape().GetDensity();
+    }
+
+    void CollisionShape::Density::set(float value)
+    {
+      getNativeCollisionShape().SetDensity(value);
+    }
+
+    /*---------------------------------------------------------------------------------*/
+    /* CollisionShape - helper Functions                                               */
     /*---------------------------------------------------------------------------------*/
     void CollisionShape::updateArrayIndex(int index)
     {
         arrayIndex = index;
     }
 
+    SHCollisionShape& SHADE::CollisionShape::getNativeCollisionShape()
+    {
+      SHColliderComponent* collider = SHComponentManager::GetComponent_s<SHColliderComponent>(entity);
+      if (!collider)
+          throw gcnew System::InvalidOperationException("Unable to retrieve Collider component!");
+
+      try
+      {
+        auto& shape = collider->GetCollisionShape(arrayIndex);
+        return shape;
+      }
+      catch (std::invalid_argument&)
+      {
+        throw gcnew System::IndexOutOfRangeException("Attempted to retrieve out of range CollisionShape!");
+      }
+    }
+
     /*---------------------------------------------------------------------------------*/
-    /* BoxColliderBound - Constructors                                                 */
+    /* BoxCollider - Constructors                                                      */
     /*---------------------------------------------------------------------------------*/
     BoxCollider::BoxCollider(int arrayIdx, Entity attachedEntity)
     : CollisionShape { arrayIndex, attachedEntity }
     {}
 
     /*---------------------------------------------------------------------------------*/
-    /* BoxColliderBound - Properties                                                   */
+    /* BoxCollider - Properties                                                        */
     /*---------------------------------------------------------------------------------*/
     Vector3 BoxCollider::Center::get()
     {
-        return Convert::ToCLI(getNativeBoundObject<SHBox>().GetCenter());
+        return Convert::ToCLI(getNativeCollisionShape<SHBox>().GetCenter());
     }
     void BoxCollider::Center::set(Vector3 value)
     {
-        getNativeBoundObject<SHBox>().SetCenter(Convert::ToNative(value));
+        getNativeCollisionShape<SHBox>().SetCenter(Convert::ToNative(value));
     }
     Vector3 BoxCollider::HalfExtents::get()
     {
-        return Convert::ToCLI(getNativeBoundObject<SHBox>().GetWorldExtents());
+        return Convert::ToCLI(getNativeCollisionShape<SHBox>().GetWorldExtents());
     }
     void BoxCollider::HalfExtents::set(Vector3 value)
     {
-        getNativeBoundObject<SHBox>().SetWorldExtents(Convert::ToNative(value));
+        getNativeCollisionShape<SHBox>().SetWorldExtents(Convert::ToNative(value));
     }
     Vector3 BoxCollider::Min::get()
     {
-        return Convert::ToCLI(getNativeBoundObject<SHBox>().GetMin());
+        return Convert::ToCLI(getNativeCollisionShape<SHBox>().GetMin());
     }
     void BoxCollider::Min::set(Vector3 value)
     {
-        getNativeBoundObject<SHBox>().SetMin(Convert::ToNative(value));
+        getNativeCollisionShape<SHBox>().SetMin(Convert::ToNative(value));
     }
     Vector3 BoxCollider::Max::get()
     {
-        return Convert::ToCLI(getNativeBoundObject<SHBox>().GetMax());
+        return Convert::ToCLI(getNativeCollisionShape<SHBox>().GetMax());
     }
     void BoxCollider::Max::set(Vector3 value)
     {
-        getNativeBoundObject<SHBox>().SetMax(Convert::ToNative(value));
+        getNativeCollisionShape<SHBox>().SetMax(Convert::ToNative(value));
     }
 
     /*---------------------------------------------------------------------------------*/
-    /* BoxColliderBound - Usage Functions                                              */
+    /* BoxCollider - Usage Functions                                                   */
     /*---------------------------------------------------------------------------------*/
     bool BoxCollider::TestPoint(Vector3 point)
     {
-        return getNativeBoundObject<SHBox>().TestPoint(Convert::ToNative(point));
+        return getNativeCollisionShape<SHBox>().TestPoint(Convert::ToNative(point));
     }
     bool BoxCollider::Raycast(Ray ray, float maxDistance)
     {
-        return getNativeBoundObject<SHBox>().Raycast(Convert::ToNative(ray), maxDistance);
+        return getNativeCollisionShape<SHBox>().Raycast(Convert::ToNative(ray), maxDistance);
     }
 
     /*---------------------------------------------------------------------------------*/
-    /* BoxColliderBound - Properties                                                   */
+    /* SphereCollider - Properties                                                     */
     /*---------------------------------------------------------------------------------*/
     Vector3 SphereCollider::Center::get()
     {
-        return Convert::ToCLI(getNativeBoundObject<SHSphere>().GetCenter());
+        return Convert::ToCLI(getNativeCollisionShape<SHSphere>().GetCenter());
     }
     void SphereCollider::Center::set(Vector3 value)
     {
-        getNativeBoundObject<SHSphere>().SetCenter(Convert::ToNative(value));
+        getNativeCollisionShape<SHSphere>().SetCenter(Convert::ToNative(value));
     }
     float SphereCollider::Radius::get()
     {
-        return getNativeBoundObject<SHSphere>().GetWorldRadius();
+        return getNativeCollisionShape<SHSphere>().GetWorldRadius();
     }
     void SphereCollider::Radius::set(float value)
     {
-        getNativeBoundObject<SHSphere>().SetWorldRadius(value);
+        getNativeCollisionShape<SHSphere>().SetWorldRadius(value);
     }
 
     /*---------------------------------------------------------------------------------*/
-    /* SphereColliderBound - Usage Functions                                           */
+    /* SphereCollider - Usage Functions                                                */
     /*---------------------------------------------------------------------------------*/
     bool SphereCollider::TestPoint(Vector3 point)
     {
-        return getNativeBoundObject<SHBox>().TestPoint(Convert::ToNative(point));
+        return getNativeCollisionShape<SHBox>().TestPoint(Convert::ToNative(point));
     }
     bool SphereCollider::Raycast(Ray ray, float maxDistance)
     {
-        return getNativeBoundObject<SHBox>().Raycast(Convert::ToNative(ray), maxDistance);
+        return getNativeCollisionShape<SHBox>().Raycast(Convert::ToNative(ray), maxDistance);
     }
 
     /*---------------------------------------------------------------------------------*/
-    /* SphereColliderBound - Constructors                                              */
+    /* SphereCollider - Constructors                                                   */
     /*---------------------------------------------------------------------------------*/
     SphereCollider::SphereCollider(int arrayIndex, Entity attachedEntity)
     : CollisionShape{ arrayIndex, attachedEntity }
@@ -154,7 +235,7 @@ namespace SHADE
     }
 
     /*---------------------------------------------------------------------------------*/
-    /* Collider - ColliderBound Functions                                              */
+    /* Collider - Collider Functions                                                   */
     /*---------------------------------------------------------------------------------*/
     CollisionShape^ Collider::GetCollisionShape(int index)
     {
@@ -166,7 +247,7 @@ namespace SHADE
 
         // Check if valid
         if (index < 0 || index >= subColliderList->Count)
-            throw gcnew System::ArgumentException("[Collider] Invalid index for Collider Bound retrieval.");
+            throw gcnew System::ArgumentException("[Collider] Invalid index for Collision Shape retrieval.");
 
         // Return the bound
         return subColliderList[index];
@@ -217,7 +298,7 @@ namespace SHADE
         {
             collidersList->Remove(wr);
         }
-        SAFE_NATIVE_CALL_END("Collider.OnColliderBoundChanged")
+        SAFE_NATIVE_CALL_END("Collider.OnCollisionShapeChanged")
     }
 
     void Collider::updateSubColliderList()

SHADE_Managed/src/Components/Collider.h++

@@ -19,7 +19,7 @@ of DigiPen Institute of Technology is prohibited.
 namespace SHADE
 {
     template<typename CollisionShapeType>
-    CollisionShapeType& SHADE::CollisionShape::getNativeBoundObject()
+    CollisionShapeType& SHADE::CollisionShape::getNativeCollisionShape()
     {
         SHColliderComponent* collider = SHComponentManager::GetComponent_s<SHColliderComponent>(entity);
         if (!collider)
@@ -29,13 +29,13 @@ namespace SHADE
         {
             auto& shape = collider->GetCollisionShape(arrayIndex);
             if (shape.GetType() != SHCollisionShape::Type::BOX)
-                throw gcnew System::InvalidOperationException("Attempted to retrieve invalid ColliderBound.");
+                throw gcnew System::InvalidOperationException("Attempted to retrieve invalid CollisionShape.");
 
             return reinterpret_cast<CollisionShapeType&>(shape);
         }
         catch (std::invalid_argument&)
         {
-            throw gcnew System::IndexOutOfRangeException("Attempted to retrieve out of range ColliderBound!");
+            throw gcnew System::IndexOutOfRangeException("Attempted to retrieve out of range CollisionShape!");
         }
     }
 }

SHADE_Managed/src/Components/Collider.hxx

@@ -30,6 +30,61 @@ namespace SHADE
     public ref class CollisionShape abstract
     {
       public:
+        /*-----------------------------------------------------------------------------*/
+        /* Properties                                                                  */
+        /*-----------------------------------------------------------------------------*/
+
+        /// <summary>
+        /// Whether or not this CollisionShape is a trigger.
+        /// </summary>
+        property bool IsTrigger
+        {
+          bool get();
+          void set(bool value);
+        }
+        /// <summary>
+        /// The positional offset of this collision shape from the transform's position.
+        /// </summary>
+        property Vector3 PositionOffset
+        {
+          Vector3 get();
+          void set(Vector3 value);
+        }
+        /// <summary>
+        /// The rotational offset of this collision shape from the transform's rotation.
+        /// </summary>
+        property Vector3 RotationOffset
+        {
+          Vector3 get();
+          void set(Vector3 value);
+        }
+
+        // TODO(Diren): Swap this to Physics Materials once asset implementation for that is done
+        /// <summary>
+        /// The frictional coefficient of the shape. Clamped between 0 and 1.
+        /// </summary>
+        property float Friction
+        {
+          float get();
+          void set(float value);
+        }
+        /// <summary>
+        /// The bounciness factor of the shape. Clamped between 0 and 1.
+        /// </summary>
+        property float Bounciness
+        {
+          float get();
+          void set(float value);
+        }
+        /// <summary>
+        /// The mass density of this shape. Cannot be negative.
+        /// </summary>
+        property float Density
+        {
+          float get();
+          void set(float value);
+        }
+
         /*-----------------------------------------------------------------------------*/
         /* Usage Functions                                                             */
         /*-----------------------------------------------------------------------------*/
@@ -63,13 +118,18 @@ namespace SHADE
         /* Helper Functions                                                            */
         /*-----------------------------------------------------------------------------*/
         template<typename CollisionShapeType>
-        CollisionShapeType& getNativeBoundObject();
+        CollisionShapeType& getNativeCollisionShape();
 
       internal:
         /*-----------------------------------------------------------------------------*/
         /* Setter Functions                                                            */
         /*-----------------------------------------------------------------------------*/
         void updateArrayIndex(int index);
+
+        /*-----------------------------------------------------------------------------*/
+        /* Helper Functions                                                            */
+        /*-----------------------------------------------------------------------------*/
+        SHCollisionShape& getNativeCollisionShape();
     };
 
     /// <summary>
@@ -205,18 +265,18 @@ namespace SHADE
         /* Usage Functions                                                             */
         /*-----------------------------------------------------------------------------*/
         /// <summary>
-        /// Retrieves a ColliderBound at the specified index in the ColliderBound list.
+        /// Retrieves a CollisionShape at the specified index in the CollisionShapes list.
         /// </summary>
         /// <param name="index">Index to retrieve a ColliderBound from.</param>
         /// <returns>ColliderBound for the specified index.</returns>
         CollisionShape^ GetCollisionShape(int index);
         /// <summary>
-        /// Retrieves a ColliderBound at the specified index in the ColliderBound list 
+        /// Retrieves a CollisionShape at the specified index in the CollisionShapes list 
         /// and casts it to the appropriate type.
         /// </summary>
-        /// <typeparam name="T">Type of the ColliderBound to cast to.</typeparam>
+        /// <typeparam name="T">Type of the CollisionShape to cast to.</typeparam>
-        /// <param name="index">Index to retrieve a ColliderBound from.</param>
+        /// <param name="index">Index to retrieve a CollisionShape from.</param>
-        /// <returns>ColliderBound for the specified index.</returns>
+        /// <returns>CollisionShape for the specified index.</returns>
         generic<typename T> where T:CollisionShape
         T GetCollisionShape(int index);