xiaoqi
/
SHADE_Y3
1
0
Fork 0
Code Issues 12 Pull Requests Packages Projects Releases 9 Wiki Activity

Merge branch 'main' into Revert-Revert-SHPhysics

This commit is contained in:
Diren D Bharwani 2023-03-03 21:07:59 +08:00
parent 5c803105b2
commit 74c32457a8
39 changed files with 387 additions and 454 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
Assets/Audio/Master.bank
View File

Binary file not shown.

BIN
Assets/Audio/Master.strings.bank
View File

Binary file not shown.

BIN
Assets/Audio/Music.bank
View File

Binary file not shown.

BIN
Assets/Audio/SFX.bank
View File

Binary file not shown.

2
Assets/Materials/UI/UIMat_Black.shmat
View File

@ -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

369
Assets/Scenes/Level2.shade
View File

File diff suppressed because it is too large Load Diff

8
Assets/Scenes/PhysicsTest.shade
View File

@ -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

5
Assets/Scripts/Gameplay/AIBehaviour/Implemented/LeafNodes/LeafChase.cs
View File

@ -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);

5
Assets/Scripts/Gameplay/AIBehaviour/Implemented/LeafNodes/LeafPatrol.cs
View File

@ -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);
}

25
Assets/Scripts/Gameplay/AIBehaviour/Implemented/LeafNodes/LeafSearch.cs
View File

@ -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;

34
Assets/Scripts/Gameplay/SC_GameManager.cs
View File

@ -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();
SceneFadeInOut.Instance.CallFadeOut();
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,7 +144,8 @@ public class GameManager : Script
AudioHandler.StopAllSounds(false);
AudioHandler.audioClipHandlers["BGMWin"].Play();
goingToWin = true;
SceneFadeInOut.Instance.CallFadeIn();
if (SceneFadeInOut.Instance != null)
SceneFadeInOut.Instance.CallFadeIn();
}
else if(!goingToWin && (timer < 0 || Input.GetKeyDown(Input.KeyCode.F2)))
{
@ -146,12 +153,27 @@ public class GameManager : Script
AudioHandler.StopAllSounds(false);
AudioHandler.audioClipHandlers["BGMLose"].Play();
goingToLose = true;
SceneFadeInOut.Instance.CallFadeIn();
if (SceneFadeInOut.Instance != null)
SceneFadeInOut.Instance.CallFadeIn();
}
}
//Handling transitions
if (SceneFadeInOut.Instance.FadeInFinished())
if (SceneFadeInOut.Instance != null)
{
if (SceneFadeInOut.Instance.FadeInFinished())
{
if (goingToWin)
{
SceneManager.ChangeScene(winScene);
}
if (goingToLose)
{
SceneManager.ChangeScene(loseScene);
}
}
}
else
{
if (goingToWin)
{

33
Assets/Scripts/Tests/PhysicsTestObj.cs
View File

@ -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>();

13
Assets/Scripts/UI/SC_ChangeSceneButton.cs
View File

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

12
Assets/Scripts/UI/SC_EndScene.cs
View File

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

6
Assets/Scripts/UI/SC_MainMenu.cs
View File

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

7
Assets/Scripts/UI/SC_PauseMenu.cs
View File

@ -13,7 +13,8 @@ public class PauseMenu : Script
protected override void awake()
{
GameManager.Instance.GamePause = false;
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;

11
Assets/Scripts/UI/SC_SceneFadeInOut.cs
View File

@ -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
{
@ -64,7 +62,8 @@ namespace SHADE_Scripting.UI
}
if (alphaValue >= 1.0f)
{
alphaValue = 1.0f;
alphaValue = 1.0f;
//GameObject.Parent.SetActive(false);
}
}
@ -82,8 +81,10 @@ namespace SHADE_Scripting.UI
}
if (alphaValue <= 0.0f)
{
alphaValue = 0.0f;
GameObject.Parent.SetActive(false);
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);
}
}

25
SHADE_Engine/src/AudioSystem/SHAudioSystem.cpp
View File

@ -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)
//{
// if (!instance)
// return;
// instance->setParameterByNameWithLabel(paramName, label);
//}
void AudioClip::SetParameterWithLabel(const char* paramName, const char* label)
{
if (!instance)
return;
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)
{

3
SHADE_Engine/src/AudioSystem/SHAudioSystem.h
View File

@ -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;

2
SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.cpp
View File

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

2
SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorComponentView.hpp
View File

@ -787,4 +787,4 @@ namespace SHADE
ImGui::PopID();
}
}
}

2
SHADE_Engine/src/Editor/SHEditor.cpp
View File

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

3
SHADE_Engine/src/Graphics/Windowing/SHWindow.cpp
View File

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

2
SHADE_Engine/src/Math/SHRay.cpp
View File

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

5
SHADE_Engine/src/Math/SHRay.h
View File

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

117
SHADE_Engine/src/Physics/Collision/Contacts/SHCollisionKey.h~HEAD Normal file
View File

@ -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

38
SHADE_Engine/src/Physics/Collision/Narrowphase/SHCollisionUtils.cpp~HEAD Normal file
View File

@ -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

1
SHADE_Engine/src/Physics/Interface/SHColliderComponent.cpp
View File

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

3
SHADE_Engine/src/Physics/Interface/SHColliderComponent.h
View File

@ -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;

25
SHADE_Engine/src/Physics/Interface/SHRigidBodyComponent.h
View File

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

2
SHADE_Engine/src/Physics/System/SHPhysicsDebugDrawSystem.h
View File

@ -151,4 +151,4 @@ namespace SHADE
};
} // namespace SHADE
} // namespace SHADE

4
SHADE_Engine/src/Physics/System/SHPhysicsSystem.h
View File

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

44
SHADE_Engine/src/Physics/System/SHPhysicsSystemInterface.h
View File

@ -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 */
/*-----------------------------------------------------------------------------------*/
@ -39,7 +37,49 @@ namespace SHADE
/// </summary>
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 */
/*---------------------------------------------------------------------------------*/

6
SHADE_Managed/src/Audio/Audio.cxx
View File

@ -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>();

1
SHADE_Managed/src/Audio/Audio.hxx
View File

@ -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);

5
SHADE_Managed/src/Audio/AudioClip.cxx
View File

@ -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());

1
SHADE_Managed/src/Audio/AudioClip.hxx
View File

@ -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);

18
SHADE_Managed/src/Components/Collider.cxx
View File

@ -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 }
{}
/*---------------------------------------------------------------------------------*/
@ -166,11 +168,11 @@ namespace SHADE
}
float SphereCollider::Radius::get()
{
return getNativeCollisionShape<SHSphere>().GetWorldRadius();
return getNativeCollisionShape<SHSphere>().GetWorldRadius();
}
void SphereCollider::Radius::set(float value)
{
getNativeCollisionShape<SHSphere>().SetWorldRadius(value);
getNativeCollisionShape<SHSphere>().SetWorldRadius(value);
}
/*---------------------------------------------------------------------------------*/
@ -307,9 +309,9 @@ namespace SHADE
case SHCollisionShape::Type::SPHERE:
bound = gcnew SphereCollider(i, Owner.GetEntity());
break;
case SHCollisionShape::Type::CAPSULE:
// TODO
break;
//case SHCollisionShape::Type::CAPSULE:
// // TODO
// break;
default:
Debug::LogWarning("[Collider] An invalid Collider Type was detected. Skipping.");
break;
@ -320,4 +322,4 @@ namespace SHADE
subColliderList->Add(bound);
}
}
}
}

2
SHADE_Managed/src/Components/Collider.hxx
View File

@ -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.