Merge branch 'main' into Revert-Revert-SHPhysics

Assets/Materials/UI/UIMat_Black.shmat

@@ -1,6 +1,6 @@
 - VertexShader: 46580970
   FragmentShader: 50110174
-  SubPass: UI
+  SubPass: UI Translucent
   Properties:
     data.color: {x: 0, y: 0, z: 0, w: 1}
     data.textureIndex: 0

Assets/Scenes/PhysicsTest.shade

@@ -10,9 +10,12 @@
       IsActive: true
     RigidBody Component:
       Type: Dynamic
+      Auto Mass: false
+      Mass: 1
       Drag: 0.00999999978
       Angular Drag: 0.100000001
       Use Gravity: true
+      Gravity Scale: 1
       Interpolate: false
       Sleeping Enabled: true
       Freeze Position X: false
@@ -75,10 +78,10 @@
       Yaw: 0
       Roll: 0
       Width: 1920
-      Height: 1080
       Near: 0.00999999978
       Far: 10000
       Perspective: true
+      FOV: 90
       IsActive: true
   Scripts: ~
 - EID: 65539
@@ -185,9 +188,12 @@
       IsActive: true
     RigidBody Component:
       Type: Dynamic
+      Auto Mass: false
+      Mass: 1
       Drag: 0.00999999978
       Angular Drag: 0.100000001
       Use Gravity: true
+      Gravity Scale: 1
       Interpolate: true
       Sleeping Enabled: true
       Freeze Position X: false

Assets/Scripts/Gameplay/AIBehaviour/Implemented/LeafNodes/LeafChase.cs

@@ -1,4 +1,4 @@
-/*********************************************************************
+/*********************************************************************
  * \file   LeafChase.cs
  * \author Ryan Wang Nian Jing
  * \brief  Leaf node implementation for AI chasing the player
@@ -113,7 +113,8 @@ public partial class LeafChase : BehaviourTreeNode
       if (GetNodeData("isAlert") != null && (bool)GetNodeData("isAlert") == true)
       {
         //AudioHandler.audioClipHandlers["BGMAdpative"].SetParameter("Detected", 0.0f);
-        Audio.SetParameter("Detected", 0.0f);
+        //Audio.SetParameter("Detected", 0.0f);
+        Audio.SetParameterWithLabel("PlayerDetection", "Undetected");
         AudioHandler.audioClipHandlers["SFXHumming"].Play();
       }
       SetNodeData("isAlert", false);

Assets/Scripts/Gameplay/AIBehaviour/Implemented/LeafNodes/LeafPatrol.cs

@@ -1,4 +1,4 @@
-/*********************************************************************
+/*********************************************************************
  * \file   LeafPatrol.cs
  * \author Ryan Wang Nian Jing
  * \brief  Leaf node implementation for patrolling AI
@@ -245,7 +245,8 @@ public partial class LeafPatrol : BehaviourTreeNode
               AudioHandler.audioClipHandlers["SFXHumming"].Play();
               //AudioHandler.audioClipHandlers["BGMUnalert"].Play();
               //AudioHandler.audioClipHandlers["BGMAdaptive"].SetParameter("Detected", 0.0f);
-              Audio.SetParameter("Detected", 0.0f);
+              //Audio.SetParameter("Detected", 0.0f);
+              Audio.SetParameterWithLabel("PlayerDetection", "Undetected");
             }
             SetNodeData("isAlert", false);
           }

Assets/Scripts/Gameplay/AIBehaviour/Implemented/LeafNodes/LeafSearch.cs

@@ -1,4 +1,4 @@
-/*********************************************************************
+/*********************************************************************
  * \file   LeafSearch.cs
  * \author Ryan Wang Nian Jing
  * \brief  Leaf node implementation for AI searching for player
@@ -26,6 +26,7 @@ public partial class LeafSearch : BehaviourTreeNode
   private Vector3 eyeOffset;
   private float sightDistance;
   private GameObject? player; //To be searched for and marked
+  private bool screamOnce;
 }
 
 //FUNCTIONS HERE
@@ -67,7 +68,8 @@ public partial class LeafSearch : BehaviourTreeNode
     if (GetNodeData("isAlert") != null && (bool)GetNodeData("isAlert") == true)
     {
       //AudioHandler.audioClipHandlers["BGMAdaptive"].SetParameter("Detected", 0.0f);
-      Audio.SetParameter("Detected", 0.0f);
+      //Audio.SetParameter("Detected", 0.0f);
+      Audio.SetParameterWithLabel("PlayerDetection", "Undetected");
       AudioHandler.audioClipHandlers["SFXHumming"].Play();
       reevaluateWaypoint();
     }
@@ -97,6 +99,7 @@ public partial class LeafSearch : BehaviourTreeNode
 
     //Search for player
     player = GameObject.Find("Player");
+    screamOnce = false;
 
     //Automatically fail if no player is found
     if (player == null)
@@ -188,31 +191,41 @@ public partial class LeafSearch : BehaviourTreeNode
       if (GetNodeData("isAlert") == null)
       {
         SetNodeData("isAlert", true);
+        screamOnce = true;
         //Audio.StopAllSounds();
-        AudioHandler.audioClipHandlers["SFXDetectAh"].Play();
+        //AudioHandler.audioClipHandlers["SFXDetectAh"].Play();
         AudioHandler.audioClipHandlers["SFXDetectSting"].Play();
         //AudioHandler.audioClipHandlers["BGMAlert"].Play();
         AudioHandler.audioClipHandlers["SFXHumming"].Stop(false);
         //AudioHandler.audioClipHandlers["BGMUnalert"].Stop(true);
         //AudioHandler.audioClipHandlers["BGMAdaptive"].SetParameter("Detected", 1.0f);
-        Audio.SetParameter("Detected", 1.0f);
+        //Audio.SetParameter("Detected", 1.0f);
+        Audio.SetParameterWithLabel("PlayerDetection", "Detected");
       }
       else
       {
         if (GetNodeData("isAlert") != null && (bool)GetNodeData("isAlert") == false)
         {
           //Audio.StopAllSounds();
-          AudioHandler.audioClipHandlers["SFXDetectAh"].Play();
+          screamOnce = true;
+          //AudioHandler.audioClipHandlers["SFXDetectAh"].Play();
           AudioHandler.audioClipHandlers["SFXDetectSting"].Play();
           //AudioHandler.audioClipHandlers["BGMAlert"].Play();
           AudioHandler.audioClipHandlers["SFXHumming"].Stop(false);
           //AudioHandler.audioClipHandlers["BGMUnalert"].Stop(true);
           //AudioHandler.audioClipHandlers["BGMAdaptive"].SetParameter("Detected", 1.0f);
-          Audio.SetParameter("Detected", 1.0f);
+          //Audio.SetParameter("Detected", 1.0f);
+          Audio.SetParameterWithLabel("PlayerDetection", "Detected");
         }
         SetNodeData("isAlert", true);
       }
 
+      if (screamOnce)
+      {
+        screamOnce = false;
+        AudioHandler.audioClipHandlers["SFXDetectAh"].Play();
+      }
+
       status = BehaviourTreeNodeStatus.SUCCESS;
       onExit(BehaviourTreeNodeStatus.SUCCESS);
       return status;

Assets/Scripts/Gameplay/SC_GameManager.cs

@@ -83,10 +83,10 @@ public class GameManager : Script
 
   protected override void start()
   {
-    AudioHandler.audioClipHandlers["BGMAdaptive"] = Audio.CreateAudioClip("event:/Music/bgm_adaptive");
+    AudioHandler.audioClipHandlers["BGMAdaptive"] = Audio.CreateAudioClip("event:/Music/bgm_adaptive_new");
     AudioHandler.audioClipHandlers["BGMAdaptive"].Play();
 
-    Audio.SetParameter("Detected", 0.0f);
+    Audio.SetParameterWithLabel("PlayerDetection", "Undetected");
 
     AudioHandler.audioClipHandlers["KitchenAmbience"] = Audio.CreateAudioClip("event:/Ambience/roomtone_kitchen");
     AudioHandler.audioClipHandlers["KitchenAmbience"].Play();
@@ -95,18 +95,24 @@ public class GameManager : Script
     AudioHandler.audioClipHandlers["SFXHumming"].SetVolume(0.15f);
     AudioHandler.audioClipHandlers["SFXHumming"].Play();
 
+    if (SceneFadeInOut.Instance != null)
       SceneFadeInOut.Instance.CallFadeOut();
+    Application.IsCursorVisible = false;
   }
 
   protected override void update()
   {
     if (GamePause || !stealFoodPopUpDone)
     {
+      Input.SetMouseCentering(false);
+      //Application.IsCursorVisible = true;
       return;
     }
 
     if (currGameState == GameState.START)
     {
+      Input.SetMouseCentering(true);
+     
       timer -= Time.DeltaTimeF;
       if(scoreText)
         scoreText.GetComponent<TextRenderable>().Text = $"{Score}";
@@ -138,6 +144,7 @@ public class GameManager : Script
         AudioHandler.StopAllSounds(false);
         AudioHandler.audioClipHandlers["BGMWin"].Play();
         goingToWin = true;
+        if (SceneFadeInOut.Instance != null)
           SceneFadeInOut.Instance.CallFadeIn();
       }
       else if(!goingToWin && (timer < 0 || Input.GetKeyDown(Input.KeyCode.F2)))
@@ -146,11 +153,14 @@ public class GameManager : Script
         AudioHandler.StopAllSounds(false);
         AudioHandler.audioClipHandlers["BGMLose"].Play();
         goingToLose = true;
+        if (SceneFadeInOut.Instance != null)
           SceneFadeInOut.Instance.CallFadeIn();
       }
     }
 
     //Handling transitions
+    if (SceneFadeInOut.Instance != null)
+    {
       if (SceneFadeInOut.Instance.FadeInFinished())
       {
         if (goingToWin)
@@ -163,6 +173,18 @@ public class GameManager : Script
         }
       }
     }
+    else
+    {
+      if (goingToWin)
+      {
+        SceneManager.ChangeScene(winScene);
+      }
+      if (goingToLose)
+      {
+        SceneManager.ChangeScene(loseScene);
+      }
+    }
+  }
 
   protected override void onDestroy()
   {

Assets/Scripts/Tests/PhysicsTestObj.cs

@@ -1,4 +1,4 @@
-using SHADE;
+using SHADE;
 using System;
 using System.Collections.Generic;
 using static Item;
@@ -65,37 +65,8 @@ public class PhysicsTestObj : Script
     };
 
     public float forceAmount = 50.0f;
-    public float torqueAmount = 25.0f;
+    public float torqueAmount = 500.0f;
 
-    protected override void onTriggerEnter(CollisionInfo info)
-    {
-        Debug.Log("Trigger Enter");
-    }
-
-    protected override void onTriggerStay(CollisionInfo info)
-    {
-        Debug.Log("Trigger Stay");
-    }
-
-    protected override void onTriggerExit(CollisionInfo info)
-    {
-        Debug.Log("Trigger Exit");
-    }
-
-    protected override void onCollisionEnter(CollisionInfo info)
-    {
-        Debug.Log("Collision Enter");
-    }
-
-    protected override void onCollisionStay(CollisionInfo info)
-    {
-        Debug.Log("Collision Stay");
-    }
-
-    protected override void onCollisionExit(CollisionInfo info)
-    {
-        Debug.Log("Collision Exit");
-    }
     protected override void awake()
     {
         tf = GetComponent<Transform>();

Assets/Scripts/UI/SC_ChangeSceneButton.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Reflection.Metadata.Ecma335;
 using SHADE;
 using SHADE_Scripting.UI;
@@ -22,13 +22,11 @@ public class ChangeSceneButton : Script
         {
             ui.OnRelease.RegisterAction(() =>
             {
-
                 if (sceneID != 0)
                 {
                   Audio.PlaySFXOnce2D("event:/UI/success");
-                    
                   Audio.StopAllSounds();
-
+                  if (SceneFadeInOut.Instance != null)
                     SceneFadeInOut.Instance.CallFadeIn();
                   clickedFlag = true;
                 }
@@ -37,7 +35,6 @@ public class ChangeSceneButton : Script
         else
         {
             Debug.LogError("Failed to register button action for ChangeSceneButton.");
-            
         }
     }
     protected override void update()

Assets/Scripts/UI/SC_EndScene.cs

@@ -1,6 +1,7 @@
-using System;
+using System;
 using SHADE;
 using SHADE_Scripting.Audio;
+using SHADE_Scripting.UI;
 
 public class EndScene : Script
 {
@@ -12,6 +13,15 @@ public class EndScene : Script
     AudioHandler.audioClipHandlers["SFXMouseDownElement"] = Audio.CreateAudioClip("event:/UI/mouse_down_element");
     AudioHandler.audioClipHandlers["SFXUISuccess"] = Audio.CreateAudioClip("event:/UI/success");
   }
+
+  protected override void start()
+  {
+    Input.SetMouseCentering(false);
+    Debug.Log("EndScene::Start():");
+    Application.IsCursorVisible = true;
+    SceneFadeInOut.Instance.CallFadeOut();
+  }
+
   protected override void update()
   {
     if (Input.GetKeyDown(Input.KeyCode.R))

Assets/Scripts/UI/SC_MainMenu.cs

@@ -1,6 +1,7 @@
-using System;
+using System;
 using SHADE;
 using SHADE_Scripting.Audio;
+using SHADE_Scripting.UI;
 
 public class MainMenu : Script
 {
@@ -23,6 +24,9 @@ public class MainMenu : Script
 
   protected override void start()
   {
+    Input.SetMouseCentering(false);
+    Application.IsCursorVisible = true;
+    SceneFadeInOut.Instance.CallFadeOut();
   }
   protected override void update()
   {

Assets/Scripts/UI/SC_PauseMenu.cs

@@ -13,6 +13,7 @@ public class PauseMenu : Script
 
   protected override void awake()
   {
+    if (GameManager.Instance != null)
       GameManager.Instance.GamePause = false;
 
     if (canvas)
@@ -41,6 +42,8 @@ public class PauseMenu : Script
         if (GameManager.Instance.GamePause)
         {
           GameManager.Instance.GamePause = false;
+          Input.SetMouseCentering(true);
+          Application.IsCursorVisible = false;
           AudioHandler.PauseAllSounds(false);
           if (gamePauseText)
             gamePauseText.Enabled = false;
@@ -91,6 +94,8 @@ public class PauseMenu : Script
     if (Input.GetKeyDown(Input.KeyCode.Escape) && !GameManager.Instance.GamePause && GameManager.Instance.stealFoodPopUpDone)
     {
       GameManager.Instance.GamePause = true;
+      Input.SetMouseCentering(false);
+      Application.IsCursorVisible = true;
       AudioHandler.PauseAllSounds(true);
       if (gamePauseText)
         gamePauseText.Enabled = true;

Assets/Scripts/UI/SC_SceneFadeInOut.cs

@@ -43,7 +43,6 @@ namespace SHADE_Scripting.UI
 
     protected override void start()
     {
-      
     }
 
     protected override void update()
@@ -56,7 +55,6 @@ namespace SHADE_Scripting.UI
           if (fadeInTime == 0.0f)
           {
             alphaValue = 1.0f;
-            
           }
           else
           {
@@ -65,6 +63,7 @@ namespace SHADE_Scripting.UI
           if (alphaValue >= 1.0f)
           {
             alphaValue = 1.0f;
+            //GameObject.Parent.SetActive(false);
           }
         }
 
@@ -83,6 +82,8 @@ namespace SHADE_Scripting.UI
           if (alphaValue <= 0.0f)
           { 
             alphaValue = 0.0f;
+            //This line is to be added so that (because the fade in and out item is usually the front-most UI element)
+            //the fade in and out UI element does not block functionality of other UI elements
             GameObject.Parent.SetActive(false);
           }
         }

SHADE_Engine/src/AudioSystem/SHAudioSystem.cpp

@@ -656,6 +656,15 @@ namespace SHADE
     }
   }
 
+  void SHAudioSystem::SetParameterWithLabel(const char* path, const char* label)
+  {
+    result = fmodStudioSystem->setParameterByNameWithLabel(path, label);
+    if (result != FMOD_OK)
+    {
+      ErrorCheck();
+    }
+  }
+
   void AudioClip::Play()
   {
     if(!instance)
@@ -734,12 +743,16 @@ namespace SHADE
     }
   }
 
-  //void AudioClip::SetParameterLabel(const char* paramName, const char* label)
+  void AudioClip::SetParameterWithLabel(const char* paramName, const char* label)
-  //{
+  {
-  //  if (!instance)
+    if (!instance)
-  //    return;
+      return;
-  //  instance->setParameterByNameWithLabel(paramName, label);
+    FMOD_RESULT result = instance->setParameterByNameWithLabel(paramName, label);
-  //}
+    if (result != FMOD_OK)
+    {
+      SHLOG_ERROR("Audio system error: {}", FMOD_ErrorString(result))
+    }
+  }
 
   float AudioClip::GetParameterValue(const char* paramName)
   {

SHADE_Engine/src/AudioSystem/SHAudioSystem.h

@@ -33,7 +33,7 @@ namespace SHADE
     void SetPause(bool pause);
     bool IsPaused();
     void SetParameter(const char* paramName, float value);
-    //void SetParameterLabel(const char* paramName, const char* label);
+    void SetParameterWithLabel(const char* paramName, const char* label);
     float GetParameterValue(const char* paramName);
     float GetVolume();
     void SetVolume(float volume);
@@ -94,6 +94,7 @@ namespace SHADE
 
     float GetParameterValue(const char* path);
     void SetParameter(const char* path, float value);
+    void SetParameterWithLabel(const char* path, const char* label);
 
   private:
     FMOD::Studio::System* fmodStudioSystem;

SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.cpp

@@ -376,7 +376,9 @@ namespace SHADE
       {
           if(editor->LoadScene(asset->id))
           {
+#ifdef SHEDITOR
             editor->editorConfig->workingSceneID = asset->id;
+#endif
           }
       }
         break;

SHADE_Engine/src/Editor/SHEditor.cpp

@@ -592,8 +592,10 @@ namespace SHADE
     {
       //Load the scene
       sceneToLoad = 0;
+#ifdef SHEDITOR
       editorConfig->workingSceneID = assetID;
       SHConfigurationManager::SaveEditorConfig();
+#endif
       SHSceneManager::RestartScene(assetID);
       return true;
     }

SHADE_Engine/src/Graphics/Windowing/SHWindow.cpp

@@ -198,6 +198,7 @@ namespace SHADE
 
   void SHWindow::SetMouseVisible(bool show)
   {
+    while(GetMouseVisible() != show)
       ShowCursor(show);
   }
 

SHADE_Engine/src/Math/SHRay.cpp

@@ -10,6 +10,8 @@
 
 #include <SHpch.h>
 
+#include <reactphysics3d/mathematics/Ray.h>
+
 // Primary Header
 #include "SHRay.h"
 

SHADE_Engine/src/Math/SHRay.h

@@ -13,8 +13,13 @@
 // Project Headers
 #include "Vector/SHVec3.h"
 
+/*-------------------------------------------------------------------------------------*/
+/* Forward Declarations                                                                */
+/*-------------------------------------------------------------------------------------*/
+
 namespace SHADE
 {
+
   /*-----------------------------------------------------------------------------------*/
   /* Type Definitions                                                                  */
   /*-----------------------------------------------------------------------------------*/

SHADE_Engine/src/Physics/Collision/Contacts/SHCollisionKey.h~HEAD

@@ -0,0 +1,117 @@
+/****************************************************************************************
+ * \file      SHCollisionID.h
+ * \author    Diren D Bharwani, diren.dbharwani, 390002520
+ * \brief     Interface for Collision Information for Collision & Triggers.
+ *
+ * \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
+
+// Project Headers
+#include "Physics/Interface/SHColliderComponent.h"
+#include "Physics/Interface/SHRigidBodyComponent.h"
+
+
+namespace SHADE
+{
+  /*-----------------------------------------------------------------------------------*/
+  /* Forward Declarations                                                              */
+  /*-----------------------------------------------------------------------------------*/
+
+  struct SHCollisionKeyHash;
+
+  /*-----------------------------------------------------------------------------------*/
+  /* Type Definitions                                                                  */
+  /*-----------------------------------------------------------------------------------*/
+
+  /**
+   * @brief
+   * Encapsulates the information when two collision shapes intersect.
+  */
+  class SH_API SHCollisionKey
+  {
+  private:
+    /*---------------------------------------------------------------------------------*/
+    /* Friends                                                                         */
+    /*---------------------------------------------------------------------------------*/
+
+    friend struct SHCollisionKeyHash;
+
+  public:
+    /*---------------------------------------------------------------------------------*/
+    /* Constructors & Destructor                                                       */
+    /*---------------------------------------------------------------------------------*/
+
+    SHCollisionKey   ()                          noexcept;
+    SHCollisionKey   (const SHCollisionKey& rhs)  noexcept;
+    SHCollisionKey   (SHCollisionKey&& rhs)       noexcept;
+
+    ~SHCollisionKey  () noexcept = default;
+
+    /*---------------------------------------------------------------------------------*/
+    /* Operator Overloads                                                              */
+    /*---------------------------------------------------------------------------------*/
+
+    SHCollisionKey& operator= (const SHCollisionKey& rhs) noexcept;
+    SHCollisionKey& operator= (SHCollisionKey&& rhs)      noexcept;
+
+    bool operator==(const SHCollisionKey& rhs) const;
+
+    /*---------------------------------------------------------------------------------*/
+    /* Getter Functions                                                                */
+    /*---------------------------------------------------------------------------------*/
+
+    [[nodiscard]] EntityID                    GetEntityA          ()  const noexcept;
+    [[nodiscard]] EntityID                    GetEntityB          ()  const noexcept;
+    [[nodiscard]] uint32_t                    GetShapeIndexA      ()  const noexcept;
+    [[nodiscard]] uint32_t                    GetShapeIndexB      ()  const noexcept;
+    [[nodiscard]] const SHRigidBodyComponent* GetRigidBodyA       ()  const noexcept;
+    [[nodiscard]] const SHRigidBodyComponent* GetRigidBodyB       ()  const noexcept;
+    [[nodiscard]] const SHCollisionShape*     GetCollisionShapeA  ()  const noexcept;
+    [[nodiscard]] const SHCollisionShape*     GetCollisionShapeB  ()  const noexcept;
+
+    /*---------------------------------------------------------------------------------*/
+    /* Setter Functions                                                                */
+    /*---------------------------------------------------------------------------------*/
+
+    void SetEntityA         (EntityID entityID)     noexcept;
+    void SetEntityB         (EntityID entityID)     noexcept;
+    void SetCollisionShapeA (uint32_t shapeIndexA)  noexcept;
+    void SetCollisionShapeB (uint32_t shapeIndexB)  noexcept;
+
+  private:
+
+    static constexpr uint32_t ENTITY_A      = 0;
+    static constexpr uint32_t SHAPE_INDEX_A = 1;
+    static constexpr uint32_t ENTITY_B      = 2;
+    static constexpr uint32_t SHAPE_INDEX_B = 3;
+
+    /*---------------------------------------------------------------------------------*/
+    /* Data Members                                                                    */
+    /*---------------------------------------------------------------------------------*/
+
+    union
+    {
+      uint64_t value[2];  // EntityValue, ShapeIndexValue
+      uint32_t ids  [4];  // EntityA, EntityB, ShapeIndexA, ShapeIndexB
+    };
+  };
+
+  /**
+   * @brief
+   * Encapsulates a functor to hash a CollisionKey
+  */
+  struct SHCollisionKeyHash
+  {
+  public:
+    /*---------------------------------------------------------------------------------*/
+    /* Member Functions                                                                */
+    /*---------------------------------------------------------------------------------*/
+
+    std::size_t operator()(const SHCollisionKey& id) const;
+  };
+
+} // namespace SHADE

SHADE_Engine/src/Physics/Collision/Narrowphase/SHCollisionUtils.cpp~HEAD

@@ -0,0 +1,38 @@
+/****************************************************************************************
+ * \file      SHCollisionUtils.cpp
+ * \author    Diren D Bharwani, diren.dbharwani, 390002520
+ * \brief     Implementation for some objects to assist with collision detection
+ *
+ * \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>
+
+// Primary Header
+#include "SHCollisionUtils.h"
+
+namespace SHADE
+{
+  /*-----------------------------------------------------------------------------------*/
+  /* Operator Overload Definitions                                                     */
+  /*-----------------------------------------------------------------------------------*/
+
+  SHVec3 SHCollisionUtils::ShapeTransform::operator*(const SHVec3& rhs) const noexcept
+  {
+    return SHVec3::Rotate(rhs, orientation) + position;
+  }
+
+  /*-----------------------------------------------------------------------------------*/
+  /* Public Member Functions Definitions                                               */
+  /*-----------------------------------------------------------------------------------*/
+
+  SHCollisionUtils::ShapeTransform SHCollisionUtils::ShapeTransform::GetInverse() const noexcept
+  {
+    const SHQuaternion INV_ORIENTATION = SHQuaternion::Inverse(orientation);
+    return ShapeTransform { SHVec3::Rotate(-position, INV_ORIENTATION), INV_ORIENTATION };
+  }
+
+
+} // namespace SHADE

SHADE_Engine/src/Physics/Interface/SHColliderComponent.cpp

@@ -9,6 +9,7 @@
 ****************************************************************************************/
 
 #include <SHpch.h>
+#include <reactphysics3d/reactphysics3d.h>
 
 // Primary Header
 #include "SHColliderComponent.h"

SHADE_Engine/src/Physics/Interface/SHColliderComponent.h

@@ -10,6 +10,8 @@
 
 #pragma once
 
+#include <vector>
+
 #include <rttr/registration>
 
 // Project Headers
@@ -29,6 +31,7 @@ namespace SHADE
     /* Friends                                                                         */
     /*---------------------------------------------------------------------------------*/
 
+    friend class SHCollisionShape;
     friend class SHPhysicsSystem;
     friend struct SHPhysicsObject;
 

SHADE_Engine/src/Physics/Interface/SHRigidBodyComponent.h

@@ -17,6 +17,15 @@
 #include "Math/Vector/SHVec3.h"
 #include "Physics/Dynamics/SHRigidBody.h"
 
+/*-------------------------------------------------------------------------------------*/
+/* Forward Declarations                                                                */
+/*-------------------------------------------------------------------------------------*/
+
+namespace reactphysics3d
+{
+  class RigidBody;
+}
+
 namespace SHADE
 {
   /*-----------------------------------------------------------------------------------*/
@@ -141,6 +150,22 @@ namespace SHADE
     void  ClearForces                 () const noexcept;
 
   private:
+    /*---------------------------------------------------------------------------------*/
+    /* Type Definitions                                                                */
+    /*---------------------------------------------------------------------------------*/
+
+    enum class Flags : uint8_t
+    {
+      GRAVITY     = 0x1
+    , SLEEPING    = 0x2
+    , LINEAR_X    = 0x4
+    , LINEAR_Y    = 0x8
+    , LINEAR_Z    = 0x10
+    , ANGULAR_X   = 0x20
+    , ANGULAR_Y   = 0x40
+    , ANGULAR_Z   = 0x80
+    };
+
     /*---------------------------------------------------------------------------------*/
     /* Data Members                                                                    */
     /*---------------------------------------------------------------------------------*/

SHADE_Engine/src/Physics/System/SHPhysicsSystem.h

@@ -39,8 +39,12 @@ namespace SHADE
     /*---------------------------------------------------------------------------------*/
 
     friend class SHPhysicsDebugDrawSystem;
+    friend class SHCollisionListener;
+    friend class SHRaycaster;
 
   public:
+    
+
     /*---------------------------------------------------------------------------------*/
     /* Constructors & Destructor                                                       */
     /*---------------------------------------------------------------------------------*/

SHADE_Engine/src/Physics/System/SHPhysicsSystemInterface.h

@@ -17,7 +17,6 @@ of DigiPen Institute of Technology is prohibited.
 #include "Physics/Collision/SHCollisionSpace.h"
 #include "Physics/Collision/Contacts/SHCollisionEvents.h"
 
-
 namespace SHADE
 {
   /*-----------------------------------------------------------------------------------*/
@@ -29,7 +28,6 @@ namespace SHADE
   struct  SHPhysicsRaycastResult;
   struct  SHCollisionSpace::RaycastInfo;
 
-
   /*-----------------------------------------------------------------------------------*/
   /* Type Definitions                                                                  */
   /*-----------------------------------------------------------------------------------*/
@@ -40,6 +38,48 @@ namespace SHADE
   class SH_API SHPhysicsSystemInterface final
   {
   public:
+
+    struct RaycastInfo
+    {
+    private:
+      /*-------------------------------------------------------------------------------*/
+      /* Friends                                                                        */
+      /*-------------------------------------------------------------------------------*/
+
+      friend class SHPhysicsSystemInterface;
+
+    public:
+      /*-------------------------------------------------------------------------------*/
+      /* Data Members                                                                  */
+      /*-------------------------------------------------------------------------------*/
+
+      bool      continuous  = false;
+      uint16_t  layers      = static_cast<uint16_t>(SHCollisionTag::Layer::ALL);
+      float     distance    = std::numeric_limits<float>::infinity();
+      SHRay     ray;
+
+      /*-------------------------------------------------------------------------------*/
+      /* Setter Functions                                                              */
+      /*-------------------------------------------------------------------------------*/
+
+      /**
+       * @brief
+       * Sets the collider ID for the raycast. Setting this specifies that the ray
+       * should ignore this collider.
+       * @param eid
+       * The entity ID of the collider.
+      */
+      void SetColliderID(EntityID eid) noexcept { colliderEntityID = eid; }
+
+    private:
+      /*-------------------------------------------------------------------------------*/
+      /* Data Members                                                                  */
+      /*-------------------------------------------------------------------------------*/
+
+      std::optional<EntityID> colliderEntityID;
+    };
+
+
     /*---------------------------------------------------------------------------------*/
     /* Constructor                                                                     */
     /*---------------------------------------------------------------------------------*/

SHADE_Managed/src/Audio/Audio.cxx

@@ -124,6 +124,12 @@ namespace SHADE
       audioSys->SetParameter(Convert::ToNative(path).data(), value);
     }
 
+    void Audio::SetParameterWithLabel(System::String^ path, System::String^ label)
+    {
+      auto audioSys = SHSystemManager::GetSystem<SHAudioSystem>();
+      audioSys->SetParameterWithLabel(Convert::ToNative(path).data(), Convert::ToNative(label).data());
+    }
+
     AudioClipHandler Audio::CreateAudioClip(System::String^ path)
     {
       auto audioSys = SHSystemManager::GetSystem<SHAudioSystem>();

SHADE_Managed/src/Audio/Audio.hxx

@@ -105,6 +105,7 @@ namespace SHADE
         static void SetVCAVolume(System::String^ path, float volume);
         static float GetParameterValue(System::String^ path);
         static void SetParameter(System::String^ path, float value);
+        static void SetParameterWithLabel(System::String^ path, System::String^ label);
 
         //to comment ltr
         static AudioClipHandler CreateAudioClip(System::String^ path);

SHADE_Managed/src/Audio/AudioClip.cxx

@@ -79,6 +79,11 @@ namespace SHADE
     NativeObject->SetParameter(Convert::ToNative(paramName).data(), value);
   }
 
+  void AudioClipHandler::SetParameterWithLabel(System::String^ paramName, System::String^ label)
+  {
+    NativeObject->SetParameterWithLabel(Convert::ToNative(paramName).data(), Convert::ToNative(label).data());
+  }
+
   float AudioClipHandler::GetParameterValue(System::String^ paramName)
   {
     return NativeObject->GetParameterValue(Convert::ToNative(paramName).data());

SHADE_Managed/src/Audio/AudioClip.hxx

@@ -71,6 +71,7 @@ namespace SHADE
     void SetPause(bool pause);
     bool IsPaused();
     void SetParameter(System::String^ paramName, float value);
+    void SetParameterWithLabel(System::String^ paramName, System::String^ label);
     float GetParameterValue(System::String^ paramName);
     float GetVolume();
     void SetVolume(float volume);

SHADE_Managed/src/Components/Collider.cxx

@@ -4,7 +4,6 @@
 \par            email: kahwei.tng\@digipen.edu
 \date           Oct 20, 2022
 \brief          Contains the definition of the functions of the managed Collider class.
-
                 Note: This file is written in C++17/CLI.
  
 Copyright (C) 2022 DigiPen Institute of Technology.
@@ -15,6 +14,9 @@ of DigiPen Institute of Technology is prohibited.
 #include "SHpch.h"
 // Primary Header
 #include "Collider.hxx"
+
+#include "Physics/Collision/Shapes/SHBox.h"
+#include "Physics/Collision/Shapes/SHSphere.h"
 #include "Utility/Debug.hxx"
 
 namespace SHADE
@@ -120,7 +122,7 @@ namespace SHADE
     /* BoxCollider - Constructors                                                      */
     /*---------------------------------------------------------------------------------*/
     BoxCollider::BoxCollider(int arrayIdx, Entity attachedEntity)
-    : CollisionShape { arrayIndex, attachedEntity }
+    : CollisionShape { arrayIdx, attachedEntity }
     {}
 
     /*---------------------------------------------------------------------------------*/
@@ -307,9 +309,9 @@ namespace SHADE
                 case SHCollisionShape::Type::SPHERE:
                     bound = gcnew SphereCollider(i, Owner.GetEntity());
                     break;
-                case SHCollisionShape::Type::CAPSULE:
+                //case SHCollisionShape::Type::CAPSULE:
-                    // TODO
+                //    // TODO
-                    break;
+                //    break;
                 default:
                     Debug::LogWarning("[Collider] An invalid Collider Type was detected. Skipping.");
                     break;

SHADE_Managed/src/Components/Collider.hxx

@@ -1,7 +1,9 @@
 /************************************************************************************//*!
 \file           Collider.hxx
 \author         Tng Kah Wei, kahwei.tng, 390009620
+                Diren D Bharwani, diren.dbharwani, 390002520
 \par            email: kahwei.tng\@digipen.edu
+                email: diren.dbharwani\@digipen.edu
 \date           Oct 20, 2022
 \brief          Contains the definition of the managed Collider class with the
                 declaration of functions for working with it.