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

Merge remote-tracking branch 'origin/main' into SP3-12-SceneGraph

This commit is contained in:
Diren D Bharwani 2022-10-29 14:51:48 +08:00
parent c9b116b8be 6477617b1b
commit 96bd982e4c
47 changed files with 1746 additions and 245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
SHADE_Application/src/Scenes/SBTestScene.cpp
View File

@ -96,11 +96,7 @@ namespace Sandbox
transform.SetWorldRotation(SHMath::GenerateRandomNumber(0.0f, 360.0f), SHMath::GenerateRandomNumber(0.0f, 360.0f), SHMath::GenerateRandomNumber(0.0f, 360.0f));
transform.SetWorldScale(TEST_OBJ_SCALE);
//if (const bool IS_EVEN = (y * NUM_ROWS + x) % 2; IS_EVEN)
collider.AddBoundingBox(SHVec3::One * 0.5f, SHVec3::Zero);
//else
// collider.AddBoundingSphere(0.5f, SHVec3::Zero);
collider.AddBoundingBox(SHVec3::One, SHVec3::Zero);
stressTestObjects.emplace_back(entity);
}
@ -124,8 +120,7 @@ namespace Sandbox
auto& floorCollider = *SHComponentManager::GetComponent_s<SHColliderComponent>(floor);
floorRenderable.SetMesh(CUBE_MESH);
floorRenderable.SetMaterial(customMat);
floorRenderable.GetModifiableMaterial()->SetProperty("data.color", SHVec4(1.0f, 1.0f, 1.0f, 1.0f));
floorRenderable.SetMaterial(graphicsSystem->GetDefaultMaterialInstance());
floorTransform.SetWorldScale({ 7.5f, 0.5f, 7.5 });
floorTransform.SetWorldPosition({ 0.0f, -3.0f, -5.0f });

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

@ -207,6 +207,10 @@ namespace SHADE
{
if (!component)
return;
// Get transform component for extrapolating relative sizes
auto* transformComponent = SHComponentManager::GetComponent<SHTransformComponent>(component->GetEID());
const auto componentType = rttr::type::get(*component);
SHEditorWidgets::CheckBox("##IsActive", [component]() {return component->isActive; }, [component](bool const& active) {component->isActive = active; });
ImGui::SameLine();
@ -221,28 +225,41 @@ namespace SHADE
for (int i{}; i < size; ++i)
{
ImGui::PushID(i);
SHCollider& collider = component->GetCollider(i);
SHCollider* collider = &component->GetCollider(i);
auto cursorPos = ImGui::GetCursorPos();
if (collider.GetType() == SHCollider::Type::BOX)
if (collider->GetType() == SHCollider::Type::BOX)
{
SHEditorWidgets::BeginPanel( std::format("{} Box Collider #{}", ICON_FA_CUBE, i).data(), { ImGui::GetContentRegionAvail().x, ImGui::GetContentRegionAvail().y });
auto box = reinterpret_cast<SHBoundingBox*>(collider.GetShape());
SHEditorWidgets::DragVec3("Half Extents", { "X", "Y", "Z" }, [box] {return box->GetHalfExtents(); }, [box](SHVec3 const& vec) {box->SetHalfExtents(vec);});
auto box = reinterpret_cast<SHBoundingBox*>(collider->GetShape());
SHEditorWidgets::DragVec3
(
"Half Extents", { "X", "Y", "Z" },
[box, transformComponent] { return (transformComponent->GetWorldScale() * 2.0f) * box->GetHalfExtents(); },
[collider](SHVec3 const& vec) { collider->SetBoundingBox(vec); });
}
else if (collider.GetType() == SHCollider::Type::SPHERE)
else if (collider->GetType() == SHCollider::Type::SPHERE)
{
SHEditorWidgets::BeginPanel(std::format("{} Sphere Collider #{}", ICON_MD_CIRCLE, i).data(), { ImGui::GetContentRegionAvail().x, ImGui::GetContentRegionAvail().y });
auto sphere = reinterpret_cast<SHBoundingSphere*>(collider.GetShape());
SHEditorWidgets::DragFloat("Radius", [sphere] {return sphere->GetRadius(); }, [sphere](float const& value) {sphere->SetRadius(value);});
auto sphere = reinterpret_cast<SHBoundingSphere*>(collider->GetShape());
SHEditorWidgets::DragFloat
(
"Radius",
[sphere, transformComponent]
{
const SHVec3& TF_WORLD_SCALE = transformComponent->GetWorldScale();
const float MAX_SCALE = SHMath::Max({ TF_WORLD_SCALE.x, TF_WORLD_SCALE.y, TF_WORLD_SCALE.z });
return sphere->GetRadius() / MAX_SCALE;
},
[collider](float const& value) { collider->SetBoundingSphere(value);});
}
else if (collider.GetType() == SHCollider::Type::CAPSULE)
else if (collider->GetType() == SHCollider::Type::CAPSULE)
{
}
{
SHEditorWidgets::BeginPanel("Offset", { ImGui::GetContentRegionAvail().x, 30.0f });
SHEditorWidgets::DragVec3("Position", { "X", "Y", "Z" }, [&collider] {return collider.GetPositionOffset(); }, [&collider](SHVec3 const& vec) {collider.SetPositionOffset(vec); });
SHEditorWidgets::DragVec3("Position", { "X", "Y", "Z" }, [&collider] {return collider->GetPositionOffset(); }, [&collider](SHVec3 const& vec) {collider->SetPositionOffset(vec); });
SHEditorWidgets::EndPanel();
}
if(ImGui::Button(std::format("{} Remove Collider #{}", ICON_MD_REMOVE, i).data()))

1
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.cpp
View File

@ -200,7 +200,6 @@ namespace SHADE
auto cubeFS = shaderModuleLibrary.GetBuiltInShaderModule("TestCube_FS");
defaultMaterial = AddMaterial(cubeVS, cubeFS, gBufferSubpass);
}
void SHGraphicsSystem::InitMiddleEnd(void) noexcept

1
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.h
View File

@ -144,6 +144,7 @@ namespace SHADE
Handle<SHMaterialInstance> AddMaterialInstanceCopy(Handle<SHMaterialInstance> materialInst);
void RemoveMaterialInstance(Handle<SHMaterialInstance> materialInstance);
Handle<SHMaterial> GetDefaultMaterial() { return defaultMaterial; }
Handle<SHMaterialInstance> GetDefaultMaterialInstance() { return AddOrGetBaseMaterialInstance(defaultMaterial); }
/*-----------------------------------------------------------------------------*/
/* Mesh Registration Functions */

18
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterial.cpp
View File

@ -4,6 +4,8 @@
#include "Graphics/Pipeline/SHVkPipeline.h"
#include "SHGraphicsConstants.h"
#include "Graphics/Shaders/BlockInterface/SHShaderBlockInterface.h"
#include "Math/Vector/SHVec3.h"
#include "Math/Vector/SHVec4.h"
namespace SHADE
{
@ -49,6 +51,22 @@ namespace SHADE
// Reset all the properties to default values
if (propMemory)
memset(propMemory.get(), 0, propMemorySize);
// Initialize Vectors to all 1.0 by default
const Handle<SHShaderBlockInterface> SHADER_INFO = GetShaderBlockInterface();
for (int i = 0; i < SHADER_INFO->GetVariableCount(); ++i)
{
const auto& VAR = SHADER_INFO->GetVariable(i);
switch (VAR->type)
{
case SHShaderBlockInterface::Variable::Type::VECTOR3:
setPropertyUnsafe(VAR->offset, SHVec3::One);
break;
case SHShaderBlockInterface::Variable::Type::VECTOR4:
setPropertyUnsafe(VAR->offset, SHVec4::One);
break;
}
}
}
void SHMaterial::ExportProperties(void* dest) const noexcept

6
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterial.h
View File

@ -75,6 +75,12 @@ namespace SHADE
Handle<SHVkPipeline> pipeline;
std::unique_ptr<char> propMemory;
Byte propMemorySize = 0;
/*-----------------------------------------------------------------------------*/
/* Helper Functions */
/*-----------------------------------------------------------------------------*/
template<typename T>
inline void setPropertyUnsafe(uint32_t memOffset, const T& value); // SetProperty() but without checks
};
}

12
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterial.hpp
View File

@ -33,7 +33,7 @@ namespace SHADE
}
// Get offset and modify the memory directly
T* dataPtr = propMemory.get() + PROP_INFO->offset;
T* dataPtr = reinterpret_cast<T*>(propMemory.get() + PROP_INFO->offset);
*dataPtr = value;
}
@ -44,7 +44,7 @@ namespace SHADE
if (memOffset + sizeof(T) > propMemorySize)
throw std::invalid_argument("Attempted to set an invalid property!");
// Set
(*reinterpret_cast<T*>(propMemory.get() + memOffset)) = value;
setPropertyUnsafe(memOffset, value);
}
template<typename T>
@ -58,7 +58,7 @@ namespace SHADE
}
// Get offset and return the memory directly
T* dataPtr = propMemory.get() + PROP_INFO->offset;
T* dataPtr = reinterpret_cast<T*>(propMemory.get() + PROP_INFO->offset);
return *dataPtr;
}
template<typename T>
@ -81,4 +81,10 @@ namespace SHADE
{
return const_cast<const T&>(const_cast<SHMaterial*>(this)->GetProperty(memOffset));
}
template<typename T>
void SHMaterial::setPropertyUnsafe(uint32_t memOffset, const T& value)
{
(*reinterpret_cast<T*>(propMemory.get() + memOffset)) = value;
}
}

4
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterialInstance.hpp
View File

@ -69,7 +69,7 @@ namespace SHADE
// Search Override Data for the property
uint32_t PROP_IDX = SHADER_INFO->GetVariableIndex(key);
auto prop = std::find(overrideData.begin(), overrideData.end(), [&](const OverrideData& data)
auto prop = std::find_if(overrideData.begin(), overrideData.end(), [&](const OverrideData& data)
{
return PROP_IDX == data.Index;
});
@ -77,7 +77,7 @@ namespace SHADE
throw std::invalid_argument("Attempted to get an property that was not set previously!");
// Get offset and return the memory directly
T* dataPtr = dataStore.get() + prop->StoredDataOffset;
T* dataPtr = reinterpret_cast<T*>(dataStore.get() + prop->StoredDataOffset);
return *dataPtr;
}
template<typename T>

3
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMeshLibrary.h
View File

@ -17,7 +17,8 @@ of DigiPen Institute of Technology is prohibited.
// Project Includes
#include "Resource/SHHandle.h"
#include "Resource/SHResourceLibrary.h"
#include "Math/SHMath.h"
#include "Math/Vector/SHVec2.h"
#include "Math/Vector/SHVec3.h"
namespace SHADE
{

62
SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.cpp
View File

@ -214,66 +214,4 @@ namespace SHADE
SHLOG_ERROR("Image layouts are invalid. ");
}
}
vk::Format SHTextureLibrary::ddsLoaderToVkFormat(tinyddsloader::DDSFile::DXGIFormat format, bool isLinear)
{
switch (format)
{
case tinyddsloader::DDSFile::DXGIFormat::BC1_UNorm:
return vk::Format::eBc1RgbaUnormBlock;
case tinyddsloader::DDSFile::DXGIFormat::BC1_UNorm_SRGB:
return vk::Format::eBc1RgbaSrgbBlock;
case tinyddsloader::DDSFile::DXGIFormat::BC2_UNorm:
case tinyddsloader::DDSFile::DXGIFormat::BC2_UNorm_SRGB:
return isLinear ? vk::Format::eBc2UnormBlock : vk::Format::eBc2SrgbBlock;
case tinyddsloader::DDSFile::DXGIFormat::BC3_UNorm:
case tinyddsloader::DDSFile::DXGIFormat::BC3_UNorm_SRGB:
return isLinear ? vk::Format::eBc3UnormBlock : vk::Format::eBc3SrgbBlock;
case tinyddsloader::DDSFile::DXGIFormat::BC5_UNorm:
case tinyddsloader::DDSFile::DXGIFormat::BC5_SNorm:
return isLinear ? vk::Format::eBc5UnormBlock : vk::Format::eBc5SnormBlock;
case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_UNorm:
case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_UNorm_SRGB:
return isLinear ? vk::Format::eR8G8B8A8Unorm : vk::Format::eR8G8B8A8Srgb;
case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_SNorm:
return vk::Format::eR8G8B8A8Snorm;
case tinyddsloader::DDSFile::DXGIFormat::B8G8R8A8_UNorm:
case tinyddsloader::DDSFile::DXGIFormat::B8G8R8A8_UNorm_SRGB:
return isLinear ? vk::Format::eB8G8R8A8Unorm : vk::Format::eB8G8R8A8Srgb;
case tinyddsloader::DDSFile::DXGIFormat::B8G8R8X8_UNorm:
case tinyddsloader::DDSFile::DXGIFormat::B8G8R8X8_UNorm_SRGB:
return isLinear ? vk::Format::eB8G8R8A8Unorm : vk::Format::eB8G8R8Srgb;
default:
throw std::runtime_error("Unsupported DDS format.");
}
//switch (format)
//{
//case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_UNorm:
//case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_UNorm_SRGB:
// return (isLinear) ? vk::Format::eR8G8B8A8Unorm : vk::Format::eR8G8B8A8Srgb;
//
//case tinyddsloader::DDSFile::DXGIFormat::B8G8R8A8_UNorm:
//case tinyddsloader::DDSFile::DXGIFormat::B8G8R8A8_UNorm_SRGB:
// return (isLinear) ? vk::Format::eB8G8R8A8Unorm : vk::Format::eB8G8R8A8Srgb;
//
//case tinyddsloader::DDSFile::DXGIFormat::BC1_UNorm:
//case tinyddsloader::DDSFile::DXGIFormat::BC1_UNorm_SRGB:
// return (isLinear) ? vk::Format::eBc1RgbaUnormBlock : vk::Format::eBc1RgbaSrgbBlock;
//case tinyddsloader::DDSFile::DXGIFormat::BC2_UNorm:
//case tinyddsloader::DDSFile::DXGIFormat::BC2_UNorm_SRGB:
// return (isLinear) ? vk::Format::eBc2UnormBlock : vk::Format::eBc2SrgbBlock;
//case tinyddsloader::DDSFile::DXGIFormat::BC3_UNorm:
//case tinyddsloader::DDSFile::DXGIFormat::BC3_UNorm_SRGB:
// return (isLinear) ? vk::Format::eBc3UnormBlock : vk::Format::eBc3SrgbBlock;
//case tinyddsloader::DDSFile::DXGIFormat::BC5_UNorm:
// return (isLinear) ? vk::Format::eBc5UnormBlock : vk::Format::eBc5SnormBlock;
//
//}
}
}

3
SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.h
View File

@ -14,8 +14,6 @@ of DigiPen Institute of Technology is prohibited.
// STL Includes
#include <vector>
// External Dependencies
#include "tinyddsloader.h"
// Project Includes
#include "Resource/SHHandle.h"
#include "Resource/SHResourceLibrary.h"
@ -169,6 +167,5 @@ namespace SHADE
/* Helper Functions */
/*-----------------------------------------------------------------------------*/
void preparePipelineBarriers(vk::ImageLayout oldLayout, vk::ImageLayout newLayout, vk::PipelineStageFlagBits& srcStage, vk::PipelineStageFlagBits& dstStage, std::vector<vk::ImageMemoryBarrier>& barriers);
vk::Format ddsLoaderToVkFormat(tinyddsloader::DDSFile::DXGIFormat format, bool isLinear);
};
}

3
SHADE_Engine/src/Math/Geometry/SHShape.cpp
View File

@ -27,10 +27,9 @@ namespace SHADE
/* Getter Function Definitions */
/*-----------------------------------------------------------------------------------*/
SHShape::Type SHShape::GetType() const
SHShape::Type SHShape::GetType() const noexcept
{
return type;
}
} // namespace SHADE

2
SHADE_Engine/src/Math/Geometry/SHShape.h
View File

@ -63,7 +63,7 @@ namespace SHADE
/* Getter Functions */
/*---------------------------------------------------------------------------------*/
[[nodiscard]] Type GetType() const;
[[nodiscard]] Type GetType () const noexcept;
/*---------------------------------------------------------------------------------*/
/* Function Members */

21
SHADE_Engine/src/Physics/Components/SHColliderComponent.cpp
View File

@ -58,7 +58,7 @@ namespace SHADE
if (index < 0 || static_cast<size_t>(index) >= colliders.size())
throw std::invalid_argument("Out-of-range access!");
return colliders[index].first;
return colliders[index];
}
/*-----------------------------------------------------------------------------------*/
@ -85,13 +85,11 @@ namespace SHADE
static constexpr auto TYPE = SHCollider::Type::BOX;
auto boxPair = std::make_pair(SHCollider{ TYPE }, true);
auto& collider = colliders.emplace_back(boxPair).first;
const auto* tf = SHComponentManager::GetComponent<SHTransformComponent>(GetEID());
auto& collider = colliders.emplace_back(SHCollider{ GetEID(), TYPE });
collider.entityID = GetEID();
collider.SetPositionOffset(posOffset);
collider.SetAsBoundingBox(tf->GetWorldScale() * halfExtents);
collider.SetBoundingBox(halfExtents);
// Notify Physics System
system->AddCollisionShape(GetEID(), &collider);
@ -109,16 +107,11 @@ namespace SHADE
static constexpr auto TYPE = SHCollider::Type::SPHERE;
auto spherePair = std::make_pair(SHCollider{ TYPE }, true);
auto& collider = colliders.emplace_back(spherePair).first;
const auto* tf = SHComponentManager::GetComponent<SHTransformComponent>(GetEID());
auto& collider = colliders.emplace_back(SHCollider{ GetEID(), TYPE });
collider.entityID = GetEID();
collider.SetPositionOffset(posOffset);
const SHVec3 TF_WORLD_SCALE = tf->GetWorldScale();
const float MAX_SCALE = SHMath::Max({ TF_WORLD_SCALE.x, TF_WORLD_SCALE.y, TF_WORLD_SCALE.z });
collider.SetAsBoundingSphere(MAX_SCALE * 0.5f * radius);
collider.SetBoundingSphere(radius);
// Notify Physics System
system->AddCollisionShape(GetEID(), &collider);

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

@ -43,8 +43,7 @@ namespace SHADE
/* Type Definitions */
/*---------------------------------------------------------------------------------*/
using ColliderDirtyPair = std::pair<SHCollider, bool>;
using Colliders = std::vector<ColliderDirtyPair>;
using Colliders = std::vector<SHCollider>;
public:

151
SHADE_Engine/src/Physics/SHCollider.cpp
View File

@ -15,6 +15,8 @@
// Project Headers
#include "Math/Geometry/SHBoundingBox.h"
#include "Math/Geometry/SHBoundingSphere.h"
#include "Math/Transform/SHTransformComponent.h"
#include "Math/SHMathHelpers.h"
namespace SHADE
{
@ -22,22 +24,24 @@ namespace SHADE
/* Constructors & Destructor Definitions */
/*-----------------------------------------------------------------------------------*/
SHCollider::SHCollider(Type colliderType)
SHCollider::SHCollider(EntityID eid, Type colliderType, const SHPhysicsMaterial& physicsMaterial)
: type { colliderType }
, entityID { eid }
, isTrigger { false }
, dirty { true }
, shape { nullptr }
, material { physicsMaterial }
{
switch (type)
{
case Type::BOX:
{
SetAsBoundingBox(SHVec3::One);
shape = new SHBoundingBox{ SHVec3::Zero, SHVec3::One };
break;
}
case Type::SPHERE:
{
SetAsBoundingSphere(1.0f);
shape = new SHBoundingSphere{ SHVec3::Zero, 0.5f };
break;
}
default: break;
@ -46,19 +50,27 @@ namespace SHADE
SHCollider::SHCollider(const SHCollider& rhs) noexcept
: type { rhs.type}
, entityID { rhs.entityID }
, isTrigger { rhs.isTrigger }
, dirty { true }
, shape { rhs.shape }
, shape { nullptr }
, material { rhs.material }
, positionOffset { rhs.positionOffset }
{}
{
CopyShape(rhs.shape);
}
SHCollider::SHCollider(SHCollider&& rhs) noexcept
: type { rhs.type}
, entityID { rhs.entityID }
, isTrigger { rhs.isTrigger }
, dirty { true }
, shape { rhs.shape }
, shape { nullptr }
, material { rhs.material }
, positionOffset { rhs.positionOffset }
{}
{
CopyShape(rhs.shape);
}
SHCollider::~SHCollider() noexcept
{
@ -75,22 +87,30 @@ namespace SHADE
return *this;
type = rhs.type;
entityID = rhs.entityID;
isTrigger = rhs.isTrigger;
dirty = true;
shape = rhs.shape;
material = rhs.material;
positionOffset = rhs.positionOffset;
delete shape;
CopyShape(rhs.shape);
return *this;
}
SHCollider& SHCollider::operator=(SHCollider&& rhs) noexcept
{
type = rhs.type;
entityID = rhs.entityID;
isTrigger = rhs.isTrigger;
dirty = true;
shape = rhs.shape;
material = rhs.material;
positionOffset = rhs.positionOffset;
delete shape;
CopyShape(rhs.shape);
return *this;
}
@ -115,19 +135,22 @@ namespace SHADE
float SHCollider::GetFriction() const noexcept
{
// TODO(Diren): Fix after implementing materials
return 0.0f;
return material.GetFriction();
}
float SHCollider::GetBounciness() const noexcept
{
// TODO(Diren): Fix after implementing materials
return 0.0f;
return material.GetBounciness();
}
float SHCollider::GetDensity() const noexcept
{
// TODO(Diren): Fix after implementing materials
return 0.0f;
return material.GetDensity();
}
const SHPhysicsMaterial& SHCollider::GetMaterial() const noexcept
{
return material;
}
const SHVec3& SHCollider::GetPositionOffset() const noexcept
@ -145,22 +168,60 @@ namespace SHADE
/* Setter Function Definitions */
/*-----------------------------------------------------------------------------------*/
void SHCollider::SetAsBoundingBox(const SHVec3& halfExtents)
void SHCollider::SetBoundingBox(const SHVec3& halfExtents)
{
dirty = true;
// Set the half extents relative to transform
SHVec3 worldHalfExtents = halfExtents;
const auto* transformComponent = SHComponentManager::GetComponent_s<SHTransformComponent>(entityID);
if (transformComponent != nullptr)
worldHalfExtents *= (transformComponent->GetWorldScale() * 0.5f);
if (type == Type::BOX)
{
auto* box = reinterpret_cast<SHBoundingBox*>(shape);
box->SetHalfExtents(worldHalfExtents);
}
else
{
type = Type::BOX;
delete shape;
shape = new SHBoundingBox{ positionOffset, halfExtents };
shape = new SHBoundingBox{ positionOffset, worldHalfExtents };
}
}
void SHCollider::SetAsBoundingSphere(float radius)
void SHCollider::SetBoundingSphere(float radius)
{
dirty = true;
// Set the radius relative to transform
float worldRadius = radius;
const auto* transformComponent = SHComponentManager::GetComponent_s<SHTransformComponent>(entityID);
if (transformComponent != nullptr)
{
const SHVec3 TF_WORLD_SCALE = transformComponent->GetWorldScale();
const float MAX_SCALE = SHMath::Max({ TF_WORLD_SCALE.x, TF_WORLD_SCALE.y, TF_WORLD_SCALE.z });
worldRadius *= MAX_SCALE;
}
if (type == Type::SPHERE)
{
auto* sphere = reinterpret_cast<SHBoundingSphere*>(shape);
sphere->SetRadius(worldRadius);
}
else
{
type = Type::SPHERE;
delete shape;
shape = new SHBoundingSphere{ positionOffset, radius };
shape = new SHBoundingSphere{ positionOffset, worldRadius };
}
}
void SHCollider::SetIsTrigger(bool trigger) noexcept
@ -172,23 +233,74 @@ namespace SHADE
void SHCollider::SetFriction(float friction) noexcept
{
dirty = true;
material.SetFriction(friction);
}
void SHCollider::SetBounciness(float bounciness) noexcept
{
dirty = true;
material.SetBounciness(bounciness);
}
void SHCollider::SetDensity(float density) noexcept
{
dirty = true;
material.SetDensity(density);
}
void SHCollider::SetMaterial(const SHPhysicsMaterial& newMaterial) noexcept
{
dirty = true;
material = newMaterial;
}
void SHCollider::SetPositionOffset(const SHVec3& posOffset) noexcept
{
dirty = true;
positionOffset = posOffset;
switch (type)
{
case Type::BOX:
{
reinterpret_cast<SHBoundingBox*>(shape)->SetCenter(positionOffset);
break;
}
case Type::SPHERE:
{
reinterpret_cast<SHBoundingSphere*>(shape)->SetCenter(positionOffset);
break;
}
default: break;
}
}
/*-----------------------------------------------------------------------------------*/
/* Private Function Member Definitions */
/*-----------------------------------------------------------------------------------*/
void SHCollider::CopyShape(const SHShape* rhs)
{
switch (type)
{
case Type::BOX:
{
const auto* RHS_BOX = reinterpret_cast<const SHBoundingBox*>(rhs);
shape = new SHBoundingBox{ positionOffset, RHS_BOX->GetHalfExtents() };
break;
}
case Type::SPHERE:
{
const auto* RHS_SPHERE = reinterpret_cast<const SHBoundingSphere*>(rhs);
shape = new SHBoundingSphere{ positionOffset, RHS_SPHERE->GetRadius() };
break;
}
default: break;
}
}
} // namespace SHADE
RTTR_REGISTRATION
@ -205,5 +317,4 @@ RTTR_REGISTRATION
registration::class_<SHCollider>("Collider")
.property("Position Offset", &SHCollider::GetPositionOffset, &SHCollider::SetPositionOffset);
// TODO(Diren): Add Physics Materials
}

27
SHADE_Engine/src/Physics/SHCollider.h
View File

@ -13,8 +13,10 @@
#include <rttr/registration>
// Project Headers
#include "ECS_Base/Entity/SHEntity.h"
#include "Math/Geometry/SHShape.h"
#include "Math/SHQuaternion.h"
#include "SHPhysicsMaterial.h"
namespace SHADE
{
@ -24,6 +26,15 @@ namespace SHADE
class SH_API SHCollider
{
private:
/*---------------------------------------------------------------------------------*/
/* Friends */
/*---------------------------------------------------------------------------------*/
friend class SHColliderComponent;
friend class SHPhysicsObject;
public:
/*---------------------------------------------------------------------------------*/
/* Type Definitions */
@ -40,7 +51,7 @@ namespace SHADE
/* Constructors & Destructor */
/*---------------------------------------------------------------------------------*/
SHCollider (Type colliderType = Type::BOX);
SHCollider (EntityID eid, Type colliderType = Type::BOX, const SHPhysicsMaterial& physicsMaterial = SHPhysicsMaterial::DEFAULT);
SHCollider (const SHCollider& rhs) noexcept;
SHCollider (SHCollider&& rhs) noexcept;
@ -66,6 +77,7 @@ namespace SHADE
[[nodiscard]] float GetFriction () const noexcept;
[[nodiscard]] float GetBounciness () const noexcept;
[[nodiscard]] float GetDensity () const noexcept;
[[nodiscard]] const SHPhysicsMaterial& GetMaterial () const noexcept;
[[nodiscard]] const SHVec3& GetPositionOffset () const noexcept;
@ -75,13 +87,14 @@ namespace SHADE
/* Setter Functions */
/*---------------------------------------------------------------------------------*/
void SetAsBoundingBox (const SHVec3& halfExtents);
void SetAsBoundingSphere (float radius);
void SetBoundingBox (const SHVec3& halfExtents);
void SetBoundingSphere (float radius);
void SetIsTrigger (bool isTrigger) noexcept;
void SetFriction (float friction) noexcept;
void SetBounciness (float bounciness) noexcept;
void SetDensity (float density) noexcept;
void SetMaterial (const SHPhysicsMaterial& newMaterial) noexcept;
void SetPositionOffset (const SHVec3& positionOffset) noexcept;
@ -91,11 +104,19 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
Type type;
EntityID entityID; // The entity this collider belongs to
bool isTrigger;
bool dirty;
SHShape* shape;
SHPhysicsMaterial material;
SHVec3 positionOffset;
/*---------------------------------------------------------------------------------*/
/* Function Members */
/*---------------------------------------------------------------------------------*/
void CopyShape(const SHShape* rhs);
RTTR_ENABLE()
};

104
SHADE_Engine/src/Physics/SHPhysicsMaterial.cpp Normal file
View File

@ -0,0 +1,104 @@
/****************************************************************************************
* \file SHPhysicsMaterial.cpp
* \author Diren D Bharwani, diren.dbharwani, 390002520
* \brief Implementation for a Physics Material.
*
* \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 "SHPhysicsMaterial.h"
// Project Headers
#include "Math/SHMathHelpers.h"
namespace SHADE
{
/*-----------------------------------------------------------------------------------*/
/* Static Data Member Definitions */
/*-----------------------------------------------------------------------------------*/
const SHPhysicsMaterial SHPhysicsMaterial::DEFAULT { 0.4f, 0.0f, 1.0f };
/*-----------------------------------------------------------------------------------*/
/* Constructors & Destructor Definitions */
/*-----------------------------------------------------------------------------------*/
SHPhysicsMaterial::SHPhysicsMaterial(float _friction, float _bounciness, float _density) noexcept
: friction { std::clamp(_friction, 0.0f, 1.0f) }
, bounciness{ std::clamp(_bounciness, 0.0f, 1.0f) }
, density { std::fabs(_density) }
{}
/*-----------------------------------------------------------------------------------*/
/* Operator Overload Definitions */
/*-----------------------------------------------------------------------------------*/
bool SHPhysicsMaterial::operator==(const SHPhysicsMaterial& rhs) const noexcept
{
return SHMath::CompareFloat(friction, rhs.friction)
&& SHMath::CompareFloat(bounciness, rhs.bounciness)
&& SHMath::CompareFloat(density, rhs.density);
}
bool SHPhysicsMaterial::operator!=(const SHPhysicsMaterial& rhs) const noexcept
{
return !SHMath::CompareFloat(friction, rhs.friction)
|| !SHMath::CompareFloat(bounciness, rhs.bounciness)
|| !SHMath::CompareFloat(density, rhs.density);
}
/*-----------------------------------------------------------------------------------*/
/* Getter Function Definitions */
/*-----------------------------------------------------------------------------------*/
float SHPhysicsMaterial::GetFriction() const noexcept
{
return friction;
}
float SHPhysicsMaterial::GetBounciness() const noexcept
{
return bounciness;
}
float SHPhysicsMaterial::GetDensity() const noexcept
{
return density;
}
/*-----------------------------------------------------------------------------------*/
/* Setter Function Definitions */
/*-----------------------------------------------------------------------------------*/
void SHPhysicsMaterial::SetFriction(float newFriction) noexcept
{
if (newFriction < 0.0f || newFriction > 1.0f)
{
SHLOG_WARNING("Clamping friction of Physics Material between [0,1].")
}
friction = std::clamp(newFriction, 0.0f, 1.0f);
}
void SHPhysicsMaterial::SetBounciness(float newBounciness) noexcept
{
if (newBounciness < 0.0f || newBounciness > 1.0f)
{
SHLOG_WARNING("Clamping bounciness of Physics Material between [0,1].")
}
bounciness = std::clamp(newBounciness, 0.0f, 1.0f);
}
void SHPhysicsMaterial::SetDensity(float newDensity) noexcept
{
if (newDensity < 0.0f)
{
SHLOG_WARNING("Setting negative density of Physics Material to positive.")
}
density = std::fabs(newDensity);
}
} // namespace SHADE

113
SHADE_Engine/src/Physics/SHPhysicsMaterial.h Normal file
View File

@ -0,0 +1,113 @@
/****************************************************************************************
* \file SHPhysicsMaterial.h
* \author Diren D Bharwani, diren.dbharwani, 390002520
* \brief Interface for a Physics Material.
*
* \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 "SH_API.h"
namespace SHADE
{
/*-----------------------------------------------------------------------------------*/
/* Type Definitions */
/*-----------------------------------------------------------------------------------*/
class SH_API SHPhysicsMaterial
{
public:
/*---------------------------------------------------------------------------------*/
/* Static Data Members */
/*---------------------------------------------------------------------------------*/
static const SHPhysicsMaterial DEFAULT;
/*---------------------------------------------------------------------------------*/
/* Constructors & Destructor */
/*---------------------------------------------------------------------------------*/
SHPhysicsMaterial (const SHPhysicsMaterial&) noexcept = default;
SHPhysicsMaterial (SHPhysicsMaterial&&) noexcept = default;
~SHPhysicsMaterial() = default;
/**
* @brief Default constructor for a physics material.
* @param friction The friction of the material. Clamped between [0,1]. Defaults to 0.4.
* @param bounciness The bounciness of the material. Clamped between [0,1].
* @param density The mass density of the material. Always made positive.
*/
SHPhysicsMaterial (float friction = 0.4f, float bounciness = 0.0f, float density = 1.0f) noexcept;
/*---------------------------------------------------------------------------------*/
/* Operator Overloads */
/*---------------------------------------------------------------------------------*/
SHPhysicsMaterial& operator= (const SHPhysicsMaterial&) noexcept = default;
SHPhysicsMaterial& operator= (SHPhysicsMaterial&&) noexcept = default;
bool operator==(const SHPhysicsMaterial& rhs) const noexcept;
bool operator!=(const SHPhysicsMaterial& rhs) const noexcept;
/*---------------------------------------------------------------------------------*/
/* Getter Functions */
/*---------------------------------------------------------------------------------*/
[[nodiscard]] float GetFriction () const noexcept;
[[nodiscard]] float GetBounciness () const noexcept;
[[nodiscard]] float GetDensity () const noexcept;
/*---------------------------------------------------------------------------------*/
/* Setter Functions */
/*---------------------------------------------------------------------------------*/
/**
* @brief Sets the friction coefficient of the physics material.
* @param newFriction The friction value to set. Clamped between [0,1].
*/
void SetFriction (float newFriction) noexcept;
/**
* @brief Sets the bounciness factor of the physics material.
* @param newBounciness The bounciness value to set. Clamped between [0,1].
*/
void SetBounciness (float newBounciness) noexcept;
/**
* @brief Sets the mass density of the physics material.
* @param newDensity The density value to set. Always made positive.
*/
void SetDensity (float newDensity) noexcept;
private:
/*---------------------------------------------------------------------------------*/
/* Data Members */
/*---------------------------------------------------------------------------------*/
/**
* @brief The friction coefficient of the physics object., clamped between [0,1].<br/>
* 0 means the object will never experience friction.
* 1 means the friction force against the object is equal to the applied force.
*/
float friction;
/**
* @brief The bounciness factor of the physics object., clamped between [0,1].<br/>
* 0 means the object will never bounce.
* 1 means the object never loses energy on a bounce.
*/
float bounciness;
/**
* @brief The density of the collider that determines the mass of the collision shape
* if it is automatically computed. Must be a positive number.
*/
float density;
};
}

6
SHADE_Engine/src/Physics/SHPhysicsObject.cpp
View File

@ -261,9 +261,9 @@ namespace SHADE
void SHPhysicsObject::SyncColliders(SHColliderComponent* c) const noexcept
{
int index = 0;
for (auto& [collider, dirty] : c->colliders)
for (auto& collider : c->colliders)
{
if (!dirty)
if (!collider.dirty)
continue;
// Update offsets
@ -293,7 +293,7 @@ namespace SHADE
default: break;
}
dirty = false;
collider.dirty = false;
++index;
}
}

32
SHADE_Engine/src/Physics/SHPhysicsSystem.cpp
View File

@ -246,21 +246,6 @@ namespace SHADE
if (physicsObject.rp3dBody == nullptr)
continue;
auto* rigidBodyComponent = SHComponentManager::GetComponent_s<SHRigidBodyComponent>(entityID);
// Clear all forces and velocities if editor is not in play
if (SHSystemManager::GetSystem<SHEditor>()->editorState == SHEditor::State::STOP)
{
if (rigidBodyComponent)
{
auto* rp3dRigidBody = reinterpret_cast<rp3d::RigidBody*>(physicsObject.rp3dBody);
rp3dRigidBody->resetForce();
rp3dRigidBody->resetTorque();
rp3dRigidBody->setLinearVelocity(SHVec3::Zero);
rp3dRigidBody->setAngularVelocity(SHVec3::Zero);
}
}
const auto* transformComponent = SHComponentManager::GetComponent_s<SHTransformComponent>(entityID);
if (transformComponent && transformComponent->HasChanged())
{
@ -270,10 +255,21 @@ namespace SHADE
physicsObject.SetPosition(WORLD_POS);
physicsObject.SetOrientation(WORLD_ROT);
auto* rigidBodyComponent = SHComponentManager::GetComponent_s<SHRigidBodyComponent>(entityID);
if (rigidBodyComponent)
{
rigidBodyComponent->position = WORLD_POS;
rigidBodyComponent->orientation = WORLD_ROT;
// Clear all forces and velocities if editor is stopped
if (SHSystemManager::GetSystem<SHEditor>()->editorState == SHEditor::State::STOP)
{
auto* rp3dRigidBody = reinterpret_cast<rp3d::RigidBody*>(physicsObject.rp3dBody);
rp3dRigidBody->resetForce();
rp3dRigidBody->resetTorque();
rp3dRigidBody->setLinearVelocity(SHVec3::Zero);
rp3dRigidBody->setAngularVelocity(SHVec3::Zero);
}
}
auto* colliderComponent = SHComponentManager::GetComponent_s<SHColliderComponent>(entityID);
@ -517,7 +513,7 @@ namespace SHADE
// Add collision shapes back into the body
if (colliderComponent != nullptr)
{
for (auto& collider : colliderComponent->colliders | std::views::keys)
for (auto& collider : colliderComponent->colliders)
physicsObject->AddCollider(&collider);
}
}
@ -538,7 +534,7 @@ namespace SHADE
}
// Add Collision Shapes
for (auto& collider : colliderComponent->colliders | std::views::keys)
for (auto& collider : colliderComponent->colliders)
physicsObject->AddCollider(&collider);
}
}
@ -576,7 +572,7 @@ namespace SHADE
rp3d::Transform{ colliderComponent->position, colliderComponent->orientation }
);
for (auto& collider : colliderComponent->colliders | std::views::keys)
for (auto& collider : colliderComponent->colliders)
physicsObject->AddCollider(&collider);
}

6
SHADE_Engine/src/Resource/SHHandle.h
View File

@ -195,6 +195,11 @@ namespace SHADE
template<typename T>
inline bool operator==(const Handle<T>& rhs) const noexcept;
/*-----------------------------------------------------------------------------*/
/* Query Functions */
/*-----------------------------------------------------------------------------*/
inline SHResourceLibraryBase* GetLibrary() const;
protected:
/*-----------------------------------------------------------------------------*/
/* Data Members */
@ -206,6 +211,7 @@ namespace SHADE
/*-----------------------------------------------------------------------------*/
template<typename T>
friend class Handle;
friend class Convert;
};
/// <summary>

5
SHADE_Engine/src/Resource/SHHandle.hpp
View File

@ -96,6 +96,11 @@ namespace SHADE
return id.Raw == rhs.id.Raw && library == static_cast<void*>(rhs.library);
}
SHResourceLibraryBase* SHADE::Handle<void>::GetLibrary() const
{
return library;
}
/*---------------------------------------------------------------------------------*/
/* ISelfHandle<T> - Constructors */
/*---------------------------------------------------------------------------------*/

8
SHADE_Engine/src/Resource/SparseSet.hpp
View File

@ -70,13 +70,13 @@ namespace SHADE
}
template<typename T>
SparseSet<T>::reference SparseSet<T>::at(index_type idx)
typename SparseSet<T>::reference SparseSet<T>::at(index_type idx)
{
return const_cast<reference>(static_cast<const SparseSet<T>&>(*this).at(idx));
}
template<typename T>
SparseSet<T>::const_reference SparseSet<T>::at(index_type idx) const
typename SparseSet<T>::const_reference SparseSet<T>::at(index_type idx) const
{
// Range Check
if (idx >= sparseArray.size() || !contains(idx))
@ -84,7 +84,7 @@ namespace SHADE
return denseArray[sparseArray[idx]];
}
template<typename T>
SparseSet<T>::size_type SparseSet<T>::size() const
typename SparseSet<T>::size_type SparseSet<T>::size() const
{
return denseArray.size();
}
@ -105,7 +105,7 @@ namespace SHADE
}
template<typename T>
template<typename ...Args>
SparseSet<T>::reference SparseSet<T>::insert(index_type idx, Args && ...args)
typename SparseSet<T>::reference SparseSet<T>::insert(index_type idx, Args && ...args)
{
// We need to resize the array
if (idx >= sparseArray.size())

4
SHADE_Engine/src/Scene/SHSceneGraph.cpp
View File

@ -582,9 +582,9 @@ namespace SHADE
ReleaseNode(node);
}
void SHSceneGraph::Traverse (const UnaryFunction& predicate) const
void SHSceneGraph::Traverse (const UnaryFunction& function) const
{
TraverseAndInvokeFunction(root, predicate);
TraverseAndInvokeFunction(root, function);
}
/*-----------------------------------------------------------------------------------*/

2
SHADE_Engine/src/Scene/SHSceneGraph.h
View File

@ -142,7 +142,7 @@ namespace SHADE
bool RemoveNode (SHSceneNode* nodeToRemove) noexcept;
void Reset () noexcept;
void Traverse (const UnaryFunction& predicate) const;
void Traverse (const UnaryFunction& function) const;
private:
/*---------------------------------------------------------------------------------*/

4
SHADE_Engine/src/Scripting/SHScriptEngine.cpp
View File

@ -417,13 +417,13 @@ namespace SHADE
(
DEFAULT_CSHARP_LIB_NAME,
DEFAULT_CSHARP_NAMESPACE + ".Collider",
"OnColliderBoundChanged"
"OnCollisionShapeChanged"
);
csColliderOnRemoved = dotNet.GetFunctionPtr<CsEventRelayFuncPtr>
(
DEFAULT_CSHARP_LIB_NAME,
DEFAULT_CSHARP_NAMESPACE + ".Collider",
"OnColliderRemoved"
"OnCollisionShapeRemoved"
);
csEditorRenderScripts = dotNet.GetFunctionPtr<CsScriptEditorFuncPtr>
(

119
SHADE_Managed/src/Assets/Material.cxx Normal file
View File

@ -0,0 +1,119 @@
/************************************************************************************//*!
\file Material.cxx
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Oct 28, 2022
\brief Contains the implementation of the functions of the managed Material
class.
Note: This file is written in C++17/CLI.
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.
*//*************************************************************************************/
// Precompiled Headers
#include "SHpch.h"
// Primary Header
#include "Material.hxx"
// Standard Library
#include <stdexcept>
// Project Includes
#include "Utility/Convert.hxx"
namespace SHADE
{
/*---------------------------------------------------------------------------------*/
/* Macro Definitions */
/*---------------------------------------------------------------------------------*/
#define SET_PROP(NATIVE_TYPE, MANAGED_TYPE) \
(T::typeid == MANAGED_TYPE::typeid) \
{ \
const NATIVE_TYPE VAL = safe_cast<NATIVE_TYPE>(System::Convert::ChangeType(value, MANAGED_TYPE::typeid)); \
NativeObject->SetProperty<NATIVE_TYPE>(PROP_NAME, VAL); \
} \
#define SET_PROP_CONVERT(NATIVE_TYPE, MANAGED_TYPE) \
(T::typeid == MANAGED_TYPE::typeid) \
{ \
const NATIVE_TYPE VAL = Convert::ToNative(safe_cast<MANAGED_TYPE>(System::Convert::ChangeType(value, MANAGED_TYPE::typeid))); \
NativeObject->SetProperty<NATIVE_TYPE>(PROP_NAME, VAL); \
} \
#define GET_PROP(NATIVE_TYPE, MANAGED_TYPE) \
(T::typeid == MANAGED_TYPE::typeid) \
{ \
return safe_cast<T>(NativeObject->GetProperty<NATIVE_TYPE>(PROP_NAME)); \
} \
#define GET_PROP_CONVERT(NATIVE_TYPE, MANAGED_TYPE) \
(T::typeid == MANAGED_TYPE::typeid) \
{ \
return safe_cast<T>(Convert::ToCLI(NativeObject->GetProperty<NATIVE_TYPE>(PROP_NAME))); \
}
/*---------------------------------------------------------------------------------*/
/* Explicit Template Instantiation */
/*---------------------------------------------------------------------------------*/
template ref class NativeAsset<SHMaterialInstance>;
/*---------------------------------------------------------------------------------*/
/* Constructors/Destructor */
/*---------------------------------------------------------------------------------*/
Material::Material(Handle<SHMaterialInstance> material)
: NativeAsset<SHMaterialInstance>{ material }
{}
/*---------------------------------------------------------------------------------*/
/* Material Properties Functions */
/*---------------------------------------------------------------------------------*/
generic<typename T>
void Material::SetProperty(System::String^ name, T value)
{
if (!NativeObject)
throw gcnew System::InvalidOperationException("Attempted to set property on an invalid material!");
// Call the correct one based on type
const std::string PROP_NAME = Convert::ToNative(name);
try
{
if SET_PROP (int, System::Int32)
else if SET_PROP (int, System::Int64)
else if SET_PROP (float, float)
else if SET_PROP (double, double)
else if SET_PROP_CONVERT(SHVec2, Vector2)
else if SET_PROP_CONVERT(SHVec3, Vector3)
// TODO: Vector4
}
catch (const std::invalid_argument&)
{
throw gcnew System::ArgumentException("Attempted to modify an invalid property on a material.");
}
}
generic<typename T>
T Material::GetProperty(System::String^ name)
{
if (!NativeObject)
throw gcnew System::InvalidOperationException("[Material] Attempted to get property of an invalid material!");
// Call the correct one based on type
const std::string PROP_NAME = Convert::ToNative(name);
try
{
if GET_PROP (int, System::Int32)
else if GET_PROP (int, System::Int64)
else if GET_PROP (float, float)
else if GET_PROP (double, double)
else if GET_PROP_CONVERT(SHVec2, Vector2)
else if GET_PROP_CONVERT(SHVec3, Vector3)
// TODO: Vector4
}
catch (const std::invalid_argument&)
{
throw gcnew System::ArgumentException("Attempted to retrieve a property on a material with an invalid type.");
}
throw gcnew System::ArgumentException("Attempted to retrieve an invalid property on a material.");
}
}

81
SHADE_Managed/src/Assets/Material.hxx Normal file
View File

@ -0,0 +1,81 @@
/************************************************************************************//*!
\file Material.hxx
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Oct 28, 2022
\brief Contains the definition of the managed Mesh class.
Note: This file is written in C++17/CLI.
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
// External Dependencies
#include "Resource/SHHandle.h"
#include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h"
// Project Includes
#include "NativeAsset.hxx"
#include "Engine/GenericHandle.hxx"
namespace SHADE
{
/// <summary>
/// Managed counterpart of the native MaterialInstance object containing material
/// data that can be fed to Renderables for rendering.
/// </summary>
public ref class Material : public NativeAsset<SHMaterialInstance>
{
internal:
/*-----------------------------------------------------------------------------*/
/* Constructors/Destructor */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Constructor for the Material
/// </summary>
/// <param name="material">Handle to the native material object.</param>
Material(Handle<SHMaterialInstance> material);
public:
/*-----------------------------------------------------------------------------*/
/* Properties */
/*-----------------------------------------------------------------------------*/
// TODO: Change Shader
/*-----------------------------------------------------------------------------*/
/* Material Properties Functions */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Set the value of a specific property.
/// </summary>
/// <typeparam name="T">Type of property to set.</typeparam>
/// <param name="name">Name of the property to set.</param>
/// <param name="value">Value to set te property to.</param>
/// <exception cref="System.InvalidOperationException">
/// If this Material object is invalid.
/// </exception>
/// <exception cref="System.ArgumentException">
/// If the name or type was specified that does not match the material's shader's
/// defined properties.
/// </exception>
generic<typename T>
void SetProperty(System::String^ name, T value);
/// <summary>
/// Retrieves the value of a specified property on the material.
/// </summary>
/// <typeparam name="T">Type of property to get.</typeparam>
/// <param name="name">Name of the property to get.</param>
/// <returns>Value of that property on the material.</returns>
/// <exception cref="System.InvalidOperationException">
/// If this Material object is invalid.
/// </exception>
/// <exception cref="System.ArgumentException">
/// If the name or type was specified that does not match the material's shader's
/// defined properties.
/// </exception>
generic<typename T>
T GetProperty(System::String^ name);
};
}

34
SHADE_Managed/src/Assets/Mesh.cxx Normal file
View File

@ -0,0 +1,34 @@
/************************************************************************************//*!
\file Mesh.cxx
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Oct 28, 2022
\brief Contains the implementation of the functions of the managed Mesh class.
Note: This file is written in C++17/CLI.
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.
*//*************************************************************************************/
// Precompiled Headers
#include "SHpch.h"
// Primary Header
#include "Mesh.hxx"
// Project Headers
#include "Utility/Convert.hxx"
namespace SHADE
{
/*---------------------------------------------------------------------------------*/
/* Explicit Template Instantiation */
/*---------------------------------------------------------------------------------*/
template ref class NativeAsset<SHMesh>;
/*---------------------------------------------------------------------------------*/
/* Constructors/Destructor */
/*---------------------------------------------------------------------------------*/
Mesh::Mesh(Handle<SHMesh> mesh)
: NativeAsset<SHMesh> { mesh }
{}
}

41
SHADE_Managed/src/Assets/Mesh.hxx Normal file
View File

@ -0,0 +1,41 @@
/************************************************************************************//*!
\file Mesh.hxx
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Oct 28, 2022
\brief Contains the definition of the managed Mesh class.
Note: This file is written in C++17/CLI.
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
// External Dependencies
#include "Resource/SHHandle.h"
#include "Graphics/MiddleEnd/Interface/SHMeshLibrary.h"
// Project Includes
#include "NativeAsset.hxx"
#include "Engine/GenericHandle.hxx"
namespace SHADE
{
/// <summary>
/// Managed counterpart of the native Mesh object containing vertex data that can
/// be fed to Renderables for rendering.
/// </summary>
public ref class Mesh : public NativeAsset<SHMesh>
{
internal:
/*-----------------------------------------------------------------------------*/
/* Constructors/Destructor */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Constructor for the Mesh
/// </summary>
/// <param name="mesh">Handle to the mesh object.</param>
Mesh(Handle<SHMesh> mesh);
};
}

26
SHADE_Managed/src/Assets/NativeAsset.cxx Normal file
View File

@ -0,0 +1,26 @@
/************************************************************************************//*!
\file NativeAsset.cxx
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Oct 28, 2022
\brief Contains the explicit template instantiation for some types of the
templated managed NativeAsset class.
Note: This file is written in C++17/CLI.
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 Include
#include "NativeAsset.hxx"
// Project Includes
#include "Engine/GenericHandle.hxx"
namespace SHADE
{
/*---------------------------------------------------------------------------------*/
/* Explicit Tempalte Instantiations */
/*---------------------------------------------------------------------------------*/
}

49
SHADE_Managed/src/Assets/NativeAsset.h++ Normal file
View File

@ -0,0 +1,49 @@
/************************************************************************************//*!
\file NativeAsset.h++
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Oct 28, 2022
\brief Contains the definition of templated functions for the managed
NativeAsset classes.
Note: This file is written in C++17/CLI.
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
// Primary Include
#include "NativeAsset.hxx"
namespace SHADE
{
/*---------------------------------------------------------------------------------*/
/* Properties */
/*---------------------------------------------------------------------------------*/
template <typename NativeAssetType>
GenericHandle NativeAsset<NativeAssetType>::NativeObjectHandle::get()
{
return nativeObjHandle;
}
template <typename NativeAssetType>
Handle<NativeAssetType> NativeAsset<NativeAssetType>::NativeObject::get()
try
{
return Handle<NativeAssetType>(Convert::ToNative(nativeObjHandle));
}
catch (const BadHandleCastException&)
{
return Handle<NativeAssetType>(); // Null handle
}
/*---------------------------------------------------------------------------------*/
/* Constructors */
/*---------------------------------------------------------------------------------*/
template <typename NativeAssetType>
NativeAsset<NativeAssetType>::NativeAsset(Handle<NativeAssetType> nativeObj)
: nativeObjHandle{ Convert::ToCLI(Handle<void>(nativeObj)) }
{}
}

66
SHADE_Managed/src/Assets/NativeAsset.hxx Normal file
View File

@ -0,0 +1,66 @@
/************************************************************************************//*!
\file NativeAsset.hxx
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Oct 28, 2022
\brief Contains the template definition of the managed class that represents
native assets with a pointer to the corresponding native object.
Note: This file is written in C++17/CLI.
Copyright (C) 2021 DigiPen Institute of Technology.
Reproduction or disclosure of this file or its contents without the prior written consent
of DigiPen Institute of Technology is prohibited.
*//*************************************************************************************/
#pragma once
#include "Engine/GenericHandle.hxx"
namespace SHADE
{
/// <summary>
/// Generalised template class for a managed representation of a native asset
/// </summary>
/// <typeparam name="NativeAssetType">
/// The type of the asset's native representation.
/// </typeparam>
template<typename NativeAssetType>
public ref class NativeAsset
{
internal:
/*-----------------------------------------------------------------------------*/
/* Properties */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Generic handle for the native object
/// </summary>
property GenericHandle NativeObjectHandle
{
GenericHandle get();
}
/// <summary>
/// Copy of the Handle to the native object.
/// </summary>
property Handle<NativeAssetType> NativeObject
{
Handle<NativeAssetType> get();
}
/*-----------------------------------------------------------------------------*/
/* Constructors/Destructor */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Constructor for the native asset
/// </summary>
/// <param name="ptr">Native asset object.</param>
NativeAsset(Handle<NativeAssetType> ptr);
protected:
/*-----------------------------------------------------------------------------*/
/* Data Members */
/*-----------------------------------------------------------------------------*/
GenericHandle nativeObjHandle;
};
}
#include "NativeAsset.h++"

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

@ -22,7 +22,7 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
/* ColliderBound - Constructors */
/*---------------------------------------------------------------------------------*/
ColliderBound::ColliderBound(int arrayIdx, Entity attachedEntity)
CollisionShape::CollisionShape(int arrayIdx, Entity attachedEntity)
: arrayIndex { arrayIdx }
, entity { attachedEntity }
{}
@ -30,7 +30,7 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
/* ColliderBound - Setter Functions */
/*---------------------------------------------------------------------------------*/
void ColliderBound::updateArrayIndex(int index)
void CollisionShape::updateArrayIndex(int index)
{
arrayIndex = index;
}
@ -38,42 +38,42 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
/* BoxColliderBound - Constructors */
/*---------------------------------------------------------------------------------*/
BoxColliderBound::BoxColliderBound(int arrayIdx, Entity attachedEntity)
: ColliderBound { arrayIndex, attachedEntity }
BoxCollider::BoxCollider(int arrayIdx, Entity attachedEntity)
: CollisionShape { arrayIndex, attachedEntity }
{}
/*---------------------------------------------------------------------------------*/
/* BoxColliderBound - Properties */
/*---------------------------------------------------------------------------------*/
Vector3 BoxColliderBound::Center::get()
Vector3 BoxCollider::Center::get()
{
return Convert::ToCLI(getNativeBoundObject<SHBoundingBox>().GetCenter());
}
void BoxColliderBound::Center::set(Vector3 value)
void BoxCollider::Center::set(Vector3 value)
{
getNativeBoundObject<SHBoundingBox>().SetCenter(Convert::ToNative(value));
}
Vector3 BoxColliderBound::HalfExtents::get()
Vector3 BoxCollider::HalfExtents::get()
{
return Convert::ToCLI(getNativeBoundObject<SHBoundingBox>().GetHalfExtents());
}
void BoxColliderBound::HalfExtents::set(Vector3 value)
void BoxCollider::HalfExtents::set(Vector3 value)
{
getNativeBoundObject<SHBoundingBox>().SetHalfExtents(Convert::ToNative(value));
}
Vector3 BoxColliderBound::Min::get()
Vector3 BoxCollider::Min::get()
{
return Convert::ToCLI(getNativeBoundObject<SHBoundingBox>().GetMin());
}
void BoxColliderBound::Min::set(Vector3 value)
void BoxCollider::Min::set(Vector3 value)
{
getNativeBoundObject<SHBoundingBox>().SetMin(Convert::ToNative(value));
}
Vector3 BoxColliderBound::Max::get()
Vector3 BoxCollider::Max::get()
{
return Convert::ToCLI(getNativeBoundObject<SHBoundingBox>().GetMax());
}
void BoxColliderBound::Max::set(Vector3 value)
void BoxCollider::Max::set(Vector3 value)
{
getNativeBoundObject<SHBoundingBox>().SetMax(Convert::ToNative(value));
}
@ -81,11 +81,11 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
/* BoxColliderBound - Usage Functions */
/*---------------------------------------------------------------------------------*/
bool BoxColliderBound::TestPoint(Vector3 point)
bool BoxCollider::TestPoint(Vector3 point)
{
return getNativeBoundObject<SHBoundingBox>().TestPoint(Convert::ToNative(point));
}
bool BoxColliderBound::Raycast(Ray ray, float maxDistance)
bool BoxCollider::Raycast(Ray ray, float maxDistance)
{
return getNativeBoundObject<SHBoundingBox>().Raycast(Convert::ToNative(ray), maxDistance);
}
@ -93,19 +93,19 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
/* BoxColliderBound - Properties */
/*---------------------------------------------------------------------------------*/
Vector3 SphereColliderBound::Center::get()
Vector3 SphereCollider::Center::get()
{
return Convert::ToCLI(getNativeBoundObject<SHBoundingSphere>().GetCenter());
}
void SphereColliderBound::Center::set(Vector3 value)
void SphereCollider::Center::set(Vector3 value)
{
getNativeBoundObject<SHBoundingSphere>().SetCenter(Convert::ToNative(value));
}
float SphereColliderBound::Radius::get()
float SphereCollider::Radius::get()
{
return getNativeBoundObject<SHBoundingSphere>().GetRadius();
}
void SphereColliderBound::Radius::set(float value)
void SphereCollider::Radius::set(float value)
{
getNativeBoundObject<SHBoundingSphere>().SetRadius(value);
}
@ -113,11 +113,11 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
/* SphereColliderBound - Usage Functions */
/*---------------------------------------------------------------------------------*/
bool SphereColliderBound::TestPoint(Vector3 point)
bool SphereCollider::TestPoint(Vector3 point)
{
return getNativeBoundObject<SHBoundingBox>().TestPoint(Convert::ToNative(point));
}
bool SphereColliderBound::Raycast(Ray ray, float maxDistance)
bool SphereCollider::Raycast(Ray ray, float maxDistance)
{
return getNativeBoundObject<SHBoundingBox>().Raycast(Convert::ToNative(ray), maxDistance);
}
@ -125,8 +125,8 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
/* SphereColliderBound - Constructors */
/*---------------------------------------------------------------------------------*/
SphereColliderBound::SphereColliderBound(int arrayIndex, Entity attachedEntity)
: ColliderBound{ arrayIndex, attachedEntity }
SphereCollider::SphereCollider(int arrayIndex, Entity attachedEntity)
: CollisionShape{ arrayIndex, attachedEntity }
{}
/*---------------------------------------------------------------------------------*/
@ -137,7 +137,7 @@ namespace SHADE
{
// Create lists if they don't exist
if (colliders == nullptr)
colliders = gcnew CollidersMap;
colliders = gcnew ColliderMap;
if (!colliders->ContainsKey(entity))
colliders->Add(entity, gcnew WeakReferenceList());
@ -148,7 +148,7 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
/* Collider - Properties */
/*---------------------------------------------------------------------------------*/
int Collider::ColliderBoundsCount::get()
int Collider::CollisionShapeCount::get()
{
return static_cast<int>(GetNativeComponent()->GetColliders().size());
}
@ -156,7 +156,7 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
/* Collider - ColliderBound Functions */
/*---------------------------------------------------------------------------------*/
ColliderBound^ Collider::GetColliderBound(int index)
CollisionShape^ Collider::GetCollisionShape(int index)
{
// Populate the list if it hasn't been
if (subColliderList == nullptr)
@ -172,15 +172,15 @@ namespace SHADE
return subColliderList[index];
}
generic<typename T>
T Collider::GetColliderBound(int index)
T Collider::GetCollisionShape(int index)
{
return safe_cast<T>(GetColliderBound(index));
return safe_cast<T>(GetCollisionShape(index));
}
/*---------------------------------------------------------------------------------*/
/* Event Handling Functions */
/*---------------------------------------------------------------------------------*/
void Collider::OnColliderRemoved(EntityID entity)
void Collider::OnCollisionShapeRemoved(EntityID entity)
{
SAFE_NATIVE_CALL_BEGIN
// Check if there are any colliders to update
@ -192,7 +192,7 @@ namespace SHADE
SAFE_NATIVE_CALL_END("Collider.OnColliderRemoved")
}
void Collider::OnColliderBoundChanged(EntityID entity)
void Collider::OnCollisionShapeChanged(EntityID entity)
{
SAFE_NATIVE_CALL_BEGIN
// Check if there are any colliders to update
@ -226,20 +226,20 @@ namespace SHADE
if (subColliderList)
subColliderList->Clear();
else
subColliderList = gcnew System::Collections::Generic::List<ColliderBound^>();
subColliderList = gcnew System::Collections::Generic::List<CollisionShape^>();
// Populate the list
int i = 0;
for (const auto& collider : GetNativeComponent()->GetColliders())
{
ColliderBound^ bound = nullptr;
switch (collider.first.GetType())
CollisionShape^ bound = nullptr;
switch (collider.GetType())
{
case SHCollider::Type::BOX:
bound = gcnew BoxColliderBound(i, Owner.GetEntity());
bound = gcnew BoxCollider(i, Owner.GetEntity());
break;
case SHCollider::Type::SPHERE:
bound = gcnew SphereColliderBound(i, Owner.GetEntity());
bound = gcnew SphereCollider(i, Owner.GetEntity());
break;
case SHCollider::Type::CAPSULE:
// TODO

6
SHADE_Managed/src/Components/Collider.h++
View File

@ -18,8 +18,8 @@ of DigiPen Institute of Technology is prohibited.
#include "Component.hxx"
namespace SHADE
{
template<typename ColliderBoundType>
ColliderBoundType& SHADE::ColliderBound::getNativeBoundObject()
template<typename CollisionShapeType>
CollisionShapeType& SHADE::CollisionShape::getNativeBoundObject()
{
SHColliderComponent* collider = SHComponentManager::GetComponent_s<SHColliderComponent>(entity);
if (!collider)
@ -31,7 +31,7 @@ namespace SHADE
if (bounds.GetType() != SHCollider::Type::BOX)
throw gcnew System::InvalidOperationException("Attempted to retrieve invalid ColliderBound.");
return reinterpret_cast<ColliderBoundType&>(bounds);
return reinterpret_cast<CollisionShapeType&>(bounds);
}
catch (std::invalid_argument&)
{

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

@ -27,7 +27,7 @@ namespace SHADE
/// <summary>
/// Base interface for all Collider Shapes.
/// </summary>
public ref class ColliderBound
public ref class CollisionShape abstract
{
public:
/*-----------------------------------------------------------------------------*/
@ -51,7 +51,7 @@ namespace SHADE
/*-----------------------------------------------------------------------------*/
/* Constructors */
/*-----------------------------------------------------------------------------*/
ColliderBound(int arrayIdx, Entity attachedEntity);
CollisionShape(int arrayIdx, Entity attachedEntity);
/*-----------------------------------------------------------------------------*/
/* Data Members */
@ -62,8 +62,8 @@ namespace SHADE
/*-----------------------------------------------------------------------------*/
/* Helper Functions */
/*-----------------------------------------------------------------------------*/
template<typename ColliderBoundType>
ColliderBoundType& getNativeBoundObject();
template<typename CollisionShapeType>
CollisionShapeType& getNativeBoundObject();
internal:
/*-----------------------------------------------------------------------------*/
@ -75,7 +75,7 @@ namespace SHADE
/// <summary>
/// Box-shaped Collider Bound.
/// </summary>
public ref class BoxColliderBound : public ColliderBound
public ref class BoxCollider : public CollisionShape
{
public:
/*-----------------------------------------------------------------------------*/
@ -128,13 +128,13 @@ namespace SHADE
/*-----------------------------------------------------------------------------*/
/* Constructors */
/*-----------------------------------------------------------------------------*/
BoxColliderBound(int arrayIndex, Entity attachedEntity);
BoxCollider(int arrayIndex, Entity attachedEntity);
};
/// <summary>
/// Sphere-shaped Collider Bound.
/// </summary>
public ref class SphereColliderBound : public ColliderBound
public ref class SphereCollider : public CollisionShape
{
public:
/*-----------------------------------------------------------------------------*/
@ -169,7 +169,7 @@ namespace SHADE
/*-----------------------------------------------------------------------------*/
/* Constructors */
/*-----------------------------------------------------------------------------*/
SphereColliderBound(int arrayIndex, Entity attachedEntity);
SphereCollider(int arrayIndex, Entity attachedEntity);
};
/// <summary>
@ -196,7 +196,7 @@ namespace SHADE
/// <summary>
/// Total number of ColliderBounds in the Collider component.
/// </summary>
property int ColliderBoundsCount
property int CollisionShapeCount
{
int get();
}
@ -209,7 +209,7 @@ namespace SHADE
/// </summary>
/// <param name="index">Index to retrieve a ColliderBound from.</param>
/// <returns>ColliderBound for the specified index.</returns>
ColliderBound^ GetColliderBound(int index);
CollisionShape^ GetCollisionShape(int index);
/// <summary>
/// Retrieves a ColliderBound at the specified index in the ColliderBound list
/// and casts it to the appropriate type.
@ -217,42 +217,42 @@ namespace SHADE
/// <typeparam name="T">Type of the ColliderBound to cast to.</typeparam>
/// <param name="index">Index to retrieve a ColliderBound from.</param>
/// <returns>ColliderBound for the specified index.</returns>
generic<typename T> where T:ColliderBound
T GetColliderBound(int index);
generic<typename T> where T:CollisionShape
T GetCollisionShape(int index);
internal:
/*-----------------------------------------------------------------------------*/
/* Event Handling Functions */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// To be called from native code when a collider has been removed.
/// To be called from native code when a collision shape has been removed.
/// </summary>
/// <param name="entity">The entity which has it's collider removed.</param>
static void OnColliderRemoved(EntityID entity);
/// <param name="entity">The entity which has it's collision shape removed.</param>
static void OnCollisionShapeRemoved(EntityID entity);
/// <summary>
/// To be called from native code when a Collider bound has been removed.
/// To be called from native code when a Collision Shape has been changed.
/// </summary>
/// <param name="entity">
/// The entity which has it's collider bounds changed.
/// The entity which has it's collision shape changed.
/// </param>
static void OnColliderBoundChanged(EntityID entity);
static void OnCollisionShapeChanged(EntityID entity);
private:
/*-----------------------------------------------------------------------------*/
/* Type Definitions */
/*-----------------------------------------------------------------------------*/
using WeakReferenceList = System::Collections::Generic::List<System::WeakReference^>;
using CollidersMap = System::Collections::Generic::Dictionary<EntityID, WeakReferenceList^>;
using ColliderMap = System::Collections::Generic::Dictionary<EntityID, WeakReferenceList^>;
/*-----------------------------------------------------------------------------*/
/* Static Data Members */
/*-----------------------------------------------------------------------------*/
static CollidersMap^ colliders;
static ColliderMap^ colliders;
/*-----------------------------------------------------------------------------*/
/* Data Members */
/*-----------------------------------------------------------------------------*/
System::Collections::Generic::List<ColliderBound^>^ subColliderList;
System::Collections::Generic::List<CollisionShape^>^ subColliderList;
/*-----------------------------------------------------------------------------*/
/* Helper Functions */

67
SHADE_Managed/src/Components/Renderable.cxx Normal file
View File

@ -0,0 +1,67 @@
/************************************************************************************//*!
\file Renderable.cxx
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Oct 28, 2022
\brief Contains the definition of the functions of the managed Renderable class.
Note: This file is written in C++17/CLI.
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.
*//*************************************************************************************/
// Precompiled Headers
#include "SHpch.h"
// Primary Header
#include "Renderable.hxx"
#include "Assets/NativeAsset.hxx"
#include "Utility/Convert.hxx"
namespace SHADE
{
/*---------------------------------------------------------------------------------*/
/* Constructors */
/*---------------------------------------------------------------------------------*/
Renderable::Renderable(Entity entity)
: Component(entity)
{}
/*---------------------------------------------------------------------------------*/
/* Properties */
/*---------------------------------------------------------------------------------*/
SHADE::Mesh^ Renderable::Mesh::get()
{
return gcnew SHADE::Mesh(GetNativeComponent()->GetMesh());
}
void Renderable::Mesh::set(SHADE::Mesh^ value)
{
if (value == nullptr)
{
GetNativeComponent()->SetMesh(Handle<SHMesh>());
}
else
{
GetNativeComponent()->SetMesh(Handle<SHMesh>(Convert::ToNative(value->NativeObjectHandle)));
}
}
SHADE::Material^ Renderable::Material::get()
{
return gcnew SHADE::Material(GetNativeComponent()->GetMaterial());
}
void Renderable::Material::set(SHADE::Material^ value)
{
if (value == nullptr)
{
GetNativeComponent()->SetMaterial(Handle<SHMaterialInstance>());
}
else
{
GetNativeComponent()->SetMaterial(Handle<SHMaterialInstance>(Convert::ToNative(value->NativeObjectHandle)));
}
}
System::Byte Renderable::LightLayer::get()
{
return GetNativeComponent()->GetLightLayer();
}
}

73
SHADE_Managed/src/Components/Renderable.hxx Normal file
View File

@ -0,0 +1,73 @@
/************************************************************************************//*!
\file Renderable.hxx
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Oct 28, 2022
\brief Contains the definition of the managed Renderable class with the
declaration of functions for working with it.
Note: This file is written in C++17/CLI.
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 Includes
#include "Components/Component.hxx"
#include "Math/Vector3.hxx"
#include "Math/Quaternion.hxx"
// External Dependencies
#include "Graphics/MiddleEnd/Interface/SHRenderable.h"
#include "Assets/Mesh.hxx"
#include "Assets/Material.hxx"
namespace SHADE
{
/// <summary>
/// CLR version of the SHADE Engine's SHRenderableComponent.
/// </summary>
public ref class Renderable : public Component<SHRenderable>
{
internal:
/*-----------------------------------------------------------------------------*/
/* Constructors */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Constructs a Renderable Component that represents a native Renderable
/// component tied to the specified Entity.
/// </summary>
/// <param name="entity">Entity that this Component will be tied to.</param>
Renderable(Entity entity);
public:
/*-----------------------------------------------------------------------------*/
/* Properties */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Mesh used to render this Renderable.
/// </summary>
property SHADE::Mesh^ Mesh
{
SHADE::Mesh^ get();
void set(SHADE::Mesh^ value);
}
/// <summary>
/// Material used to render this Renderable.
/// </summary>
property SHADE::Material^ Material
{
SHADE::Material^ get();
void set(SHADE::Material^ value);
}
/// <summary>
/// Material used to render this Renderable.
/// </summary>
property System::Byte LightLayer
{
System::Byte get();
}
};
}

47
SHADE_Managed/src/Engine/GenericHandle.cxx Normal file
View File

@ -0,0 +1,47 @@
/************************************************************************************//*!
\file Renderable.cxx
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Oct 28, 2022
\brief Contains the definition of the functions of the managed Renderable class.
Note: This file is written in C++17/CLI.
Copyright (C) 2022 DigiPen Institute of Technology.
Reproduction or disclosure of this file or its contents without the prior written consent
of DigiPen Institute of Technology is prohibited.
*//*************************************************************************************/
#include "SHpch.h"
#include "GenericHandle.hxx"
namespace SHADE
{
/*---------------------------------------------------------------------------------*/
/* Constructors */
/*---------------------------------------------------------------------------------*/
GenericHandle::GenericHandle(Handle<void> handle)
: id { handle.GetId().Raw }
, library { reinterpret_cast<void*>(handle.GetLibrary()) }
{}
/*---------------------------------------------------------------------------------*/
/* Properties */
/*---------------------------------------------------------------------------------*/
System::UInt64 GenericHandle::Id::get()
{
return id;
}
System::IntPtr GenericHandle::Library::get()
{
return library;
}
/*---------------------------------------------------------------------------------*/
/* Overloaded Operators */
/*---------------------------------------------------------------------------------*/
GenericHandle::operator bool()
{
return library.ToPointer() != nullptr && id != System::UInt64::MaxValue;
}
}

68
SHADE_Managed/src/Engine/GenericHandle.hxx Normal file
View File

@ -0,0 +1,68 @@
/************************************************************************************//*!
\file Handle.hxx
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Oct 28, 2022
\brief Contains the definition of the managed GenericHandle struct.
Note: This file is written in C++17/CLI.
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
// External Dependencies
#include "Resource/SHHandle.h"
namespace SHADE
{
/// <summary>
/// Managed version of the generic Handle<void>.
/// </summary>
public value struct GenericHandle
{
public:
/*-----------------------------------------------------------------------------*/
/* Constructors */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Constructs a GenericHandle for a native generic Handle<void>.
/// </summary>
/// <param name="handle">Handle to create a GenericHandle from.</param>
explicit GenericHandle(Handle<void> handle);
/*-----------------------------------------------------------------------------*/
/* Properties */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// The internal ID of the handle.
/// </summary>
property System::UInt64 Id
{
System::UInt64 get();
}
/// <summary>
/// The library that the handle was issued by.
/// </summary>
property System::IntPtr Library
{
System::IntPtr get();
}
/*-----------------------------------------------------------------------------*/
/* Overloaded Operators */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Converts to true if this is a valid Handle.
/// </summary>
inline operator bool();
/*-----------------------------------------------------------------------------*/
/* Data Members */
/*-----------------------------------------------------------------------------*/
System::UInt64 id;
System::IntPtr library;
};
}

154
SHADE_Managed/src/Graphics/Color.cxx Normal file
View File

@ -0,0 +1,154 @@
/************************************************************************************//*!
\file Color.cxx
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Nov 3, 2021
\brief Contains the definition of the functions of the managed Color struct.
Note: This file is written in C++17/CLI.
Copyright (C) 2021 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.
*//*************************************************************************************/
// Precompiled Headers
#include "SHpch.h"
// Primary Header
#include "Graphics/Color.hxx"
// Standard Libraries
#include <algorithm>
// Project Includes
#include "Math/Math.hxx"
namespace SHADE
{
/*---------------------------------------------------------------------------------*/
/* Constructors */
/*---------------------------------------------------------------------------------*/
Color::Color(float _red)
: Color { _red, 0.0f, 0.0f, 1.0f }
{}
Color::Color(float _red, float _green)
: Color { _red, _green, 0.0f, 1.0f }
{}
Color::Color(float _red, float _green, float _blue)
: Color { _red, _green, _blue, 1.0f }
{}
Color::Color(float _red, float _green, float _blue, float _alpha)
: r { _red }
, g { _green }
, b { _blue }
, a { _alpha }
{}
/*---------------------------------------------------------------------------------*/
/* IEquatable */
/*---------------------------------------------------------------------------------*/
bool Color::Equals(Object^ o)
{
try
{
Color col = safe_cast<Color>(o);
return Equals(col);
}
catch (System::InvalidCastException^)
{
return false;
}
}
/*---------------------------------------------------------------------------------*/
/* Object Overrides */
/*---------------------------------------------------------------------------------*/
bool Color::Equals(Color other)
{
return Math::CompareFloat(this->r, other.r)
&&
Math::CompareFloat(this->g, other.g)
&&
Math::CompareFloat(this->b, other.b)
&&
Math::CompareFloat(this->a, other.a);
}
int Color::GetHashCode()
{
const int HASH = 19;
const int HASH2 = 23;
const int HASH3 = 29;
return r.GetHashCode() * HASH
+ g.GetHashCode() * HASH2
+ b.GetHashCode() * HASH3
+ a.GetHashCode();
}
/*---------------------------------------------------------------------------------*/
/* Static Functions */
/*---------------------------------------------------------------------------------*/
Color Color::Lerp(Color colA, Color colB, float t)
{
return LerpUnclamped(colA, colB, std::clamp(t, 0.0f, 1.0f));
}
Color Color::LerpUnclamped(Color colA, Color colB, float t)
{
return colA + ((colB - colA) * t);
}
Color Color::operator+(Color lhs, Color rhs)
{
return Color
(
lhs.r + rhs.r,
lhs.g + rhs.g,
lhs.b + rhs.b,
lhs.a + rhs.a
);
}
Color Color::operator-(Color lhs, Color rhs)
{
return Color
(
lhs.r - rhs.r,
lhs.g - rhs.g,
lhs.b - rhs.b,
lhs.a - rhs.a
);
}
Color Color::operator*(Color lhs, Color rhs)
{
return Color
(
lhs.r * rhs.r,
lhs.g * rhs.g,
lhs.b * rhs.b,
lhs.a * rhs.a
);
}
Color Color::operator*(Color lhs, float rhs)
{
return Color
(
lhs.r * rhs,
lhs.g * rhs,
lhs.b * rhs,
lhs.a * rhs
);
}
Color Color::operator/(Color lhs, float rhs)
{
return Color
(
lhs.r / rhs,
lhs.g / rhs,
lhs.b / rhs,
lhs.a / rhs
);
}
bool Color::operator==(Color lhs, Color rhs)
{
return lhs.Equals(rhs);
}
bool Color::operator!=(Color lhs, Color rhs)
{
return !(lhs == rhs);
}
}

287
SHADE_Managed/src/Graphics/Color.hxx Normal file
View File

@ -0,0 +1,287 @@
/************************************************************************************//*!
\file Color.hxx
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Oct 28, 2022
\brief Contains the definition of the managed Color struct with the
declaration of functions for working with it.
Note: This file is written in C++17/CLI.
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
namespace SHADE
{
/// <summary>
/// CLR version of the the SHADE Engine's Color struct which describes a Color
/// encoded using floating point numbers that range from 0.0f to 1.0f.
/// </summary>
[System::Runtime::InteropServices::StructLayout(System::Runtime::InteropServices::LayoutKind::Sequential)]
public value struct Color : public System::IEquatable<Color>
{
public:
/*-----------------------------------------------------------------------------*/
/* Type Definitions */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// A static class that contains a set of default Colors.
/// </summary>
ref class Defaults abstract sealed
{
public:
/*-------------------------------------------------------------------------*/
/* Properties */
/*-------------------------------------------------------------------------*/
/// <summary>
/// Pure black.
/// </summary>
static property Color Black
{
Color get() { return Color(0.0f, 0.0f, 0.0f); }
}
/// <summary>
/// Light Gray, lighter than gray.
/// </summary>
static property Color LightGray
{
Color get() { return Color(0.827451f, 0.827451f, 0.827451f); }
}
/// <summary>
/// Gray, halfway between black and white.
/// </summary>
static property Color Gray
{
Color get() { return Color(0.5f, 0.5f, 0.5f); }
}
/// <summary>
/// Dark Gray, darker than gray.
/// </summary>
static property Color DarkGray
{
Color get() { return Color(0.622f, 0.622f, 0.622f); }
}
/// <summary>
/// Pure white.
/// </summary>
static property Color White
{
Color get() { return Color(1.0f, 1.0f, 1.0f); }
}
/// <summary>
/// Pure red.
/// </summary>
static property Color Red
{
Color get() { return Color(1.0f, 0.0f, 0.0f); }
}
/// <summary>
/// Pure green.
/// </summary>
static property Color Green
{
Color get() { return Color(0.0f, 1.0f, 0.0f); }
}
/// <summary>
/// Pure blue.
/// </summary>
static property Color Blue
{
Color get() { return Color(0.0f, 0.0f, 1.0f); }
}
/// <summary>
/// Pure cyan, mix of pure green and blue.
/// </summary>
static property Color Cyan
{
Color get() { return Color(0.0f, 1.0f, 1.0f); }
}
/// <summary>
/// Pure magenta, mix of pure red and blue.
/// </summary>
static property Color Magenta
{
Color get() { return Color(1.0f, 0.0f, 1.0f); }
}
/// <summary>
/// Pure yellow, mix of pure red and green.
/// </summary>
static property Color Yellow
{
Color get() { return Color(1.0f, 1.0f, 0.0f); }
}
};
/*-----------------------------------------------------------------------------*/
/* Constructors */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Constructor to construct a Color with the specified components with the
/// green, blue and alpha component set to 1.0f.
/// </summary>
/// <param name="_red">Red component to set.</param>
Color(float _red);
/// <summary>
/// Constructor to construct a Color with the specified components with the
/// blue and alpha component set to 1.0f.
/// </summary>
/// <param name="_red">Red component to set.</param>
/// <param name="_green">Green component to set.</param>
Color(float _red, float _green);
/// <summary>
/// Constructor to construct a Color with the specified components with the
/// alpha component set to 1.0f.
/// </summary>
/// <param name="_red">Red component to set.</param>
/// <param name="_green">Green component to set.</param>
/// <param name="_blue">Blue component to set.</param>
Color(float _red, float _green, float _blue);
/// <summary>
/// Constructor to construct a Color with the specified components.
/// </summary>
/// <param name="_red">Red component to set.</param>
/// <param name="_green">Green component to set.</param>
/// <param name="_blue">Blue component to set.</param>
/// <param name="_alpha">Alpha component to set.</param>
Color(float _red, float _green, float _blue, float _alpha);
/*-----------------------------------------------------------------------------*/
/* Public Members */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Red component of the colour. Ranges from 0.0f to 1.0f.
/// </summary>
float r;
/// <summary>
/// Green component of the colour. Ranges from 0.0f to 1.0f.
/// </summary>
float g;
/// <summary>
/// Blue component of the colour. Ranges from 0.0f to 1.0f.
/// </summary>
float b;
/// <summary>
/// Alpha component of the colour. Ranges from 0.0f to 1.0f.
/// </summary>
float a;
/*-----------------------------------------------------------------------------*/
/* IEquatable */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Compares equality with an object of the same type.
/// </summary>
/// <param name="other">The object to compare with.</param>
/// <returns>True if both objects are the same.</returns>
virtual bool Equals(Color other);
/*-----------------------------------------------------------------------------*/
/* Object */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Compares equality with another unboxed object.
/// </summary>
/// <param name="o">The unboxed object to compare with.</param>
/// <returns>True if both objects are the same.</returns>
bool Equals(Object^ o) override;
/// <summary>
/// Gets a unique hash for this object.
/// </summary>
/// <returns>Unique hash for this object.</returns>
int GetHashCode() override;
/*-----------------------------------------------------------------------------*/
/* Static Functions */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Linearly interpolates between two specified points.
/// This is most commonly used to find a point some fraction of the way along a
/// line between two endpoints.
/// </summary>
/// <param name="colA">The start Color, returned when t = 0.0.</param>
/// <param name="colB">The end Color, returned when t = 1.0.</param>
/// <param name="t">
/// Value used to interpolate between a and b which is clamped to
/// the range[0, 1].
/// </param>
/// <returns>The interpolated Vector3.</returns>
static Color Lerp(Color colA, Color colB, float t);
/// <summary>
/// Linearly interpolates between two specified points.
/// This is most commonly used to find a point some fraction of the way along a
/// line between two endpoints.
/// Unlike Lerp(), t is not clamped to a range at all.
/// </summary>
/// <param name="colA">The start Color, returned when t = 0.0.</param>
/// <param name="colB">The end Color, returned when t = 1.0.</param>
/// <param name="t">Value used to interpolate between a and b.</param>
/// <returns>The interpolated Color.</returns>
static Color LerpUnclamped(Color colA, Color colB, float t);
/*-----------------------------------------------------------------------------*/
/* Overloaded Operators */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Adds two Colors together and returns the result.
/// </summary>
/// <param name="lhs">Color to add.</param>
/// <param name="rhs">Another Color to add.</param>
/// <returns>The result of lhs added to rhs</returns>
static Color operator+(Color lhs, Color rhs);
/// <summary>
/// Subtracts a Color from another Color and returns the result.
/// </summary>
/// <param name="lhs">Color to subtract from.</param>
/// <param name="rhs">Another Color to subtract.</param>
/// <returns>The result of rhs subtracted from lhs.</returns>
static Color operator-(Color lhs, Color rhs);
/// <summary>
/// Calculates the component-wise multiplication of two Colors and returns the
/// result.
/// </summary>
/// <param name="lhs">Color to multiply with.</param>
/// <param name="rhs">Another Color to multiply with.</param>
/// <returns>The result of rhs subtracted from lhs.</returns>
static Color operator*(Color lhs, Color rhs);
/// <summary>
/// Calculates the multiplication of a Color with a scalar value and returns
/// the result.
/// </summary>
/// <param name="lhs">Color to multiply with.</param>
/// <param name="rhs">Scalar to multiply with.</param>
/// <returns>The result of the scalar multiplication.</returns>
static Color operator*(Color lhs, float rhs);
/// <summary>
/// Calculates the division of a Color with a scalar value and returns
/// the result.
/// </summary>
/// <param name="lhs">Scalar to divide with.</param>
/// <param name="rhs">Color to divide with.</param>
/// <returns>The result of the scalar division.</returns>
static Color operator/(Color lhs, float rhs);
/// <summary>
/// Checks if two Colors are approximately equal.
/// </summary>
/// <param name="lhs">Color to compare.</param>
/// <param name="rhs">Another Color to compare.</param>
/// <returns>
/// True if all components are approximately equal within the default
/// tolerance value.
/// </returns>
static bool operator==(Color lhs, Color rhs);
/// <summary>
/// Checks if two Colors are not approximately equal.
/// </summary>
/// <param name="lhs">Color to compare.</param>
/// <param name="rhs">Another Color to compare.</param>
/// <returns>
/// True if all components are not approximately equal within the default
/// tolerance value.
/// </returns>
static bool operator!=(Color lhs, Color rhs);
};
}

11
SHADE_Managed/src/Math/Math.cxx
View File

@ -54,4 +54,15 @@ namespace SHADE
{
return (value - a) / (b - a);
}
bool Math::CompareFloat(float a, float b)
{
return CompareFloat(a, b, Epsilon);
}
bool Math::CompareFloat(float a, float b, float tolerance)
{
return System::MathF::Abs(a - b) < tolerance;
}
}

20
SHADE_Managed/src/Math/Math.hxx
View File

@ -81,12 +81,30 @@ namespace SHADE
/// <returns>The interpolated float result between the two float values.</returns>
static float LerpUnclamped(float a, float b, float t);
/// <summary>
/// Calculates the linear parameter t that produces the interpolant value within the range [a, b].
/// Calculates the linear parameter t that produces the interpolant value within
/// the range [a, b].
/// </summary>
/// <param name="a">Start value.</param>
/// <param name="b">End value.</param>
/// <param name="value">Value between start and end.</param>
/// <returns>Percentage of value between start and end.</returns>
static float InverseLerp(float a, float b, float value);
/// <summary>
/// Compares if two float values are close enough to be the same with a tolerance
/// of Epsilon.
/// </summary>
/// <param name="a">One of the values to compare.</param>
/// <param name="b">The other value to compare.</param>
/// <returns>True if a and b are practically the same.</returns>
static bool CompareFloat(float a, float b);
/// <summary>
/// Compares if two float values are close enough to be the same with the
/// specified tolerance value.
/// </summary>
/// <param name="a">One of the values to compare.</param>
/// <param name="b">The other value to compare.</param>
/// <param name="tolerance">Tolerance for floating point comparison.</param>
/// <returns>True if a and b are practically the same.</returns>
static bool CompareFloat(float a, float b, float tolerance);
};
}

16
SHADE_Managed/src/Utility/Convert.cxx
View File

@ -84,4 +84,20 @@ namespace SHADE
{
return msclr::interop::marshal_as<System::String^>(str);
}
/*---------------------------------------------------------------------------------*/
/* Handle Conversions */
/*---------------------------------------------------------------------------------*/
Handle<void> Convert::ToNative(GenericHandle handle)
{
Handle<void> nativeHandle;
nativeHandle.id.Raw = handle.Id;
nativeHandle.library = reinterpret_cast<SHResourceLibraryBase*>(handle.Library.ToPointer());
return nativeHandle;
}
GenericHandle Convert::ToCLI(Handle<void> handle)
{
return GenericHandle(handle);
}
}

19
SHADE_Managed/src/Utility/Convert.hxx
View File

@ -20,6 +20,7 @@ of DigiPen Institute of Technology is prohibited.
#include "Math/Vector/SHVec3.h"
#include "Math/SHQuaternion.h"
#include "Math/SHRay.h"
#include "Resource/SHHandle.h"
// Project Includes
#include "Engine/Entity.hxx"
@ -27,6 +28,7 @@ of DigiPen Institute of Technology is prohibited.
#include "Math/Vector3.hxx"
#include "Math/Quaternion.hxx"
#include "Math/Ray.hxx"
#include "Engine/GenericHandle.hxx"
namespace SHADE
{
@ -118,6 +120,23 @@ namespace SHADE
/// <param name="str">The native std::string to convert from.</param>
/// <returns>Managed copy of a native std::string.</returns>
static System::String^ ToCLI(const std::string& str);
/*-----------------------------------------------------------------------------*/
/* Handle Conversions */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Converts from a managed GenericHandle to a Handle<void>.
/// </summary>
/// <param name="handle">GenericHandle to convert from.</param>
/// <returns>Native generic Handle.</returns>
static Handle<void> ToNative(GenericHandle handle);
/// <summary>
/// Converts from a native generic Handle<void> to a managed GenericHandle.
/// </summary>
/// <param name="handle">The native handle to convert.</param>
/// <returns>Managed copy of the native Handle.</returns>
static GenericHandle ToCLI(Handle<void> handle);
};
/// <summary>