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

Scene loads correctly now

This commit is contained in:
Sri Sham Haran 2022-11-04 14:44:18 +08:00
parent 74b9882024
commit 4ee0294977
27 changed files with 834 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Assets/Application.SHConfig Normal file
View File

@ -0,0 +1,4 @@
Start in Fullscreen: false
Starting Scene ID: 94283040
Window Size: {x: 1920, y: 1080}
Window Title: SHADE Engine

2
Assets/Materials/TestMat.shmat
View File

@ -2,7 +2,7 @@
FragmentShader: 46377769
SubPass: G-Buffer Write
Properties:
data.color: {x: 1, y: 0.200000003, z: 0.100000001, w: 1}
data.color: {x: 0, y: 0, z: 0, w: 1}
data.textureIndex: 64651793
data.alpha: 0
data.beta: {x: 1, y: 1, z: 1}

8
Assets/Materials/WhiteMat.shmat Normal file
View File

@ -0,0 +1,8 @@
- VertexShader: 39210065
FragmentShader: 46377769
SubPass: G-Buffer Write
Properties:
data.color: {x: 1, y: 1, z: 1, w: 1}
data.textureIndex: 0
data.alpha: 0
data.beta: {x: 1, y: 1, z: 1}

3
Assets/Materials/WhiteMat.shmat.shmeta Normal file
View File

@ -0,0 +1,3 @@
Name: WhiteMat
ID: 124370424
Type: 7

216
Assets/Scenes/M2Scene.shade Normal file
View File

@ -0,0 +1,216 @@
- EID: 0
Name: Default
IsActive: true
NumberOfChildren: 0
Components:
Camera Component:
Position: {x: 0, y: 0, z: 0}
Pitch: 0
Yaw: 0
Roll: 0
Width: 1920
Height: 1080
Near: 0.00999999978
Far: 10000
Perspective: true
Light Component:
Position: {x: 0, y: 0, z: 0}
Type: Directional
Direction: {x: 1.79999995, y: 0, z: 1}
Color: {x: 0.951541841, y: 0.921719015, z: 0.553319454, w: 1}
Layer: 4294967295
Strength: 0
Scripts: ~
- EID: 1
Name: Default
IsActive: true
NumberOfChildren: 0
Components:
Transform Component:
Translate: {x: -1.440328, y: -4.41369677, z: -5}
Rotate: {x: -0, y: 0, z: -0}
Scale: {x: 49.4798889, y: 0.5, z: 17.5}
Renderable Component:
Mesh: 80365422
Material: 126974645
RigidBody Component:
Type: Static
Mass: 1
Drag: 0
Angular Drag: 0
Use Gravity: true
Interpolate: true
Freeze Position X: false
Freeze Position Y: false
Freeze Position Z: false
Freeze Rotation X: false
Freeze Rotation Y: false
Freeze Rotation Z: false
Collider Component:
Colliders:
- Is Trigger: false
Type: Box
Half Extents: {x: 0.0170898438, y: 0.00048828125, z: 0.0170898438}
Friction: 0.400000006
Bounciness: 0
Density: 1
Position Offset: {x: 0, y: 0, z: 0}
Scripts: ~
- EID: 2
Name: Player
IsActive: true
NumberOfChildren: 2
Components:
Transform Component:
Translate: {x: -3.06177855, y: -2, z: -5}
Rotate: {x: -0, y: 0, z: -0}
Scale: {x: 2, y: 2, z: 2}
Renderable Component:
Mesh: 80365422
Material: 126974645
RigidBody Component:
Type: Dynamic
Mass: 1
Drag: 0
Angular Drag: 0
Use Gravity: true
Interpolate: true
Freeze Position X: false
Freeze Position Y: false
Freeze Position Z: false
Freeze Rotation X: false
Freeze Rotation Y: false
Freeze Rotation Z: false
Collider Component:
Colliders:
- Is Trigger: false
Type: Box
Half Extents: {x: 0.0009765625, y: 0.0009765625, z: 0.0009765625}
Friction: 0.400000006
Bounciness: 0
Density: 1
Position Offset: {x: 0, y: 0.5, z: 0}
Scripts: ~
- EID: 3
Name: Default
IsActive: true
NumberOfChildren: 0
Components:
Transform Component:
Translate: {x: -0.0094268322, y: 0, z: 0}
Rotate: {x: -0, y: 0, z: -0}
Scale: {x: 1, y: 1, z: 1}
Scripts: ~
- EID: 4
Name: Default
IsActive: true
NumberOfChildren: 0
Components:
Transform Component:
Translate: {x: 0, y: 0, z: 0}
Rotate: {x: 0, y: 0, z: 0}
Scale: {x: 1, y: 1, z: 1}
Scripts: ~
- EID: 5
Name: item
IsActive: true
NumberOfChildren: 0
Components:
Transform Component:
Translate: {x: 0, y: -2, z: -5}
Rotate: {x: 0, y: 0, z: 0}
Scale: {x: 2, y: 2, z: 2}
Renderable Component:
Mesh: 80365422
Material: 124370424
RigidBody Component:
Type: Dynamic
Mass: 1
Drag: 0
Angular Drag: 0
Use Gravity: true
Interpolate: false
Freeze Position X: false
Freeze Position Y: false
Freeze Position Z: false
Freeze Rotation X: true
Freeze Rotation Y: true
Freeze Rotation Z: true
Collider Component:
Colliders:
- Is Trigger: false
Type: Box
Half Extents: {x: 0.0009765625, y: 0.0009765625, z: 0.0009765625}
Friction: 0.400000006
Bounciness: 0
Density: 1
Position Offset: {x: 0, y: 0.5, z: 0}
- Is Trigger: true
Type: Box
Half Extents: {x: 0.001953125, y: 0.001953125, z: 0.001953125}
Friction: 0.400000006
Bounciness: 0
Density: 1
Position Offset: {x: 0, y: 0.5, z: 0}
Scripts: ~
- EID: 6
Name: AI
IsActive: true
NumberOfChildren: 0
Components:
Transform Component:
Translate: {x: -8, y: -2, z: 2.5}
Rotate: {x: 0, y: 0, z: 0}
Scale: {x: 2, y: 2, z: 2}
Renderable Component:
Mesh: 80365422
Material: 126974645
RigidBody Component:
Type: Dynamic
Mass: 1
Drag: 0
Angular Drag: 0
Use Gravity: true
Interpolate: false
Freeze Position X: false
Freeze Position Y: false
Freeze Position Z: false
Freeze Rotation X: true
Freeze Rotation Y: true
Freeze Rotation Z: true
Collider Component:
Colliders:
- Is Trigger: false
Type: Box
Half Extents: {x: 0.0009765625, y: 0.0009765625, z: 0.0009765625}
Friction: 0.400000006
Bounciness: 0
Density: 1
Position Offset: {x: 0, y: 0.5, z: 0}
Scripts: ~
- EID: 7
Name: Default
IsActive: true
NumberOfChildren: 0
Components:
Transform Component:
Translate: {x: 3, y: -1, z: -1}
Rotate: {x: 0, y: 0, z: 0}
Scale: {x: 5, y: 5, z: 5}
Renderable Component:
Mesh: 80365422
Material: 126974645
Scripts: ~
- EID: 8
Name: Default
IsActive: true
NumberOfChildren: 0
Components:
Light Component:
Position: {x: 0, y: 0, z: 0}
Type: Ambient
Direction: {x: 0, y: 0, z: 1}
Color: {x: 1, y: 1, z: 1, w: 1}
Layer: 4294967295
Strength: 0.25
Scripts: ~

3
Assets/Scenes/M2Scene.shade.shmeta Normal file
View File

@ -0,0 +1,3 @@
Name: M2Scene
ID: 94283040
Type: 5

15
SHADE_Application/src/Application/SBApplication.cpp
View File

@ -41,6 +41,8 @@
#include "Assets/SHAssetManager.h"
#include "Scenes/SBMainScene.h"
#include "Serialization/Configurations/SHConfigurationManager.h"
#include "Tools/SHLogger.h"
#include "Tools/SHDebugDraw.h"
@ -60,8 +62,9 @@ namespace Sandbox
{
// Set working directory
SHFileUtilities::SetWorkDirToExecDir();
window.Create(hInstance, hPrevInstance, lpCmdLine, nCmdShow);
WindowData wndData{};
auto& appConfig = SHConfigurationManager::LoadApplicationConfig(&wndData);
window.Create(hInstance, hPrevInstance, lpCmdLine, nCmdShow, wndData);
// Create Systems
SHSystemManager::CreateSystem<SHGraphicsSystem>();
@ -80,7 +83,11 @@ namespace Sandbox
SDL_Init(SDL_INIT_VIDEO);
sdlWindow = SDL_CreateWindowFrom(window.GetHWND());
SHSystemManager::CreateSystem<SHEditor>();
SHSystemManager::GetSystem<SHEditor>()->SetSDLWindow(sdlWindow);
if(auto editor = SHSystemManager::GetSystem<SHEditor>())
{
editor->SetSDLWindow(sdlWindow);
editor->SetSHWindow(&window);
}
#endif
// Create Routines
@ -128,7 +135,7 @@ namespace Sandbox
SHSystemManager::Init();
SHSceneManager::InitSceneManager<SBTestScene>("TestScene");
SHSceneManager::InitSceneManager<SBMainScene>(appConfig.startingSceneID);
SHFrameRateController::UpdateFRC();

62
SHADE_Application/src/Scenes/SBMainScene.cpp Normal file
View File

@ -0,0 +1,62 @@
#include "SBpch.h"
#include "SBMainScene.h"
#include "ECS_Base/Managers/SHSystemManager.h"
#include "Graphics/MiddleEnd/Meshes/SHPrimitiveGenerator.h"
#include "ECS_Base/Managers/SHEntityManager.h"
#include "Graphics/MiddleEnd/Interface/SHRenderable.h"
#include "Scene/SHSceneManager.h"
#include "Graphics/MiddleEnd/Interface/SHGraphicsSystem.h"
#include "Scripting/SHScriptEngine.h"
#include "Math/Transform/SHTransformComponent.h"
#include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h"
#include "Physics/Components/SHRigidBodyComponent.h"
#include "Physics/Components/SHColliderComponent.h"
#include "Graphics/MiddleEnd/Lights/SHLightComponent.h"
#include "Assets/SHAssetManager.h"
#include "Camera/SHCameraComponent.h"
#include "Resource/SHResourceManager.h"
#include "Serialization/SHSerialization.h"
using namespace SHADE;
namespace Sandbox
{
void SBMainScene::WindowFocusFunc([[maybe_unused]] void* window, int focused)
{
if (focused)
{
}
else
{
}
}
void SBMainScene::Load()
{
}
void SBMainScene::Init()
{
sceneName = SHSerialization::DeserializeSceneFromFile(sceneAssetID);
}
void SBMainScene::Update(float dt)
{
}
void SBMainScene::Render()
{
}
void SBMainScene::Unload()
{
}
void SBMainScene::Free()
{
//SHSerialization::SerializeScene("resources/scenes/Scene01.SHADE");
}
}

30
SHADE_Application/src/Scenes/SBMainScene.h Normal file
View File

@ -0,0 +1,30 @@
#pragma once
#include "Scene/SHScene.h"
#include "Scene/SHSceneManager.h"
namespace Sandbox
{
class SBMainScene : public SHADE::SHScene
{
private:
EntityID camera;
EntityID testObj;
std::vector<EntityID> stressTestObjects;
public:
virtual void Load();
virtual void Init();
virtual void Update(float dt);
virtual void Render();
virtual void Free();
virtual void Unload();
//TODO: Change to new window DO IT IN CPP TOO
void WindowFocusFunc(void* window, int focused);
SBMainScene(void) = default;
};
}

46
SHADE_Engine/src/Editor/EditorWindow/MenuBar/SHEditorMenuBar.cpp
View File

@ -3,6 +3,7 @@
//#==============================================================#
//|| SHADE Includes ||
//#==============================================================#
#include "Editor/SHEditorWidgets.hpp"
#include "Editor/SHEditor.h"
#include "SHEditorMenuBar.h"
#include "Editor/IconsMaterialDesign.h"
@ -17,7 +18,11 @@
#include <imgui_internal.h>
#include <rttr/type>
#include "Assets/SHAssetManager.h"
#include "Assets/Asset Types/SHSceneAsset.h"
#include "Scene/SHSceneManager.h"
#include "Serialization/SHSerialization.h"
#include "Serialization/Configurations/SHConfigurationManager.h"
namespace SHADE
{
@ -75,13 +80,17 @@ namespace SHADE
{
if (ImGui::BeginMenu("File"))
{
if(ImGui::Selectable("New Scene"))
{
SHSystemManager::GetSystem<SHEditor>()->NewScene();
}
if(ImGui::Selectable("Save"))
{
SHSerialization::SerializeSceneToFile("../../Assets/Scenes/Test.SHADE");
SHSystemManager::GetSystem<SHEditor>()->SaveScene();
}
if(ImGui::Selectable("Load"))
{
SHSerialization::DeserializeSceneFromFile("../../Assets/Scenes/Test.SHADE");
//SHSystemManager::GetSystem<SHEditor>()->LoadScene()
}
ImGui::EndMenu();
}
@ -155,6 +164,35 @@ namespace SHADE
}
ImGui::EndMenu();
}
if (ImGui::BeginMenu("Application Config"))
{
auto& appConfig = SHConfigurationManager::applicationConfig;
ImGui::InputText("Window Title", &appConfig.windowTitle);
ImGui::Checkbox("Start in Fullscreen", &appConfig.startInFullScreen);
SHEditorWidgets::DragN<float, 2>("Window Size", { "Width", "Height" }, { &appConfig.windowSize.x, &appConfig.windowSize.y });
//ImGui::InputScalar("Starting Scene", ImGuiDataType_U32, &appConfig.startingSceneID);
auto sceneAsset = SHAssetManager::GetData<SHSceneAsset>(appConfig.startingSceneID);
if(ImGui::BeginCombo("Starting Scne", sceneAsset ? sceneAsset->name.data() : ""))
{
auto scenes = SHAssetManager::GetAllRecordOfType(AssetType::SCENE);
for(auto const& scene : scenes)
{
if(ImGui::Selectable(scene.name.data()))
{
appConfig.startingSceneID = scene.id;
}
}
ImGui::EndCombo();
}
if (ImGui::Button("Save"))
{
SHConfigurationManager::SaveApplicationConfig();
}
ImGui::EndMenu();
}
ImGui::EndMainMenuBar();
}
@ -174,6 +212,8 @@ namespace SHADE
const auto editor = SHSystemManager::GetSystem<SHEditor>();
ImGui::BeginDisabled(editor->editorState == SHEditor::State::PLAY);
if(ImGui::SmallButton(ICON_MD_PLAY_ARROW))
{
if(editor->SaveScene())
{
const SHEditorStateChangeEvent STATE_CHANGE_EVENT
{
@ -183,6 +223,7 @@ namespace SHADE
SHEventManager::BroadcastEvent<SHEditorStateChangeEvent>(STATE_CHANGE_EVENT, SH_EDITOR_ON_PLAY_EVENT);
}
}
ImGui::EndDisabled();
ImGui::BeginDisabled(editor->editorState == SHEditor::State::PAUSE);
if(ImGui::SmallButton(ICON_MD_PAUSE))
@ -206,6 +247,7 @@ namespace SHADE
editor->editorState = SHEditor::State::STOP;
SHEventManager::BroadcastEvent<SHEditorStateChangeEvent>(STATE_CHANGE_EVENT, SH_EDITOR_ON_STOP_EVENT);
editor->LoadScene(SHSceneManager::GetCurrentSceneAssetID());
}
ImGui::EndDisabled();
ImGui::EndMenuBar();

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

@ -45,7 +45,11 @@
#include <backends/imgui_impl_sdl.h>
#include <backends/imgui_impl_vulkan.h>
#include "Assets/SHAssetManager.h"
#include "Assets/Asset Types/SHSceneAsset.h"
#include "Graphics/MiddleEnd/Interface/SHMousePickSystem.h"
#include "Scene/SHSceneManager.h"
#include "Serialization/SHSerialization.h"
#include "Tools/SHDebugDraw.h"
RTTR_REGISTRATION
@ -148,6 +152,8 @@ namespace SHADE
}
}
RenderSceneNamePrompt();
RenderUnsavedChangesPrompt();
//PollPicking();
if(ImGui::IsKeyDown(ImGuiKey_LeftShift) && ImGui::IsKeyDown(ImGuiKey_LeftCtrl) && ImGui::IsKeyReleased(ImGuiKey_Z))
@ -172,6 +178,60 @@ namespace SHADE
}
}
void SHEditor::RenderSceneNamePrompt() noexcept
{
if(isSceneNamePromptOpen)
{
ImGui::OpenPopup(sceneNamePromptName.data());
}
if(ImGui::BeginPopupModal(sceneNamePromptName.data(), &isSceneNamePromptOpen))
{
static std::string newSceneName{};
ImGui::Text("Enter new scene name");
ImGui::InputText("##name", &newSceneName);
ImGui::BeginDisabled(newSceneName.empty());
if(ImGui::Button("Save"))
{
SaveScene(newSceneName);
newSceneName.clear();
isSceneNamePromptOpen = false;
ImGui::CloseCurrentPopup();
}
ImGui::EndDisabled();
ImGui::SameLine();
if(ImGui::Button("Cancel"))
{
isSceneNamePromptOpen = false;
ImGui::CloseCurrentPopup();
}
ImGui::EndPopup();
}
}
void SHEditor::RenderUnsavedChangesPrompt() noexcept
{
if(isUnsavedChangesPromptOpen)
{
ImGui::OpenPopup(unsavedChangesPromptName.data());
}
if(ImGui::BeginPopupModal(unsavedChangesPromptName.data(), &isUnsavedChangesPromptOpen))
{
ImGui::Text("You have unsaved changes!");
if(ImGui::Button("Save"))
{
isSceneNamePromptOpen = true;
}
ImGui::SameLine();
if(ImGui::Button("Cancel"))
{
isUnsavedChangesPromptOpen = false;
ImGui::CloseCurrentPopup();
}
}
}
void SHEditor::InitLayout() noexcept
{
if(!std::filesystem::exists(io->IniFilename))
@ -470,6 +530,66 @@ namespace SHADE
}
}
void SHEditor::NewScene()
{
if(shWindow->IsUnsavedChanges())
{
//Unsaved changes prompt
sceneToLoad = 0;
isUnsavedChangesPromptOpen = true;
}
else
{
SHSceneManager::RestartScene(0);
shWindow->ToggleUnsavedChanges();
}
}
bool SHEditor::SaveScene(std::string const& newSceneName)
{
auto const data = SHAssetManager::GetData<SHSceneAsset>(SHSceneManager::GetCurrentSceneAssetID());
if (!data)
{
if (newSceneName.empty())
{
//Prompt for scene name
isSceneNamePromptOpen = true;
return false;
}
//Else We have a new name
SHSceneManager::SetCurrentSceneName(newSceneName);
SHSceneManager::SetCurrentSceneAssetID(SHAssetManager::CreateNewAsset(AssetType::SCENE, newSceneName));
}
//Get data, if data is null, asset doesn't exist, prompt for a name and create a new asset with the name
//serialize the scene
if(SHSerialization::SerializeSceneToFile(SHSceneManager::GetCurrentSceneAssetID()))
{
if(shWindow->IsUnsavedChanges())
shWindow->ToggleUnsavedChanges();
return true;
}
return false;
}
void SHEditor::LoadScene(AssetID const& assetID) noexcept
{
if(shWindow->IsUnsavedChanges())
{
//Unsaved changes prompt
isUnsavedChangesPromptOpen = true;
sceneToLoad = assetID;
}
else
{
//Load the scene
sceneToLoad = 0;
SHSceneManager::RestartScene(assetID);
}
}
void SHEditor::NewFrame()
{
SDL_Event event;

26
SHADE_Engine/src/Editor/SHEditor.h
View File

@ -16,15 +16,18 @@
#include "Resource/SHHandle.h"
#include "EditorWindow/SHEditorWindow.h"
#include "Tools/SHLog.h"
#include "Gizmos/SHTransformGizmo.h"`
#include "Gizmos/SHTransformGizmo.h"
#include "Events/SHEventDefines.h"
#include "Events/SHEvent.h"
#include "Graphics/Windowing/SHWindow.h"
//#==============================================================#
//|| Library Includes ||
//#==============================================================#
#include <SDL_video.h>
#include "Assets/SHAssetMacros.h"
namespace SHADE
{
//#==============================================================#
@ -171,9 +174,16 @@ namespace SHADE
void InitBackend();
void SetSDLWindow(SDL_Window* inSDLWindow){sdlWindow = inSDLWindow;};
void SetSHWindow(SHWindow* inWindow){shWindow = inWindow;}
void PollPicking();
void NewScene();
bool SaveScene(std::string const& newSceneName = {});
void LoadScene(AssetID const& assetID) noexcept;
// List of selected entities
std::vector<EntityID> selectedEntities;
@ -191,6 +201,10 @@ namespace SHADE
*/
void Render();
void RenderSceneNamePrompt() noexcept;
void RenderUnsavedChangesPrompt() noexcept;
void InitLayout() noexcept;
void InitFonts() noexcept;
@ -199,12 +213,22 @@ namespace SHADE
SHEventHandle onEditorStateChanged(SHEventPtr eventPtr);
bool isSceneNamePromptOpen = false;
bool isUnsavedChangesPromptOpen = false;
static constexpr std::string_view sceneNamePromptName = "Save scene as...";
static constexpr std::string_view unsavedChangesPromptName = "Unsaved Changes";
AssetID sceneToLoad = 0;
// Handle to command pool used for ImGui Vulkan Backend
Handle<SHVkCommandPool> imguiCommandPool;
// Handle to command buffer used for ImGui Vulkan Backend
Handle<SHVkCommandBuffer> imguiCommandBuffer;
SDL_Window* sdlWindow {nullptr};
SHWindow* shWindow {nullptr};
ImGuiIO* io{nullptr};

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

@ -764,6 +764,7 @@ namespace SHADE
void SHGraphicsSystem::BeginRoutine::Execute(double) noexcept
{
SHResourceManager::FinaliseChanges();
reinterpret_cast<SHGraphicsSystem*>(system)->BeginRender();
}
@ -789,7 +790,6 @@ namespace SHADE
void SHGraphicsSystem::EndRoutine::Execute(double) noexcept
{
reinterpret_cast<SHGraphicsSystem*>(system)->EndRender();
SHResourceManager::FinaliseChanges();
}
/*-----------------------------------------------------------------------------------*/
@ -807,11 +807,6 @@ namespace SHADE
if (!renderable.HasChanged())
continue;
if (!renderable.GetMesh())
{
SHLOG_CRITICAL("NULL Mesh provided!");
}
// Remove from the SuperBatch it is previously in (prevMat if mat has changed)
Handle<SHMaterialInstance> prevMaterial = renderable.HasMaterialChanged() ? renderable.GetPrevMaterial() : renderable.GetMaterial();
if (prevMaterial)
@ -821,8 +816,9 @@ namespace SHADE
}
// Add to new SuperBatch if there is a material
// Add to new SuperBatch if there is a material and a mesh to render
Handle<SHMaterialInstance> newMatInstance = renderable.GetMaterial();
if (newMatInstance)
if (newMatInstance && renderable.GetMesh())
{
Handle<SHSuperBatch> newSuperBatch = newMatInstance->GetBaseMaterial()->GetPipeline()->GetPipelineState().GetSubpass()->GetSuperBatch();
newSuperBatch->Add(&renderable);

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

@ -4,7 +4,6 @@
#include "ECS_Base/Managers/SHSystemManager.h"
#include "Input/SHInputManager.h"
namespace SHADE
{
SHWindow::SHWindow()
@ -151,11 +150,11 @@ namespace SHADE
SetWindowText(wndHWND, LPCWSTR(wndData.title.c_str()));
}
SHWindow::SHVec2 SHWindow::GetPosition() const
SHWindow::WindowSize SHWindow::GetPosition() const
{
RECT rect;
GetWindowRect(wndHWND, &rect);
return SHVec2(static_cast<uint32_t>(rect.left), static_cast<uint32_t>(rect.top));
return WindowSize(static_cast<uint32_t>(rect.left), static_cast<uint32_t>(rect.top));
}
void SHWindow::SetPosition(unsigned x, unsigned y)
@ -165,18 +164,18 @@ namespace SHADE
wndData.y = y;
}
SHWindow::SHVec2 SHWindow::GetWindowSize() const
SHWindow::WindowSize SHWindow::GetWindowSize() const
{
RECT rect;
GetClientRect(wndHWND, &rect);
return SHVec2(static_cast<uint32_t>(rect.right - rect.left), static_cast<uint32_t>(rect.bottom - rect.top));
return WindowSize(static_cast<uint32_t>(rect.right - rect.left), static_cast<uint32_t>(rect.bottom - rect.top));
}
SHWindow::SHVec2 SHWindow::GetCurrentDisplaySize() const
SHWindow::WindowSize SHWindow::GetCurrentDisplaySize() const
{
unsigned screenWidth = GetSystemMetrics(SM_CXSCREEN);
unsigned screenHeight = GetSystemMetrics(SM_CYSCREEN);
return SHVec2(screenWidth, screenHeight);
return WindowSize(screenWidth, screenHeight);
}
void SHWindow::SetMouseVisible(bool show)
@ -260,7 +259,7 @@ namespace SHADE
return wndHWND;
}
const WindowData SHWindow::GetWindowData() const
const WindowData SHWindow::GetWindowData() const noexcept
{
return wndData;
}
@ -287,6 +286,15 @@ namespace SHADE
windowCloseCallbacks.erase(callbackid);
}
void SHWindow::ToggleUnsavedChanges() noexcept
{
unsavedChanges = !unsavedChanges;
std::wstring title = wndData.title;
if(unsavedChanges)
title.append(L"*");
SetWindowText(wndHWND, title.data());
}
LRESULT SHWindow::WndProcStatic(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
auto window = windowMap.GetWindow(hwnd);

15
SHADE_Engine/src/Graphics/Windowing/SHWindow.h
View File

@ -74,7 +74,7 @@ namespace SHADE
class SH_API SHWindow
{
public:
using SHVec2 = std::pair<uint32_t, uint32_t>;
using WindowSize = std::pair<uint32_t, uint32_t>;
typedef std::function<void(uint32_t width, uint32_t height)> WindowResizeCallbackFn;
typedef std::function<void(void)> WindowCloseCallbackFn;
typedef uint16_t CALLBACKID;
@ -92,15 +92,15 @@ namespace SHADE
void SetTitle(std::wstring title);
SHVec2 GetPosition() const;
WindowSize GetPosition() const;
void SetPosition(unsigned x, unsigned y);
//void SetPosition(SHMathVec2U);
SHVec2 GetWindowSize() const;
WindowSize GetWindowSize() const;
//Get size of display the window is in (whichever window contains the window origin)
SHVec2 GetCurrentDisplaySize() const;
WindowSize GetCurrentDisplaySize() const;
void SetMouseVisible(bool show);
@ -123,7 +123,7 @@ namespace SHADE
HWND GetHWND();
const WindowData GetWindowData() const;
const WindowData GetWindowData() const noexcept;
CALLBACKID RegisterWindowSizeCallback(WindowResizeCallbackFn);
void UnregisterWindowSizeCallback(CALLBACKID const& callbackid);
@ -131,6 +131,8 @@ namespace SHADE
void UnregisterWindowCloseCallback(CALLBACKID const& callbackid);
bool IsMinimized() const { return wndData.isMinimised; }
void ToggleUnsavedChanges() noexcept;
bool IsUnsavedChanges() const noexcept{return unsavedChanges;}
protected:
static LRESULT CALLBACK WndProcStatic(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
@ -164,7 +166,8 @@ namespace SHADE
std::unordered_map<CALLBACKID, WindowCloseCallbackFn> windowCloseCallbacks;
CALLBACKID windowResizeCallbackCount{};
CALLBACKID windowCloseCallbackCount{};
//TODO: Shift to events abstraction
bool unsavedChanges = false;
void OnCreate(HWND hwnd, LPCREATESTRUCT create_struct);
void OnClose();

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

@ -282,6 +282,9 @@ namespace SHADE
case SHADE::SHShaderBlockInterface::Variable::Type::INT:
{
Handle<SHTexture> texture = LoadOrGet<SHTexture>(PROP_NODE.as<int>());
// HACK: Need to split this out to a separate pass before loading the materials and subsequently, the scenes
gfxSystem->BuildTextures();
if (texture)
{
matHandle->SetProperty(VARIABLE->offset, texture->TextureArrayIndex);

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

@ -13,6 +13,7 @@
#include <string>
#include "SHSceneGraph.h"
#include "Assets/SHAssetMacros.h"
#include "ECS_Base/General/SHFamily.h"
namespace SHADE
@ -32,6 +33,7 @@ namespace SHADE
virtual ~SHScene() = default;
std::string sceneName;
AssetID sceneAssetID;
SHSceneGraph& GetSceneGraph() noexcept { return sceneGraph; }

28
SHADE_Engine/src/Scene/SHSceneManager.cpp
View File

@ -29,7 +29,7 @@ namespace SHADE
std::string SHSceneManager::newSceneName{};
uint32_t SHSceneManager::currentSceneID = UINT32_MAX;
uint32_t SHSceneManager::nextSceneID = UINT32_MAX;
AssetID SHSceneManager::currentSceneAssetID{};
SHScene* SHSceneManager::currentScene = nullptr;
//SHScene* SHSceneManager::nextScene = nullptr;
@ -107,16 +107,18 @@ namespace SHADE
}
}
void SHSceneManager::RestartScene(std::string const& sceneName) noexcept
void SHSceneManager::RestartScene(AssetID const& assetID ) noexcept
{
if (currentScene->sceneName != sceneName)
if (currentScene->sceneAssetID != assetID)
{
cleanReload = true;
newSceneName = sceneName;
//cleanReload = true;
cleanReload = false;
//newSceneName = sceneName;
}
else
cleanReload = false;
currentScene->sceneAssetID = assetID;
nextSceneID = currentSceneID;
sceneChanged = true;
}
@ -151,4 +153,20 @@ namespace SHADE
{
return currentScene->sceneName;
}
void SHSceneManager::SetCurrentSceneName(std::string const& sceneName) noexcept
{
currentScene->sceneName = sceneName;
}
AssetID SHSceneManager::GetCurrentSceneAssetID() noexcept
{
return currentScene->sceneAssetID;
}
void SHSceneManager::SetCurrentSceneAssetID(AssetID const& newAssetID)
{
currentScene->sceneAssetID = newAssetID;
currentSceneAssetID = newAssetID;
}
}

23
SHADE_Engine/src/Scene/SHSceneManager.h
View File

@ -20,6 +20,7 @@
//Project Headers
#include "SH_API.h"
#include "ECS_Base/General/SHFamily.h"
#include "Assets/SHAssetMacros.h"
namespace SHADE
{
@ -47,6 +48,9 @@ namespace SHADE
//pointer to the current scene
static SHScene* currentScene;
//Scene AssetID of the current scene
static AssetID currentSceneAssetID;
//Used in reloading scene.
static std::string newSceneName;
@ -80,10 +84,10 @@ namespace SHADE
* None.
***************************************************************************/
template<typename T>
static std::enable_if_t<std::is_base_of_v<SHScene, T>, void> InitSceneManager(std::string const& sceneName) noexcept
static std::enable_if_t<std::is_base_of_v<SHScene, T>, void> InitSceneManager(AssetID const& sceneAssetID) noexcept
{
//prevSceneCreate = newScene;
newScene = [sceneName]() { currentScene = new T(); currentScene->sceneName = sceneName; };
newScene = [sceneAssetID]() { currentScene = new T(); currentScene->sceneAssetID = sceneAssetID; };
//nextSceneID = SHFamilyID<SHScene>::GetID<T>();
nextSceneID = 0;
@ -99,7 +103,7 @@ namespace SHADE
* None.
***************************************************************************/
template<typename T>
static std::enable_if_t<std::is_base_of_v<SHScene, T>, void> ChangeScene(std::string const& sceneName) noexcept
static std::enable_if_t<std::is_base_of_v<SHScene, T>, void> ChangeScene(AssetID const& sceneAssetID) noexcept
{
//check if this new Scene is current Scene (Use RestartScene instead)
if (currentSceneID == SHFamilyID<SHScene>::GetID<T>())
@ -107,7 +111,7 @@ namespace SHADE
return;
}
//prevSceneCreate = newScene;
newScene = [sceneName]() { currentScene = new T(); currentScene->sceneName; };
newScene = [sceneAssetID]() { currentScene = new T(); currentScene->sceneAssetID = sceneAssetID; };
nextSceneID = SHFamilyID<SHScene>::GetID<T>();
sceneChanged = true;
}
@ -137,11 +141,11 @@ namespace SHADE
* Restarts current scene. Only Scene::Init() and Scene::Free()
* Scene::Load() and Scene::Unload() will not be called.
* Edit: allows for RestartScene to restart the scene with a different
* scene name.
* If a sceneName is different from the current one, Load and Unload will
* scene asset ID.
* If a scene asset id is different from the current one, Load and Unload will
* run.
***************************************************************************/
static void RestartScene(std::string const& sceneName ) noexcept;
static void RestartScene(AssetID const& assetID ) noexcept;
/*!*************************************************************************
* \brief
@ -164,7 +168,10 @@ namespace SHADE
static void Exit() noexcept;
static std::string GetSceneName() noexcept;
static void SetCurrentSceneName(std::string const& sceneName) noexcept;
static AssetID GetCurrentSceneAssetID() noexcept;
//Only if scene doesn't exist, and scene asset id needs to be updated to the new one
static void SetCurrentSceneAssetID(AssetID const& newAssetID);
};

89
SHADE_Engine/src/Serialization/Configurations/SHConfigurationManager.cpp Normal file
View File

@ -0,0 +1,89 @@
#include "SHpch.h"
#include "SHConfigurationManager.h"
#include "Tools/FileIO/SHFileIO.h"
#include "Serialization/SHSerializationHelper.hpp"
namespace SHADE
{
SHApplicationConfig SHConfigurationManager::applicationConfig;
#ifdef SHEDITOR
SHEditorConfig SHConfigurationManager::editorConfig;
#endif
void SHConfigurationManager::SaveApplicationConfig()
{
YAML::Emitter out;
out << SHSerializationHelper::RTTRToNode(applicationConfig);
SHFileIO::WriteStringToFile(applicationConfigPath, out.c_str());
}
SHApplicationConfig& SHConfigurationManager::LoadApplicationConfig(WindowData* wndData)
{
if(!std::filesystem::exists(applicationConfigPath))
{
SaveApplicationConfig();
return applicationConfig;
}
auto const node = YAML::Load(SHFileIO::GetStringFromFile(applicationConfigPath));
auto properties = rttr::type::get<SHApplicationConfig>().get_properties();
for(auto const& property : properties)
{
if(node[property.get_name().data()].IsDefined())
SHSerializationHelper::InitializeProperty(&applicationConfig, property, node[property.get_name().data()]);
}
if(wndData != nullptr)
{
wndData->isFullscreen = applicationConfig.startInFullScreen;
wndData->title = std::wstring(applicationConfig.windowTitle.begin(), applicationConfig.windowTitle.end());
wndData->width = static_cast<uint32_t>(applicationConfig.windowSize.x);
wndData->height = static_cast<uint32_t>(applicationConfig.windowSize.y);
}
return applicationConfig;
}
#ifdef SHEDITOR
void SHConfigurationManager::SaveEditorConfig()
{
YAML::Emitter out;
out << SHSerializationHelper::RTTRToNode(editorConfig);
SHFileIO::WriteStringToFile(editorConfigPath, out.c_str());
}
SHEditorConfig& SHConfigurationManager::LoadEditorConfig()
{
auto const node = YAML::Load(SHFileIO::GetStringFromFile(editorConfigPath));
auto properties = rttr::type::get<SHApplicationConfig>().get_properties();
for(auto const& property : properties)
{
if(node[property.get_name().data()].IsDefined())
SHSerializationHelper::InitializeProperty(&editorConfig, property, node[property.get_name().data()]);
}
return editorConfig;
}
void SHConfigurationManager::FetchEditorCameraData()
{
}
void SHConfigurationManager::SetEditorCameraData()
{
}
#endif
}
RTTR_REGISTRATION
{
using namespace rttr;
using namespace SHADE;
registration::class_<SHApplicationConfig>("Application Config")
.property("Start in Fullscreen", &SHApplicationConfig::startInFullScreen)
.property("Starting Scene ID", &SHApplicationConfig::startingSceneID)
.property("Window Size", &SHApplicationConfig::windowSize)
.property("Window Title", &SHApplicationConfig::windowTitle);
}

44
SHADE_Engine/src/Serialization/Configurations/SHConfigurationManager.h Normal file
View File

@ -0,0 +1,44 @@
#pragma once
#include <rttr/registration>
#include "Assets/SHAssetMacros.h"
#include "Graphics/Windowing/SHWindow.h"
#include "SH_API.h"
#include "Math/Vector/SHVec2.h"
namespace SHADE
{
struct SHApplicationConfig
{
bool startInFullScreen{ false };
AssetID startingSceneID{};
SHVec2 windowSize {1920, 1080};
std::string windowTitle {"SHADE Engine"};
RTTR_ENABLE()
};
struct SHEditorConfig
{
};
class SH_API SHConfigurationManager
{
public:
static constexpr std::string_view applicationConfigPath{"../../Assets/Application.SHConfig"};
static constexpr std::string_view editorConfigPath{"../../Assets/Editor/Editor.SHConfig"};
static void SaveApplicationConfig();
static SHApplicationConfig& LoadApplicationConfig(WindowData* wndData = nullptr);
static SHApplicationConfig applicationConfig;
#ifdef SHEDITOR
static void SaveEditorConfig();
static SHEditorConfig& LoadEditorConfig();
static SHEditorConfig editorConfig;
private:
static void FetchEditorCameraData();
static void SetEditorCameraData();
#endif
};
}

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

@ -10,6 +10,7 @@
#include "Assets/SHAssetManager.h"
#include <fstream>
#include "Assets/Asset Types/SHSceneAsset.h"
#include "Camera/SHCameraComponent.h"
#include "Graphics/MiddleEnd/Interface/SHRenderable.h"
#include "Math/Transform/SHTransformComponent.h"
@ -17,19 +18,23 @@
#include "ECS_Base/Managers/SHSystemManager.h"
#include "Graphics/MiddleEnd/Lights/SHLightComponent.h"
#include "Scripting/SHScriptEngine.h"
#include "Tools/FileIO/SHFileIO.h"
namespace SHADE
{
void SHSerialization::SerializeSceneToFile(std::filesystem::path const& path)
bool SHSerialization::SerializeSceneToFile(AssetID const& sceneAssetID)
{
auto assetData = SHAssetManager::GetData<SHSceneAsset>(sceneAssetID);
if(!assetData)
{
SHLOG_ERROR("Asset does not exist: {}", sceneAssetID);
return false;
}
YAML::Emitter out;
SerializeSceneToEmitter(out);
std::ofstream file(path.c_str());
if (file.good())
{
file << out.c_str();
file.close();
}
assetData->data = out.c_str();
return SHAssetManager::SaveAsset(sceneAssetID);
}
std::string SHSerialization::SerializeSceneToString()
@ -91,31 +96,16 @@ namespace SHADE
return eid;
}
void SHSerialization::DeserializeSceneFromFile(std::filesystem::path const& path)
std::string SHSerialization::DeserializeSceneFromFile(AssetID const& sceneAssetID) noexcept
{
//TODO:Shift to using XQ's FileIO
std::ifstream iFile;
iFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
std::string fileContent = "";
try
auto assetData = SHAssetManager::GetData<SHSceneAsset>(sceneAssetID);
if(!assetData)
{
// Open file
// Read file's buffer contents into streams
iFile.open(path);
std::stringstream fileStream;
fileStream << iFile.rdbuf();
fileContent = fileStream.str();
// Close file handler
iFile.close();
SHLOG_ERROR("Attempted to load scene that doesn't exist {}", sceneAssetID)
SHSceneManager::SetCurrentSceneAssetID(0);
return NewSceneName.data();
}
catch (std::ifstream::failure e)
{
SHLOG_ERROR("Could not read file");
}
YAML::Node entities = YAML::Load(fileContent);
YAML::Node entities = YAML::Load(assetData->data);
std::vector<EntityID> createdEntities{};
//Create Entities
@ -126,7 +116,7 @@ namespace SHADE
if (createdEntities.empty())
{
SHLOG_ERROR("Failed to create entities from deserializaiton")
return;
return NewSceneName.data();
}
//Initialize Entity
auto entityVecIt = createdEntities.begin();
@ -134,6 +124,8 @@ namespace SHADE
{
InitializeEntity(*it, *entityVecIt++);
}
return assetData->name;
}
void SHSerialization::EmitEntity(SHSceneNode* entityNode, YAML::Emitter& out)

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

@ -5,6 +5,7 @@
#include <filesystem>
#include <ECS_Base/Components/SHComponent.h>
#include <Assets/SHAssetMacros.h>
namespace YAML
{
@ -25,12 +26,11 @@ namespace SHADE
struct SH_API SHSerialization
{
//TODO: change paths to resource ID
static void SerializeSceneToFile(std::filesystem::path const& path);
static bool SerializeSceneToFile(AssetID const& sceneAssetID);
static std::string SerializeSceneToString();
static void SerializeSceneToEmitter(YAML::Emitter& out);
static void DeserializeSceneFromFile(std::filesystem::path const& path);
static std::string DeserializeSceneFromFile(AssetID const& sceneAssetID) noexcept;
static void EmitEntity(SHSceneNode* entityNode, YAML::Emitter& out);
@ -44,5 +44,7 @@ namespace SHADE
static std::vector<ComponentTypeID> GetComponentIDList(YAML::Node const& componentsNode);
private:
static void InitializeEntity(YAML::Node const& entityNode, EntityID const& eid);
static constexpr std::string_view NewSceneName = "New Scene";
};
}

40
SHADE_Engine/src/Serialization/SHSerializationHelper.hpp
View File

@ -397,6 +397,8 @@ namespace SHADE
node = YAML::Null;
}
}
else if (varType == rttr::type::get<std::string>())
node = var.to_string();
else
{
auto properties = var.get_type().get_properties();
@ -432,63 +434,65 @@ namespace SHADE
return node;
}
template <typename ComponentType, std::enable_if_t<std::is_base_of_v<SHComponent, ComponentType>, bool> = true>
static void InitializeProperty(ComponentType* component, rttr::property const& prop, YAML::Node const& propertyNode)
template <typename Type>
static void InitializeProperty(Type* object, rttr::property const& prop, YAML::Node const& propertyNode)
{
auto propType = prop.get_type();
if (propType == rttr::type::get<SHVec4>())
{
SHVec4 vec = propertyNode.as<SHVec4>();
prop.set_value(component, vec);
prop.set_value(object, vec);
}
else if (propType == rttr::type::get<SHVec3>())
{
SHVec3 vec = propertyNode.as<SHVec3>();
prop.set_value(component, vec);
prop.set_value(object, vec);
}
else if (propType == rttr::type::get<SHVec2>())
{
SHVec2 vec = propertyNode.as<SHVec2>();
prop.set_value(component, vec);
prop.set_value(object, vec);
}
else if (propType.is_arithmetic())
{
bool ok = false;
if (propType == rttr::type::get<bool>())
prop.set_value(component, propertyNode.as<bool>());
prop.set_value(object, propertyNode.as<bool>());
else if (propType == rttr::type::get<int8_t>())
prop.set_value(component, propertyNode.as<int8_t>());
prop.set_value(object, propertyNode.as<int8_t>());
else if (propType == rttr::type::get<int16_t>())
prop.set_value(component, propertyNode.as<int16_t>());
prop.set_value(object, propertyNode.as<int16_t>());
else if (propType == rttr::type::get<int32_t>())
prop.set_value(component, propertyNode.as<int32_t>());
prop.set_value(object, propertyNode.as<int32_t>());
else if (propType == rttr::type::get<int64_t>())
prop.set_value(component, propertyNode.as<int64_t>());
prop.set_value(object, propertyNode.as<int64_t>());
else if (propType == rttr::type::get<uint8_t>())
prop.set_value(component, propertyNode.as<uint8_t>());
prop.set_value(object, propertyNode.as<uint8_t>());
else if (propType == rttr::type::get<uint16_t>())
prop.set_value(component, propertyNode.as<uint16_t>());
prop.set_value(object, propertyNode.as<uint16_t>());
else if (propType == rttr::type::get<uint32_t>())
prop.set_value(component, propertyNode.as<uint32_t>());
prop.set_value(object, propertyNode.as<uint32_t>());
else if (propType == rttr::type::get<uint64_t>())
prop.set_value(component, propertyNode.as<uint64_t>());
prop.set_value(object, propertyNode.as<uint64_t>());
else if (propType == rttr::type::get<float>())
prop.set_value(component, propertyNode.as<float>());
prop.set_value(object, propertyNode.as<float>());
else if (propType == rttr::type::get<double>())
prop.set_value(component, propertyNode.as<double>());
prop.set_value(object, propertyNode.as<double>());
}
else if (propType.is_enumeration())
{
auto enumAlign = prop.get_enumeration();
prop.set_value(component, enumAlign.name_to_value(propertyNode.as<std::string>()));
prop.set_value(object, enumAlign.name_to_value(propertyNode.as<std::string>()));
}
else if (propType == rttr::type::get<std::string>())
prop.set_value(object, propertyNode.as<std::string>());
else
{
auto properties = propType.get_properties();
for (auto const& property : properties)
{
if(propertyNode[property.get_name().data()].IsDefined())
InitializeProperty(component, property, propertyNode[property.get_name().data()]);
InitializeProperty(object, property, propertyNode[property.get_name().data()]);
}
}
}

31
SHADE_Engine/src/Tools/FileIO/SHFieIO.cpp Normal file
View File

@ -0,0 +1,31 @@
#include "SHpch.h"
#include "SHFileIO.h"
#include <fstream>
namespace SHADE
{
int SHFileIO::WriteStringToFile(std::filesystem::path const& filePath, std::string_view const& strView)
{
std::ofstream file(filePath);
if(file.good())
{
file << strView;
file.close();
return 1;
}
return 0;
}
std::string SHFileIO::GetStringFromFile(std::filesystem::path const& filePath)
{
std::ifstream iFile;
iFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
std::string fileData{};
iFile.open(filePath, std::iostream::binary);
std::stringstream ss;
ss << iFile.rdbuf();
fileData = ss.str();
iFile.close();
return fileData;
}
}

14
SHADE_Engine/src/Tools/FileIO/SHFileIO.h Normal file
View File

@ -0,0 +1,14 @@
#pragma once
#include <filesystem>
#include <string>
#include <string_view>
#include <SH_API.h>
namespace SHADE
{
struct SH_API SHFileIO
{
static int WriteStringToFile(std::filesystem::path const& filePath, std::string_view const& strView);
static std::string GetStringFromFile(std::filesystem::path const& file);
};
}

1
SHADE_Managed/premake5.lua
View File

@ -38,6 +38,7 @@ project "SHADE_Managed"
"%{IncludeDir.RTTR}/include",
"%{IncludeDir.dotnet}\\include",
"%{IncludeDir.reactphysics3d}\\include",
"%{IncludeDir.VULKAN}\\include",
"%{wks.location}/SHADE_Engine/src"
}