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

Added C# Assets System and Serialization of Script Enabled State #247

Merged
Pycorax merged 11 commits from SP3-6-c-scripting into main 2022-11-22 18:59:32 +08:00
Conversation 0 Commits 11 Files Changed 34 +995 -271
34 changed files with 995 additions and 271 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Assets/Scripts/RaccoonShowcase.cs
View File

@ -23,7 +23,9 @@ public class RaccoonShowcase : Script
[Range(-5, 5)]
public List<int> intList = new List<int>(new int[] { 2, 8, 2, 6, 8, 0, 1 });
public List<Light.Type> enumList = new List<Light.Type>(new Light.Type[] { Light.Type.Point, Light.Type.Directional, Light.Type.Ambient });
public FontAsset fontAsset;
public MeshAsset mesh;
public MaterialAsset matAsset;
protected override void awake()
{
Transform = GetComponent<Transform>();

49
SHADE_Engine/src/Editor/SHEditorUI.cpp
View File

@ -15,8 +15,10 @@ of DigiPen Institute of Technology is prohibited.
#include "SHEditorUI.h"
// External Dependencies
#include <imgui.h>
// Project Includes
#include "SHEditorWidgets.hpp"
#include "ECS_Base/Managers/SHEntityManager.h"
#include "Assets/SHAssetManager.h"
namespace SHADE
{
@ -351,6 +353,53 @@ namespace SHADE
return changed;
}
bool SHEditorUI::InputAssetField(const std::string& label, AssetID& value, AssetType type, bool* isHovered)
{
// Label
if (!label.empty())
{
ImGui::Text(label.c_str());
ImGui::SameLine();
}
// Hover tracking
if (isHovered)
*isHovered = ImGui::IsItemHovered();
ImGui::SameLine();
// Attempt to get the asset's data for rendering editor
auto asset = SHAssetManager::GetAsset(value);
std::string assetName;
if (asset.has_value())
{
assetName = asset.value().name;
}
// Editor
bool changed = ImGui::InputText("##", &assetName, ImGuiInputTextFlags_ReadOnly);
if (SHDragDrop::BeginTarget())
{
if (AssetID* payload = SHDragDrop::AcceptPayload<AssetID>(SHDragDrop::DRAG_RESOURCE))
{
// Check if type matches
auto draggedAsset = SHAssetManager::GetAsset(*payload);
if (draggedAsset.has_value() && draggedAsset.value().type == type)
{
value = draggedAsset.value().id;
changed = true;
}
SHDragDrop::EndTarget();
}
}
ImGui::SameLine();
if (ImGui::Button("Clear"))
{
value = INVALID_ASSET_ID;
changed = true;
}
return changed;
}
bool SHEditorUI::InputEnumCombo(const std::string& label, int& v, const std::vector<std::string>& enumNames, bool* isHovered)
{
// Clamp input value

10
SHADE_Engine/src/Editor/SHEditorUI.h
View File

@ -19,6 +19,7 @@ of DigiPen Institute of Technology is prohibited.
#include "Math/Vector/SHVec3.h"
#include "Math/Vector/SHVec4.h"
#include "Math/SHMatrix.h"
#include "Assets/SHAssetMacros.h"
namespace SHADE
{
@ -298,7 +299,7 @@ namespace SHADE
/// <returns>True if the value was changed.</returns>
static bool InputTextField(const std::string& label, std::string& value, bool* isHovered = nullptr);
/// <summary>
/// Creates a drag field widget for int input.
/// Creates a drag field widget for GameObject input.
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
@ -310,6 +311,13 @@ namespace SHADE
/// <returns>True if the value was changed.</returns>
static bool InputGameObjectField(const std::string& label, uint32_t& value, bool* isHovered = nullptr, bool alwaysNull = false);
/// <summary>
/// Creates a drag field widget for Asset input.
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <param name="isHovered>If set, stores the hover state of this widget.</param>
static bool InputAssetField(const std::string& label, AssetID& value, AssetType type, bool* isHovered = nullptr);
/// <summary>
/// Creates a combo box for enumeration input.
/// </summary>
/// <typeparam name="Enum">The type of enum to input.</typeparam>

6
SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderable.cpp
View File

@ -76,6 +76,12 @@ namespace SHADE
sharedMaterial = materialInstance;
}
void SHRenderable::SetMaterial(Handle<SHMaterial> material)
{
SHGraphicsSystem* gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>();
SetMaterial(gfxSystem->AddOrGetBaseMaterialInstance(material));
}
Handle<SHMaterialInstance> SHRenderable::GetMaterial() const
{
if (material)

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

@ -48,6 +48,7 @@ namespace SHADE
/*-------------------------------------------------------------------------------*/
/* Material Functions */
/*-------------------------------------------------------------------------------*/
void SetMaterial(Handle<SHMaterial> material);
void SetMaterial(Handle<SHMaterialInstance> materialInstance);
Handle<SHMaterialInstance> GetMaterial() const;
Handle<SHMaterialInstance> GetModifiableMaterial();

3
SHADE_Engine/src/Resource/SHResourceManager.h
View File

@ -49,7 +49,8 @@ namespace SHADE
template<> struct SHResourceLoader<SHMaterialSpec> { using AssetType = SHMaterialAsset; };
template<> struct SHResourceLoader<SHMaterial> { using AssetType = SHMaterialSpec; };
template<> struct SHResourceLoader<SHFont> { using AssetType = SHFontAsset; };
/// <summary>
/// <summary>
/// Static class responsible for loading and caching runtime resources from their
/// serialised Asset IDs.
/// </summary>

59
SHADE_Engine/src/Resource/SHResourceManagerInterface.cpp Normal file
View File

@ -0,0 +1,59 @@
/************************************************************************************//*!
\file SHResourceManagerInterface.cpp
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Nov 22, 2022
\brief Contains the definition of the functions of the
SHResourceManagerInterface static class.
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 Header
#include "SHpch.h"
// Primary Include
#include "SHResourceManagerInterface.h"
// Project Includes
#include "SHResourceManager.h"
namespace SHADE
{
Handle<SHMesh> SHResourceManagerInterface::LoadOrGetMesh(AssetID assetId)
{
return SHResourceManager::LoadOrGet<SHMesh>(assetId);
}
Handle<SHTexture> SHResourceManagerInterface::LoadOrGetTexture(AssetID assetId)
{
return SHResourceManager::LoadOrGet<SHTexture>(assetId);
}
Handle<SHVkShaderModule> SHResourceManagerInterface::LoadOrGetShaderModule(AssetID assetId)
{
return SHResourceManager::LoadOrGet<SHVkShaderModule>(assetId);
}
Handle<SHMaterialSpec> SHResourceManagerInterface::LoadOrGetMaterialSpec(AssetID assetId)
{
return SHResourceManager::LoadOrGet<SHMaterialSpec>(assetId);
}
Handle<SHMaterial> SHResourceManagerInterface::LoadOrGetMaterial(AssetID assetId)
{
return SHResourceManager::LoadOrGet<SHMaterial>(assetId);
}
Handle<SHFont> SHResourceManagerInterface::LoadOrGetFont(AssetID assetId)
{
return SHResourceManager::LoadOrGet<SHFont>(assetId);
}
/*-----------------------------------------------------------------------------------*/
/* Query Functions */
/*-----------------------------------------------------------------------------------*/
std::optional<AssetID> SHResourceManagerInterface::GetAssetID(Handle<void> handle)
{
return SHResourceManager::GetAssetID(handle);
}
std::optional<std::string> SHResourceManagerInterface::GetAssetName(Handle<void> handle)
{
return SHResourceManager::GetAssetName(handle);
}
}

111
SHADE_Engine/src/Resource/SHResourceManagerInterface.h Normal file
View File

@ -0,0 +1,111 @@
/************************************************************************************//*!
\file SHResourceManagerInterface.h
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Nov 22, 2022
\brief Contains the definition of the SHResourceManagerInterface static class.
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
// STL Includes
#include <optional>
// Project Includes
#include "SH_API.h"
#include "Resource/SHHandle.h"
#include "Assets/SHAssetMacros.h"
namespace SHADE
{
/*-----------------------------------------------------------------------------------*/
/* Forward Declarations */
/*-----------------------------------------------------------------------------------*/
class SHMesh;
class SHTexture;
class SHVkShaderModule;
struct SHMaterialSpec;
class SHMaterial;
class SHFont;
/*-----------------------------------------------------------------------------------*/
/* Type Definitions */
/*-----------------------------------------------------------------------------------*/
/// <summary>
/// Static class providing access to non-templated functions of SHResourceManager for
/// SHADE_Managed.
/// </summary>
class SH_API SHResourceManagerInterface
{
public:
/*---------------------------------------------------------------------------------*/
/* Loading Functions */
/*---------------------------------------------------------------------------------*/
/// <summary>
/// Wrapper for SHResourceManager::LoadOrGet<SHMesh>().
/// </summary>
/// <param name="assetId">Asset ID of the resource to load.</param>
/// <returns>Handle to the resource to retrieve.</returns>
static Handle<SHMesh> LoadOrGetMesh(AssetID assetId);
/// <summary>
/// Wrapper for SHResourceManager::LoadOrGet<SHTexture>().
/// </summary>
/// <param name="assetId"></param>
/// <returns>Handle to the resource to retrieve.</returns>
static Handle<SHTexture> LoadOrGetTexture(AssetID assetId);
/// <summary>
/// Wrapper for SHResourceManager::LoadOrGet<SHVkShaderModule>().
/// </summary>
/// <param name="assetId">Asset ID of the resource to load.</param>
/// <returns>Handle to the resource to retrieve.</returns>
static Handle<SHVkShaderModule> LoadOrGetShaderModule(AssetID assetId);
/// <summary>
/// Wrapper for SHResourceManager::LoadOrGet<SHMaterialSpec>().
/// </summary>
/// <param name="assetId">Asset ID of the resource to load.</param>
/// <returns>Handle to the resource to retrieve.</returns>
static Handle<SHMaterialSpec> LoadOrGetMaterialSpec (AssetID assetId);
/// <summary>
/// Wrapper for SHResourceManager::LoadOrGet<SHMaterial>().
/// </summary>
/// <param name="assetId">Asset ID of the resource to load.</param>
/// <returns>Handle to the resource to retrieve.</returns>
static Handle<SHMaterial> LoadOrGetMaterial(AssetID assetId);
/// <summary>
/// Wrapper for SHResourceManager::LoadOrGet<SHFont>().
/// </summary>
/// <param name="assetId">Asset ID of the resource to load.</param>
/// <returns>Handle to the resource to retrieve.</returns>
static Handle<SHFont> LoadOrGetFont(AssetID assetId);
/*---------------------------------------------------------------------------------*/
/* Query Functions */
/*---------------------------------------------------------------------------------*/
/// <summary>
/// Retrieves the AssetID associated with a specified Handle.
/// Compared to the templated version, this function is slower as it requires
/// searching through the storage of all resource types.
/// </summary>
/// <param name="handle">Handle to get the AssetID of.</param>
/// <return>
/// AssetID for the specified Handle. If the Handle is invalid, there will be no
/// value.
/// </return>
static std::optional<AssetID> GetAssetID(Handle<void> handle);
/// <summary>
/// Retrieves the name associated with the AssetID that is associated with the
/// specified Handle.
/// Compared to the templated version, this function is slower as it requires
/// searching through the storage of all resource types.
/// </summary>
/// <param name="handle">Handle to get the name of.</param>
/// <return>
/// Name for the specified Handle. If the Handle is invalid, there will be no
/// value.
/// </return>
static std::optional<std::string> GetAssetName(Handle<void> handle);
};
}

32
SHADE_Managed/src/Assets/Font.cxx
View File

@ -1,32 +0,0 @@
/************************************************************************************//*!
\file Font.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 Font 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 "Font.hxx"
namespace SHADE
{
/*---------------------------------------------------------------------------------*/
/* Explicit Template Instantiation */
/*---------------------------------------------------------------------------------*/
template ref class NativeAsset<SHFont>;
/*---------------------------------------------------------------------------------*/
/* Constructors/Destructor */
/*---------------------------------------------------------------------------------*/
Font::Font(Handle<SHFont> font)
: NativeAsset<SHFont> { font }
{}
}

41
SHADE_Managed/src/Assets/Font.hxx
View File

@ -1,41 +0,0 @@
/************************************************************************************//*!
\file Font.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 Font 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/TextRendering/SHFont.h"
// Project Includes
#include "NativeAsset.hxx"
#include "Engine/GenericHandle.hxx"
namespace SHADE
{
/// <summary>
/// Managed counterpart of the native Font object that can be fed to TextRenderables
/// for rendering.
/// </summary>
public ref class Font : public NativeAsset<SHFont>
{
internal:
/*-----------------------------------------------------------------------------*/
/* Constructors/Destructor */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Constructor for the Font.
/// </summary>
/// <param name="font">Handle to the font object.</param>
Font(Handle<SHFont> font);
};
}

69
SHADE_Managed/src/Assets/FontAsset.cxx Normal file
View File

@ -0,0 +1,69 @@
/************************************************************************************//*!
\file Font.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 Font 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 "FontAsset.hxx"
// External Dependencies
#include "Resource/SHResourceManagerInterface.h"
// Project Headers
#include "Utility/Convert.hxx"
namespace SHADE
{
/*---------------------------------------------------------------------------------*/
/* Properties */
/*---------------------------------------------------------------------------------*/
Handle<SHFont> FontAsset::NativeObject::get()
try
{
return SHResourceManagerInterface::LoadOrGetFont(asset.NativeAssetID);
}
catch (const BadHandleCastException&)
{
return Handle<SHFont>();
}
AssetID FontAsset::NativeAssetID::get()
{
return asset.NativeAssetID;
}
/*---------------------------------------------------------------------------------*/
/* Constructors/Destructor */
/*---------------------------------------------------------------------------------*/
FontAsset::FontAsset(AssetID fontId)
: asset { fontId }
{}
/*---------------------------------------------------------------------------------*/
/* Operator Overloads */
/*---------------------------------------------------------------------------------*/
FontAsset::operator bool(FontAsset asset)
{
return asset.asset;
}
/*---------------------------------------------------------------------------------*/
/* Conversion Operators */
/*---------------------------------------------------------------------------------*/
FontAsset::operator Asset(FontAsset nativeAsset)
{
return nativeAsset.asset;
}
FontAsset::operator FontAsset(Asset asset)
{
return FontAsset(asset.NativeAssetID);
}
}

89
SHADE_Managed/src/Assets/FontAsset.hxx Normal file
View File

@ -0,0 +1,89 @@
/************************************************************************************//*!
\file Font.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 Font 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/TextRendering/SHFont.h"
// Project Includes
#include "NativeAsset.hxx"
#include "Engine/GenericHandle.hxx"
namespace SHADE
{
/// <summary>
/// Managed counterpart of the native Font object that can be fed to TextRenderables
/// for rendering.
/// </summary>
public value struct FontAsset
{
internal:
/*-----------------------------------------------------------------------------*/
/* Properties */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Copy of the Handle to the native object.
/// </summary>
property Handle<SHFont> NativeObject
{
Handle<SHFont> get();
}
/// <summary>
/// The raw asset ID of the asset.
/// </summary>
property AssetID NativeAssetID
{
AssetID get();
}
/*-----------------------------------------------------------------------------*/
/* Constructors/Destructor */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Constructor for the Font.
/// </summary>
/// <param name="fontId">AssetID to the font asset.</param>
FontAsset(AssetID fontId);
/*-----------------------------------------------------------------------------*/
/* Operator Overloads */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Implicit conversion operator to enable checking if a Font is valid.
/// </summary>
/// <param name="gameObj">Asset to check.</param>
/// <returns>True if the Asset is valid.</returns>
static operator bool(FontAsset asset);
/*-----------------------------------------------------------------------------*/
/* Conversion Operators */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Conversion operator to enable casting from a Font to an Asset.
/// </summary>
/// <param name="vec">Vector3 to convert from.</param>
static explicit operator Asset(FontAsset nativeAsset);
/// <summary>
/// Conversion operator to enable casting from a Asset to a Font.
/// </summary>
/// <param name="asset"></param>
static explicit operator FontAsset(Asset asset);
protected:
/*-----------------------------------------------------------------------------*/
/* Data Members */
/*-----------------------------------------------------------------------------*/
Asset asset;
};
}

70
SHADE_Managed/src/Assets/MaterialAsset.cxx Normal file
View File

@ -0,0 +1,70 @@
/************************************************************************************//*!
\file MaterialAsset.cxx
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Nov 22, 2022
\brief Contains the implementation of the functions of the managed Material
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.
*//*************************************************************************************/
// Precompiled Headers
#include "SHpch.h"
// Primary Header
#include "MaterialAsset.hxx"
// External Dependencies
#include "Resource/SHResourceManagerInterface.h"
// Project Headers
#include "Utility/Convert.hxx"
namespace SHADE
{
/*---------------------------------------------------------------------------------*/
/* Properties */
/*---------------------------------------------------------------------------------*/
Handle<SHMaterial> MaterialAsset::NativeObject::get()
try
{
return SHResourceManagerInterface::LoadOrGetMaterial(asset.NativeAssetID);
}
catch (const BadHandleCastException&)
{
return Handle<SHMaterial>();
}
AssetID MaterialAsset::NativeAssetID::get()
{
return asset.NativeAssetID;
}
/*---------------------------------------------------------------------------------*/
/* Constructors/Destructor */
/*---------------------------------------------------------------------------------*/
MaterialAsset::MaterialAsset(AssetID MaterialId)
: asset { MaterialId }
{}
/*---------------------------------------------------------------------------------*/
/* Operator Overloads */
/*---------------------------------------------------------------------------------*/
MaterialAsset::operator bool(MaterialAsset asset)
{
return asset.asset;
}
/*---------------------------------------------------------------------------------*/
/* Conversion Operators */
/*---------------------------------------------------------------------------------*/
MaterialAsset::operator Asset(MaterialAsset nativeAsset)
{
return nativeAsset.asset;
}
MaterialAsset::operator MaterialAsset(Asset asset)
{
return MaterialAsset(asset.NativeAssetID);
}
}

89
SHADE_Managed/src/Assets/MaterialAsset.hxx Normal file
View File

@ -0,0 +1,89 @@
/************************************************************************************//*!
\file MaterialAsset.hxx
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Nov 22, 2022
\brief Contains the definition of the managed MaterialAsset 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"
#include "Graphics/MiddleEnd/Interface/SHMaterial.h"
// Project Includes
#include "NativeAsset.hxx"
#include "Engine/GenericHandle.hxx"
namespace SHADE
{
/// <summary>
/// Managed counterpart of the native Material object that can be fed to TextRenderables
/// for rendering.
/// </summary>
public value struct MaterialAsset
{
internal:
/*-----------------------------------------------------------------------------*/
/* Properties */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Copy of the Handle to the native object.
/// </summary>
property Handle<SHMaterial> NativeObject
{
Handle<SHMaterial> get();
}
/// <summary>
/// The raw asset ID of the asset.
/// </summary>
property AssetID NativeAssetID
{
AssetID get();
}
/*-----------------------------------------------------------------------------*/
/* Constructors/Destructor */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Constructor for the Material.
/// </summary>
/// <param name="MaterialId">AssetID to the Material asset.</param>
MaterialAsset(AssetID MaterialId);
/*-----------------------------------------------------------------------------*/
/* Operator Overloads */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Implicit conversion operator to enable checking if a Material is valid.
/// </summary>
/// <param name="gameObj">Asset to check.</param>
/// <returns>True if the Asset is valid.</returns>
static operator bool(MaterialAsset asset);
/*-----------------------------------------------------------------------------*/
/* Conversion Operators */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Conversion operator to enable casting from a Material to an Asset.
/// </summary>
/// <param name="vec">Vector3 to convert from.</param>
static explicit operator Asset(MaterialAsset nativeAsset);
/// <summary>
/// Conversion operator to enable casting from a Asset to a Material.
/// </summary>
/// <param name="asset"></param>
static explicit operator MaterialAsset(Asset asset);
protected:
/*-----------------------------------------------------------------------------*/
/* Data Members */
/*-----------------------------------------------------------------------------*/
Asset asset;
};
}

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

@ -1,34 +0,0 @@
/************************************************************************************//*!
\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
View File

@ -1,41 +0,0 @@
/************************************************************************************//*!
\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);
};
}

69
SHADE_Managed/src/Assets/MeshAsset.cxx Normal file
View File

@ -0,0 +1,69 @@
/************************************************************************************//*!
\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 "MeshAsset.hxx"
// External Dependencies
#include "Resource/SHResourceManagerInterface.h"
// Project Headers
#include "Utility/Convert.hxx"
namespace SHADE
{
/*---------------------------------------------------------------------------------*/
/* Properties */
/*---------------------------------------------------------------------------------*/
Handle<SHMesh> MeshAsset::NativeObject::get()
try
{
return SHResourceManagerInterface::LoadOrGetMesh(asset.NativeAssetID);
}
catch (const BadHandleCastException&)
{
return Handle<SHMesh>();
}
AssetID MeshAsset::NativeAssetID::get()
{
return asset.NativeAssetID;
}
/*---------------------------------------------------------------------------------*/
/* Constructors/Destructor */
/*---------------------------------------------------------------------------------*/
MeshAsset::MeshAsset(AssetID meshId)
: asset{ meshId }
{}
/*---------------------------------------------------------------------------------*/
/* Operator Overloads */
/*---------------------------------------------------------------------------------*/
MeshAsset::operator bool(MeshAsset asset)
{
return asset.asset;
}
/*---------------------------------------------------------------------------------*/
/* Conversion Operators */
/*---------------------------------------------------------------------------------*/
MeshAsset::operator Asset(MeshAsset nativeAsset)
{
return nativeAsset.asset;
}
MeshAsset::operator MeshAsset(Asset asset)
{
return MeshAsset(asset.NativeAssetID);
}
}

89
SHADE_Managed/src/Assets/MeshAsset.hxx Normal file
View File

@ -0,0 +1,89 @@
/************************************************************************************//*!
\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 value struct MeshAsset
{
internal:
/*-----------------------------------------------------------------------------*/
/* Properties */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Copy of the Handle to the native object.
/// </summary>
property Handle<SHMesh> NativeObject
{
Handle<SHMesh> get();
}
/// <summary>
/// The raw asset ID of the asset.
/// </summary>
property AssetID NativeAssetID
{
AssetID get();
}
/*-----------------------------------------------------------------------------*/
/* Constructors/Destructor */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Constructor for the Mesh.
/// </summary>
/// <param name="meshId">AssetID to the Mesh asset.</param>
MeshAsset(AssetID meshId);
/*-----------------------------------------------------------------------------*/
/* Operator Overloads */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Implicit conversion operator to enable checking if a Mesh is valid.
/// </summary>
/// <param name="gameObj">Asset to check.</param>
/// <returns>True if the Asset is valid.</returns>
static operator bool(MeshAsset asset);
/*-----------------------------------------------------------------------------*/
/* Conversion Operators */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Conversion operator to enable casting from a Mesh to an Asset.
/// </summary>
/// <param name="vec">Vector3 to convert from.</param>
static explicit operator Asset(MeshAsset nativeAsset);
/// <summary>
/// Conversion operator to enable casting from a Asset to a Mesh.
/// </summary>
/// <param name="asset"></param>
static explicit operator MeshAsset(Asset asset);
protected:
/*-----------------------------------------------------------------------------*/
/* Data Members */
/*-----------------------------------------------------------------------------*/
Asset asset;
};
}

17
SHADE_Managed/src/Assets/NativeAsset.cxx
View File

@ -17,21 +17,30 @@ of DigiPen Institute of Technology is prohibited.
#include "NativeAsset.hxx"
// Project Includes
#include "Engine/GenericHandle.hxx"
#include "Utility/Convert.hxx"
namespace SHADE
{
/*---------------------------------------------------------------------------------*/
/* Properties */
/*---------------------------------------------------------------------------------*/
GenericHandle Asset::NativeObjectHandle::get()
AssetID Asset::NativeAssetID::get()
{
return nativeObjHandle;
return assetId;
}
/*---------------------------------------------------------------------------------*/
/* Constructors */
/*---------------------------------------------------------------------------------*/
Asset::Asset(Handle<void> nativeHandle)
: nativeObjHandle { Convert::ToCLI(Handle<void>(nativeHandle)) }
Asset::Asset(AssetID id)
: assetId { id }
{}
/*---------------------------------------------------------------------------------*/
/* Operator Overloads */
/*---------------------------------------------------------------------------------*/
Asset::operator bool(Asset asset)
{
return asset.NativeAssetID != INVALID_ASSET_ID;
}
}

44
SHADE_Managed/src/Assets/NativeAsset.h++
View File

@ -1,44 +0,0 @@
/************************************************************************************//*!
\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"
#include "Utility/Convert.hxx"
namespace SHADE
{
/*---------------------------------------------------------------------------------*/
/* Properties */
/*---------------------------------------------------------------------------------*/
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)
: Asset { Handle<void>(nativeObj) }
{}
}

62
SHADE_Managed/src/Assets/NativeAsset.hxx
View File

@ -14,25 +14,28 @@ of DigiPen Institute of Technology is prohibited.
*//*************************************************************************************/
#pragma once
// External Dependencies
#include "Assets/SHAssetMacros.h"
// Project Includes
#include "Engine/GenericHandle.hxx"
namespace SHADE
{
/// <summary>
/// Abstract base class that all Native Assets will inherit from.
/// Struct that contains native asset information.
/// </summary>
public ref class Asset abstract
public value struct Asset
{
internal:
/*-----------------------------------------------------------------------------*/
/* Properties */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Generic handle for the native object
/// The raw asset ID of the asset.
/// </summary>
property GenericHandle NativeObjectHandle
property AssetID NativeAssetID
{
GenericHandle get();
AssetID get();
}
/*-----------------------------------------------------------------------------*/
@ -41,46 +44,23 @@ namespace SHADE
/// <summary>
/// Constructor for the asset.
/// </summary>
/// <param name="ptr">Native asset object handle.</param>
Asset(Handle<void> nativeHandle);
/// <param name="id">Native asset ID to construct this asset from.</param>
explicit Asset(AssetID id);
/*-----------------------------------------------------------------------------*/
/* Operator Overloads */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Implicit conversion operator to enable checking if a Asset is valid.
/// </summary>
/// <param name="gameObj">Asset to check.</param>
/// <returns>True if the Asset is valid.</returns>
static operator bool(Asset asset);
protected:
/*-----------------------------------------------------------------------------*/
/* Data Members */
/*-----------------------------------------------------------------------------*/
GenericHandle nativeObjHandle;
};
/// <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 abstract : Asset
{
internal:
/*-----------------------------------------------------------------------------*/
/* Properties */
/*-----------------------------------------------------------------------------*/
/// <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 handle.</param>
NativeAsset(Handle<NativeAssetType> ptr);
AssetID assetId;
};
}
#include "NativeAsset.h++"

16
SHADE_Managed/src/Components/Renderable.cxx
View File

@ -30,11 +30,11 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
/* Properties */
/*---------------------------------------------------------------------------------*/
SHADE::Mesh^ Renderable::Mesh::get()
SHADE::MeshAsset^ Renderable::Mesh::get()
{
return gcnew SHADE::Mesh(GetNativeComponent()->GetMesh());
return gcnew SHADE::MeshAsset(GetNativeComponent()->GetMesh());
}
void Renderable::Mesh::set(SHADE::Mesh^ value)
void Renderable::Mesh::set(SHADE::MeshAsset^ value)
{
if (value == nullptr)
{
@ -42,7 +42,7 @@ namespace SHADE
}
else
{
GetNativeComponent()->SetMesh(Handle<SHMesh>(Convert::ToNative(value->NativeObjectHandle)));
GetNativeComponent()->SetMesh(value->NativeObject);
}
}
SHADE::Material^ Renderable::Material::get()
@ -64,4 +64,12 @@ namespace SHADE
{
return GetNativeComponent()->GetLightLayer();
}
/*---------------------------------------------------------------------------------*/
/* Properties */
/*---------------------------------------------------------------------------------*/
void Renderable::SetMaterial(MaterialAsset materialAsset)
{
GetNativeComponent()->SetMaterial(materialAsset.NativeObject);
}
}

21
SHADE_Managed/src/Components/Renderable.hxx
View File

@ -20,8 +20,9 @@ of DigiPen Institute of Technology is prohibited.
#include "Math/Quaternion.hxx"
// External Dependencies
#include "Graphics/MiddleEnd/Interface/SHRenderable.h"
#include "Assets/Mesh.hxx"
#include "Assets/Material.hxx"
#include "Assets/MeshAsset.hxx"
#include "Graphics/Material.hxx"
#include "Assets/MaterialAsset.hxx"
namespace SHADE
{
@ -48,10 +49,10 @@ namespace SHADE
/// <summary>
/// Mesh used to render this Renderable.
/// </summary>
property SHADE::Mesh^ Mesh
property SHADE::MeshAsset^ Mesh
{
SHADE::Mesh^ get();
void set(SHADE::Mesh^ value);
SHADE::MeshAsset^ get();
void set(SHADE::MeshAsset^ value);
}
/// <summary>
/// Material used to render this Renderable.
@ -68,6 +69,16 @@ namespace SHADE
{
System::Byte get();
}
/*-----------------------------------------------------------------------------*/
/* Usage functions */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Sets the Material used by this Renderable to be an instance of the specified
/// base MaterialAsset.
/// </summary>
/// <param name="asset">Material to set.</param>
void SetMaterial(MaterialAsset materialAsset);
};
}

8
SHADE_Managed/src/Components/TextRenderable.cxx
View File

@ -39,11 +39,11 @@ namespace SHADE
{
GetNativeComponent()->SetText(Convert::ToNative(value));
}
SHADE::Font^ TextRenderable::Font::get()
SHADE::FontAsset^ TextRenderable::Font::get()
{
return gcnew SHADE::Font(GetNativeComponent()->GetFont());
return gcnew SHADE::FontAsset(GetNativeComponent()->GetFont());
}
void TextRenderable::Font::set(SHADE::Font^ value)
void TextRenderable::Font::set(SHADE::FontAsset^ value)
{
if (value == nullptr)
{
@ -51,7 +51,7 @@ namespace SHADE
}
else
{
GetNativeComponent()->SetFont(Handle<SHFont>(Convert::ToNative(value->NativeObjectHandle)));
GetNativeComponent()->SetFont(value->NativeObject);
}
}
}

8
SHADE_Managed/src/Components/TextRenderable.hxx
View File

@ -20,7 +20,7 @@ of DigiPen Institute of Technology is prohibited.
#include "Components/Component.hxx"
#include "Math/Vector3.hxx"
#include "Math/Quaternion.hxx"
#include "Assets/Font.hxx"
#include "Assets/FontAsset.hxx"
namespace SHADE
{
@ -55,10 +55,10 @@ namespace SHADE
/// <summary>
/// Font to use to render using this TextRenderable.
/// </summary>
property SHADE::Font^ Font
property SHADE::FontAsset^ Font
{
SHADE::Font^ get();
void set(SHADE::Font^ value);
SHADE::FontAsset^ get();
void set(SHADE::FontAsset^ value);
}
};
}

10
SHADE_Managed/src/Editor/Editor.cxx
View File

@ -176,7 +176,10 @@ namespace SHADE
renderSpecificField<SHVec3 , Vector3 >(field, object, SHEditorUI::InputVec3 , &isHovered) ||
renderSpecificField<uint32_t , GameObject >(field, object, nullptr , &isHovered) ||
renderSpecificField<std::string, System::String^>(field, object, nullptr , &isHovered) ||
renderSpecificField<int , System::Enum >(field, object, nullptr , &isHovered);
renderSpecificField<int , System::Enum >(field, object, nullptr , &isHovered) ||
renderSpecificField<AssetID , FontAsset >(field, object, nullptr , &isHovered) ||
renderSpecificField<AssetID , MeshAsset >(field, object, nullptr , &isHovered) ||
renderSpecificField<AssetID , MaterialAsset >(field, object, nullptr , &isHovered);
if (!MODIFIED_PRIMITIVE)
{
@ -319,7 +322,10 @@ namespace SHADE
renderFieldEditor<SHVec3 , Vector3 >(fieldName, object, SHEditorUI::InputVec3 , nullptr, rangeAttrib, modified) ||
renderFieldEditor<uint32_t , GameObject >(fieldName, object, nullptr , nullptr, rangeAttrib, modified) ||
renderFieldEditor<std::string, System::String^>(fieldName, object, nullptr , nullptr, rangeAttrib, modified) ||
renderFieldEditor<int , System::Enum >(fieldName, object, nullptr , nullptr, rangeAttrib, modified);
renderFieldEditor<int , System::Enum >(fieldName, object, nullptr , nullptr, rangeAttrib, modified) ||
renderFieldEditor<AssetID , FontAsset >(fieldName, object, nullptr , nullptr, rangeAttrib, modified) ||
renderFieldEditor<AssetID , MeshAsset >(fieldName, object, nullptr , nullptr, rangeAttrib, modified) ||
renderFieldEditor<AssetID , MaterialAsset >(fieldName, object, nullptr , nullptr, rangeAttrib, modified);
return modified;
}

39
SHADE_Managed/src/Editor/Editor.h++
View File

@ -20,6 +20,9 @@ of DigiPen Institute of Technology is prohibited.
#include "Editor/SHEditorUI.h"
// Project Includes
#include "Utility/Convert.hxx"
#include "Assets/FontAsset.hxx"
#include "Assets/MeshAsset.hxx"
#include "Assets/MaterialAsset.hxx"
namespace SHADE
{
@ -198,6 +201,42 @@ namespace SHADE
return true;
}
return false;
}
template<>
bool Editor::renderFieldEditorInternal<AssetID, FontAsset>(const std::string& fieldName, interior_ptr<FontAsset> managedValPtr, EditorFieldFunc<uint32_t>, bool* isHovered, RangeAttribute^)
{
uint32_t assetId = managedValPtr->NativeAssetID;
if (SHEditorUI::InputAssetField(fieldName, assetId, AssetType::FONT, isHovered, !(*managedValPtr)))
{
*managedValPtr = FontAsset(assetId);
return true;
}
return false;
}
template<>
bool Editor::renderFieldEditorInternal<AssetID, MeshAsset>(const std::string& fieldName, interior_ptr<MeshAsset> managedValPtr, EditorFieldFunc<uint32_t>, bool* isHovered, RangeAttribute^)
{
uint32_t assetId = managedValPtr->NativeAssetID;
if (SHEditorUI::InputAssetField(fieldName, assetId, AssetType::MESH, isHovered, !(*managedValPtr)))
{
*managedValPtr = MeshAsset(assetId);
return true;
}
return false;
}
template<>
bool Editor::renderFieldEditorInternal<AssetID, MaterialAsset>(const std::string& fieldName, interior_ptr<MaterialAsset> managedValPtr, EditorFieldFunc<uint32_t>, bool* isHovered, RangeAttribute^)
{
uint32_t assetId = managedValPtr->NativeAssetID;
if (SHEditorUI::InputAssetField(fieldName, assetId, AssetType::MATERIAL, isHovered, !(*managedValPtr)))
{
*managedValPtr = MaterialAsset(assetId);
return true;
}
return false;
}
}

31
SHADE_Managed/src/Assets/Material.cxx → SHADE_Managed/src/Graphics/Material.cxx
View File

@ -20,6 +20,7 @@ of DigiPen Institute of Technology is prohibited.
#include <stdexcept>
// Project Includes
#include "Utility/Convert.hxx"
#include "Resource/SHResourceManagerInterface.h"
namespace SHADE
{
@ -53,15 +54,31 @@ namespace SHADE
}
/*---------------------------------------------------------------------------------*/
/* Explicit Template Instantiation */
/* Properties */
/*---------------------------------------------------------------------------------*/
template ref class NativeAsset<SHMaterialInstance>;
Handle<SHMaterialInstance> Material::NativeObject::get()
try
{
return Handle<SHMaterialInstance>(Convert::ToNative(matInstHandle));
}
catch (const BadHandleCastException&)
{
return Handle<SHMaterialInstance>();
}
GenericHandle Material::NativeObjectHandle::get()
{
return matInstHandle;
}
AssetID Material::NativeAssetID::get()
{
return SHResourceManagerInterface::GetAssetID(Convert::ToNative(matInstHandle)).value_or(INVALID_ASSET_ID);
}
/*---------------------------------------------------------------------------------*/
/* Constructors/Destructor */
/*---------------------------------------------------------------------------------*/
Material::Material(Handle<SHMaterialInstance> material)
: NativeAsset<SHMaterialInstance>{ material }
: matInstHandle{ Handle<void>(material) }
{}
/*---------------------------------------------------------------------------------*/
@ -116,4 +133,12 @@ namespace SHADE
throw gcnew System::ArgumentException("Attempted to retrieve an invalid property on a material.");
}
/*---------------------------------------------------------------------------------*/
/* Operator Overloads */
/*---------------------------------------------------------------------------------*/
Material::operator bool(Material materialInstance)
{
return materialInstance;
}
}

45
SHADE_Managed/src/Assets/Material.hxx → SHADE_Managed/src/Graphics/Material.hxx
View File

@ -16,8 +16,8 @@ of DigiPen Institute of Technology is prohibited.
// External Dependencies
#include "Resource/SHHandle.h"
#include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h"
#include "Assets/SHAssetMacros.h"
// Project Includes
#include "NativeAsset.hxx"
#include "Engine/GenericHandle.hxx"
namespace SHADE
@ -26,9 +26,34 @@ namespace SHADE
/// 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>
public value struct Material
{
internal:
/*-----------------------------------------------------------------------------*/
/* Properties */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Copy of the Handle to the native object.
/// </summary>
property Handle<SHMaterialInstance> NativeObject
{
Handle<SHMaterialInstance> get();
}
/// <summary>
/// Generic handle for the native object
/// </summary>
property GenericHandle NativeObjectHandle
{
GenericHandle get();
}
/// <summary>
/// The raw asset ID of the asset.
/// </summary>
property AssetID NativeAssetID
{
AssetID get();
}
/*-----------------------------------------------------------------------------*/
/* Constructors/Destructor */
/*-----------------------------------------------------------------------------*/
@ -77,5 +102,21 @@ namespace SHADE
/// </exception>
generic<typename T>
T GetProperty(System::String^ name);
/*-----------------------------------------------------------------------------*/
/* Operator Overloads */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Implicit conversion operator to enable checking if a Material is valid.
/// </summary>
/// <param name="gameObj">Asset to check.</param>
/// <returns>True if the Asset is valid.</returns>
static operator bool(Material asset);
protected:
/*-----------------------------------------------------------------------------*/
/* Data Members */
/*-----------------------------------------------------------------------------*/
GenericHandle matInstHandle;
};
}

8
SHADE_Managed/src/Scripts/Script.cxx
View File

@ -258,6 +258,14 @@ namespace SHADE
Script::Script()
: OnGizmosDrawOverriden { false }
{}
/*---------------------------------------------------------------------------------*/
/* Manipulation Functions */
/*---------------------------------------------------------------------------------*/
void Script::SetEnabledWithoutEvents(bool enable)
{
enabled = enable;
}
/*---------------------------------------------------------------------------------*/
/* Virtual "All-Time" Lifecycle Functions */

9
SHADE_Managed/src/Scripts/Script.hxx
View File

@ -326,6 +326,15 @@ namespace SHADE
/// <param name="collision">Information on the collision event.</param>
void OnTriggerExit(CollisionInfo collision);
/*-----------------------------------------------------------------------------*/
/* Manipulation Functions */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Function to set the enabled state of this script without triggering events.
/// </summary>
/// <param name="enable">Whether to enable or disable the script.</param>
void SetEnabledWithoutEvents(bool enable);
protected:
/*-----------------------------------------------------------------------------*/
/* Constructors */

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

@ -744,7 +744,7 @@ namespace SHADE
for (YAML::Node& node : *yamlNode)
{
// Get the name of the script
if (!node["Type"])
if (!node["Type"].IsDefined())
{
Debug::LogWarning("[ScriptStore] Script with no type detected, skipping.");
continue;

53
SHADE_Managed/src/Serialisation/SerialisationUtilities.cxx
View File

@ -18,11 +18,16 @@ of DigiPen Institute of Technology is prohibited.
#include "Serialisation/SerialisationUtilities.hxx"
// Project Includes
#include "ReflectionUtilities.hxx"
#include "Assets/FontAsset.hxx"
#include "Assets/MaterialAsset.hxx"
#include "Assets/MeshAsset.hxx"
#include "Scripts/Script.hxx"
/*-------------------------------------------------------------------------------------*/
/* File-Level Constants */
/*-------------------------------------------------------------------------------------*/
static const std::string_view SCRIPT_TYPE_YAMLTAG = "Type";
static const std::string_view SCRIPT_ENABLED_YAMLTAG = "Enabled";
/*-------------------------------------------------------------------------------------*/
/* Function Definitions */
@ -36,10 +41,19 @@ namespace SHADE
{
using namespace System::Reflection;
// Obtain script
Script^ script = safe_cast<Script^>(object);
if (script == nullptr)
{
Debug::LogWarning("[SerialisationUtilities] Attempted to serialise an object that is not a script!");
return;
}
// Create YAML object
YAML::Node scriptNode;
scriptNode.SetStyle(YAML::EmitterStyle::Block);
scriptNode[SCRIPT_TYPE_YAMLTAG.data()] = Convert::ToNative(object->GetType()->FullName);
scriptNode[SCRIPT_ENABLED_YAMLTAG.data()] = script->Enabled;
// Get all fields
System::Collections::Generic::IEnumerable<FieldInfo^>^ fields = ReflectionUtilities::GetInstanceFields(object);
@ -69,7 +83,7 @@ namespace SHADE
{
using namespace System::Reflection;
// Load the YAML
// Error Checking
if (!yamlNode.IsMap())
{
// Invalid
@ -80,6 +94,21 @@ namespace SHADE
);
return;
}
// Get the script
Script^ script = safe_cast<Script^>(object);
if (script == nullptr)
{
Debug::LogWarning("[SerialisationUtilities] Attempted to deserialise an object that is not a script!");
return;
}
// Set enabled state
if (yamlNode[SCRIPT_ENABLED_YAMLTAG.data()].IsDefined())
{
script->SetEnabledWithoutEvents(yamlNode[SCRIPT_ENABLED_YAMLTAG.data()].as<bool>());
}
// Get all fields
System::Collections::Generic::IEnumerable<FieldInfo^>^ fields = ReflectionUtilities::GetInstanceFields(object);
for each (FieldInfo^ field in fields)
@ -92,7 +121,7 @@ namespace SHADE
// Deserialise
const std::string FIELD_NAME = Convert::ToNative(field->Name);
if (yamlNode[FIELD_NAME])
if (yamlNode[FIELD_NAME].IsDefined())
{
writeYamlIntoField(field, object, yamlNode[FIELD_NAME]);
}
@ -129,7 +158,10 @@ namespace SHADE
fieldInsertYaml<System::String>(fieldInfo, object, fieldNode) ||
fieldInsertYaml<Vector2 >(fieldInfo, object, fieldNode) ||
fieldInsertYaml<Vector3 >(fieldInfo, object, fieldNode) ||
fieldInsertYaml<GameObject >(fieldInfo, object, fieldNode);
fieldInsertYaml<GameObject >(fieldInfo, object, fieldNode) ||
fieldInsertYaml<FontAsset >(fieldInfo, object, fieldNode) ||
fieldInsertYaml<MaterialAsset >(fieldInfo, object, fieldNode) ||
fieldInsertYaml<MeshAsset >(fieldInfo, object, fieldNode);
// Serialization of more complex types
if (!PRIMITIVE_SERIALIZED)
@ -190,7 +222,10 @@ namespace SHADE
varInsertYamlInternal<System::String>(object, fieldNode) ||
varInsertYamlInternal<Vector2 >(object, fieldNode) ||
varInsertYamlInternal<Vector3 >(object, fieldNode) ||
varInsertYamlInternal<GameObject >(object, fieldNode);
varInsertYamlInternal<GameObject >(object, fieldNode) ||
varInsertYamlInternal<FontAsset >(object, fieldNode) ||
varInsertYamlInternal<MaterialAsset >(object, fieldNode) ||
varInsertYamlInternal<MeshAsset >(object, fieldNode);
return INSERTED;
}
@ -214,7 +249,10 @@ namespace SHADE
fieldAssignYaml<System::String>(fieldInfo, object, node) ||
fieldAssignYaml<Vector2> (fieldInfo, object, node) ||
fieldAssignYaml<Vector3> (fieldInfo, object, node) ||
fieldAssignYaml<GameObject> (fieldInfo, object, node);
fieldAssignYaml<GameObject> (fieldInfo, object, node) ||
fieldAssignYaml<FontAsset> (fieldInfo, object, node) ||
fieldAssignYaml<MaterialAsset> (fieldInfo, object, node) ||
fieldAssignYaml<MeshAsset> (fieldInfo, object, node);
if (!ASSIGNED)
{
if (ReflectionUtilities::FieldIsList(fieldInfo))
@ -277,7 +315,10 @@ namespace SHADE
varAssignYamlInternal<System::String>(object, node) ||
varAssignYamlInternal<Vector2> (object, node) ||
varAssignYamlInternal<Vector3> (object, node) ||
varAssignYamlInternal<GameObject> (object, node);
varAssignYamlInternal<GameObject> (object, node) ||
varAssignYamlInternal<FontAsset> (object, node) ||
varAssignYamlInternal<MaterialAsset> (object, node) ||
varAssignYamlInternal<MeshAsset> (object, node);
return DESERIALISED;
}
}

27
SHADE_Managed/src/Serialisation/SerialisationUtilities.h++
View File

@ -60,6 +60,12 @@ namespace SHADE
{
fieldNode = MAX_EID;
}
else if constexpr (std::is_same_v<FieldType, FontAsset> ||
std::is_same_v<FieldType, MaterialAsset> ||
std::is_same_v<FieldType, MeshAsset>)
{
fieldNode = INVALID_ASSET_ID;
}
else
{
fieldNode = FieldType();
@ -122,6 +128,17 @@ namespace SHADE
return true;
}
}
else if constexpr (std::is_same_v<FieldType, FontAsset> ||
std::is_same_v<FieldType, MaterialAsset> ||
std::is_same_v<FieldType, MeshAsset>)
{
if (object->GetType() == FieldType::typeid)
{
FieldType asset = safe_cast<FieldType>(object);
fieldNode = asset.NativeAssetID;
return true;
}
}
else
{
if (object->GetType() == FieldType::typeid)
@ -229,6 +246,16 @@ namespace SHADE
const uint32_t EID = node.as<uint32_t>();
object = (EID == MAX_EID ? GameObject() : GameObject(EID));
}
else if constexpr (std::is_same_v<FieldType, FontAsset> ||
std::is_same_v<FieldType, MaterialAsset> ||
std::is_same_v<FieldType, MeshAsset>)
{
if (object->GetType() == FieldType::typeid)
{
object = FieldType(node.as<AssetID>());
return true;
}
}
else
{
object = node.as<CastType>();