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

Added initial implementation of script inspector

This commit is contained in:
Kah Wei 2022-09-28 00:06:47 +08:00
parent a57c4d0d73
commit 7010e1b688
9 changed files with 662 additions and 783 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -12,6 +12,8 @@
#include "Editor/SHEditorWidgets.hpp"
#include "SHEditorComponentView.hpp"
#include "Graphics/MiddleEnd/Interface/SHRenderable.h"
#include "Scripting/SHScriptEngine.h"
#include "ECS_Base/Managers/SHSystemManager.h"
namespace SHADE
{
@ -61,6 +63,11 @@ namespace SHADE
DrawAddComponentButton<SHRenderable>(eid);
ImGui::EndMenu();
}
// Render Scripts
SHScriptEngine* scriptEngine = static_cast<SHScriptEngine*>(SHSystemManager::GetSystem<SHScriptEngine>());
scriptEngine->RenderScriptsInInspector(eid);
}
ImGui::End();
}

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

@ -10,412 +10,276 @@ Reproduction or disclosure of this file or its contents without the prior writte
of DigiPen Institute of Technology is prohibited.
*//*************************************************************************************/
// Precompiled Header
#include <pch.h>
#include "SHpch.h"
// Primary Header
#include "Editor/EditorUI.h"
#include "SHEditorUI.h"
// External Dependencies
#include <imgui.h>
// Project Headers
#include "Core/Resource/ResourceManager.h"
#include "Editor/ImGuiExtensions.h"
#include "Editor/Editor.h"
namespace Pls
namespace SHADE
{
/*---------------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - ID Stack */
/*---------------------------------------------------------------------------------*/
void EditorUI::PushID(const std::string& id)
/*-----------------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - ID Stack */
/*-----------------------------------------------------------------------------------*/
void SHEditorUI::PushID(const std::string& id)
{
ImGui::PushID(id.c_str());
}
void SHEditorUI::PushID(int id)
{
ImGui::PushID(id);
}
void SHEditorUI::PopID()
{
ImGui::PopID();
}
/*-----------------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Indent */
/*-----------------------------------------------------------------------------------*/
void SHEditorUI::Indent()
{
ImGui::Indent();
}
void SHEditorUI::Unindent()
{
ImGui::Unindent();
}
/*-----------------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Organizers */
/*-----------------------------------------------------------------------------------*/
bool SHEditorUI::CollapsingHeader(const std::string& title)
{
return ImGui::CollapsingHeader(title.c_str());
}
void SHEditorUI::SameLine()
{
ImGui::SameLine();
}
void SHEditorUI::Separator()
{
ImGui::Separator();
}
bool SHEditorUI::BeginMenu(const std::string& label)
{
return ImGui::BeginMenu(label.data());
}
bool SHEditorUI::BeginMenu(const std::string& label, const char* icon)
{
return ImGui::BeginMenu(std::format("{} {}", icon, label.data()).data());
}
void SHEditorUI::EndMenu()
{
ImGui::EndMenu();
}
/*-----------------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Pop Ups */
/*-----------------------------------------------------------------------------------*/
bool SHEditorUI::BeginPopup(const std::string& label)
{
return ImGui::BeginPopup(label.c_str());
}
bool SHEditorUI::BeginPopupContextItem(const std::string& label)
{
return ImGui::BeginPopupContextItem(label.data());
}
void SHEditorUI::EndPopup()
{
ImGui::EndPopup();
}
void SHEditorUI::OpenPopup(const std::string& label)
{
ImGui::OpenPopup(label.c_str());
}
bool SHEditorUI::MenuItem(const std::string& label)
{
return ImGui::MenuItem(label.c_str());
}
/*-----------------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Widgets */
/*-----------------------------------------------------------------------------------*/
void SHEditorUI::Text(const std::string& title)
{
ImGui::Text(title.c_str());
}
bool SHEditorUI::SmallButton(const std::string& title)
{
return ImGui::SmallButton(title.c_str());
}
bool SHEditorUI::Button(const std::string& title)
{
return ImGui::Button(title.c_str());
}
bool SHEditorUI::Selectable(const std::string& label)
{
return ImGui::Selectable(label.data());
}
bool SHEditorUI::Selectable(const std::string& label, const char* icon)
{
return ImGui::Selectable(std::format("{} {}", icon, label).data());
}
bool SHEditorUI::InputCheckbox(const std::string& label, bool& value)
{
return ImGui::Checkbox(label.c_str(), &value);
}
bool SHEditorUI::InputInt(const std::string& label, int& value)
{
return ImGui::InputInt(label.c_str(), &value,
1, 10,
ImGuiInputTextFlags_EnterReturnsTrue);
}
bool SHEditorUI::InputUnsignedInt(const std::string& label, unsigned int& value)
{
int signedVal = static_cast<int>(value);
const bool CHANGED = InputInt(label, signedVal);
if (CHANGED)
{
ImGui::PushID(id.c_str());
signedVal = std::clamp(signedVal, 0, std::numeric_limits<int>::max());
value = static_cast<unsigned int>(signedVal);
}
return CHANGED;
}
bool SHEditorUI::InputFloat(const std::string& label, float& value)
{
return ImGui::InputFloat(label.c_str(), &value,
0.1f, 1.0f, "%.3f",
ImGuiInputTextFlags_EnterReturnsTrue);
}
bool SHEditorUI::InputDouble(const std::string& label, double& value)
{
return ImGui::InputDouble(label.c_str(), &value,
0.1, 1.0, "%.3f",
ImGuiInputTextFlags_EnterReturnsTrue);
}
bool SHEditorUI::InputAngle(const std::string& label, double& value)
{
return ImGui::InputDouble(label.c_str(), &value,
1.0, 45.0, "%.3f",
ImGuiInputTextFlags_EnterReturnsTrue);
}
bool SHEditorUI::InputSlider(const std::string& label, double min, double max, double& value)
{
float val = static_cast<float>(value);
const bool CHANGED = ImGui::SliderFloat(label.c_str(), &val,
static_cast<float>(min), static_cast<float>(max), "%.3f",
ImGuiInputTextFlags_EnterReturnsTrue);
if (CHANGED)
{
value = val;
}
void EditorUI::PushID(int id)
{
ImGui::PushID(id);
}
void EditorUI::PopID()
{
ImGui::PopID();
}
return CHANGED;
}
/*---------------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Indent */
/*---------------------------------------------------------------------------------*/
void EditorUI::Indent()
bool SHEditorUI::InputVec2(const std::string& label, SHVec2& value)
{
float vec[2] =
{
ImGui::Indent();
}
void EditorUI::Unindent()
static_cast<float>(value.x),
static_cast<float>(value.y)
};
const bool CHANGED = ImGui::InputFloat2(label.c_str(), vec, "%.3f",
ImGuiInputTextFlags_EnterReturnsTrue);
if (CHANGED)
{
ImGui::Unindent();
value.x = vec[0];
value.y = vec[1];
}
return CHANGED;
}
bool SHEditorUI::InputVec3(const std::string& label, SHVec3& value)
{
float vec[3] =
{
static_cast<float>(value.x),
static_cast<float>(value.y),
static_cast<float>(value.z)
};
const bool CHANGED = ImGui::InputFloat3(label.c_str(), vec, "%.3f",
ImGuiInputTextFlags_EnterReturnsTrue);
if (CHANGED)
{
value.x = vec[0];
value.y = vec[1];
value.z = vec[2];
}
return CHANGED;
}
/*---------------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Organisers */
/*---------------------------------------------------------------------------------*/
bool EditorUI::CollapsingHeader(const std::string& title)
bool SHEditorUI::InputSliderVec3(const std::string& label, double min, double max, SHVec3& value)
{
float vec[3] =
{
return ImGui::CollapsingHeader(title.c_str());
}
/*---------------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Pop Ups */
/*---------------------------------------------------------------------------------*/
bool EditorUI::BeginPopup(const std::string& label)
static_cast<float>(value.x),
static_cast<float>(value.y),
static_cast<float>(value.z)
};
const bool CHANGED = ImGui::SliderFloat3(label.c_str(), vec,
static_cast<float>(min), static_cast<float>(max), "%.3f",
ImGuiInputTextFlags_EnterReturnsTrue);
if (CHANGED)
{
return ImGui::BeginPopup(label.c_str());
}
void EditorUI::EndPopup()
{
ImGui::EndPopup();
}
void EditorUI::OpenPopup(const std::string& label)
{
ImGui::OpenPopup(label.c_str());
value.x = vec[0];
value.y = vec[1];
value.z = vec[2];
}
return CHANGED;
}
bool EditorUI::MenuItem(const std::string& label)
bool SHEditorUI::InputTextField(const std::string& label, std::string& value)
{
std::array<char, TEXT_FIELD_MAX_LENGTH> buffer = { '\0' };
strcpy_s(buffer.data(), TEXT_FIELD_MAX_LENGTH, value.c_str());
const bool CHANGED = ImGui::InputText(label.c_str(), &buffer[0], TEXT_FIELD_MAX_LENGTH);
if (CHANGED)
{
return ImGui::MenuItem(label.c_str());
value = std::string(buffer.data(), buffer.data() + TEXT_FIELD_MAX_LENGTH);
}
return CHANGED;
}
/*---------------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Widgets */
/*---------------------------------------------------------------------------------*/
void EditorUI::Text(const std::string& title)
bool SHEditorUI::InputEnumCombo(const std::string& label, int& v, const std::vector<std::string>& enumNames)
{
// Clamp input value
const std::string& INITIAL_NAME = v >= static_cast<int>(enumNames.size()) ? "Unknown" : enumNames[v];
bool b = false;
if (ImGui::BeginCombo(label.c_str(), INITIAL_NAME.c_str(), ImGuiComboFlags_None))
{
ImGui::Text(title.c_str());
}
bool EditorUI::SmallButton(const std::string& title)
{
return ImGui::SmallButton(title.c_str());
}
bool EditorUI::Button(const std::string& title)
{
return ImGui::Button(title.c_str());
}
bool EditorUI::InputCheckbox(const std::string& label, bool& value)
{
return ImGui::Checkbox(label.c_str(), &value);
}
bool EditorUI::InputInt(const std::string& label, int& value)
{
return ImGui::InputInt(label.c_str(), &value,
1, 10,
ImGuiInputTextFlags_EnterReturnsTrue);
}
bool EditorUI::InputUnsignedInt(const std::string& label, unsigned int& value)
{
int signedVal = static_cast<int>(value);
const bool CHANGED = InputInt(label, signedVal);
if (CHANGED)
for (int i = 0; i < enumNames.size(); ++i)
{
const bool IS_SELECTED = v == i;
if (ImGui::Selectable(enumNames[i].c_str(), IS_SELECTED))
{
signedVal = std::clamp(signedVal, 0, std::numeric_limits<int>::max());
value = static_cast<unsigned int>(signedVal);
v = i;
b = true;
}
return CHANGED;
}
bool EditorUI::InputFloat(const std::string& label, float& value)
{
return ImGui::InputFloat(label.c_str(), &value,
0.1f, 1.0f, "%.3f",
ImGuiInputTextFlags_EnterReturnsTrue);
}
bool EditorUI::InputDouble(const std::string& label, double& value)
{
return ImGui::InputDouble(label.c_str(), &value,
0.1, 1.0, "%.3f",
ImGuiInputTextFlags_EnterReturnsTrue);
}
bool EditorUI::InputAngle(const std::string& label, double& value)
{
return ImGui::InputDouble(label.c_str(), &value,
1.0, 45.0, "%.3f",
ImGuiInputTextFlags_EnterReturnsTrue);
}
bool EditorUI::InputSlider(const std::string& label, double min, double max, double& value)
{
float val = static_cast<float>(value);
const bool CHANGED = ImGui::SliderFloat(label.c_str(), &val,
static_cast<float>(min), static_cast<float>(max), "%.3f",
ImGuiInputTextFlags_EnterReturnsTrue);
if (CHANGED)
if (IS_SELECTED)
{
value = val;
ImGui::SetItemDefaultFocus();
}
return CHANGED;
}
ImGui::EndCombo();
}
bool EditorUI::InputVec2(const std::string& label, vec2& value)
{
float vec[2] =
{
static_cast<float>(value.x),
static_cast<float>(value.y)
};
const bool CHANGED = ImGui::InputFloat2(label.c_str(), vec, "%.3f",
ImGuiInputTextFlags_EnterReturnsTrue);
if (CHANGED)
{
value.x = vec[0];
value.y = vec[1];
}
return CHANGED;
}
bool EditorUI::InputVec3(const std::string& label, vec3& value)
{
float vec[3] =
{
static_cast<float>(value.x),
static_cast<float>(value.y),
static_cast<float>(value.z)
};
const bool CHANGED = ImGui::InputFloat3(label.c_str(), vec, "%.3f",
ImGuiInputTextFlags_EnterReturnsTrue);
if (CHANGED)
{
value.x = vec[0];
value.y = vec[1];
value.z = vec[2];
}
return CHANGED;
}
bool EditorUI::InputSliderVec3(const std::string& label, double min, double max, vec3& value)
{
float vec[3] =
{
static_cast<float>(value.x),
static_cast<float>(value.y),
static_cast<float>(value.z)
};
const bool CHANGED = ImGui::SliderFloat3(label.c_str(), vec,
static_cast<float>(min), static_cast<float>(max), "%.3f",
ImGuiInputTextFlags_EnterReturnsTrue);
if (CHANGED)
{
value.x = vec[0];
value.y = vec[1];
value.z = vec[2];
}
return CHANGED;
}
bool EditorUI::InputColor(const std::string& label, GFX::Color& value)
{
float color[4] =
{
value.R,
value.G,
value.B,
value.A
};
const bool CHANGED = ImGui::ColorEdit4(label.c_str(), color,
ImGuiColorEditFlags_AlphaBar |
ImGuiColorEditFlags_AlphaPreview |
ImGuiColorEditFlags_Float);
if (CHANGED)
{
value.R = color[0];
value.G = color[1];
value.B = color[2];
value.A = std::clamp(color[3], 0.f, 1.f);
}
return CHANGED;
}
bool EditorUI::InputTextField(const std::string& label, std::string& value)
{
std::array<char, TEXT_FIELD_MAX_LENGTH> buffer = { '\0' };
strcpy_s(buffer.data(), TEXT_FIELD_MAX_LENGTH, value.c_str());
const bool CHANGED = ImGui::InputText(label.c_str(), &buffer[0], TEXT_FIELD_MAX_LENGTH);
if (CHANGED)
{
value = std::string(buffer.data(), buffer.data() + TEXT_FIELD_MAX_LENGTH);
}
return CHANGED;
}
bool EditorUI::InputEnumCombo(const std::string& label, int& v, const std::vector<std::string>& enumNames)
{
// Clamp input value
const std::string& INITIAL_NAME = v >= static_cast<int>(enumNames.size()) ? "Unknown" : enumNames[v];
bool b = false;
if (ImGui::BeginCombo(label.c_str(), INITIAL_NAME.c_str(), ImGuiComboFlags_None))
{
for (int i = 0; i < enumNames.size(); ++i)
{
const bool IS_SELECTED = v == i;
if (ImGui::Selectable(enumNames[i].c_str(), IS_SELECTED))
{
v = i;
b = true;
}
if (IS_SELECTED)
{
ImGui::SetItemDefaultFocus();
}
}
ImGui::EndCombo();
}
return b;
}
bool EditorUI::InputTextureDropDown(const std::string& label, Resource::Snowflake& v)
{
static std::vector<std::reference_wrapper<Resource>> resources;
// Register texture popup
bool hasChanges = false;
if (ImGui::BeginPopup("Texture Menu"))
{
if (ImGui::Button("None"))
{
v = Resource::INVALID_SNOWFLAKE;
ImGui::CloseCurrentPopup();
hasChanges = true;
}
for (auto& rscWrapper : resources)
{
Resource& rsc = rscWrapper.get();
ImGui::PushID(static_cast<int>(rsc.GetID()));
const GFX::Texture* TEX = rsc.LoadTexture();
if (TEX == nullptr)
{
continue;
}
const ImTextureID TEX_ID = reinterpret_cast<void*>(static_cast<intptr_t>(TEX->GetHandle()));
const std::string NAME = rsc.GetPath().filename().string();
const std::string FP = rsc.GetPath().string();
if (ImGui::ImageButtonWithText(TEX_ID, NAME.c_str()))
{
v = rsc.GetID();
ImGui::CloseCurrentPopup();
hasChanges = true;
}
ImGui::TextDisabled(FP.c_str());
ImGui::PopID();
}
ImGui::EndPopup();
}
// Get texture ID of resource
ImTextureID texID = 0;
std::string texName = "None";
Resource* rsc = ResourceManager::Find(v);
if (rsc)
{
// File
if (rsc->IsType<GFX::Texture>())
{
GFX::Texture* tex = rsc->LoadTexture();
if (tex)
{
texID = reinterpret_cast<void*>(static_cast<intptr_t>(tex->GetHandle()));
}
}
else
{
// TODO (Clarence): replace with missing texture image
texID = Editor::Editor::GetInternalTexture("scene.png");
}
texName = rsc->GetPath().filename().string();
}
// Show texture selection menu
if (ImGui::ImageButtonWithText(texID, texName.c_str(), label.c_str()))
{
resources = ResourceManager::FindAllOfType<GFX::Texture>();
ImGui::OpenPopup("Texture Menu");
}
return hasChanges;
}
bool EditorUI::InputFontDropDown(const char* label, Resource::Snowflake& v)
{
static std::vector<std::reference_wrapper<Resource>> resources;
// Register texture popup
bool hasChanges = false;
if (ImGui::BeginPopup("Font Menu"))
{
if (ImGui::Button("None"))
{
v = Resource::INVALID_SNOWFLAKE;
ImGui::CloseCurrentPopup();
hasChanges = true;
}
for (auto& rscWrapper : resources)
{
Resource& rsc = rscWrapper.get();
ImGui::PushID(static_cast<int>(rsc.GetID()));
const GFX::Font* FONT = rsc.LoadFont();
if (FONT == nullptr)
{
continue;
}
const std::string NAME = rsc.GetPath().filename().string();
const std::string FP = rsc.GetPath().string();
if (ImGui::Button(NAME.c_str()))
{
v = rsc.GetID();
ImGui::CloseCurrentPopup();
hasChanges = true;
}
ImGui::TextDisabled(FP.c_str());
ImGui::PopID();
}
ImGui::EndPopup();
}
// Get font ID of resource
ImTextureID fontID = 0;
std::string fontName = "None";
Resource* rsc = ResourceManager::Find(v);
if (rsc)
{
// File
if (rsc)
{
GFX::Font* font = rsc->LoadFont();
if (font)
{
fontID = reinterpret_cast<void*>(static_cast<intptr_t>(font->GetID()));
if (font->CreatedThisFrame())
{
font->OnCreate() = false;
hasChanges = true;
}
}
}
else
{
// TODO (Clarence): replace with missing texture image
fontID = Editor::Editor::GetInternalFont("selawk.tff");
}
fontName = rsc->GetPath().filename().string();
}
// Show font selection menu
if (ImGui::ButtonWithText(fontName.c_str(), label))
{
resources = ResourceManager::FindAllOfType<GFX::Font>();
ImGui::OpenPopup("Font Menu");
}
return hasChanges;
}
} // namespace PlushieEngine
return b;
}
}

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

@ -1,312 +1,297 @@
/************************************************************************************//*!
\file EditorUI.h
\author Tng Kah Wei, kahwei.tng, 390009620 (50%)
\file SHEditorUI.h
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\author Tay Yan Chong Clarence, t.yanchongclarence, 620008720 (50%)
\par email: t.yanchongclarence\@digipen.edu
\date Nov 7, 2021
\brief Defines a class that encapsulates the running of a Plushie Engine
application.
\date Sep 27, 2022
\brief Defines a class that contains wrapper functions for ImGui.
Copyright (C) 2021 DigiPen Institute of Technology.
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
// Platform Defines
#include "PlushieDefines.h"
// Standard Library
#include <functional> // std::function
#include <string> // std::string
#include <functional> // std::function
#include <string> // std::string
// Project Includes
#include "Math/Vector/SHVec2.h"
#include "Math/Vector/SHVec3.h"
#include "Math/Vector/SHVec4.h"
#include "Math/SHMatrix.h"
#include "Core/Resource/Resource.h"
#include "Graphics/Color.h"
#include "Math/Vector2.h"
#include "Math/Vector3.h"
namespace Pls
namespace SHADE
{
/// <summary>
/// Static class that contains useful functions for Editor UI using ImGui.
/// </summary>
class SH_API SHEditorUI final
{
public:
/*-----------------------------------------------------------------------------*/
/* Constants */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Static class that contains useful functions for Editor UI using ImGui.
/// Maximum length of a string supported by InputTextField()
/// </summary>
class PLS_API EditorUI final
{
public:
/*-----------------------------------------------------------------------------*/
/* Constants */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Maximum length of a string supported by InputTextField()
/// </summary>
static constexpr size_t TEXT_FIELD_MAX_LENGTH = 256;
static constexpr size_t TEXT_FIELD_MAX_LENGTH = 256;
/*-----------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - ID Stack */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Marks the start of a stack of ImGui widgets with the specified id.
/// <br/>
/// Wraps up ImGui::PushID().
/// </summary>
/// <param name="id">String-based ID.</param>
static void PushID(const std::string& id);
/// <summary>
/// Marks the start of a stack of ImGui widgets with the specified id.
/// <br/>
/// Wraps up ImGui::PushID().
/// </summary>
/// <param name="id">Integer-based ID.</param>
static void PushID(int id);
/// <summary>
/// Marks the end of a stack of ImGui widgets from the last PushID() call.
/// <br/>
/// Wraps up ImGui::PopID().
/// </summary>
static void PopID();
/*-----------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - ID Stack */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Marks the start of a stack of ImGui widgets with the specified id.
/// <br/>
/// Wraps up ImGui::PushID().
/// </summary>
/// <param name="id">String-based ID.</param>
static void PushID(const std::string& id);
/// <summary>
/// Marks the start of a stack of ImGui widgets with the specified id.
/// <br/>
/// Wraps up ImGui::PushID().
/// </summary>
/// <param name="id">Integer-based ID.</param>
static void PushID(int id);
/// <summary>
/// Marks the end of a stack of ImGui widgets from the last PushID() call.
/// <br/>
/// Wraps up ImGui::PopID().
/// </summary>
static void PopID();
/*-----------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Indent */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Indents the widgets rendered after this call.
/// <br/>
/// Wraps up ImGui::Indent().
/// </summary>
static void Indent();
/// <summary>
/// Unindents the widgets rendered after this call.
/// <br/>
/// Wraps up ImGui::Unindent().
/// </summary>
static void Unindent();
/*-----------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Indent */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Indents the widgets rendered after this call.
/// <br/>
/// Wraps up ImGui::Indent().
/// </summary>
static void Indent();
/// <summary>
/// Unindents the widgets rendered after this call.
/// <br/>
/// Wraps up ImGui::Unindent().
/// </summary>
static void Unindent();
/*-----------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Organisers */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Creates a collapsing title header.
/// <br/>
/// Wraps up ImGui::CollapsingHeader().
/// </summary>
/// <param name="title">Label for the header.</param>
/// <returns>True if the header is open, false otherwise.</returns>
static bool CollapsingHeader(const std::string& title);
/*-----------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Organizers */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Creates a collapsing title header.
/// <br/>
/// Wraps up ImGui::CollapsingHeader().
/// </summary>
/// <param name="title">Label for the header.</param>
/// <returns>True if the header is open, false otherwise.</returns>
static bool CollapsingHeader(const std::string& title);
static void SameLine();
static void Separator();
/*-----------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Pop Ups */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Marks the start of a definition of a mini pop up that can show options.
/// <br/>
/// Wraps up ImGui::BeginPopup().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <returns>Whether or not the pop up is open.</returns>
static bool BeginPopup(const std::string& label);
/// <summary>
/// Marks the end of a definition of a mini pop up that can show options.
/// <br/>
/// Wraps up ImGui::EndPopup().
/// </summary>
static void EndPopup();
/// <summary>
/// Opens the popup that was defined with the specified label.
/// <br/>
/// Wraps up ImGui::OpenPopup().
/// </summary>
static void OpenPopup(const std::string& label);
/// <summary>
/// Creates a menu item in the list of items for a mini popup.
/// <br/>
/// Wraps up ImGui::MenuItem().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <returns>Whether or not the menu item was selected.</returns>
static bool MenuItem(const std::string& label);
/*-----------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Menu */
/*-----------------------------------------------------------------------------*/
static bool BeginMenu(const std::string& label);
static bool BeginMenu(const std::string& label, const char* icon);
static void EndMenu();
/*-----------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Widgets */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Creates a visual text widget.
/// <br/>
/// Wraps up ImGui::Text().
/// </summary>
/// <param name="title">Text to display.</param>
static void Text(const std::string& title);
/// <summary>
/// Creates a small inline button widget.
/// <br/>
/// Wraps up ImGui::SmallButton().
/// </summary>
/// <param name="title">Text to display.</param>
/// <returns>True if button was pressed.</returns>
static bool SmallButton(const std::string& title);
/// <summary>
/// Creates a inline button widget.
/// <br/>
/// Wraps up ImGui::Button().
/// </summary>
/// <param name="title">Text to display.</param>
/// <returns>True if button was pressed.</returns>
static bool Button(const std::string& title);
/// <summary>
/// Creates a checkbox widget for boolean input.
/// <br/>
/// Wraps up ImGui::Checkbox().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputCheckbox(const std::string& label, bool& value);
/// <summary>
/// Creates a integer field widget for integer input.
/// <br/>
/// Wraps up ImGui::InputInt().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputInt(const std::string& label, int& value);
/// <summary>
/// Creates a integer field widget for unsigned integer input.
/// <br/>
/// Wraps up ImGui::InputInt() with an additional clamping of values.
/// <br/>
/// Note: As a result, the range of this function limits it to the maximum
/// value of a 32-bit signed integer instead of a 32-bit unsigned integer.
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputUnsignedInt(const std::string& label, unsigned int& value);
/// <summary>
/// Creates a decimal field widget for single precision float input.
/// <br/>
/// Wraps up ImGui::InputFloat().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputFloat(const std::string& label, float& value);
/// <summary>
/// Creates a decimal field widget for double precision float input.
/// <br/>
/// Wraps up ImGui::InputDouble().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputDouble(const std::string& label, double& value);
/// <summary>
/// Creates a decimal field widget for double input with increments of higher
/// steps meant for angle variables.
/// <br/>
/// Wraps up ImGui::InputDouble().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputAngle(const std::string& label, double& value);
/// <summary>
/// Creates a double slider field widget for double input.
/// <br/>
/// Wraps up ImGui::InputSliderFloat().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="min">Minimum value of the slider.</param>
/// <param name="max">Maximum value of the slider.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputSlider(const std::string& label, double min, double max, double& value);
/// <summary>
/// Creates a 2x double field widget for Vector2 input.
/// <br/>
/// Wraps up ImGui::InputFloat2().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputVec2(const std::string& label, vec2& value);
/// <summary>
/// Creates a 3x double field widget for Vector3 input.
/// <br/>
/// Wraps up ImGui::InputFloat3().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputVec3(const std::string& label, vec3& value);
/// <summary>
/// Creates a 3x double slider field widget for Vector3 input.
/// <br/>
/// Wraps up ImGui::InputSliderFloat3().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="min">Minimum value of the slider.</param>
/// <param name="max">Maximum value of the slider.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputSliderVec3(const std::string& label, double min, double max, vec3& value);
/// <summary>
/// Creates a colour field widget for Color input.
/// <br/>
/// Wraps up ImGui::ColorEdit4().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputColor(const std::string& label, GFX::Color& value);
/// <summary>
/// Creates a text field widget for string input.
/// <br/>
/// Wraps up ImGui::InputText().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputTextField(const std::string& label, std::string& value);
/// <summary>
/// Creates a combo box for enumeration input.
/// </summary>
/// <typeparam name="Enum">The type of enum to input.</typeparam>
/// <param name="label">The name of the input.</param>
/// <param name="v">The reference to the value to modify.</param>
/// <param name="maxVal">The maximum value of the enum.</param>
/// <param name="toStrFn">
/// Conversion function from the type of enum
/// to C-style string.</param>
/// <returns>Whether the value was modified.</returns>
template<typename Enum>
static bool InputEnumCombo(const std::string& label, Enum& v, int maxVal, std::function<const char*(Enum)> toStrFn);
/// <summary>
/// Creates a combo box for enumeration input using a specified list of names.
/// </summary>
/// <param name="label">The name of the input.</param>
/// <param name="v">The reference to the value to modify.</param>
/// <param name="enumNames">Vector of names for each enumeration value.</param>
/// <returns>Whether the value was modified.</returns>
static bool InputEnumCombo(const std::string& label, int& v, const std::vector<std::string>& enumNames);
/// <summary>
/// Creates a drop down widget for texture selection.
/// </summary>
/// <param name="label">The name of the input.</param>
/// <param name="v">The reference to the value to modify.</param>
/// <returns>Whether the value was modified.</returns>
static bool InputTextureDropDown(const std::string& label, Resource::Snowflake& v);
/// <summary>
/// Creates a drop down widget for font selection.
/// </summary>
/// <param name="label">The name of the input.</param>
/// <param name="v">The reference to the value to modify.</param>
/// <returns>Whether the value was modified.</returns>
static bool InputFontDropDown(const char* label, Resource::Snowflake& v);
/*-----------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Pop Ups */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Marks the start of a definition of a mini pop up that can show options.
/// <br/>
/// Wraps up ImGui::BeginPopup().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <returns>Whether or not the pop up is open.</returns>
static bool BeginPopup(const std::string& label);
static bool BeginPopupContextItem(const std::string& label);
/// <summary>
/// Marks the end of a definition of a mini pop up that can show options.
/// <br/>
/// Wraps up ImGui::EndPopup().
/// </summary>
static void EndPopup();
/// <summary>
/// Opens the popup that was defined with the specified label.
/// <br/>
/// Wraps up ImGui::OpenPopup().
/// </summary>
static void OpenPopup(const std::string& label);
/// <summary>
/// Creates a menu item in the list of items for a mini popup.
/// <br/>
/// Wraps up ImGui::MenuItem().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <returns>Whether or not the menu item was selected.</returns>
static bool MenuItem(const std::string& label);
/*-----------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Widgets */
/*-----------------------------------------------------------------------------*/
/// <summary>
/// Creates a visual text widget.
/// <br/>
/// Wraps up ImGui::Text().
/// </summary>
/// <param name="title">Text to display.</param>
static void Text(const std::string& title);
/// <summary>
/// Creates a small inline button widget.
/// <br/>
/// Wraps up ImGui::SmallButton().
/// </summary>
/// <param name="title">Text to display.</param>
/// <returns>True if button was pressed.</returns>
static bool SmallButton(const std::string& title);
/// <summary>
/// Creates a inline button widget.
/// <br/>
/// Wraps up ImGui::Button().
/// </summary>
/// <param name="title">Text to display.</param>
/// <returns>True if button was pressed.</returns>
static bool Button(const std::string& title);
static bool Selectable(const std::string& label);
static bool Selectable(const std::string& label, const char* icon);
/// <summary>
/// Creates a checkbox widget for boolean input.
/// <br/>
/// Wraps up ImGui::Checkbox().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputCheckbox(const std::string& label, bool& value);
/// <summary>
/// Creates a integer field widget for integer input.
/// <br/>
/// Wraps up ImGui::InputInt().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputInt(const std::string& label, int& value);
/// <summary>
/// Creates a integer field widget for unsigned integer input.
/// <br/>
/// Wraps up ImGui::InputInt() with an additional clamping of values.
/// <br/>
/// Note: As a result, the range of this function limits it to the maximum
/// value of a 32-bit signed integer instead of a 32-bit unsigned integer.
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputUnsignedInt(const std::string& label, unsigned int& value);
/// <summary>
/// Creates a decimal field widget for single precision float input.
/// <br/>
/// Wraps up ImGui::InputFloat().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputFloat(const std::string& label, float& value);
/// <summary>
/// Creates a decimal field widget for double precision float input.
/// <br/>
/// Wraps up ImGui::InputDouble().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputDouble(const std::string& label, double& value);
/// <summary>
/// Creates a decimal field widget for double input with increments of higher
/// steps meant for angle variables.
/// <br/>
/// Wraps up ImGui::InputDouble().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputAngle(const std::string& label, double& value);
/// <summary>
/// Creates a double slider field widget for double input.
/// <br/>
/// Wraps up ImGui::InputSliderFloat().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="min">Minimum value of the slider.</param>
/// <param name="max">Maximum value of the slider.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputSlider(const std::string& label, double min, double max, double& value);
/// <summary>
/// Creates a 2x double field widget for Vector2 input.
/// <br/>
/// Wraps up ImGui::InputFloat2().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputVec2(const std::string& label, SHVec2& value);
/// <summary>
/// Creates a 3x double field widget for Vector3 input.
/// <br/>
/// Wraps up ImGui::InputFloat3().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputVec3(const std::string& label, SHVec3& value);
/// <summary>
/// Creates a 3x double slider field widget for Vector3 input.
/// <br/>
/// Wraps up ImGui::InputSliderFloat3().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="min">Minimum value of the slider.</param>
/// <param name="max">Maximum value of the slider.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputSliderVec3(const std::string& label, double min, double max, SHVec3& value);
/// <summary>
/// Creates a text field widget for string input.
/// <br/>
/// Wraps up ImGui::InputText().
/// </summary>
/// <param name="label">Label used to identify this widget.</param>
/// <param name="value">Reference to the variable to store the result.</param>
/// <returns>True if the value was changed.</returns>
static bool InputTextField(const std::string& label, std::string& value);
/// <summary>
/// Creates a combo box for enumeration input.
/// </summary>
/// <typeparam name="Enum">The type of enum to input.</typeparam>
/// <param name="label">The name of the input.</param>
/// <param name="v">The reference to the value to modify.</param>
/// <param name="maxVal">The maximum value of the enum.</param>
/// <param name="toStrFn">
/// Conversion function from the type of enum to C-style string.
/// </param>
/// <returns>Whether the value was modified.</returns>
template<typename Enum>
static bool InputEnumCombo(const std::string& label, Enum& v, int maxVal, std::function<const char*(Enum)> toStrFn);
/// <summary>
/// Creates a combo box for enumeration input using a specified list of names.
/// </summary>
/// <param name="label">The name of the input.</param>
/// <param name="v">The reference to the value to modify.</param>
/// <param name="enumNames">Vector of names for each enumeration value.</param>
/// <returns>Whether the value was modified.</returns>
static bool InputEnumCombo(const std::string& label, int& v, const std::vector<std::string>& enumNames);
private:
// Prevent instantiation of this static class
EditorUI() = delete;
};
} // namespace PlushieEngine
private:
// Prevent instantiation of this static class
SHEditorUI() = delete;
};
}
#include "EditorUI.hpp"
#include "SHEditorUI.hpp"

78
SHADE_Engine/src/Editor/SHEditorUI.hpp
View File

@ -1,49 +1,51 @@
/************************************************************************************//*!
\file EditorUI.hpp
\author Tay Yan Chong Clarence, t.yanchongclarence, 620008720
\par email: t.yanchongclarence\@digipen.edu
\date Nov 8, 2021
\file SHEditorUI.hpp
\author Tng Kah Wei, kahwei.tng, 390009620
\par email: kahwei.tng\@digipen.edu
\date Sep 27, 2022
\brief Contains the implementation of editor inspector template functions.
Copyright (C) 2021 DigiPen Institute of Technology.
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.
*//*************************************************************************************/
// Primary Header
#include "EditorUI.h"
#include "SHEditorUI.h"
// External Dependencies
#include <imgui.h>
namespace Pls
namespace SHADE
{
/*---------------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Widgets */
/*---------------------------------------------------------------------------------*/
template<typename Enum>
inline bool EditorUI::InputEnumCombo(const std::string& label, Enum& v, int maxVal, std::function<const char* (Enum)> toStrFn)
/*---------------------------------------------------------------------------------*/
/* ImGui Wrapper Functions - Widgets */
/*---------------------------------------------------------------------------------*/
template<typename Enum>
inline bool SHEditorUI::InputEnumCombo(const std::string& label, Enum& v, int maxVal, std::function<const char* (Enum)> toStrFn)
{
std::vector<Enum> values;
for (int i = 0; i <= maxVal; ++i)
{
std::vector<Enum> values;
for (int i = 0; i <= maxVal; ++i)
{
values.emplace_back(static_cast<Enum>(i));
}
bool b = false;
if (ImGui::BeginCombo(label.c_str(), toStrFn(v), ImGuiComboFlags_None))
{
for (int i = 0; i <= maxVal; ++i)
{
const auto VALUE = values[i];
const bool IS_SELECTED = v == VALUE;
if (ImGui::Selectable(toStrFn(VALUE), IS_SELECTED))
{
v = VALUE;
b = true;
}
if (IS_SELECTED)
{
ImGui::SetItemDefaultFocus();
}
}
ImGui::EndCombo();
}
return b;
values.emplace_back(static_cast<Enum>(i));
}
} // namespace PlushieEngine
bool b = false;
if (ImGui::BeginCombo(label.c_str(), toStrFn(v), ImGuiComboFlags_None))
{
for (int i = 0; i <= maxVal; ++i)
{
const auto VALUE = values[i];
const bool IS_SELECTED = v == VALUE;
if (ImGui::Selectable(toStrFn(VALUE), IS_SELECTED))
{
v = VALUE;
b = true;
}
if (IS_SELECTED)
{
ImGui::SetItemDefaultFocus();
}
}
ImGui::EndCombo();
}
return b;
}
}

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

@ -82,22 +82,18 @@ namespace SHADE
void SHScriptEngine::Exit()
{
// Do not allow deinitialization if not initialised
if (!dotNet.IsLoaded())
{
SHLOG_ERROR("[ScriptEngine] Attempted to clean up an unloaded DotNetRuntime.");
return;
}
// Do not allow deinitialization if not initialised
if (!dotNet.IsLoaded())
{
SHLOG_ERROR("[ScriptEngine] Attempted to clean up an unloaded DotNetRuntime.");
return;
}
// Unlink events
/*ECS::OnEntityCreated -= onEntityCreate;
ECS::OnEntityDestroy -= onEntityDestroy;*/
// Clean up the CSharp Engine
csEngineExit();
// Clean up the CSharp Engine
csEngineExit();
// Shut down the CLR
dotNet.Exit();
// Shut down the CLR
dotNet.Exit();
}
/*-----------------------------------------------------------------------------------*/
@ -105,15 +101,15 @@ namespace SHADE
/*-----------------------------------------------------------------------------------*/
bool SHScriptEngine::AddScript(EntityID entity, const std::string_view& scriptName)
{
return csScriptsAdd(entity, scriptName.data());
return csScriptsAdd(entity, scriptName.data());
}
void SHScriptEngine::RemoveAllScripts(EntityID entity)
{
csScriptsRemoveAll(entity);
csScriptsRemoveAll(entity);
}
void SHScriptEngine::RemoveAllScriptsImmediately(EntityID entity, bool callOnDestroy)
{
csScriptsRemoveAllImmediately(entity, callOnDestroy);
csScriptsRemoveAllImmediately(entity, callOnDestroy);
}
/*---------------------------------------------------------------------------------*/
@ -121,24 +117,24 @@ namespace SHADE
/*---------------------------------------------------------------------------------*/
std::string SHScriptEngine::SerialiseScripts(const SHEntity& entity) const
{
// Create buffer needed to store serialised script data
constexpr int BUFFER_SIZE = 10240;
std::unique_ptr<char> buffer { new char[BUFFER_SIZE] };
std::memset(buffer.get(), 0, BUFFER_SIZE);
// Create buffer needed to store serialised script data
constexpr int BUFFER_SIZE = 10240;
std::unique_ptr<char> buffer { new char[BUFFER_SIZE] };
std::memset(buffer.get(), 0, BUFFER_SIZE);
// Attempt to serialise the script
std::string result;
if (csScriptsSerialise(entity.GetEID(), buffer.get(), BUFFER_SIZE))
{
result = std::string(buffer.get());
}
else
{
SHLOG_ERROR("[ScriptEngine] Failed to serialise scripts as string buffer is too small!");
}
// Attempt to serialise the script
std::string result;
if (csScriptsSerialise(entity.GetEID(), buffer.get(), BUFFER_SIZE))
{
result = std::string(buffer.get());
}
else
{
SHLOG_ERROR("[ScriptEngine] Failed to serialise scripts as string buffer is too small!");
}
// Return an empty string since we failed to serialise
return result;
// Return an empty string since we failed to serialise
return result;
}
/*-----------------------------------------------------------------------------------*/
@ -152,9 +148,9 @@ namespace SHADE
/*-----------------------------------------------------------------------------------*/
/* Script Editor Functions */
/*-----------------------------------------------------------------------------------*/
void SHScriptEngine::RenderScriptsInInspector(const SHEntity& entity) const
void SHScriptEngine::RenderScriptsInInspector(EntityID entity) const
{
csEditorRenderScripts(entity.GetEID());
csEditorRenderScripts(entity);
}
/*-----------------------------------------------------------------------------------*/
@ -267,7 +263,7 @@ namespace SHADE
// Attempt to create the file
std::ofstream file(path);
if (!file.is_open())
throw std::runtime_error("Unable to create CsProj file!");
throw std::runtime_error("Unable to create CsProj file!");
// Fill the file
file << FILE_CONTENTS;
@ -281,9 +277,9 @@ namespace SHADE
/*-----------------------------------------------------------------------------------*/
SHEventHandle SHScriptEngine::onEntityDestroyed(SHEventPtr eventPtr)
{
auto eventData = reinterpret_cast<const SHEventSpec<SHEntityDestroyedEvent>*>(eventPtr.get());
csScriptsRemoveAll(eventData->data->eid);
return eventData->handle;
auto eventData = reinterpret_cast<const SHEventSpec<SHEntityDestroyedEvent>*>(eventPtr.get());
csScriptsRemoveAll(eventData->data->eid);
return eventData->handle;
}
/*-----------------------------------------------------------------------------------*/
@ -397,13 +393,13 @@ namespace SHADE
DEFAULT_CSHARP_LIB_NAME,
DEFAULT_CSHARP_NAMESPACE + ".ScriptStore",
"SerialiseScriptsYaml"
);
);*/
csEditorRenderScripts = dotNet.GetFunctionPtr<CsScriptEditorFuncPtr>
(
DEFAULT_CSHARP_LIB_NAME,
DEFAULT_CSHARP_NAMESPACE + ".Editor",
"RenderScriptsInInspector"
);*/
);
}
void SHScriptEngine::registerEvents()

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

@ -170,7 +170,7 @@ namespace SHADE
/// rendering code.
/// </summary>
/// <param name="entity">The Entity to render the Scripts of.</param>
void RenderScriptsInInspector(const SHEntity& entity) const;
void RenderScriptsInInspector(EntityID entity) const;
/*-----------------------------------------------------------------------------*/
/* Static Utility Functions */

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

@ -17,15 +17,17 @@ of DigiPen Institute of Technology is prohibited.
// Primary Header
#include "Editor/Editor.hxx"
// External Dependencies
#include "Editor/SHEditorUI::.h"
#include "Editor/SHEditorUI.h"
// Project Headers
#include "Components/Component.hxx"
#include "Scripts/ScriptStore.hxx"
#include "Utility/Convert.hxx"
#include "Utility/Debug.hxx"
#include "Serialisation/ReflectionUtilities.hxx"
#include "Editor/IconsMaterialDesign.h"
// Using Directives
using namespace System;
using namespace System::Collections::Generic;
/*-------------------------------------------------------------------------------------*/
@ -46,7 +48,7 @@ using namespace System::Collections::Generic;
(field->FieldType == MANAGED_TYPE::typeid) \
{ \
NATIVE_TYPE val = safe_cast<NATIVE_TYPE>(field->GetValue(object)); \
if (SHEditorUI::::FUNC(Convert::ToNative(field->Name), val)) \
if (SHEditorUI::FUNC(Convert::ToNative(field->Name), val)) \
{ \
field->SetValue(object, val); \
} \
@ -67,7 +69,7 @@ using namespace System::Collections::Generic;
(field->FieldType == MANAGED_TYPE::typeid) \
{ \
NATIVE_TYPE val = Convert::ToNative(safe_cast<MANAGED_TYPE>(field->GetValue(object))); \
if (SHEditorUI::::FUNC(Convert::ToNative(field->Name), val)) \
if (SHEditorUI::FUNC(Convert::ToNative(field->Name), val)) \
{ \
field->SetValue(object, Convert::ToCLI(val)); \
} \
@ -99,10 +101,31 @@ namespace SHADE
}
// Render Add Script
//RenderScriptAddButton(entity);
RenderScriptAddButton(entity);
SAFE_NATIVE_CALL_END_N("SHADE_Managed.Editor.RenderScriptsInInspector")
}
void Editor::RenderScriptAddButton(Entity entity)
{
// Get list of Scripts
auto scriptTypes = ScriptStore::GetAvailableScriptList();
// Define pop up
if (SHEditorUI::BeginMenu("Add Script", ICON_MD_LIBRARY_ADD))
{
for each (Type ^ type in scriptTypes)
{
if (SHEditorUI::Selectable(Convert::ToNative(type->Name)))
{
// Add the script
ScriptStore::AddScriptViaName(entity, type->Name);
}
}
SHEditorUI::EndMenu();
}
}
/*---------------------------------------------------------------------------------*/
/* Helper Functions */
/*---------------------------------------------------------------------------------*/
@ -110,30 +133,23 @@ namespace SHADE
{
// Constants
const std::string LABEL = Convert::ToNative(script->GetType()->Name);
const char* CONTEXT_MENU_ID = "scriptContextMenu";
// Header
SHEditorUI::::PushID(index);
if (SHEditorUI::::CollapsingHeader(LABEL))
SHEditorUI::PushID(index);
if (SHEditorUI::CollapsingHeader(LABEL))
{
SHEditorUI::::PushID(LABEL);
SHEditorUI::::Indent();
SHEditorUI::PushID(LABEL);
SHEditorUI::Indent();
{
// Define context menu
if (SHEditorUI::::BeginPopup(CONTEXT_MENU_ID))
// Right Click Menu
if (SHEditorUI::BeginPopupContextItem("scriptContextMenu"))
{
if (SHEditorUI::::MenuItem("Remove Script"))
if (SHEditorUI::Selectable("Delete Script", ICON_MD_DELETE))
{
// Mark script for removal
ScriptStore::RemoveScript(entity, script);
}
SHEditorUI::::EndPopup();
}
// Context menu button
if (SHEditorUI::::SmallButton("..."))
{
SHEditorUI::::OpenPopup(CONTEXT_MENU_ID);
SHEditorUI::EndPopup();
}
// Go through all fields and output them
@ -146,16 +162,16 @@ namespace SHADE
continue;
// Render the input field for this field
SHEditorUI::::PushID(LABEL + std::to_string(id++));
SHEditorUI::PushID(LABEL + std::to_string(id++));
renderFieldInInspector(field, script);
SHEditorUI::::PopID();
SHEditorUI::PopID();
}
}
SHEditorUI::::Unindent();
SHEditorUI::::PopID();
SHEditorUI::Unindent();
SHEditorUI::PopID();
}
SHEditorUI::::PopID();
SHEditorUI::PopID();
}
void Editor::renderFieldInInspector(Reflection::FieldInfo^ field, Object^ object)
{
@ -180,13 +196,13 @@ namespace SHADE
}
int val = safe_cast<int>(field->GetValue(object));
if (SHEditorUI::::InputEnumCombo(Convert::ToNative(field->Name), val, nativeEnumNames))
if (SHEditorUI::InputEnumCombo(Convert::ToNative(field->Name), val, nativeEnumNames))
{
field->SetValue(object, val);
}
}
else if RENDER_FIELD_CASTED(Vector2, vec2, InputVec2)
else if RENDER_FIELD_CASTED(Vector3, vec3, InputVec3)
else if RENDER_FIELD_CASTED(Vector2, SHVec2, InputVec2)
else if RENDER_FIELD_CASTED(Vector3, SHVec3, InputVec3)
else if (field->FieldType == String::typeid)
{
// Prevent issues where String^ is null due to being empty
@ -198,7 +214,7 @@ namespace SHADE
// Actual Field
std::string val = Convert::ToNative(stringVal);
if (SHEditorUI::::InputTextField(Convert::ToNative(field->Name), val))
if (SHEditorUI::InputTextField(Convert::ToNative(field->Name), val))
{
field->SetValue(object, Convert::ToCLI(val));
}

8
SHADE_Managed/src/Editor/Editor.hxx
View File

@ -36,7 +36,13 @@ namespace SHADE
/// rendering code.
/// </summary>
/// <param name="entity">The Entity to render the Scripts of.</param>
static void RenderScriptsInInspector(Entity entity);
static void RenderScriptsInInspector(Entity entity);
/// <summary>
/// Renders a dropdown button that allows for the addition of PlushieScripts
/// onto the specified Entity.
/// </summary>
/// <param name="entity">The Entity to add PlushieScripts to.</param>
static void RenderScriptAddButton(Entity entity);
private:
/*-----------------------------------------------------------------------------*/

5
TempScriptsFolder/TestScript.cs
View File

@ -2,6 +2,9 @@ using SHADE;
public class TestScript : Script
{
public double Speed = 1.0;
public Vector3 ATestVector;
public bool ABoolean;
private Transform Transform;
private double time = 0.0;
public TestScript(GameObject gameObj) : base(gameObj) {}
@ -21,7 +24,7 @@ public class TestScript : Script
}
protected override void update()
{
time += 0.16;
time += Speed * 0.16;
Transform.GlobalPosition = new Vector3(System.Math.Sin(time), System.Math.Cos(time), 0.0f);
}
protected override void onDestroy()