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

Implemented a custom physics engine #316

Merged
direnbharwani merged 95 commits from SHPhysics into main 2023-01-23 15:55:45 +08:00
Conversation 0 Commits 95 Files Changed 144 +411 -159
23 changed files with 411 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 826a1bc617 - Show all commits

15
SHADE_Engine/src/Common/SHAllComponents.h Normal file
View File

@ -0,0 +1,15 @@
#pragma once
#include "Camera/SHCameraComponent.h"
#include "Camera/SHCameraArmComponent.h"
#include "Math/Transform/SHTransformComponent.h"
#include "Graphics/MiddleEnd/Interface/SHRenderable.h"
#include "Physics/Interface/SHRigidBodyComponent.h"
#include "UI/SHCanvasComponent.h"
#include "UI/SHButtonComponent.h"
#include "UI/SHUIComponent.h"
#include "UI/SHToggleButtonComponent.h"
#include "UI/SHSliderComponent.h"
#include "Graphics/MiddleEnd/Lights/SHLightComponent.h"
#include "Graphics/MiddleEnd/Interface/SHRenderable.h"
#include "Physics/Interface/SHColliderComponent.h"
#include "Graphics/MiddleEnd/TextRendering/SHTextRenderableComponent.h"

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

@ -239,10 +239,7 @@ namespace SHADE
case AssetType::TEXTURE: break;
case AssetType::MESH: break;
case AssetType::SCENE:
if(auto editor = SHSystemManager::GetSystem<SHEditor>())
{
editor->LoadScene(asset->id);
}
break;
case AssetType::PREFAB: break;
case AssetType::MATERIAL:

33
SHADE_Engine/src/Editor/EditorWindow/EditorPopups/SHEditorPopups.cpp Normal file
View File

@ -0,0 +1,33 @@
#include "SHpch.h"
#include "SHEditorPopups.h"
#include "Editor/SHEditor.h"
#include "misc/cpp/imgui_stdlib.h"
namespace SHADE
{
void SHSceneSavePrompt::Draw()
{
if(Begin())
{
static std::string newSceneName{};
ImGui::Text("Enter new scene name");
ImGui::InputText("##name", &newSceneName);
ImGui::BeginDisabled(newSceneName.empty());
if (ImGui::Button("Save"))
{
editor->SaveScene(newSceneName);
newSceneName.clear();
isOpen = false;
ImGui::CloseCurrentPopup();
}
ImGui::EndDisabled();
ImGui::SameLine();
if (ImGui::Button("Cancel"))
{
isOpen = false;
ImGui::CloseCurrentPopup();
}
ImGui::EndPopup();
}
}
}

17
SHADE_Engine/src/Editor/EditorWindow/EditorPopups/SHEditorPopups.h Normal file
View File

@ -0,0 +1,17 @@
#pragma once
#include "SH_API.h"
#include "Editor/EditorWindow/SHPopUpWindow.h"
namespace SHADE
{
class SHSceneSavePrompt : public SHPopUpWindow
{
public:
SHSceneSavePrompt():SHPopUpWindow("Save Scene As", true, 0, 0){}
void Draw() override;
private:
};
}

109
SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.cpp
View File

@ -3,6 +3,11 @@
//#==============================================================#
#include "SHpch.h"
//#==============================================================#
//|| Library Includes ||
//#==============================================================#
#include <imgui.h>
//#==============================================================#
//|| SHADE Includes ||
//#==============================================================#
@ -16,14 +21,11 @@
#include "Tools/SHException.h"
#include "Editor/IconsMaterialDesign.h"
#include "SHHierarchyPanelCommands.h"
//#==============================================================#
//|| Library Includes ||
//#==============================================================#
#include <imgui.h>
#include "Common/SHAllComponents.h"
#include "Serialization/SHSerialization.h"
#include "Tools/Utilities/SHClipboardUtilities.h"
#include "Tools/Utilities/SHStringUtilities.h"
namespace SHADE
@ -80,7 +82,6 @@ namespace SHADE
if (ImGui::IsWindowHovered() && !SHDragDrop::hasDragDrop && !ImGui::IsAnyItemHovered() && ImGui::IsMouseReleased(ImGuiMouseButton_Left))
{
if (auto editor = SHSystemManager::GetSystem<SHEditor>())
editor->selectedEntities.clear();
}
ImGui::SeparatorEx(ImGuiSeparatorFlags_Horizontal);
@ -99,7 +100,6 @@ namespace SHADE
}
if (ImGui::IsKeyDown(ImGuiKey_LeftCtrl) && ImGui::IsKeyDown(ImGuiKey_LeftShift) && ImGui::IsKeyReleased(ImGuiKey_V))
{
const auto editor = SHSystemManager::GetSystem<SHEditor>();
if (editor->selectedEntities.size() == 1)
{
PasteEntities(editor->selectedEntities.back());
@ -141,16 +141,18 @@ namespace SHADE
//#==============================================================#
//|| Private Member Functions ||
//#==============================================================#
void SHHierarchyPanel::DrawMenuBar() const noexcept
void SHHierarchyPanel::DrawMenuBar() noexcept
{
if (ImGui::BeginMenuBar())
{
auto size = ImGui::GetWindowSize();
auto g = ImGui::GetCurrentContext();
DrawHierarchyPanelFilter();
ImGui::SetCursorPosX(size.x - g->Style.FramePadding.x * 15.0f);
if (ImGui::SmallButton(ICON_MD_CLEAR_ALL))
{
auto editor = SHSystemManager::GetSystem<SHEditor>();
editor->selectedEntities.clear();
}
if (ImGui::IsItemHovered())
@ -173,6 +175,56 @@ namespace SHADE
}
}
void SHHierarchyPanel::DrawHierarchyPanelFilter() noexcept
{
if(ImGui::InputTextWithHint("##hierarchyPanelFilter", "Filter", &filter))
{
}
ImGui::SameLine();
if(ImGui::Button("x"))
{
filter.clear();
}
}
bool SHHierarchyPanel::EntityFilterCheck(SHSceneNode* entityNode) noexcept
{
if(!entityNode || filter.empty())
return false;
EntityID const eid = entityNode->GetEntityID();
SHEntity* entity = SHEntityManager::GetEntityByID(eid);
bool result = false;
result |= SHStringUtilities::StringFindInsensitive(entity->name, filter) != std::string::npos;
if(SHStringUtilities::StringFindInsensitive(rttr::type::get<SHTransformComponent>().get_name().data(), filter) != std::string::npos)
{
result |= SHComponentManager::HasComponent<SHTransformComponent>(eid);
}
//result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHColliderComponent>().get_name().data(), filter) != std::string::npos;
//result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHRigidBodyComponent>().get_name().data(), filter) != std::string::npos;
//result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHCameraComponent>().get_name().data(), filter) != std::string::npos;
//result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHCameraArmComponent>().get_name().data(), filter) != std::string::npos;
//result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHRenderable>().get_name().data(), filter) != std::string::npos;
//result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHLightComponent>().get_name().data(), filter) != std::string::npos;
//result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHTextRenderableComponent>().get_name().data(), filter) != std::string::npos;
//result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHUIComponent>().get_name().data(), filter) != std::string::npos;
//result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHButtonComponent>().get_name().data(), filter) != std::string::npos;
//result |= SHStringUtilities::StringFindInsensitive(rttr::type::get<SHCanvasComponent>().get_name().data(), filter) != std::string::npos;
//std::vector<SHSceneNode*> const& children = entityNode->GetChildren();
//for (auto const& child : children)
//{
// result |= EntityFilterCheck(child);
//}
return result;
}
ImRect SHHierarchyPanel::RecursivelyDrawEntityNode(SHSceneNode* const currentNode)
{
if (currentNode == nullptr)
@ -189,21 +241,39 @@ namespace SHADE
scrollTo = MAX_EID;
}
auto editor = SHSystemManager::GetSystem<SHEditor>();
auto* entity = SHEntityManager::GetEntityByID(eid);
const bool isSelected = (std::ranges::find(editor->selectedEntities, eid) != editor->selectedEntities.end());
const ImGuiTreeNodeFlags nodeFlags = ((isSelected) ? ImGuiTreeNodeFlags_Selected : 0) | ((children.empty()) ? ImGuiTreeNodeFlags_Leaf : ImGuiTreeNodeFlags_OpenOnArrow);
//bool highlighted = false;
//if(highlighted)
bool highlighted = false;
//if(!filter.empty())
//{
// highlighted = EntityFilterCheck(currentNode);
// if (highlighted)
// {
// ImGui::PushStyleColor(ImGuiCol_Text, highlightedColor);
//
// ImGui::SetNextItemOpen(true);
//
//
// }
// else
// {
//
// }
//}
auto* entity = SHEntityManager::GetEntityByID(currentNode->GetEntityID());
const ImGuiTreeNodeFlags nodeFlags = ((isSelected) ? ImGuiTreeNodeFlags_Selected : 0) | ((children.empty()) ? ImGuiTreeNodeFlags_Leaf : ImGuiTreeNodeFlags_OpenOnArrow);
//Draw Node
bool isNodeOpen = ImGui::TreeNodeEx(reinterpret_cast<void*>(entity), nodeFlags, "%u: %s", SHEntityManager::GetEntityIndex(eid), entity->name.c_str());
bool isNodeOpen = ImGui::TreeNodeEx(reinterpret_cast<void*>(eid), nodeFlags, "%u: %s", SHEntityManager::GetEntityIndex(eid), entity->name.c_str());
if (highlighted)
{
ImGui::PopStyleColor();
}
const ImRect nodeRect = ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());
//Check For Begin Drag
@ -336,6 +406,7 @@ namespace SHADE
drawList->AddLine(vertLineStart, vertLineEnd, treeLineColor, 2);
ImGui::TreePop();
}
return nodeRect;
}
@ -350,7 +421,6 @@ namespace SHADE
std::vector<EntityID> entitiesToParent = CleanUpEIDList(entities);
//auto const editor = SHSystemManager::GetSystem<SHEditor>();
SHEntityParentCommand::EntityParentData entityParentData;
std::vector<EntityID> parentedEIDS;
for (auto const& eid : entitiesToParent)
@ -371,7 +441,7 @@ namespace SHADE
void SHHierarchyPanel::SelectRangeOfEntities(EntityID beginEID, EntityID endEID)
{
bool startSelecting = false; bool endSelecting = false;
auto const editor = SHSystemManager::GetSystem<SHEditor>();
editor->selectedEntities.clear();
auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph();
sceneGraph.Traverse([&](SHSceneNode* nodePtr)
@ -403,7 +473,6 @@ namespace SHADE
void SHHierarchyPanel::SelectAllEntities()
{
const auto editor = SHSystemManager::GetSystem<SHEditor>();
editor->selectedEntities.clear();
auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph();
sceneGraph.Traverse([&](SHSceneNode* nodePtr)
@ -415,7 +484,6 @@ namespace SHADE
void SHHierarchyPanel::CopySelectedEntities()
{
const auto editor = SHSystemManager::GetSystem<SHEditor>();
std::vector<EntityID> entitiesToCopy = CleanUpEIDList(editor->selectedEntities);
SHClipboardUtilities::WriteToClipboard(SHSerialization::SerializeEntitiesToString(entitiesToCopy));
}
@ -428,7 +496,6 @@ namespace SHADE
void SHHierarchyPanel::DeleteSelectedEntities()
{
const auto editor = SHSystemManager::GetSystem<SHEditor>();
std::vector<EntityID> entitiesToDelete = CleanUpEIDList(editor->selectedEntities);
SHCommandManager::PerformCommand(std::make_shared<SHDeleteEntitiesCommand>(entitiesToDelete));
}

8
SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.h
View File

@ -10,6 +10,8 @@
#include "imgui_internal.h"
#include "ECS_Base/SHECSMacros.h"
#include "Editor/EditorWindow/SHEditorWindow.h"
#include "ECS_Base/Entity/SHEntity.h"
namespace SHADE
{
class SHSceneNode;
@ -24,7 +26,11 @@ namespace SHADE
void Exit() override;
void SetScrollTo(EntityID eid);
private:
void DrawMenuBar() const noexcept;
void DrawMenuBar() noexcept;
void DrawHierarchyPanelFilter() noexcept;
bool EntityFilterCheck(SHSceneNode* entityNode) noexcept;
ImRect RecursivelyDrawEntityNode(SHSceneNode* const);
void CreateChildEntity(EntityID parentEID) const noexcept;
void ParentSelectedEntities(EntityID parentEID, std::vector<EntityID> const& entities) noexcept;

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

@ -78,7 +78,7 @@ namespace SHADE
ImGui::PushID(SHFamilyID<SHComponent>::GetID<T>());
SHEditorWidgets::CheckBox("##IsActive", [component]() {return component->isActive; }, [component](bool const& active) {component->isActive = active; }, "Is Component Active");
ImGui::SameLine();
if (ImGui::CollapsingHeader(componentType.get_name().data()))
if (ImGui::CollapsingHeader(componentType.get_name().data(), ImGuiTreeNodeFlags_DefaultOpen))
{
DrawContextMenu(component);
auto const& properties = componentType.get_properties();
@ -235,7 +235,7 @@ namespace SHADE
const auto componentType = rttr::type::get<SHRigidBodyComponent>();
SHEditorWidgets::CheckBox("##IsActive", [component]() {return component->isActive; }, [component](bool const& active) {component->isActive = active; }, "Is Component Active");
ImGui::SameLine();
if (ImGui::CollapsingHeader(componentType.get_name().data()))
if (ImGui::CollapsingHeader(componentType.get_name().data(), ImGuiTreeNodeFlags_DefaultOpen))
{
DrawContextMenu(component);
@ -338,7 +338,7 @@ namespace SHADE
const auto componentType = rttr::type::get(*component);
SHEditorWidgets::CheckBox("##IsActive", [component]() {return component->isActive; }, [component](bool const& active) {component->isActive = active; }, "Is Component Active");
ImGui::SameLine();
if (ImGui::CollapsingHeader(componentType.get_name().data()))
if (ImGui::CollapsingHeader(componentType.get_name().data(), ImGuiTreeNodeFlags_DefaultOpen))
{
DrawContextMenu(component);
@ -462,7 +462,7 @@ namespace SHADE
const auto componentType = rttr::type::get(*component);
SHEditorWidgets::CheckBox("##IsActive", [component]() {return component->isActive; }, [component](bool const& active) {component->isActive = active; }, "Is Component Active");
ImGui::SameLine();
if (ImGui::CollapsingHeader(componentType.get_name().data()))
if (ImGui::CollapsingHeader(componentType.get_name().data(), ImGuiTreeNodeFlags_DefaultOpen))
{
DrawContextMenu(component);
@ -494,7 +494,7 @@ namespace SHADE
const auto componentType = rttr::type::get(*component);
SHEditorWidgets::CheckBox("##IsActive", [component]() {return component->isActive; }, [component](bool const& active) {component->isActive = active; }, "Is Component Active");
ImGui::SameLine();
if (ImGui::CollapsingHeader(componentType.get_name().data()))
if (ImGui::CollapsingHeader(componentType.get_name().data(), ImGuiTreeNodeFlags_DefaultOpen))
{
DrawContextMenu(component);
Handle<SHMesh> const& mesh = component->GetMesh();
@ -552,7 +552,7 @@ namespace SHADE
const auto componentType = rttr::type::get(*component);
SHEditorWidgets::CheckBox("##IsActive", [component]() {return component->isActive; }, [component](bool const& active) {component->isActive = active; }, "Is Component Active");
ImGui::SameLine();
if (ImGui::CollapsingHeader(componentType.get_name().data()))
if (ImGui::CollapsingHeader(componentType.get_name().data(), ImGuiTreeNodeFlags_DefaultOpen))
{
DrawContextMenu(component);
Handle<SHFont> const& font = component->GetFont();

1
SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorInspector.cpp
View File

@ -94,7 +94,6 @@ namespace SHADE
SHEditorWindow::Update();
if (Begin())
{
auto editor = SHSystemManager::GetSystem<SHEditor>();
if (editor && !editor->selectedEntities.empty())
{
EntityID const& eid = editor->selectedEntities[0];

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

@ -112,7 +112,7 @@ namespace SHADE
{
ImGui::BeginMenuBar();
ImGui::SetCursorPosX(ImGui::GetContentRegionAvail().x * 0.5f - 80.f);
const auto editor = SHSystemManager::GetSystem<SHEditor>();
ImGui::BeginDisabled(editor->editorState == SHEditor::State::PLAY);
if(ImGui::SmallButton(ICON_MD_PLAY_ARROW))
{
@ -167,16 +167,18 @@ namespace SHADE
{
if (ImGui::Selectable("New Scene"))
{
SHSystemManager::GetSystem<SHEditor>()->NewScene();
editor->NewScene();
}
if (ImGui::Selectable("Save"))
{
SHSystemManager::GetSystem<SHEditor>()->SaveScene();
editor->SaveScene();
}
ImGui::BeginDisabled(true);
if (ImGui::Selectable("Load"))
{
//SHSystemManager::GetSystem<SHEditor>()->LoadScene()
}
ImGui::EndDisabled();
ImGui::EndMenu();
}
}
@ -213,7 +215,7 @@ namespace SHADE
auto* scriptEngine = static_cast<SHScriptEngine*>(SHSystemManager::GetSystem<SHScriptEngine>());
scriptEngine->OpenSolution();
}
ImGui::BeginDisabled(SHSystemManager::GetSystem<SHEditor>()->editorState != SHEditor::State::STOP);
ImGui::BeginDisabled(editor->editorState != SHEditor::State::STOP);
if (ImGui::Selectable("Build Scripts - Debug"))
{
auto* scriptEngine = static_cast<SHScriptEngine*>(SHSystemManager::GetSystem<SHScriptEngine>());
@ -254,7 +256,6 @@ namespace SHADE
{
if (ImGui::Selectable(style.to_string().c_str()))
{
if (auto editor = SHSystemManager::GetSystem<SHEditor>())
editor->SetStyle(style.convert<SHEditor::Style>());
}
}

3
SHADE_Engine/src/Editor/EditorWindow/SHEditorWindow.cpp
View File

@ -7,6 +7,8 @@
//|| SHADE Includes ||
//#==============================================================#
#include "SHEditorWindow.h"
#include "ECS_Base/Managers/SHSystemManager.h"
#include "Editor/SHEditor.h"
//#==============================================================#
//|| Library Includes ||
@ -21,6 +23,7 @@ namespace SHADE
SHEditorWindow::SHEditorWindow(std::string_view const& name, ImGuiWindowFlags const& inFlags)
:isOpen(true), isWindowHovered(false), windowName(name), windowFlags(inFlags), io(ImGui::GetIO())
{
editor = SHSystemManager::GetSystem<SHEditor>();
}
void SHEditorWindow::Init()

4
SHADE_Engine/src/Editor/EditorWindow/SHEditorWindow.h
View File

@ -12,9 +12,9 @@
//#==============================================================#
struct ImGuiIO;
typedef int ImGuiWindowFlags;
namespace SHADE
{
class SHEditor;
class SHEditorWindow
{
public:
@ -38,6 +38,6 @@ namespace SHADE
ImGuiWindowFlags windowFlags = 0;
ImGuiIO& io;
SHEditor* editor;
};//class SHEditorWindow
}//namespace SHADE

2
SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowManager.cpp
View File

@ -4,5 +4,7 @@
namespace SHADE
{
SHEditorWindowManager::EditorWindowMap SHEditorWindowManager::editorWindows{};
SHEditorWindowManager::PopupWindowMap SHEditorWindowManager::popupWindows{};
SHEditorWindowManager::EditorWindowID SHEditorWindowManager::windowCount{};
SHEditorWindowManager::EditorWindowID SHEditorWindowManager::popupWindowCount{};
}

58
SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowManager.h
View File

@ -3,6 +3,7 @@
#include <memory>
#include <unordered_map>
#include "SHEditorWindow.h"
#include "SHPopUpWindow.h"
#include "Tools/Logger/SHLog.h"
namespace SHADE
@ -16,6 +17,10 @@ namespace SHADE
using EditorWindowID = uint8_t;
using EditorWindowPtr = std::unique_ptr<SHEditorWindow>;
using EditorWindowMap = std::unordered_map<EditorWindowID, EditorWindowPtr>;
using PopupWindowPtr = std::unique_ptr<SHPopUpWindow>;
using PopupWindowMap = std::unordered_map<EditorWindowID, PopupWindowPtr>;
/**
* @brief Get ID for the Editor Window Type
*
@ -67,10 +72,63 @@ namespace SHADE
return reinterpret_cast<T*>(editorWindows[GetEditorWindowID<T>()].get());
}
/**
* @brief Get ID for the Popup Window Type
*
* @tparam T Type of Popup Window
* @return EditorWindowID ID of Popup Window Type
*/
template <typename T, std::enable_if_t<std::is_base_of_v<SHPopUpWindow, T>, bool> = true>
static EditorWindowID GetPopupWindowID()
{
static EditorWindowID id;
static bool idCreated = false;
if (!idCreated)
{
id = popupWindowCount++;
idCreated = true;
}
return id;
}
/**
* @brief Create an Popup Window
*
* @tparam T Type of Popup Window to create
*/
template <typename T, std::enable_if_t<std::is_base_of_v<SHPopUpWindow, T>, bool> = true>
static void CreatePopupWindow()
{
static bool isCreated = false;
if (!isCreated)
{
popupWindows[GetPopupWindowID<T>()] = std::make_unique<T>();
isCreated = true;
}
else
{
SHLog::Warning("Attempt to create duplicate of Popup window type");
}
}
/**
* @brief Get pointer to the Editor Window
*
* @tparam T Type of editor window to retrieve
* @return T* Pointer to the editor window
*/
template <typename T, std::enable_if_t<std::is_base_of_v<SHPopUpWindow, T>, bool> = true>
static T* GetPopupWindow()
{
return reinterpret_cast<T*>(popupWindows[GetPopupWindowID<T>()].get());
}
static EditorWindowMap editorWindows;
static PopupWindowMap popupWindows;
private:
// Number of windows; used for Editor Window ID Generation
static EditorWindowID windowCount;
static EditorWindowID popupWindowCount;
// Map of Editor Windows
friend class SHEditor;
};

21
SHADE_Engine/src/Editor/EditorWindow/SHPopUpWindow.cpp Normal file
View File

@ -0,0 +1,21 @@
#include "SHpch.h"
#include "SHPopUpWindow.h"
#include "ECS_Base/Managers/SHSystemManager.h"
#include "Editor/SHEditor.h"
namespace SHADE
{
SHPopUpWindow::SHPopUpWindow(std::string_view const& name, bool modal, ImGuiPopupFlags inPopupFlags, ImGuiWindowFlags inWindowFlags)
:editor(nullptr), windowName(name), popupFlags(inPopupFlags), windowFlags(inWindowFlags), isOpen(false), isModal(modal)
{
editor = SHSystemManager::GetSystem<SHEditor>();
}
bool SHPopUpWindow::Begin()
{
if (isOpen)
ImGui::OpenPopup(windowName.data(), popupFlags);
return isModal ? ImGui::BeginPopupModal(windowName.data(), &isOpen, windowFlags) : ImGui::BeginPopup(windowName.data(), windowFlags);
}
}

31
SHADE_Engine/src/Editor/EditorWindow/SHPopUpWindow.h Normal file
View File

@ -0,0 +1,31 @@
#pragma once
//#==============================================================#
//|| STL Includes ||
//#==============================================================#
#include <string>
#include <imgui.h>
#include "SH_API.h"
namespace SHADE
{
class SHEditor;
class SHPopUpWindow
{
public:
SHPopUpWindow(std::string_view const& name, bool modal, ImGuiPopupFlags inPopupFlags, ImGuiWindowFlags inWindowFlags);
virtual ~SHPopUpWindow() = default;
virtual void Draw(){};
bool isOpen;
protected:
virtual bool Begin();
SHEditor* editor;
std::string_view windowName;
ImGuiPopupFlags popupFlags;
ImGuiWindowFlags windowFlags;
bool isModal;
};
}

1
SHADE_Engine/src/Editor/EditorWindow/ViewportWindow/SHEditorViewport.cpp
View File

@ -35,7 +35,6 @@ namespace SHADE
{
SHEditorWindow::Update();
auto camSystem = SHSystemManager::GetSystem<SHCameraSystem>();
SHEditor* editor = SHSystemManager::GetSystem<SHEditor>();
if (!editor->selectedEntities.empty())
{

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

@ -32,6 +32,9 @@
#include "EditorWindow/SHEditorWindowManager.h"
#include "EditorWindow/SHEditorWindowIncludes.h"
#include "EditorWindow/SHPopUpWindow.h"
#include "EditorWindow/EditorPopups/SHEditorPopups.h"
//#==============================================================#
//|| Library Includes ||
//#==============================================================#
@ -98,15 +101,18 @@ namespace SHADE
//Add editor windows
SHEditorWindowManager::CreateEditorWindow<SHEditorMenuBar>();
SHEditorWindowManager::CreateEditorWindow<SHHierarchyPanel>();
SHEditorWindowManager::CreateEditorWindow<SHEditorInspector>();
SHEditorWindowManager::CreateEditorWindow<SHEditorProfiler>();
SHEditorWindowManager::CreateEditorWindow<SHAssetBrowser>();
SHEditorWindowManager::CreateEditorWindow<SHMaterialInspector>();
SHEditorWindowManager::CreateEditorWindow<SHColliderTagPanel>();
SHEditorWindowManager::CreateEditorWindow<SHHierarchyPanel>();
SHEditorWindowManager::CreateEditorWindow<SHEditorInspector>();
SHEditorWindowManager::CreateEditorWindow<SHEditorViewport>();
//Add popup windows
SHEditorWindowManager::CreatePopupWindow<SHSceneSavePrompt>();
io = &ImGui::GetIO();
io->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
@ -150,7 +156,7 @@ namespace SHADE
{
(void)dt;
NewFrame();
for (const auto& window : SHEditorWindowManager::editorWindows | std::views::values)
for (auto const& window : SHEditorWindowManager::editorWindows | std::views::values)
{
if(window->isOpen)
{
@ -158,7 +164,11 @@ namespace SHADE
}
}
RenderSceneNamePrompt();
for(auto const& popupWindow : SHEditorWindowManager::popupWindows | std::views::values)
{
popupWindow->Draw();
}
RenderUnsavedChangesPrompt();
//PollPicking();
@ -177,37 +187,6 @@ 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)
@ -220,12 +199,12 @@ namespace SHADE
ImGui::Text("You have unsaved changes!");
if(ImGui::Button("Save"))
{
isSceneNamePromptOpen = true;
SHEditorWindowManager::GetPopupWindow<SHSceneSavePrompt>()->isOpen = true;
}
ImGui::SameLine();
if(ImGui::Button("Cancel"))
{
isUnsavedChangesPromptOpen = false;
SHEditorWindowManager::GetPopupWindow<SHSceneSavePrompt>()->isOpen = true;
ImGui::CloseCurrentPopup();
}
}
@ -563,7 +542,7 @@ namespace SHADE
if (newSceneName.empty())
{
//Prompt for scene name
isSceneNamePromptOpen = true;
SHEditorWindowManager::GetPopupWindow<SHSceneSavePrompt>()->isOpen = true;
return false;
}
//Else We have a new name
@ -644,7 +623,7 @@ namespace SHADE
editorState = SHEditor::State::STOP;
SHCommandManager::SwapStacks();
SHEventManager::BroadcastEvent<SHEditorStateChangeEvent>(STATE_CHANGE_EVENT, SH_EDITOR_ON_STOP_EVENT);
LoadScene(SHSceneManager::GetCurrentSceneAssetID());
LoadScene(editorConfig->workingSceneID);
}
void SHEditor::ProcessShortcuts()

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

@ -37,8 +37,6 @@ namespace SHADE
class SHVkCommandBuffer;
class SHVkCommandPool;
/**
* @brief SHEditor static class contains editor variables and implementation of editor functions.
*
@ -144,8 +142,6 @@ namespace SHADE
*/
void Render();
void RenderSceneNamePrompt() noexcept;
void RenderUnsavedChangesPrompt() noexcept;
void InitLayout() noexcept;
@ -156,8 +152,6 @@ namespace SHADE
SHEventHandle onEditorStateChanged(SHEventPtr eventPtr);
bool isSceneNamePromptOpen = false;
bool isUnsavedChangesPromptOpen = false;
static constexpr std::string_view sceneNamePromptName = "Save scene as...";

30
SHADE_Engine/src/Editor/SHEditorWidgets.hpp
View File

@ -13,6 +13,8 @@
#include "Command/SHCommandManager.h"
#include "SHImGuiHelpers.hpp"
#include "SH_API.h"
#include "Assets/SHAssetMacros.h"
#include "ECS_Base/SHECSMacros.h"
//#==============================================================#
//|| Library Includes ||
@ -454,7 +456,33 @@ namespace SHADE
ImGui::BeginGroup();
ImGui::PushID(label.data());
TextLabel(label);
const bool hasChange = ImGui::InputScalar("##dragScalar", data_type, &value);
bool hasChange = ImGui::DragScalar("##dragScalar", data_type, &value);
if constexpr(std::is_same_v<T, uint32_t>) //EID or Resource
{
if (SHDragDrop::BeginTarget())
{
if(AssetID * payload = SHDragDrop::AcceptPayload<T>(SHDragDrop::DRAG_RESOURCE))
{
value = *payload;
SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<T>>(get(), value, set)), false);
hasChange = true;
SHDragDrop::EndTarget();
}
else if (std::vector<EntityID>* payload = SHDragDrop::AcceptPayload<std::vector<EntityID>>(SHDragDrop::DRAG_EID))
{
value = payload->back();
SHCommandManager::PerformCommand(std::reinterpret_pointer_cast<SHBaseCommand>(std::make_shared<SHCommand<T>>(get(), value, set)), false);
hasChange = true;
SHDragDrop::EndTarget();
}
if(hasChange)
{
ImGui::PopID();
ImGui::EndGroup();
return true;
}
}
}
static bool startRecording = false;
if (hasChange)
{

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

@ -11,16 +11,8 @@
#include <fstream>
#include "Assets/Asset Types/SHSceneAsset.h"
#include "Camera/SHCameraComponent.h"
#include "Camera/SHCameraArmComponent.h"
#include "Math/Transform/SHTransformComponent.h"
#include "Graphics/MiddleEnd/Interface/SHRenderable.h"
#include "Physics/Interface/SHRigidBodyComponent.h"
#include "UI/SHCanvasComponent.h"
#include "UI/SHButtonComponent.h"
#include "UI/SHToggleButtonComponent.h"
#include "Common/SHAllComponents.h"
#include "ECS_Base/Managers/SHSystemManager.h"
#include "Graphics/MiddleEnd/Lights/SHLightComponent.h"
#include "Scripting/SHScriptEngine.h"
#include "Tools/FileIO/SHFileIO.h"

4
SHADE_Engine/src/Serialization/SHYAMLConverters.h
View File

@ -1,5 +1,7 @@
#pragma once
#include "Graphics/MiddleEnd/Interface/SHRenderable.h"
#include "Physics/Interface/SHColliderComponent.h"
#include "Graphics/MiddleEnd/TextRendering/SHTextRenderableComponent.h"
#include "Graphics/MiddleEnd/Materials/SHMaterialSpec.h"
#include "Resource/SHResourceManager.h"
#include "Math/Vector/SHVec2.h"
@ -8,8 +10,6 @@
#include "Graphics/MiddleEnd/Interface/SHMaterial.h"
#include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h"
#include "SHSerializationTools.h"
#include "Physics/Interface/SHColliderComponent.h"
#include "Graphics/MiddleEnd/TextRendering/SHTextRenderableComponent.h"
#include "Graphics/MiddleEnd/TextRendering/SHFont.h"
#include "Physics/Collision/SHCompositeCollider.h"
#include "Physics/Collision/CollisionTags/SHCollisionTagMatrix.h"

8
SHADE_Engine/src/Tools/Utilities/SHStringUtilities.cpp
View File

@ -13,6 +13,7 @@ of DigiPen Institute of Technology is prohibited.
#include <SHpch.h>
// Primary Header
#include "SHStringUtilities.h"
#include <algorithm>
namespace SHADE
{
@ -51,4 +52,11 @@ namespace SHADE
return std::system_category().message(errorCode);
}
size_t SHStringUtilities::StringFindInsensitive(std::string str, std::string search, size_t pos)
{
std::transform(str.begin(), str.end(), str.begin(), [](char c) {return static_cast<char>(std::tolower(c)); });
std::transform(search.begin(), search.end(), search.begin(), [](char c) {return static_cast<char>(std::tolower(c)); });
return str.find(search, pos);
}
}

2
SHADE_Engine/src/Tools/Utilities/SHStringUtilities.h
View File

@ -70,6 +70,8 @@ namespace SHADE
/// <returns>String that represents the Win32 error.</returns>
static std::string GetWin32ErrorMessage(unsigned long errorCode);
static size_t StringFindInsensitive(std::string str, std::string search, size_t pos = 0);
private:
/*-------------------------------------------------------------------------------*/
/* Constructors/Destructors */