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

Add Editor Features - Transform Gizmo #105

Merged
srishamharan merged 14 commits from SP3-4-editor_fix into main 2022-10-21 20:58:48 +08:00
Conversation 0 Commits 14 Files Changed 26 +459 -373
72 changed files with 459 additions and 373 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit bf0e7ab256 - Show all commits

4
SHADE_Application/premake5.lua
View File

@ -37,7 +37,8 @@ project "SHADE_Application"
"%{IncludeDir.VULKAN}/include",
"%{IncludeDir.spdlog}/include",
"%{IncludeDir.tinyddsloader}",
"%{IncludeDir.reactphysics3d}\\include"
"%{IncludeDir.reactphysics3d}\\include",
"%{IncludeDir.yamlcpp}"
}
externalwarnings "Off"
@ -51,6 +52,7 @@ project "SHADE_Application"
{
"SHADE_Engine",
"SHADE_Managed",
"yaml-cpp",
"SDL2.lib",
"SDL2main.lib"
}

2
SHADE_Engine/src/Camera/SHCameraComponent.cpp
View File

@ -7,7 +7,7 @@ namespace SHADE
{
SHCameraComponent::SHCameraComponent()
:yaw(0.0f), pitch(0.0f), roll(0.0f)
, width(1920.0f), height(1080.0f), zNear(0.01f), zFar(10000.0f), fov(90.0f), movementSpeed(1.0f), turnSpeed(1.0f)
, width(1920.0f), height(1080.0f), zNear(0.01f), zFar(10000.0f), fov(90.0f), movementSpeed(1.0f), turnSpeed(0.5f)
, perspProj(true), dirtyView(true), dirtyProj(true)
, viewMatrix(), projMatrix()
, position()

138
SHADE_Engine/src/Camera/SHCameraSystem.cpp
View File

@ -2,6 +2,7 @@
#include "SHCameraSystem.h"
#include "Math/SHMathHelpers.h"
#include "Input/SHInputManager.h"
#include "Math/Vector/SHVec2.h"
@ -12,56 +13,51 @@ namespace SHADE
{
SHCameraSystem* system = static_cast<SHCameraSystem*>(GetSystem());
auto& camera = system->editorCamera;
SHVec3 target{ 0.0f,0.0f,-1.0f };
SHVec3 up = { 0.0f,1.0f,0.0f };
SHVec3::RotateY(target, SHMath::DegreesToRadians(camera.yaw));
SHVec3::RotateX(target, SHMath::DegreesToRadians(camera.pitch));
target += camera.position;
////SHVec3::RotateZ(target, SHMath::DegreesToRadians(camera.roll));
//target = SHVec3::Normalise(target);
SHVec3::RotateZ(up, camera.roll);
up = SHVec3::Normalise(up);
SHVec3 view = target - camera.position; view = SHVec3::Normalise(view);
SHVec3 right = SHVec3::Cross(view, up); right = SHVec3::Normalise(right);
const SHVec3 UP = SHVec3::Cross(view, right);
SHVec3 view, right, UP;
system->GetCameraAxis(camera, view, right, UP);
if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::A))
{
system->editorCamera.position -= right * dt * camera.movementSpeed;
system->editorCamera.dirtyView = true;
camera.position -= right * dt * camera.movementSpeed;
camera.dirtyView = true;
}
if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::D))
{
system->editorCamera.position += right * dt * camera.movementSpeed;
system->editorCamera.dirtyView = true;
camera.position += right * dt * camera.movementSpeed;
camera.dirtyView = true;
}
if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::W))
{
system->editorCamera.position += view * dt * camera.movementSpeed;
system->editorCamera.dirtyView = true;
camera.position += view * dt * camera.movementSpeed;
camera.dirtyView = true;
}
if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::S))
{
system->editorCamera.position -= view * dt * camera.movementSpeed;
system->editorCamera.dirtyView = true;
camera.position -= view * dt * camera.movementSpeed;
camera.dirtyView = true;
}
if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::Q))
{
system->editorCamera.position += UP * dt * camera.movementSpeed;
system->editorCamera.dirtyView = true;
camera.position += UP * dt * camera.movementSpeed;
camera.dirtyView = true;
}
if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::E))
{
system->editorCamera.position -= UP * dt * camera.movementSpeed;
system->editorCamera.dirtyView = true;
camera.position -= UP * dt * camera.movementSpeed;
camera.dirtyView = true;
}
if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::RMB))
{
double mouseX, mouseY;
SHInputManager::GetMouseVelocity(&mouseX,&mouseY);
//std::cout << camera.yaw << std::endl;
camera.pitch -= mouseY * dt * camera.turnSpeed.x;
camera.yaw -= mouseX * dt * camera.turnSpeed.y;
camera.dirtyView = true;
}
system->UpdateCameraComponent(system->editorCamera);
}
@ -89,24 +85,9 @@ namespace SHADE
{
if (camera.dirtyView)
{
SHVec3 target{ 0.0f,0.0f,-1.0f };
SHVec3 up = { 0.0f,1.0f,0.0f };
SHVec3::RotateY(target, SHMath::DegreesToRadians(camera.yaw));
SHVec3::RotateX(target, SHMath::DegreesToRadians(camera.pitch));
target += camera.position;
////SHVec3::RotateZ(target, SHMath::DegreesToRadians(camera.roll));
//target = SHVec3::Normalise(target);
SHVec3::RotateZ(up, camera.roll);
up = SHVec3::Normalise(up);
SHVec3 view = target - camera.position; view = SHVec3::Normalise(view);
SHVec3 right = SHVec3::Cross(view, up); right = SHVec3::Normalise(right);
const SHVec3 UP = SHVec3::Cross(view, right);
SHVec3 view, right, UP;
GetCameraAxis(camera, view, right, UP);
camera.viewMatrix = SHMatrix::Identity;
camera.viewMatrix(0, 0) = right[0];
@ -142,38 +123,51 @@ namespace SHADE
camera.projMatrix(3, 2) = 1.0f;
camera.projMatrix(2, 3) = -(camera.zFar * camera.zNear) / (camera.zFar - camera.zNear);
//const float fov_rad = SHMath::DegreesToRadians(camera.fov);
//const float focal_length = 1.0f / tan(fov_rad * 0.5f);
//camera.projMatrix(0,0) = focal_length / camera.GetAspectRatio();
//camera.projMatrix(1,1) = -focal_length;
//camera.projMatrix(2,2) = camera.zNear / (camera.zFar - camera.zNear);
//camera.projMatrix(2,3) = camera.zFar * (camera.zNear / (camera.zFar - camera.zNear));
//camera.projMatrix(3,2) = -1.0f;
//camera.projMatrix(3,3) = 0.0f;
//camera.projMatrix = SHMatrix::Inverse(camera.projMatrix);
camera.dirtyProj = false;
}
else
{
const float R = camera.width * 0.5f;
const float L = -R;
const float T = camera.height * 0.5f;
const float B = -T;
//const float R = camera.width * 0.5f;
//const float L = -R;
//const float T = camera.height * 0.5f;
//const float B = -T;
camera.projMatrix = SHMatrix::Identity;
camera.projMatrix(0, 0) = 2.0f / (R - L);
camera.projMatrix(1, 1) = 2.0f / (B - T);
camera.projMatrix(2, 2) = 1.0f / (camera.zFar - camera.zNear);
camera.projMatrix(3, 0) = -(R + L) / (R - L);
camera.projMatrix(3, 1) = -(B + T) / (B - T);
camera.projMatrix(3, 2) = -camera.zNear / (camera.zFar - camera.zNear);
//camera.projMatrix = SHMatrix::Identity;
//camera.projMatrix(0, 0) = 2.0f / (R - L);
//camera.projMatrix(1, 1) = 2.0f / (B - T);
//camera.projMatrix(2, 2) = 1.0f / (camera.zFar - camera.zNear);
//camera.projMatrix(3, 0) = -(R + L) / (R - L);
//camera.projMatrix(3, 1) = -(B + T) / (B - T);
//camera.projMatrix(3, 2) = -camera.zNear / (camera.zFar - camera.zNear);
camera.dirtyProj = false;
}
}
}
void SHCameraSystem::GetCameraAxis(SHCameraComponent const& camera, SHVec3& forward, SHVec3& right, SHVec3& upVec) const noexcept
{
SHVec3 target{ 0.0f,0.0f,-1.0f };
SHVec3 up = { 0.0f,1.0f,0.0f };
target = SHVec3::RotateY(target, SHMath::DegreesToRadians(camera.yaw));
target =SHVec3::RotateX(target, SHMath::DegreesToRadians(camera.pitch));
std::cout << "Target vec: " << target.x<<", "<<target.y<<", "<<target.z << std::endl;
target += camera.position;
////SHVec3::RotateZ(target, SHMath::DegreesToRadians(camera.roll));
//target = SHVec3::Normalise(target);
SHVec3::RotateZ(up, camera.roll);
up = SHVec3::Normalise(up);
forward = target - camera.position; forward = SHVec3::Normalise(forward);
right = SHVec3::Cross(forward, up); right = SHVec3::Normalise(right);
upVec = SHVec3::Cross(forward, right);
}
}

2
SHADE_Engine/src/Camera/SHCameraSystem.h
View File

@ -40,6 +40,8 @@ namespace SHADE
void UpdateCameraComponent(SHCameraComponent& camera) noexcept;
void GetCameraAxis(SHCameraComponent const& camera, SHVec3& forward, SHVec3& right, SHVec3& up) const noexcept;
};

5
SHADE_Engine/src/ECS_Base/Components/SHComponent.h
View File

@ -48,6 +48,9 @@ namespace SHADE
{
}
public:
//Whether or not this component is active.
//Systems using this component should are responsible for checking the active state of the component before running their functionality.
@ -59,7 +62,7 @@ namespace SHADE
* \return uint32_t
* The entityID that this component belongs to.
***************************************************************************/
uint32_t GetEID()const
uint32_t GetEID()const noexcept
{
return this->entityID;
}

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

@ -13,7 +13,7 @@
#include "ECS_Base/SHECSMacros.h"
#include "ECS_Base/System/SHSystem.h"
#include "ECS_Base/System/SHSystemRoutine.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
#include "EditorWindow/SHEditorWindow.h"
#include "Tools/SHLogger.h"
#include "Gizmos/SHTransformGizmo.h"

2
SHADE_Engine/src/Graphics/Buffers/SHVkBuffer.h
View File

@ -3,7 +3,7 @@
#include "Graphics/SHVulkanIncludes.h"
#include "vk_mem_alloc.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
namespace SHADE
{

4
SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.h
View File

@ -4,7 +4,7 @@
#include "Graphics/SHVulkanIncludes.h"
#include "Graphics/SHVulkanDefines.h"
#include "SHCommandPoolResetMode.h"
#include "Resource/ResourceLibrary.h"
#include "Resource/SHResourceLibrary.h"
#include "Graphics/Pipeline/SHVkPipelineLayout.h"
namespace SHADE
@ -36,7 +36,7 @@ namespace SHADE
class SHVkCommandBuffer
{
friend class SHVkCommandPool;
friend class ResourceLibrary<SHVkCommandBuffer>;
friend class SHResourceLibrary<SHVkCommandBuffer>;
static constexpr uint16_t PUSH_CONSTANT_SIZE = 512;
private:

2
SHADE_Engine/src/Graphics/Commands/SHVkCommandPool.cpp
View File

@ -2,7 +2,7 @@
#include "SHVkCommandPool.h"
#include "Graphics/Devices/SHVkLogicalDevice.h"
#include "Graphics/Instance/SHVkInstance.h"
#include "Resource/ResourceLibrary.h"
#include "Resource/SHResourceLibrary.h"
#include "Tools/SHLogger.h"
namespace SHADE

2
SHADE_Engine/src/Graphics/Commands/SHVkCommandPool.h
View File

@ -6,7 +6,7 @@
#include "Graphics/Queues/SHVkQueue.h"
#include "SHCommandPoolResetMode.h"
#include "SHVkCommandBuffer.h"
#include "Resource/ResourceLibrary.h"
#include "Resource/SHResourceLibrary.h"
namespace SHADE
{

2
SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorPool.h
View File

@ -2,7 +2,7 @@
// Project Includes
#include "Graphics/SHVulkanIncludes.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
namespace SHADE
{

2
SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetGroup.h
View File

@ -4,7 +4,7 @@
// Project Includes
#include "Graphics/SHVulkanIncludes.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
#include "Graphics/Shaders/SHShaderReflected.h"
#include "SHDescriptorSetUpdater.h"

2
SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetLayout.h
View File

@ -2,7 +2,7 @@
// Project Includes
#include "Graphics/SHVulkanIncludes.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
namespace SHADE
{

4
SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.h
View File

@ -8,8 +8,8 @@
#include "Graphics/SHVulkanIncludes.h"
#include "Graphics/Devices/SHVkPhysicalDevice.h"
#include "Graphics/Queues/SHVkQueue.h"
#include "Resource/Handle.h"
#include "Resource/ResourceLibrary.h"
#include "Resource/SHHandle.h"
#include "Resource/SHResourceLibrary.h"
#include "Graphics/Swapchain/SHSwapchainParams.h"
#include "Graphics/Commands/SHCommandPoolResetMode.h"
#include "Graphics/Commands/SHVkCommandPool.h"

2
SHADE_Engine/src/Graphics/Framebuffer/SHVkFramebuffer.h
View File

@ -2,7 +2,7 @@
#define SH_VK_FRAMEBUFFER_H
#include "Graphics/SHVulkanIncludes.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
#include <span>
namespace SHADE

2
SHADE_Engine/src/Graphics/Images/SHVkImage.h
View File

@ -3,7 +3,7 @@
#include "SHImageViewDetails.h"
#include "Graphics/SHVulkanDefines.h"
#include "Resource/ResourceLibrary.h"
#include "Resource/SHResourceLibrary.h"
#include "vk_mem_alloc.h"
namespace SHADE

2
SHADE_Engine/src/Graphics/Images/SHVkImageView.h
View File

@ -2,7 +2,7 @@
#define SH_VK_IMAGE_VIEW_H
#include "Graphics/SHVulkanIncludes.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
#include "SHImageViewDetails.h"
namespace SHADE

2
SHADE_Engine/src/Graphics/Images/SHVkSampler.h
View File

@ -15,7 +15,7 @@ of DigiPen Institute of Technology is prohibited.
#include <vector>
// Project Includes
#include "Graphics/SHVulkanIncludes.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
namespace SHADE
{

4
SHADE_Engine/src/Graphics/Instance/SHVkInstance.cpp
View File

@ -15,7 +15,7 @@ namespace SHADE
bool SHVkInstance::validationLayersOn;
vk::Instance SHVkInstance::vkInstance;
SHVkDebugMessenger SHVkInstance::debugMessenger;
ResourceManager SHVkInstance::resourceManager;
SHResourceHub SHVkInstance::resourceManager;
/***************************************************************************/
/*!
@ -258,7 +258,7 @@ namespace SHADE
return vkInstance;
}
ResourceManager& SHVkInstance::GetResourceManager(void) noexcept
SHResourceHub& SHVkInstance::GetResourceManager(void) noexcept
{
return resourceManager;
}

6
SHADE_Engine/src/Graphics/Instance/SHVkInstance.h
View File

@ -18,7 +18,7 @@ written consent of DigiPen Institute of Technology is prohibited.
#include "Graphics/Debugging/SHVkDebugMessenger.h"
#include "Graphics/Devices/SHVkPhysicalDevice.h"
#include "Graphics/Devices/SHVkLogicalDevice.h"
#include "Resource/ResourceLibrary.h"
#include "Resource/SHResourceLibrary.h"
namespace SHADE
@ -61,7 +61,7 @@ namespace SHADE
static SHVkDebugMessenger debugMessenger;
//! Resource management for vulkan project
static ResourceManager resourceManager;
static SHResourceHub resourceManager;
/*-----------------------------------------------------------------------*/
/* PRIVATE MEMBER FUNCTIONS */
@ -85,7 +85,7 @@ namespace SHADE
/* Getters and Setters */
/*-----------------------------------------------------------------------*/
static vk::Instance const& GetVkInstance (void) noexcept;
static ResourceManager& GetResourceManager(void) noexcept;
static SHResourceHub& GetResourceManager(void) noexcept;
};
}

2
SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.h
View File

@ -18,7 +18,7 @@ of DigiPen Institute of Technology is prohibited.
// External Dependencies
#include "Graphics/SHVulkanIncludes.h"
// Project Includes
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
#include "Graphics/MiddleEnd/Interface/SHMaterial.h"
#include "Math/SHMatrix.h"
#include "Graphics/MiddleEnd/Interface/SHGraphicsConstants.h"

2
SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatcher.h
View File

@ -15,7 +15,7 @@ of DigiPen Institute of Technology is prohibited.
// STL Includes
#include <vector>
// Project Includes
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
namespace SHADE
{

2
SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHSuperBatch.h
View File

@ -15,7 +15,7 @@ of DigiPen Institute of Technology is prohibited.
// External Dependencies
#include "Graphics/SHVulkanIncludes.h"
// Project Includes
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
#include "SHBatch.h"
#include "Graphics/Pipeline/SHVkPipeline.h"

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

@ -17,7 +17,7 @@ of DigiPen Institute of Technology is prohibited.
#include <array>
// Project Includes
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
#include "Graphics/SHVulkanIncludes.h"
#include "Graphics/MiddleEnd/PerFrame/SHRenderContext.h"
#include "Graphics/RenderGraph/SHRenderGraph.h"
@ -313,7 +313,7 @@ namespace SHADE
SHWindow* window = nullptr;
// Middle End Resources
ResourceManager resourceManager;
SHResourceHub resourceManager;
SHMeshLibrary meshLibrary;
SHTextureLibrary texLibrary;
SHSamplerCache samplerCache;

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

@ -15,7 +15,7 @@ of DigiPen Institute of Technology is prohibited.
// STL Includes
#include <unordered_map>
// Project Includes
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
#include "SHCommonTypes.h"
namespace SHADE

2
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterialInstance.h
View File

@ -13,7 +13,7 @@ of DigiPen Institute of Technology is prohibited.
// STL Includes
#include <memory>
// Project Includes
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
#include "Graphics/Shaders/BlockInterface/SHShaderBlockInterface.h"
#include "SH_API.h"

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

@ -15,8 +15,8 @@ of DigiPen Institute of Technology is prohibited.
// STL Includes
#include <vector>
// Project Includes
#include "Resource/Handle.h"
#include "Resource/ResourceLibrary.h"
#include "Resource/SHHandle.h"
#include "Resource/SHResourceLibrary.h"
#include "Math/SHMath.h"
namespace SHADE
@ -167,7 +167,7 @@ namespace SHADE
std::vector<MeshAddJob> meshAddJobs;
std::vector<Handle<SHMesh>> meshRemoveJobs;
// Tracking
ResourceLibrary<SHMesh> meshes{};
SHResourceLibrary<SHMesh> meshes{};
std::vector<Handle<SHMesh>> meshOrder;
// CPU Storage
std::vector<SHMesh::VertexPosition> vertPosStorage;

2
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHPostOffscreenRenderSystem.h
View File

@ -1,6 +1,6 @@
#pragma once
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
namespace SHADE
{

2
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderable.h
View File

@ -12,7 +12,7 @@ of DigiPen Institute of Technology is prohibited.
#pragma once
// Project Includes
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
//#include "SHTransform.h"
#include "ECS_Base/Components/SHComponent.h"
#include "Math/SHMatrix.h"

2
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderer.h
View File

@ -17,7 +17,7 @@ of DigiPen Institute of Technology is prohibited.
// Project Includes
#include "SHCamera.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
#include "Graphics/RenderGraph/SHRenderGraph.h"
#include "Math/SHMath.h"
#include <vector>

4
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHViewport.cpp
View File

@ -17,7 +17,7 @@ of DigiPen Institute of Technology is prohibited.
#include "Graphics/Instance/SHVkInstance.h"
#include "Tools/SHLogger.h"
#include "SHRenderer.h"
#include "Resource/ResourceLibrary.h"
#include "Resource/SHResourceLibrary.h"
#include "Graphics/RenderGraph/SHRenderGraph.h"
namespace SHADE
@ -49,7 +49,7 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
/* Renderer Registration Functions */
/*---------------------------------------------------------------------------------*/
Handle<SHRenderer> SHViewport::AddRenderer(ResourceManager& resourceManager, uint32_t numFrames, std::vector<Handle<SHVkCommandPool>>& cmdPools, Handle<SHVkDescriptorPool> descriptorPool, Handle<SHVkDescriptorSetLayout> cameraDescLayout, Handle<SHRenderGraph> renderGraph)
Handle<SHRenderer> SHViewport::AddRenderer(SHResourceHub& resourceManager, uint32_t numFrames, std::vector<Handle<SHVkCommandPool>>& cmdPools, Handle<SHVkDescriptorPool> descriptorPool, Handle<SHVkDescriptorSetLayout> cameraDescLayout, Handle<SHRenderGraph> renderGraph)
{
// Create the renderer
auto renderer = resourceManager.Create<SHRenderer>(device, numFrames, cmdPools, descriptorPool, cameraDescLayout, GetHandle(), renderGraph);

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

@ -17,7 +17,7 @@ of DigiPen Institute of Technology is prohibited.
// External Dependencies
#include "Graphics/SHVulkanIncludes.h"
// Project Includes
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
namespace SHADE
{
@ -28,7 +28,7 @@ namespace SHADE
class SHVkCommandBuffer;
class SHVkLogicalDevice;
class SHVkImageView;
class ResourceManager;
class SHResourceHub;
class SHRenderGraph;
class SHVkDescriptorPool;
class SHVkDescriptorSetLayout;
@ -59,7 +59,7 @@ namespace SHADE
/*-----------------------------------------------------------------------------*/
/* Renderers Registration Functions */
/*-----------------------------------------------------------------------------*/
Handle<SHRenderer> AddRenderer(ResourceManager& resourceManager, uint32_t numFrames, std::vector<Handle<SHVkCommandPool>>& cmdPools, Handle<SHVkDescriptorPool> descriptorPool, Handle<SHVkDescriptorSetLayout> cameraDescLayout, Handle<SHRenderGraph> renderGraph);
Handle<SHRenderer> AddRenderer(SHResourceHub& resourceManager, uint32_t numFrames, std::vector<Handle<SHVkCommandPool>>& cmdPools, Handle<SHVkDescriptorPool> descriptorPool, Handle<SHVkDescriptorSetLayout> cameraDescLayout, Handle<SHRenderGraph> renderGraph);
void RemoveRenderer(Handle<SHRenderer> renderer);
/*-----------------------------------------------------------------------------*/

4
SHADE_Engine/src/Graphics/MiddleEnd/Materials/SHMaterialInstanceCache.cpp
View File

@ -14,7 +14,7 @@ of DigiPen Institute of Technology is prohibited.
#include "SHMaterialInstanceCache.h"
#include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h"
#include "Resource/ResourceLibrary.h"
#include "Resource/SHResourceLibrary.h"
namespace SHADE
@ -22,7 +22,7 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
/* Usage Functions */
/*---------------------------------------------------------------------------------*/
SHADE::Handle<SHADE::SHMaterialInstance> SHMaterialInstanceCache::CreateOrGet(ResourceManager& manager, Handle<SHMaterial> material)
SHADE::Handle<SHADE::SHMaterialInstance> SHMaterialInstanceCache::CreateOrGet(SHResourceHub& manager, Handle<SHMaterial> material)
{
// Check if there is already an existing instance
auto matInst = cache.find(material);

6
SHADE_Engine/src/Graphics/MiddleEnd/Materials/SHMaterialInstanceCache.h
View File

@ -15,7 +15,7 @@ of DigiPen Institute of Technology is prohibited.
// STL Includes
#include <unordered_map>
// Project Includes
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
namespace SHADE
{
@ -24,7 +24,7 @@ namespace SHADE
/*-----------------------------------------------------------------------------------*/
class SHMaterial;
class SHMaterialInstance;
class ResourceManager;
class SHResourceHub;
/*-----------------------------------------------------------------------------------*/
/* Type Definitions */
@ -56,7 +56,7 @@ namespace SHADE
*/
/***********************************************************************************/
Handle<SHMaterialInstance> CreateOrGet(ResourceManager& manager, Handle<SHMaterial> material);
Handle<SHMaterialInstance> CreateOrGet(SHResourceHub& manager, Handle<SHMaterial> material);
/***********************************************************************************/
/*!

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

@ -17,8 +17,8 @@ of DigiPen Institute of Technology is prohibited.
// External Dependencies
#include "tinyddsloader.h"
// Project Includes
#include "Resource/Handle.h"
#include "Resource/ResourceLibrary.h"
#include "Resource/SHHandle.h"
#include "Resource/SHResourceLibrary.h"
#include "Math/SHMath.h"
#include "Graphics/SHVulkanIncludes.h"
@ -156,7 +156,7 @@ namespace SHADE
std::vector<AddJob> addJobs;
std::vector<Handle<SHTexture>> removeJobs;
// Tracking
ResourceManager resourceManager;
SHResourceHub resourceManager;
std::vector<Handle<SHTexture>> texOrder;
// CPU Storage
std::vector<std::tuple<Handle<SHVkImageView>, Handle<SHVkSampler>, vk::ImageLayout>> combinedImageSamplers;

2
SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHVkSamplerCache.h
View File

@ -16,7 +16,7 @@ of DigiPen Institute of Technology is prohibited.
// External Dependencies
#include "Graphics/SHVulkanIncludes.h"
// Project Includes
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
namespace SHADE
{

2
SHADE_Engine/src/Graphics/Pipeline/SHPipelineLayoutParams.h
View File

@ -2,7 +2,7 @@
#define SH_PIPELINE_LAYOUT_PARAMS_H
#include "Graphics/SHVulkanIncludes.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
#include "Graphics/Descriptors/SHVkDescriptorSetLayout.h"
namespace SHADE

2
SHADE_Engine/src/Graphics/Pipeline/SHVkPipeline.h
View File

@ -3,7 +3,7 @@
#include "SHPipelineState.h"
#include "SHPipelineType.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
#include "Graphics/Pipeline/SHVkPipelineLayout.h"
namespace SHADE

2
SHADE_Engine/src/Graphics/Queues/SHVkQueue.h
View File

@ -3,7 +3,7 @@
#include "Graphics/SHVulkanIncludes.h"
#include "Graphics/SHVulkanDefines.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
namespace SHADE
{

2
SHADE_Engine/src/Graphics/RenderGraph/SHAttachmentDescInitParams.h
View File

@ -1,6 +1,6 @@
#pragma once
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
namespace SHADE
{

2
SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.cpp
View File

@ -367,7 +367,7 @@ namespace SHADE
, graphResources{}
, resourceManager{nullptr}
{
resourceManager = std::make_shared<ResourceManager>();
resourceManager = std::make_shared<SHResourceHub>();
}
SHRenderGraph::SHRenderGraph(SHRenderGraph&& rhs) noexcept

4
SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.h
View File

@ -2,7 +2,7 @@
#define SH_RENDER_GRAPH_H
#include "Graphics/Renderpass/SHVkRenderpass.h"
#include "Resource/ResourceLibrary.h"
#include "Resource/SHResourceLibrary.h"
#include "SH_API.h"
#include "Graphics/MiddleEnd/Pipeline/SHPipelineLibrary.h"
#include "Graphics/MiddleEnd/Batching/SHSuperBatch.h"
@ -71,7 +71,7 @@ namespace SHADE
std::unordered_map<std::string, Handle<SHRenderGraphResource>> graphResources;
//! Resource library for graph handles
std::shared_ptr<ResourceManager> resourceManager;
std::shared_ptr<SHResourceHub> resourceManager;
public:
/*-----------------------------------------------------------------------*/

2
SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.cpp
View File

@ -104,7 +104,7 @@ namespace SHADE
*/
/***************************************************************************/
SHRenderGraphNode::SHRenderGraphNode(std::shared_ptr<ResourceManager> rm, Handle<SHVkLogicalDevice> const& logicalDevice, Handle<SHVkSwapchain> const& swapchain, std::vector<SHAttachmentDescInitParams> attDescInitParams, std::vector<Handle<SHRenderGraphNode>> predecessors, std::unordered_map<std::string, Handle<SHRenderGraphResource>> const* resources) noexcept
SHRenderGraphNode::SHRenderGraphNode(std::shared_ptr<SHResourceHub> rm, Handle<SHVkLogicalDevice> const& logicalDevice, Handle<SHVkSwapchain> const& swapchain, std::vector<SHAttachmentDescInitParams> attDescInitParams, std::vector<Handle<SHRenderGraphNode>> predecessors, std::unordered_map<std::string, Handle<SHRenderGraphResource>> const* resources) noexcept
: logicalDeviceHdl{ logicalDevice }
, renderpass{}
, framebuffers{}

6
SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.h
View File

@ -13,7 +13,7 @@
namespace SHADE
{
class ResourceManager;
class SHResourceHub;
class SHVkFramebuffer;
class SHRenderGraphResource;
class SHVkLogicalDevice;
@ -26,7 +26,7 @@ namespace SHADE
/*-----------------------------------------------------------------------*/
/* PRIVATE MEMBER VARIABLES */
/*-----------------------------------------------------------------------*/
std::shared_ptr<ResourceManager> resourceManager;
std::shared_ptr<SHResourceHub> resourceManager;
//! For Vulkan object creation
Handle<SHVkLogicalDevice> logicalDeviceHdl;
@ -88,7 +88,7 @@ namespace SHADE
/*-----------------------------------------------------------------------*/
/* CTORS AND DTORS */
/*-----------------------------------------------------------------------*/
SHRenderGraphNode(std::shared_ptr<ResourceManager> rm, Handle<SHVkLogicalDevice> const& logicalDevice, Handle<SHVkSwapchain> const& swapchain, std::vector<SHAttachmentDescInitParams> attDescInitParams, std::vector<Handle<SHRenderGraphNode>> predecessors, std::unordered_map<std::string, Handle<SHRenderGraphResource>> const* resources) noexcept;
SHRenderGraphNode(std::shared_ptr<SHResourceHub> rm, Handle<SHVkLogicalDevice> const& logicalDevice, Handle<SHVkSwapchain> const& swapchain, std::vector<SHAttachmentDescInitParams> attDescInitParams, std::vector<Handle<SHRenderGraphNode>> predecessors, std::unordered_map<std::string, Handle<SHRenderGraphResource>> const* resources) noexcept;
SHRenderGraphNode(SHRenderGraphNode&& rhs) noexcept;
SHRenderGraphNode& operator= (SHRenderGraphNode&& rhs) noexcept;

2
SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphResource.h
View File

@ -3,7 +3,7 @@
#include <string>
#include "SHAttachmentDescriptionType.h"
#include <vector>
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
#include "Graphics/SHVulkanIncludes.h"
#include "SH_API.h"

2
SHADE_Engine/src/Graphics/RenderGraph/SHSubpass.cpp
View File

@ -182,7 +182,7 @@ namespace SHADE
exteriorDrawCalls.push_back(newDrawCall);
}
void SHSubpass::Init(ResourceManager& resourceManager) noexcept
void SHSubpass::Init(SHResourceHub& resourceManager) noexcept
{
superBatch = resourceManager.Create<SHSuperBatch>(GetHandle());

4
SHADE_Engine/src/Graphics/RenderGraph/SHSubpass.h
View File

@ -3,7 +3,7 @@
#include "SHAttachmentDescriptionType.h"
#include <string>
#include "SH_API.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
#include "Graphics/SHVulkanIncludes.h"
@ -78,7 +78,7 @@ namespace SHADE
void Execute(Handle<SHVkCommandBuffer>& commandBuffer, Handle<SHVkDescriptorPool> descPool, uint32_t frameIndex) noexcept;
void AddExteriorDrawCalls(std::function<void(Handle<SHVkCommandBuffer>&)> const& newDrawCall) noexcept;
void Init(ResourceManager& resourceManager) noexcept;
void Init(SHResourceHub& resourceManager) noexcept;
/*-----------------------------------------------------------------------*/
/* GETTERS AND SETTERS */

2
SHADE_Engine/src/Graphics/RenderGraph/SHSubpassCompute.h
View File

@ -1,6 +1,6 @@
#pragma once
#include <Resource/Handle.h>
#include <Resource/SHHandle.h>
namespace SHADE
{

2
SHADE_Engine/src/Graphics/Renderpass/SHVkAttachDescGen.h
View File

@ -2,7 +2,7 @@
#define SH_VK_ATTACHMENT_DESC_GEN_H
#include "Graphics/SHVulkanIncludes.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
namespace SHADE
{

2
SHADE_Engine/src/Graphics/Renderpass/SHVkRenderpass.h
View File

@ -3,7 +3,7 @@
#include "SHVkAttachDescGen.h"
#include "SHVkSubpassParams.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
#include <span>
namespace SHADE

2
SHADE_Engine/src/Graphics/Renderpass/SHVkSubpassParams.h
View File

@ -2,7 +2,7 @@
#define SH_VK_SUBPASS_PARAMS_H
#include "Graphics/SHVulkanIncludes.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
#include <span>
namespace SHADE

2
SHADE_Engine/src/Graphics/SHVkUtil.h
View File

@ -3,7 +3,7 @@
#include "SHVulkanIncludes.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
namespace SHADE
{

2
SHADE_Engine/src/Graphics/Shaders/SHVkShaderModule.h
View File

@ -2,7 +2,7 @@
#define SH_VK_SHADER_MODULE_H
#include "Graphics/SHVulkanIncludes.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
#include "SHShaderReflected.h"
#include <vector>

2
SHADE_Engine/src/Graphics/Swapchain/SHVkSwapchain.h
View File

@ -4,7 +4,7 @@
#include <cstdint>
#include <vector>
#include "Graphics/SHVulkanIncludes.h"
#include "Resource/ResourceLibrary.h"
#include "Resource/SHResourceLibrary.h"
#include "Graphics/Swapchain/SHSwapchainParams.h"
namespace SHADE

2
SHADE_Engine/src/Graphics/Synchronization/SHVkFence.h
View File

@ -2,7 +2,7 @@
#define SH_VK_FENCE_H
#include "Graphics/SHVulkanIncludes.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
namespace SHADE
{

2
SHADE_Engine/src/Graphics/Synchronization/SHVkSemaphore.h
View File

@ -2,7 +2,7 @@
#define SH_VK_SEMAPHORE_H
#include "Graphics/SHVulkanIncludes.h"
#include "Resource/Handle.h"
#include "Resource/SHHandle.h"
namespace SHADE
{

2
SHADE_Engine/src/Graphics/Windowing/Surface/SHVkSurface.h
View File

@ -3,7 +3,7 @@
#include <windows.h>
#include "Graphics/SHVulkanIncludes.h"
#include "Resource/ResourceLibrary.h"
#include "Resource/SHResourceLibrary.h"
namespace SHADE
{

10
SHADE_Engine/src/Resource/Handle.h → SHADE_Engine/src/Resource/SHHandle.h
View File

@ -9,7 +9,7 @@ namespace SHADE
/* Forward Declarations */
/*---------------------------------------------------------------------------------*/
template<typename T>
class ResourceLibrary;
class SHResourceLibrary;
/*---------------------------------------------------------------------------------*/
/* Type Definitions */
@ -140,12 +140,12 @@ namespace SHADE
/*-----------------------------------------------------------------------------*/
/* Data Members */
/*-----------------------------------------------------------------------------*/
ResourceLibrary<T>* library = nullptr;
SHResourceLibrary<T>* library = nullptr;
/*-----------------------------------------------------------------------------*/
/* Friend Declarations */
/*-----------------------------------------------------------------------------*/
friend class ResourceLibrary<T>;
friend class SHResourceLibrary<T>;
};
/// <summary>
@ -183,7 +183,7 @@ namespace SHADE
/// </summary>
/// <param name="rscLib">Required to lock usage to ResourceLibrary only.</param>
/// <param name="hdl">Handle to set.</param>
void SetHandle(const ResourceLibrary<T>& rscLib, Handle<T> hdl);
void SetHandle(const SHResourceLibrary<T>& rscLib, Handle<T> hdl);
private:
/*-----------------------------------------------------------------------------*/
@ -220,4 +220,4 @@ namespace std
};
}
#include "Handle.hpp"
#include "SHHandle.hpp"

6
SHADE_Engine/src/Resource/Handle.hpp → SHADE_Engine/src/Resource/SHHandle.hpp
View File

@ -1,7 +1,7 @@
#pragma once
// Primary Header
#include "Handle.h"
#include "ResourceLibrary.h"
#include "SHHandle.h"
#include "SHResourceLibrary.h"
namespace SHADE
{
@ -96,7 +96,7 @@ namespace SHADE
return handle;
}
template<typename T>
inline void ISelfHandle<T>::SetHandle(const ResourceLibrary<T>&, Handle<T> hdl)
inline void ISelfHandle<T>::SetHandle(const SHResourceLibrary<T>&, Handle<T> hdl)
{
handle = hdl;
}

4
SHADE_Engine/src/Resource/ResourceLibrary.cpp → SHADE_Engine/src/Resource/SHResourceLibrary.cpp
View File

@ -1,11 +1,11 @@
#include "SHPch.h"
#include "ResourceLibrary.h"
#include "SHResourceLibrary.h"
namespace SHADE
{
/*-----------------------------------------------------------------------------*/
/* Constructors/Destructors */
/*-----------------------------------------------------------------------------*/
ResourceManager::~ResourceManager()
SHResourceHub::~SHResourceHub()
{
// Delete all resources libraries
for (auto iter = deleters.rbegin(); iter != deleters.rend(); ++iter)

16
SHADE_Engine/src/Resource/ResourceLibrary.h → SHADE_Engine/src/Resource/SHResourceLibrary.h
View File

@ -6,7 +6,7 @@
#include <queue>
// Project Headers
#include "Handle.h"
#include "SHHandle.h"
#include "Resource/SparseSet.h"
namespace SHADE
@ -17,13 +17,13 @@ namespace SHADE
/// </summary>
/// <typeparam name="T">Type of resources that this library stores.</typeparam>
template<typename T>
class ResourceLibrary
class SHResourceLibrary
{
public:
/*-----------------------------------------------------------------------------*/
/* Constructor */
/*-----------------------------------------------------------------------------*/
ResourceLibrary();
SHResourceLibrary();
/*-----------------------------------------------------------------------------*/
/* Usage Functions */
@ -75,13 +75,13 @@ namespace SHADE
/// <summary>
/// Manages all resources in multiple ResourceLibraries.
/// </summary>
class ResourceManager final
class SHResourceHub final
{
public:
/*-----------------------------------------------------------------------------*/
/* Constructors/Destructors */
/*-----------------------------------------------------------------------------*/
~ResourceManager();
~SHResourceHub();
/*-----------------------------------------------------------------------------*/
/* Usage Functions */
@ -136,10 +136,10 @@ namespace SHADE
/* Helper Functions */
/*-----------------------------------------------------------------------------*/
template<typename T>
ResourceLibrary<T>& getLibrary();
SHResourceLibrary<T>& getLibrary();
template<typename T>
const ResourceLibrary<T>& getLibrary() const;
const SHResourceLibrary<T>& getLibrary() const;
};
}
#include "ResourceLibrary.hpp"
#include "SHResourceLibrary.hpp"

34
SHADE_Engine/src/Resource/ResourceLibrary.hpp → SHADE_Engine/src/Resource/SHResourceLibrary.hpp
View File

@ -1,6 +1,6 @@
#pragma once
// Primary Header
#include "ResourceLibrary.h"
#include "SHResourceLibrary.h"
// Standard Library
#include <utility>
@ -10,7 +10,7 @@ namespace SHADE
/* ResourceLibrary - Constructor */
/*---------------------------------------------------------------------------------*/
template <typename T>
ResourceLibrary<T>::ResourceLibrary()
SHResourceLibrary<T>::SHResourceLibrary()
{
// Type Checking
//static_assert(std::is_copy_assignable_v<T>, "Resource Library's resources must be copy assignable.");
@ -24,7 +24,7 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
template <typename T>
template <typename ... Args>
Handle<T> ResourceLibrary<T>::Create(Args&&... args)
Handle<T> SHResourceLibrary<T>::Create(Args&&... args)
{
// Create the handle
Handle<T> handle;
@ -55,7 +55,7 @@ namespace SHADE
}
template <typename T>
void ResourceLibrary<T>::Free(Handle<T> handle)
void SHResourceLibrary<T>::Free(Handle<T> handle)
{
assertHandleValid(handle);
@ -63,7 +63,7 @@ namespace SHADE
}
template <typename T>
T& ResourceLibrary<T>::Get(Handle<T> handle)
T& SHResourceLibrary<T>::Get(Handle<T> handle)
{
assertHandleValid(handle);
@ -71,7 +71,7 @@ namespace SHADE
}
template <typename T>
const T& ResourceLibrary<T>::Get(Handle<T> handle) const
const T& SHResourceLibrary<T>::Get(Handle<T> handle) const
{
assertHandleValid(handle);
@ -82,14 +82,14 @@ namespace SHADE
/* ResourceLibrary - Helper Functions */
/*---------------------------------------------------------------------------------*/
template <typename T>
void ResourceLibrary<T>::assertHandleValid(Handle<T> handle) const
void SHResourceLibrary<T>::assertHandleValid(Handle<T> handle) const
{
if (!handle || handle.id.Data.Version != versionCounts[handle.id.Data.Index])
throw std::invalid_argument("Invalid handle provided!");
}
template<typename T>
inline uint32_t ResourceLibrary<T>::getAvailableFreeIndex()
inline uint32_t SHResourceLibrary<T>::getAvailableFreeIndex()
{
// Get from the free list if present
if (!freeList.empty())
@ -107,25 +107,25 @@ namespace SHADE
/* ResourceManager - Usage Functions */
/*---------------------------------------------------------------------------------*/
template <typename T, typename ... Args>
Handle<T> ResourceManager::Create(Args&&... args)
Handle<T> SHResourceHub::Create(Args&&... args)
{
return getLibrary<T>().Create(std::forward<Args>(args) ...);
}
template <typename T>
void ResourceManager::Free(Handle<T> handle)
void SHResourceHub::Free(Handle<T> handle)
{
getLibrary<T>().Free(handle);
}
template <typename T>
T& ResourceManager::Get(Handle<T> handle)
T& SHResourceHub::Get(Handle<T> handle)
{
return getLibrary<T>().Get(handle);
}
template <typename T>
const T& ResourceManager::Get(Handle<T> handle) const
const T& SHResourceHub::Get(Handle<T> handle) const
{
return getLibrary<T>().Get(handle);
}
@ -134,18 +134,18 @@ namespace SHADE
/* ResourceManager - Helper Functions */
/*-----------------------------------------------------------------------------*/
template <typename T>
ResourceLibrary<T>& ResourceManager::getLibrary()
SHResourceLibrary<T>& SHResourceHub::getLibrary()
{
// Attempt to retrieve the library
const std::type_index RSC_TYPE = typeid(T);
if (resourceLibs.contains(RSC_TYPE))
{
return *static_cast<ResourceLibrary<T>*>(resourceLibs.at(RSC_TYPE));
return *static_cast<SHResourceLibrary<T>*>(resourceLibs.at(RSC_TYPE));
}
else
{
// Construct library if doesn't exist
ResourceLibrary<T>* lib = new ResourceLibrary<T>();
SHResourceLibrary<T>* lib = new SHResourceLibrary<T>();
resourceLibs.emplace(RSC_TYPE, static_cast<void*>(lib));
// Construct deleter to properly delete objects with void*
@ -156,8 +156,8 @@ namespace SHADE
}
template <typename T>
const ResourceLibrary<T>& ResourceManager::getLibrary() const
const SHResourceLibrary<T>& SHResourceHub::getLibrary() const
{
return const_cast<ResourceManager*>(this).getLibrary<T>();
return const_cast<SHResourceHub*>(this).getLibrary<T>();
}
}

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

@ -115,34 +115,22 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
/* Script Serialisation Functions */
/*---------------------------------------------------------------------------------*/
std::string SHScriptEngine::SerialiseScripts(EntityID entity) const
bool SHScriptEngine::SerialiseScripts(EntityID entity, YAML::Node& scriptsNode) const
{
// Create buffer needed to store serialised script data
constexpr int BUFFER_SIZE = 10240;
std::unique_ptr<char> buffer { new char[BUFFER_SIZE] };
std::memset(buffer.get(), 0, BUFFER_SIZE);
// Attempt to serialise the script
std::string result;
if (csScriptsSerialise(entity, buffer.get(), BUFFER_SIZE))
{
result = std::string(buffer.get());
}
else
{
SHLOG_ERROR("[ScriptEngine] Failed to serialise scripts as string buffer is too small!");
}
if (csScriptsSerialiseYaml(entity, &scriptsNode))
return true;
// Return an empty string since we failed to serialise
return result;
SHLOG_ERROR("[ScriptEngine] Failed to serialise scripts for entity #{}.", entity);
return false;
}
/*-----------------------------------------------------------------------------------*/
/* Script Serialisation Functions */
/*-----------------------------------------------------------------------------------*/
void SHScriptEngine::DeserialiseScript(EntityID entity, const std::string& yaml) const
bool SHScriptEngine::DeserialiseScripts(EntityID entity, const YAML::Node& scriptsNode) const
{
csScriptDeserialise(entity, yaml.c_str());
return csScriptsDeserialiseYaml(entity, &scriptsNode);
}
/*-----------------------------------------------------------------------------------*/
@ -380,30 +368,18 @@ namespace SHADE
DEFAULT_CSHARP_NAMESPACE + ".ScriptStore",
"RemoveAllScriptsImmediately"
);
/*csScriptsSerialise = dotNet.GetFunctionPtr<CsScriptSerialiseFuncPtr>
csScriptsSerialiseYaml = dotNet.GetFunctionPtr<CsScriptSerialiseYamlFuncPtr>
(
DEFAULT_CSHARP_LIB_NAME,
DEFAULT_CSHARP_NAMESPACE + ".ScriptStore",
"SerialiseScripts"
);
csScriptsSerialiseYaml = dotNet.GetFunctionPtr<CsScriptSerialiseYamlFuncPtr>
csScriptsDeserialiseYaml = dotNet.GetFunctionPtr<CsScriptDeserialiseYamlFuncPtr>
(
DEFAULT_CSHARP_LIB_NAME,
DEFAULT_CSHARP_NAMESPACE + ".ScriptStore",
"SerialiseScriptsYaml"
"DeserialiseScripts"
);
csScriptDeserialise = dotNet.GetFunctionPtr<CsScriptDeserialiseFuncPtr>
(
DEFAULT_CSHARP_LIB_NAME,
DEFAULT_CSHARP_NAMESPACE + ".ScriptStore",
"DeserialiseScript"
);
csScriptDeserialiseYaml = dotNet.GetFunctionPtr<CsScriptSerialiseYamlFuncPtr>
(
DEFAULT_CSHARP_LIB_NAME,
DEFAULT_CSHARP_NAMESPACE + ".ScriptStore",
"SerialiseScriptsYaml"
);*/
csEditorRenderScripts = dotNet.GetFunctionPtr<CsScriptEditorFuncPtr>
(
DEFAULT_CSHARP_LIB_NAME,

85
SHADE_Engine/src/Scripting/SHScriptEngine.h
View File

@ -13,7 +13,8 @@ of DigiPen Institute of Technology is prohibited.
// STL Includes
#include <filesystem>
// External Dependencies
#include <yaml-cpp/yaml.h>
// Project Headers
#include "SH_API.h"
#include "SHDotNetRuntime.h"
@ -141,23 +142,26 @@ namespace SHADE
/* Script Serialisation Functions */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Generates a JSON string that represents the set of Scripts attached to the
/// specified Entity.
/// Performs serialization of all scripts for the specified entity into the
/// YAML::Node specified. This node will contain all serialised scripts after
/// calling this function.
/// </summary>
/// <param name="entity"> The Entity to Serialise.</param>
/// <returns>
/// String that represents the set of scripts attached to the specified Entity.
/// </returns>
std::string SerialiseScripts(EntityID entity) const;
/// <param name="entity">The Entity to Serialise.</param>
/// <param name="scriptsNode">
/// YAML Node that will store the serialised scripts.
/// </param>
/// <return>True if successfully serialised.</return>
bool SerialiseScripts(EntityID entity, YAML::Node& scriptsNode) const;
/// <summary>
/// Loads the specified JSON string and creates a Script for the specified Entity
/// based on the specified JSON string.
/// Creates scripts and sets fields for the specified Entity based on the specified
/// YAML node.
/// </summary>
/// <param name="entity">The Entity to deserialise a Script on to.</param>
/// <param name="yaml">
/// The YAML string that represents the Script to load into the Entity.
/// <param name="scriptsNode">
/// YAML Node that contains the serialised script data.
/// </param>
void DeserialiseScript(EntityID entity, const std::string& yaml) const;
/// <return>True if successfully deserialised.</return>
bool DeserialiseScripts(EntityID entity, const YAML::Node& scriptsNode) const;
/*-----------------------------------------------------------------------------*/
/* Script Editor Functions */
@ -207,14 +211,13 @@ namespace SHADE
/*-----------------------------------------------------------------------------*/
/* Type Definitions */
/*-----------------------------------------------------------------------------*/
using CsFuncPtr = void(*)(void);
using CsScriptManipFuncPtr = bool(*)(EntityID, const char*);
using CsScriptBasicFuncPtr = void(*)(EntityID);
using CsScriptOptionalFuncPtr = void(*)(EntityID, bool);
using CsScriptSerialiseFuncPtr = bool(*)(EntityID, char*, int);
using CsScriptDeserialiseFuncPtr = bool(*)(EntityID, const char*);
using CsScriptSerialiseYamlFuncPtr = bool(*)(EntityID, void*);
using CsScriptEditorFuncPtr = void(*)(EntityID);
using CsFuncPtr = void(*)(void);
using CsScriptManipFuncPtr = bool(*)(EntityID, const char*);
using CsScriptBasicFuncPtr = void(*)(EntityID);
using CsScriptOptionalFuncPtr = void(*)(EntityID, bool);
using CsScriptSerialiseYamlFuncPtr = bool(*)(EntityID, void*);
using CsScriptDeserialiseYamlFuncPtr = bool(*)(EntityID, const void*);
using CsScriptEditorFuncPtr = void(*)(EntityID);
/*-----------------------------------------------------------------------------*/
/* Constants */
@ -228,31 +231,29 @@ namespace SHADE
/*-----------------------------------------------------------------------------*/
/* Data Members */
/*-----------------------------------------------------------------------------*/
SHDotNetRuntime dotNet { false };
SHDotNetRuntime dotNet { false };
// Function Pointers to CLR Code
// - Engine Lifecycle
CsFuncPtr csEngineInit = nullptr;
CsFuncPtr csEngineLoadScripts = nullptr;
CsFuncPtr csEngineUnloadScripts = nullptr;
CsFuncPtr csEngineReloadScripts = nullptr;
CsFuncPtr csEngineExit = nullptr;
CsFuncPtr csEngineInit = nullptr;
CsFuncPtr csEngineLoadScripts = nullptr;
CsFuncPtr csEngineUnloadScripts = nullptr;
CsFuncPtr csEngineReloadScripts = nullptr;
CsFuncPtr csEngineExit = nullptr;
// - Scripts Store
CsFuncPtr csScriptsFrameSetUp = nullptr;
CsFuncPtr csScriptsExecuteFixedUpdate = nullptr;
CsFuncPtr csScriptsExecuteUpdate = nullptr;
CsFuncPtr csScriptsExecuteLateUpdate = nullptr;
CsFuncPtr csScriptsFrameCleanUp = nullptr;
CsScriptManipFuncPtr csScriptsAdd = nullptr;
CsScriptBasicFuncPtr csScriptsRemoveAll = nullptr;
CsScriptOptionalFuncPtr csScriptsRemoveAllImmediately = nullptr;
CsScriptSerialiseFuncPtr csScriptsSerialise = nullptr;
CsScriptDeserialiseFuncPtr csScriptDeserialise = nullptr;
CsScriptSerialiseYamlFuncPtr csScriptsSerialiseYaml = nullptr;
CsScriptSerialiseYamlFuncPtr csScriptDeserialiseYaml = nullptr;
CsFuncPtr csScriptsFrameSetUp = nullptr;
CsFuncPtr csScriptsExecuteFixedUpdate = nullptr;
CsFuncPtr csScriptsExecuteUpdate = nullptr;
CsFuncPtr csScriptsExecuteLateUpdate = nullptr;
CsFuncPtr csScriptsFrameCleanUp = nullptr;
CsScriptManipFuncPtr csScriptsAdd = nullptr;
CsScriptBasicFuncPtr csScriptsRemoveAll = nullptr;
CsScriptOptionalFuncPtr csScriptsRemoveAllImmediately = nullptr;
CsScriptSerialiseYamlFuncPtr csScriptsSerialiseYaml = nullptr;
CsScriptDeserialiseYamlFuncPtr csScriptsDeserialiseYaml = nullptr;
// - Editor
CsScriptEditorFuncPtr csEditorRenderScripts = nullptr;
CsFuncPtr csEditorUndo = nullptr;
CsFuncPtr csEditorRedo = nullptr;
CsScriptEditorFuncPtr csEditorRenderScripts = nullptr;
CsFuncPtr csEditorUndo = nullptr;
CsFuncPtr csEditorRedo = nullptr;
/*-----------------------------------------------------------------------------*/
/* Event Handler Functions */

14
SHADE_Engine/src/Serialization/SHSerialization.cpp
View File

@ -13,6 +13,8 @@
#include "Graphics/MiddleEnd/Interface/SHRenderable.h"
#include "Math/Transform/SHTransformComponent.h"
#include "Physics/Components/SHRigidBodyComponent.h"
#include "ECS_Base/Managers/SHSystemManager.h"
#include "Scripting/SHScriptEngine.h"
namespace SHADE
{
@ -79,7 +81,10 @@ namespace SHADE
}
}
}
return eid;
// Deserialise scripts
if (node[ScriptsNode])
SHSystemManager::GetSystem<SHScriptEngine>()->DeserialiseScripts(eid, node[ScriptsNode]);
}
void SHSerialization::DeserializeSceneFromFile(std::filesystem::path const& path)
@ -166,7 +171,7 @@ namespace SHADE
node = YAML::Null;
return node;
}
node.SetStyle(YAML::EmitterStyle::Block);
node.SetStyle(YAML::EmitterStyle::Block);
node[EIDNode] = eid;
node[EntityNameNode] = entity->name;
node[IsActiveNode] = sceneNode->IsActive();
@ -188,6 +193,11 @@ namespace SHADE
components[rttr::type::get<SHRigidBodyComponent>().get_name().data()] = SHSerializationHelper::SerializeComponentToNode(rigidbody);
}
node[ComponentsNode] = components;
YAML::Node scripts;
SHSystemManager::GetSystem<SHScriptEngine>()->SerialiseScripts(eid, scripts);
node[ScriptsNode] = scripts;
return node;
}

1
SHADE_Engine/src/Serialization/SHSerialization.h
View File

@ -21,6 +21,7 @@ namespace SHADE
constexpr const char* EIDNode = "EID";
constexpr const char* IsActiveNode = "IsActive";
constexpr const char* NumberOfChildrenNode = "NumberOfChildren";
constexpr const char* ScriptsNode = "Scripts";
struct SH_API SHSerialization
{

101
SHADE_Managed/src/Scripts/ScriptStore.cxx
View File

@ -26,6 +26,7 @@ of DigiPen Institute of Technology is prohibited.
#include "Utility/Convert.hxx"
#include "Script.hxx"
#include "Engine/Entity.hxx"
#include "Serialisation/ReflectionUtilities.hxx"
namespace SHADE
{
@ -470,72 +471,90 @@ namespace SHADE
}
SAFE_NATIVE_CALL_END_N("SHADE.ScriptStore")
}
bool ScriptStore::SerialiseScripts(Entity entity, System::Text::StringBuilder^ buffer, int bufferSize)
bool ScriptStore::SerialiseScripts(Entity entity, System::IntPtr yamlNodePtr)
{
SAFE_NATIVE_CALL_BEGIN
// Create a buffer that we can work with temporarily
System::Text::StringBuilder^ jsonString = gcnew System::Text::StringBuilder();
// Convert to pointer
YAML::Node* yamlNode = reinterpret_cast<YAML::Node*>(yamlNodePtr.ToPointer());
// Check if yamlNode is valid
if (yamlNode == nullptr)
{
Debug::LogWarning("[ScriptStore] Attempted to serialise scripts with an invalid YAML Node! Skipping.");
return false;
}
// Check if entity exists, otherwise nothing
if (!EntityUtils::IsValid(entity))
return true;
{
Debug::LogWarning("[ScriptStore] Attempted to serialise scripts for an invalid Entity! Skipping.");
return false;
}
// Check if entity exists in the script storage
if (!scripts.ContainsKey(entity))
if (!scripts.ContainsKey(entity))
return true;
// Serialise each script
yamlNode->SetStyle(YAML::EmitterStyle::Block);
System::Collections::Generic::List<Script^>^ scriptList = scripts[entity];
for (int i = 0; i < scriptList->Count; ++i)
for each (Script^ script in scriptList)
{
throw gcnew System::NotImplementedException;
//jsonString->Append(ReflectionUtilities::Serialise(scriptList[i]));
// Only add separator if is not last script
if (i != scriptList->Count - 1)
{
jsonString->Append(",\r\n");
}
ReflectionUtilities::Serialise(script, *yamlNode);
}
// Check if the size is too big
if (jsonString->Length > bufferSize)
return false;
// Otherwise we copy it over
buffer->Clear();
buffer->Append(jsonString->ToString());
return true;
SAFE_NATIVE_CALL_END_N("SHADE.ScriptStore")
return false;
}
bool ScriptStore::DeserialiseScript(Entity entity, System::String^ yaml)
bool ScriptStore::DeserialiseScripts(Entity entity, System::IntPtr yamlNodePtr)
{
SAFE_NATIVE_CALL_BEGIN
// Convert to pointer
YAML::Node* yamlNode = reinterpret_cast<YAML::Node*>(yamlNodePtr.ToPointer());
// Check if yamlNode is valid
if (yamlNode == nullptr)
{
Debug::LogWarning("[ScriptStore] Attempted to deserialise scripts with an invalid YAML Node! Skipping.");
return false;
}
// Check if entity exists, otherwise nothing
if (!EntityUtils::IsValid(entity))
return false;
// Get the name of the script
const int FIRST_QUOTE = yaml->IndexOf('\"');
const int FIRST_COLON = yaml->IndexOf(':');
if (FIRST_QUOTE < 0 || FIRST_COLON < 0) // No script name, it's invalid
return false;
const int SCRIPT_NAME_START = FIRST_QUOTE + 1;
const int SCRIPT_NAME_END = FIRST_COLON - 1;
System::String^ typeName = yaml->Substring(SCRIPT_NAME_START, SCRIPT_NAME_END - SCRIPT_NAME_START);
// Create the script
Script^ script;
if (AddScriptViaNameWithRef(entity, typeName, script))
{
// Copy the data in
throw gcnew System::NotImplementedException;
//ReflectionUtilities::Deserialise(json, script);
return true;
Debug::LogWarning("[ScriptStore] Attempted to deserialise scripts for an invalid Entity! Skipping.");
return false;
}
// Go through all elements in the node
for (YAML::Node& node : *yamlNode)
{
// Get the name of the script
if (!node["Type"])
{
Debug::LogWarning("[ScriptStore] Script with no type detected, skipping.");
continue;
}
System::String^ typeName = Convert::ToCLI(node["Type"].as<std::string>());
// Create
Script^ script;
if (AddScriptViaNameWithRef(entity, typeName, script))
{
// Copy the data in
ReflectionUtilities::Deserialise(script, node);
}
else
{
Debug::LogWarning("[ScriptStore] Script with unloaded type detected, skipping.");
}
}
return true;
SAFE_NATIVE_CALL_END_N("SHADE.ScriptStore")
return false;
}

23
SHADE_Managed/src/Scripts/ScriptStore.hxx
View File

@ -17,6 +17,7 @@ of DigiPen Institute of Technology is prohibited.
// Project Includes
#include "Engine/Entity.hxx"
#include "Script.hxx"
#include "Serialization/SHSerialization.h"
namespace SHADE
{
@ -237,27 +238,23 @@ namespace SHADE
/* Serialisation Functions */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Generates a JSON string that represents the set of Scripts attached
/// to the specified Entity.
/// Populates a YAML node with the scripts for a specified Entity.
/// <br/> <br/>
/// This function should only be called from native unmanaged code.
/// </summary>
/// <param name="entity">The Entity to Serialise.</param>
/// <param name="buffer">
/// StringBuilder handle that maps to a native char array that will contain the
/// serialised string.
/// </param>
/// <param name="bufferSize">
/// The size of the char array.
/// <param name="yamlNode">
/// Pointer to a YAML::Node that will be populated with all of the serialised
/// scripts and their associated fields.
/// </param>
/// <returns>
/// True if serialisation is successful. False if the buffer is too small for
/// the serialised output.
/// </returns>
static bool SerialiseScripts(Entity entity, System::Text::StringBuilder^ buffer, int bufferSize);
static bool SerialiseScripts(Entity entity, System::IntPtr yamlNode);
/// <summary>
/// Processes a JSON string that represents a single Script and attaches
/// it onto the specified Entity.
/// Processes a YAML node that contains a list of multiple scripts to be loaded
/// into the specified Entity.
/// <br/> <br/>
/// This function should only be called from native unmanaged code.
/// </summary>
@ -265,10 +262,10 @@ namespace SHADE
/// The Entity to attach the deserialised Scripts to.
/// </param>
/// <param name="yaml">
/// JSON string that describes the Script to serialise.
/// Pointer to the YAML::Node that contains serialized script data.
/// </param>
/// <returns></returns>
static bool DeserialiseScript(Entity entity, System::String^ yaml);
static bool DeserialiseScripts(Entity entity, System::IntPtr yamlNode);
private:
/*-----------------------------------------------------------------------------*/

116
SHADE_Managed/src/Serialisation/ReflectionUtilities.cxx
View File

@ -38,6 +38,11 @@ if (iter != jsonValue.MemberEnd()) \
vec.MEMBER = iter->value.GetDouble(); \
} \
/*-------------------------------------------------------------------------------------*/
/* File-Level Constants */
/*-------------------------------------------------------------------------------------*/
static const std::string_view SCRIPT_TYPE_YAMLTAG = "Type";
/*-------------------------------------------------------------------------------------*/
/* Function Definitions */
/*-------------------------------------------------------------------------------------*/
@ -61,13 +66,14 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
/* Serialisation Functions */
/*---------------------------------------------------------------------------------*/
void ReflectionUtilities::Serialise(System::Object^ object, YAML::Emitter& yaml)
void ReflectionUtilities::Serialise(System::Object^ object, YAML::Node& scriptListNode)
{
using namespace System::Reflection;
// Create YAML object
yaml << YAML::Key << Convert::ToNative(object->GetType()->FullName);
yaml << YAML::BeginMap;
YAML::Node scriptNode;
scriptNode.SetStyle(YAML::EmitterStyle::Block);
scriptNode[SCRIPT_TYPE_YAMLTAG.data()] = Convert::ToNative(object->GetType()->FullName);
// Get all fields
System::Collections::Generic::IEnumerable<FieldInfo^>^ fields = GetInstanceFields(object);
@ -78,12 +84,12 @@ namespace SHADE
continue;
// Serialise
writeFieldIntoYaml(field, object, yaml);
writeFieldIntoYaml(field, object, scriptNode);
}
yaml << YAML::EndMap;
scriptListNode.push_back(scriptNode);
}
void ReflectionUtilities::Deserialise(YAML::Node& yamlNode, Object^ object)
void ReflectionUtilities::Deserialise(Object^ object, YAML::Node& yamlNode)
{
using namespace System::Reflection;
@ -117,53 +123,63 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
/* Serialization Helper Functions */
/*---------------------------------------------------------------------------------*/
void ReflectionUtilities::writeFieldIntoYaml(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Emitter& yaml)
void ReflectionUtilities::writeFieldIntoYaml(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& yamlNode)
{
// Field Name
yaml << YAML::Key << Convert::ToNative(fieldInfo->Name);
// Field Value
yaml << YAML::Value;
if (fieldInsertYaml<System::Int16> (fieldInfo, object, yaml) ||
fieldInsertYaml<System::Int32> (fieldInfo, object, yaml) ||
fieldInsertYaml<System::Int64> (fieldInfo, object, yaml) ||
fieldInsertYaml<System::UInt16>(fieldInfo, object, yaml) ||
fieldInsertYaml<System::UInt32>(fieldInfo, object, yaml) ||
fieldInsertYaml<System::UInt64>(fieldInfo, object, yaml) ||
fieldInsertYaml<System::Byte> (fieldInfo, object, yaml) ||
fieldInsertYaml<bool> (fieldInfo, object, yaml) ||
fieldInsertYaml<float> (fieldInfo, object, yaml) ||
fieldInsertYaml<double> (fieldInfo, object, yaml))
// Field YAML Node
YAML::Node fieldNode;
// Retrieve string for the YAML
const bool PRIMITIVE_SERIALIZED = fieldInsertYaml<System::Int16>(fieldInfo, object, fieldNode) ||
fieldInsertYaml<System::Int32>(fieldInfo, object, fieldNode) ||
fieldInsertYaml<System::Int64>(fieldInfo, object, fieldNode) ||
fieldInsertYaml<System::UInt16>(fieldInfo, object, fieldNode) ||
fieldInsertYaml<System::UInt32>(fieldInfo, object, fieldNode) ||
fieldInsertYaml<System::UInt64>(fieldInfo, object, fieldNode) ||
fieldInsertYaml<System::Byte>(fieldInfo, object, fieldNode) ||
fieldInsertYaml<bool>(fieldInfo, object, fieldNode) ||
fieldInsertYaml<float>(fieldInfo, object, fieldNode) ||
fieldInsertYaml<double>(fieldInfo, object, fieldNode);
// Serialization of more complex types
if (!PRIMITIVE_SERIALIZED)
{
return;
}
else if (fieldInfo->FieldType->IsSubclassOf(System::Enum::typeid))
{
yaml << safe_cast<int>(fieldInfo->GetValue(object));
}
else if (fieldInfo->FieldType == System::String::typeid)
{
System::String^ str = safe_cast<System::String^>(fieldInfo->GetValue(object));
yaml << Convert::ToNative(str);
}
else if (fieldInfo->FieldType == Vector2::typeid)
{
Vector2 vec = safe_cast<Vector2>(fieldInfo->GetValue(object));
yaml << YAML::BeginSeq << YAML::Flow << vec.x << vec.y << YAML::EndSeq;
}
else if (fieldInfo->FieldType == Vector3::typeid)
{
Vector3 vec = safe_cast<Vector3>(fieldInfo->GetValue(object));
yaml << YAML::BeginSeq << YAML::Flow << vec.x << vec.y << vec.z << YAML::EndSeq;
}
else // Not any of the supported types
{
Debug::LogWarning(Convert::ToNative(System::String::Format
(
"[ReflectionUtilities] Failed to parse \"{0}\" of \"{1}\" type for serialization.",
fieldInfo->Name, fieldInfo->FieldType)
));
if (fieldInfo->FieldType->IsSubclassOf(System::Enum::typeid))
{
fieldNode = std::to_string(safe_cast<int>(fieldInfo->GetValue(object)));
}
else if (fieldInfo->FieldType == System::String::typeid)
{
System::String^ str = safe_cast<System::String^>(fieldInfo->GetValue(object));
fieldNode = Convert::ToNative(str);
}
else if (fieldInfo->FieldType == Vector2::typeid)
{
Vector2 vec = safe_cast<Vector2>(fieldInfo->GetValue(object));
fieldNode.SetStyle(YAML::EmitterStyle::Flow);
fieldNode.push_back(vec.x);
fieldNode.push_back(vec.y);
}
else if (fieldInfo->FieldType == Vector3::typeid)
{
Vector3 vec = safe_cast<Vector3>(fieldInfo->GetValue(object));
fieldNode.SetStyle(YAML::EmitterStyle::Flow);
fieldNode.push_back(vec.x);
fieldNode.push_back(vec.y);
fieldNode.push_back(vec.z);
}
else // Not any of the supported types
{
Debug::LogWarning(Convert::ToNative(System::String::Format
(
"[ReflectionUtilities] Failed to parse \"{0}\" of \"{1}\" type for serialization.",
fieldInfo->Name, fieldInfo->FieldType)
));
return;
}
}
// Store the field into YAML
yamlNode[Convert::ToNative(fieldInfo->Name)] = fieldNode;
}
void ReflectionUtilities::writeYamlIntoField(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& node)

7
SHADE_Managed/src/Serialisation/ReflectionUtilities.h++
View File

@ -23,11 +23,12 @@ namespace SHADE
/* Serialization Helper Functions */
/*---------------------------------------------------------------------------------*/
template<typename FieldType>
bool ReflectionUtilities::fieldInsertYaml(System::Reflection::FieldInfo^ fieldInfo, System::Object^ object, YAML::Emitter& emitter)
bool ReflectionUtilities::fieldInsertYaml(System::Reflection::FieldInfo^ fieldInfo, System::Object^ object, YAML::Node& fieldNode)
{
if (fieldInfo->FieldType == FieldType::typeid)
{
emitter << safe_cast<FieldType>(fieldInfo->GetValue(object));
const FieldType VALUE = safe_cast<FieldType>(fieldInfo->GetValue(object));
fieldNode = static_cast<FieldType>(VALUE);
return true;
}
@ -37,7 +38,7 @@ namespace SHADE
template<typename FieldType>
bool ReflectionUtilities::fieldAssignYaml(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& node)
{
return fieldAssignYaml<FieldType, FieldType>(fieldInfo, object, node);
return fieldAssignYaml<FieldType, ToNativeType_T<FieldType>>(fieldInfo, object, node);
}
template<typename FieldType, typename CastType>

12
SHADE_Managed/src/Serialisation/ReflectionUtilities.hxx
View File

@ -52,24 +52,24 @@ namespace SHADE
/// attribute will be serialised.
/// </summary>
/// <param name="object">The object to serialise.</param>
static void Serialise(System::Object^ object, YAML::Emitter& yaml);
static void Serialise(System::Object^ object, YAML::Node& yamlNode);
/// <summary>
/// Deserialises a YAML node that contains a map of Scripts and copies the
/// deserialised data into the specified object if there are matching fields.
/// </summary>
/// <param name="yamlNode">
/// The JSON string that contains the data to copy into this PlushieScript
/// object.
/// The JSON string that contains the data to copy into this Script object.
/// </param>
/// <param name="object">The object to copy deserialised data into.</param>
static void Deserialise(YAML::Node& yamlNode, Object^ object);
static void Deserialise(System::Object^ object, YAML::Node& yamlNode);
private:
/*-----------------------------------------------------------------------------*/
/* Serialization Helper Functions */
/*-----------------------------------------------------------------------------*/
static void writeFieldIntoYaml(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Emitter& yaml);
static void writeFieldIntoYaml(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& yamlNode);
template<typename FieldType>
static bool fieldInsertYaml(System::Reflection::FieldInfo^ fieldInfo, System::Object^ object, YAML::Emitter& emitter);
static bool fieldInsertYaml(System::Reflection::FieldInfo^ fieldInfo, System::Object^ object, YAML::Node& fieldNode);
static void writeYamlIntoField(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& node);
template<typename FieldType>
static bool fieldAssignYaml(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& node);

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

@ -91,4 +91,68 @@ namespace SHADE
/// <returns>Managed copy of a native std::string.</returns>
static System::String^ ToCLI(const std::string& str);
};
/// <summary>
/// Type Transformer for managed types to native types.
/// </summary>
/// <typeparam name="ManagedType">
/// Managed type to get the native type for.
/// </typeparam>
template<typename ManagedType>
struct ToNativeType
{
public:
using Value = void;
};
template<> struct ToNativeType<System::Int16> { using Value = int16_t; };
template<> struct ToNativeType<System::Int32> { using Value = int32_t; };
template<> struct ToNativeType<System::Int64> { using Value = int64_t; };
template<> struct ToNativeType<System::UInt16> { using Value = uint16_t; };
template<> struct ToNativeType<System::UInt32> { using Value = uint32_t; };
template<> struct ToNativeType<System::UInt64> { using Value = uint64_t; };
template<> struct ToNativeType<System::Byte> { using Value = int8_t; };
template<> struct ToNativeType<bool> { using Value = bool; };
template<> struct ToNativeType<double> { using Value = double; };
template<> struct ToNativeType<float> { using Value = float; };
/// <summary>
/// Alias for ToNativeType::Value
/// </summary>
/// <typeparam name="ManagedType">
/// Managed type to get the native type for.
/// </typeparam>
template<typename ManagedType>
using ToNativeType_T = typename ToNativeType<ManagedType>::Value;
/// <summary>
/// Type Transformer for native types to managed types.
/// </summary>
/// <typeparam name="ManagedType">
/// Managed type to get the native type for.
/// </typeparam>
template<typename NativeType>
struct ToManagedType
{
public:
using Value = void;
};
template<> struct ToManagedType<int8_t> { using Value = System::Byte; };
template<> struct ToManagedType<int16_t> { using Value = System::Int16; };
template<> struct ToManagedType<int32_t> { using Value = System::Int32; };
template<> struct ToManagedType<int64_t> { using Value = System::Int64; };
template<> struct ToManagedType<uint16_t> { using Value = System::UInt16; };
template<> struct ToManagedType<uint32_t> { using Value = System::UInt32; };
template<> struct ToManagedType<uint64_t> { using Value = System::UInt64; };
template<> struct ToManagedType<bool> { using Value = bool; };
template<> struct ToManagedType<double> { using Value = double; };
template<> struct ToManagedType<float> { using Value = float; };
/// <summary>
/// Alias for ToManagedType::Value
/// </summary>
/// <typeparam name="ManagedType">
/// Managed type to get the native type for.
/// </typeparam>
template<typename NativeType>
using ToManagedType_T = typename ToManagedType<NativeType>::Value;
}