628 lines
16 KiB
C++
628 lines
16 KiB
C++
#include "imguiManager.h"
|
||
#include "applicationclass.h"
|
||
#include <string>
|
||
|
||
imguiManager::imguiManager()
|
||
{
|
||
io = nullptr;
|
||
}
|
||
|
||
imguiManager::~imguiManager()
|
||
{
|
||
}
|
||
|
||
bool imguiManager::Initialize(HWND hwnd, ID3D11Device* device, ID3D11DeviceContext* deviceContext)
|
||
{
|
||
Logger::Get().Log("Initializing imgui", __FILE__, __LINE__, Logger::LogLevel::Initialize);
|
||
|
||
m_device = device;
|
||
m_deviceContext = deviceContext;
|
||
|
||
IMGUI_CHECKVERSION();
|
||
ImGui::CreateContext();
|
||
io = &ImGui::GetIO();
|
||
io->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
|
||
io->ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
|
||
|
||
|
||
ImGui_ImplWin32_Init(hwnd);
|
||
ImGui_ImplDX11_Init(m_device, m_deviceContext);
|
||
ImGui::StyleColorsDark();
|
||
|
||
Logger::Get().Log("imgui initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
|
||
|
||
return true;
|
||
}
|
||
|
||
void imguiManager::Shutdown()
|
||
{
|
||
Logger::Get().Log("Shutting down imgui", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
|
||
ImGui_ImplDX11_Shutdown();
|
||
ImGui_ImplWin32_Shutdown();
|
||
ImGui::DestroyContext();
|
||
Logger::Get().Log("imgui shutdown", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
|
||
}
|
||
|
||
void imguiManager::Render()
|
||
{
|
||
ImGui::Render();
|
||
ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
|
||
}
|
||
|
||
void imguiManager::NewFrame()
|
||
{
|
||
ImGui_ImplDX11_NewFrame();
|
||
ImGui_ImplWin32_NewFrame();
|
||
ImGui::NewFrame();
|
||
}
|
||
|
||
void imguiManager::SetupDockspace() {
|
||
ImGuiWindowFlags window_flags = ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoDocking;
|
||
ImGuiViewport* viewport = ImGui::GetMainViewport();
|
||
ImGui::SetNextWindowPos(viewport->Pos);
|
||
ImGui::SetNextWindowSize(viewport->Size);
|
||
ImGui::SetNextWindowViewport(viewport->ID);
|
||
ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
|
||
ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
|
||
window_flags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove;
|
||
window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus;
|
||
|
||
ImGui::Begin("DockSpace", nullptr, window_flags);
|
||
ImGui::PopStyleVar(2);
|
||
|
||
ImGuiID dockspace_id = ImGui::GetID("MainDockSpace");
|
||
ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), ImGuiDockNodeFlags_PassthruCentralNode);
|
||
|
||
ImGui::End();
|
||
}
|
||
|
||
void imguiManager::WidgetSpeedSlider(float* speed)
|
||
{
|
||
ImGui::SliderFloat("Speed", speed, 0.0f, 100.0f);
|
||
}
|
||
|
||
void imguiManager::WidgetButton()
|
||
{
|
||
static int counter = 0;
|
||
|
||
if (ImGui::Button("Button")) // Buttons return true when clicked (most widgets return true when edited/activated)
|
||
counter++;
|
||
ImGui::SameLine();
|
||
ImGui::Text("counter = %d", counter);
|
||
}
|
||
|
||
void imguiManager::WidgetFPS()
|
||
{
|
||
ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io->Framerate, io->Framerate);
|
||
}
|
||
|
||
void imguiManager::WidgetAddObject(ApplicationClass* app)
|
||
{
|
||
if (ImGui::CollapsingHeader("Objects"))
|
||
{
|
||
if (ImGui::Button("Add Cube"))
|
||
{
|
||
app->AddCube();
|
||
}
|
||
ImGui::SameLine();
|
||
if (ImGui::Button("Import Object"))
|
||
{
|
||
// Open file dialog
|
||
OPENFILENAME ofn;
|
||
WCHAR szFile[260];
|
||
ZeroMemory(&ofn, sizeof(ofn));
|
||
ofn.lStructSize = sizeof(ofn);
|
||
ofn.hwndOwner = NULL;
|
||
ofn.lpstrFile = szFile;
|
||
ofn.lpstrFile[0] = '\0';
|
||
ofn.nMaxFile = sizeof(szFile);
|
||
ofn.lpstrFilter = L"OBJ\0*.obj\0KOBJ\0*.kobj\0TXT\0*.txt";
|
||
ofn.nFilterIndex = 1;
|
||
ofn.lpstrFileTitle = NULL;
|
||
ofn.nMaxFileTitle = 0;
|
||
ofn.lpstrInitialDir = NULL;
|
||
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
|
||
|
||
if (GetOpenFileName(&ofn))
|
||
{
|
||
app->AddKobject(ofn.lpstrFile);
|
||
}
|
||
|
||
}
|
||
ImGui::SameLine();
|
||
ImGui::Text("Number of cubes: %d", app->GetCubeCount());
|
||
}
|
||
}
|
||
|
||
void imguiManager::WidgetShaderWindow(ApplicationClass* app)
|
||
{
|
||
ImGui::Begin("Shader Manager");
|
||
|
||
// Checkbox for toggling cel shading globally in the application class by calling the SetCelShading function in the application class when the checkbox state changes
|
||
ImGui::Checkbox("Enable Cel Shading", &m_EnableCelShading);
|
||
app->SetCelShading(m_EnableCelShading);
|
||
|
||
ImGui::End();
|
||
}
|
||
|
||
void imguiManager::WidgetObjectWindow(ApplicationClass* app)
|
||
{
|
||
ImGui::Begin("Objects", &showObjectWindow);
|
||
int index = 0;
|
||
for (auto& object : app->GetKobjects())
|
||
{
|
||
std::string headerName = object->GetName() + " " + std::to_string(index);
|
||
if (ImGui::CollapsingHeader(headerName.c_str()))
|
||
{
|
||
|
||
XMVECTOR position = object->GetPosition();
|
||
XMVECTOR rotation = object->GetRotation();
|
||
XMVECTOR scale = object->GetScale();
|
||
|
||
float pos[3] = { XMVectorGetX(position), XMVectorGetY(position), XMVectorGetZ(position) };
|
||
std::string posLabel = "Position##" + std::to_string(index);
|
||
if (ImGui::DragFloat3(posLabel.c_str(), pos))
|
||
{
|
||
object->SetPosition(XMVectorSet(pos[0], pos[1], pos[2], 0.0f));
|
||
}
|
||
|
||
float rot[3] = { XMVectorGetX(rotation), XMVectorGetY(rotation), XMVectorGetZ(rotation) };
|
||
std::string rotLabel = "Rotation##" + std::to_string(index);
|
||
if (ImGui::DragFloat3(rotLabel.c_str(), rot))
|
||
{
|
||
object->SetRotation(XMVectorSet(rot[0], rot[1], rot[2], 0.0f));
|
||
}
|
||
|
||
float scl[3] = { XMVectorGetX(scale), XMVectorGetY(scale), XMVectorGetZ(scale) };
|
||
std::string sclLabel = "Scale##" + std::to_string(index);
|
||
if (ImGui::DragFloat3(sclLabel.c_str(), scl))
|
||
{
|
||
object->SetScale(XMVectorSet(scl[0], scl[1], scl[2], 0.0f));
|
||
}
|
||
|
||
ImGui::Separator();
|
||
|
||
// Texture
|
||
// add all texture category names to a vector
|
||
std::vector<std::string> textureCategories = {
|
||
"Diffuse",
|
||
"Normal",
|
||
"Specular",
|
||
"Reflection",
|
||
"Refraction"
|
||
};
|
||
|
||
// Display all images
|
||
for (int count = 0; count < textureCategories.size(); count++)
|
||
{
|
||
std::string textureLabel = "Texture##" + std::to_string(index) + "##" + std::to_string(count);
|
||
ID3D11ShaderResourceView* texture = object->GetTexture(count);
|
||
if (texture != nullptr)
|
||
{
|
||
ImGui::Text(textureCategories[count].c_str());
|
||
ImGui::SameLine();
|
||
|
||
std::string buttonLabel = "button " + std::to_string(count);
|
||
if (ImGui::ImageButton(buttonLabel.c_str(), (ImTextureID)texture, ImVec2(64, 64)))
|
||
{
|
||
// Open file dialog
|
||
OPENFILENAME ofn;
|
||
WCHAR szFile[260];
|
||
ZeroMemory(&ofn, sizeof(ofn));
|
||
ofn.lStructSize = sizeof(ofn);
|
||
ofn.hwndOwner = NULL;
|
||
ofn.lpstrFile = szFile;
|
||
ofn.lpstrFile[0] = '\0';
|
||
ofn.nMaxFile = sizeof(szFile);
|
||
ofn.lpstrFilter = L"Texture\0*.png\0";
|
||
ofn.nFilterIndex = 1;
|
||
ofn.lpstrFileTitle = NULL;
|
||
ofn.nMaxFileTitle = 0;
|
||
ofn.lpstrInitialDir = NULL;
|
||
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
|
||
|
||
if (GetOpenFileName(&ofn))
|
||
{
|
||
// Load the selected texture
|
||
object->ChangeTexture(m_device, m_deviceContext, ofn.lpstrFile, count);
|
||
}
|
||
}
|
||
|
||
if (ImGui::IsItemHovered())
|
||
{
|
||
ImGui::BeginTooltip();
|
||
ImGui::Image((ImTextureID)texture, ImVec2(256, 256));
|
||
ImGui::EndTooltip();
|
||
}
|
||
|
||
if (count < textureCategories.size() - 1)
|
||
{
|
||
ImGui::SameLine();
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
ImGui::Separator();
|
||
|
||
// Delete button
|
||
std::string deleteLabel = "Delete##" + std::to_string(index);
|
||
if (ImGui::Button(deleteLabel.c_str()))
|
||
{
|
||
app->DeleteKobject(index);
|
||
}
|
||
|
||
// Shader selection
|
||
std::string shaderLabel = "Shader##" + std::to_string(index);
|
||
|
||
// Radio buttons for shader options
|
||
Object::ShaderType activeShader = object->GetActiveShader();
|
||
|
||
if (ImGui::RadioButton("Enable Lighting", activeShader == Object::LIGHTING))
|
||
{
|
||
object->SetActiveShader(Object::LIGHTING);
|
||
}
|
||
|
||
if (ImGui::RadioButton("Enable Cel Shading", activeShader == Object::CEL_SHADING))
|
||
{
|
||
object->SetActiveShader(Object::CEL_SHADING);
|
||
}
|
||
|
||
if (ImGui::RadioButton("Enable Normal Mapping", activeShader == Object::NORMAL_MAPPING))
|
||
{
|
||
object->SetActiveShader(Object::NORMAL_MAPPING);
|
||
}
|
||
|
||
if (ImGui::RadioButton("Enable Specular Mapping", activeShader == Object::SPECULAR_MAPPING))
|
||
{
|
||
object->SetActiveShader(Object::SPECULAR_MAPPING);
|
||
}
|
||
|
||
ImGui::Separator();
|
||
|
||
// Physics
|
||
std::string physicsLabel = "Physics##" + std::to_string(index);
|
||
|
||
if (ImGui::Checkbox(physicsLabel.c_str(), &m_isPhyiscsEnabled))
|
||
{
|
||
object->SetPhysicsEnabled(m_isPhyiscsEnabled);
|
||
}
|
||
|
||
// 3 radio button on the same line to set the ObjectType
|
||
std::string typeLabel = "Type##" + std::to_string(index);
|
||
ObjectType type = object->GetType();
|
||
if (ImGui::RadioButton("None", type == ObjectType::Unknown))
|
||
{
|
||
object->SetType(ObjectType::Unknown);
|
||
}
|
||
ImGui::SameLine();
|
||
if (ImGui::RadioButton("Cube", type == ObjectType::Cube))
|
||
{
|
||
object->SetType(ObjectType::Cube);
|
||
}
|
||
ImGui::SameLine();
|
||
if (ImGui::RadioButton("Sphere", type == ObjectType::Sphere))
|
||
{
|
||
object->SetType(ObjectType::Sphere);
|
||
}
|
||
|
||
|
||
|
||
ImGui::Separator();
|
||
|
||
// Demo spinning
|
||
std::string demoLabel = "Demo spinning##" + std::to_string(index);
|
||
ImGui::Checkbox(demoLabel.c_str(), &object->m_demoSpinning);
|
||
}
|
||
index++;
|
||
}
|
||
|
||
ImGui::End();
|
||
}
|
||
|
||
void imguiManager::WidgetTerrainWindow(ApplicationClass* app)
|
||
{
|
||
ImGui::Begin("Terrain", &showTerrainWindow);
|
||
|
||
ImGui::Text("Number of terrain cubes: %d", app->GetTerrainCubeCount());
|
||
|
||
ImGui::Separator();
|
||
|
||
if (ImGui::Button("Generate Terrain"))
|
||
{
|
||
app->GenerateTerrain();
|
||
}
|
||
|
||
ImGui::SameLine();
|
||
|
||
if (ImGui::Button("Delete All Terrain Cubes"))
|
||
{
|
||
app->DeleteTerrain();
|
||
}
|
||
|
||
|
||
ImGui::End();
|
||
}
|
||
|
||
bool imguiManager::ImGuiWidgetRenderer(ApplicationClass* app)
|
||
{
|
||
// Start the Dear ImGui frame
|
||
NewFrame();
|
||
|
||
// Setup the dockspace
|
||
SetupDockspace();
|
||
|
||
//ImGui Widget
|
||
ImGui::Begin("Khaotic Engine", NULL);
|
||
|
||
float speed = app->GetSpeed();
|
||
WidgetSpeedSlider(&speed);
|
||
app->SetSpeed(speed);
|
||
WidgetButton();
|
||
WidgetFPS();
|
||
WidgetAddObject(app);
|
||
ImGui::Separator();
|
||
|
||
// Add buttons for opening windows
|
||
if (ImGui::Button("Open Object Window"))
|
||
{
|
||
showObjectWindow = true;
|
||
}
|
||
|
||
if (ImGui::Button("Open Terrain Window"))
|
||
{
|
||
showTerrainWindow = true;
|
||
}
|
||
|
||
if (ImGui::Button("Open Light Window"))
|
||
{
|
||
showLightWindow = true;
|
||
}
|
||
|
||
if (ImGui::Button("Open Shader Window"))
|
||
{
|
||
showShaderWindow = true;
|
||
}
|
||
|
||
if (ImGui::Button("Open Engine Settings Window"))
|
||
{
|
||
showEngineSettingsWindow = true;
|
||
}
|
||
|
||
if (ImGui::Button("Open Log Window"))
|
||
{
|
||
showLogWindow = true;
|
||
}
|
||
|
||
ImGui::End();
|
||
|
||
// Show windows if their corresponding variables are true
|
||
if (showObjectWindow)
|
||
{
|
||
WidgetObjectWindow(app);
|
||
}
|
||
|
||
if (showTerrainWindow)
|
||
{
|
||
WidgetTerrainWindow(app);
|
||
}
|
||
|
||
if (showLightWindow)
|
||
{
|
||
WidgetLightWindow(app);
|
||
}
|
||
|
||
if (showShaderWindow)
|
||
{
|
||
WidgetShaderWindow(app);
|
||
}
|
||
|
||
if (showEngineSettingsWindow)
|
||
{
|
||
WidgetEngineSettingsWindow(app);
|
||
}
|
||
|
||
if (showLogWindow)
|
||
{
|
||
WidgetLogWindow(app);
|
||
}
|
||
|
||
WidgetRenderWindow(app, ImVec2(800, 600));
|
||
|
||
//render imgui
|
||
Render();
|
||
|
||
return true;
|
||
}
|
||
|
||
void imguiManager::WidgetLightWindow(ApplicationClass* app)
|
||
{
|
||
ImGui::Begin("Light", &showLightWindow);
|
||
int index = 0;
|
||
|
||
for(auto& light : app->GetLights())
|
||
{
|
||
std::string headerName = "Light " + std::to_string(index);
|
||
if (ImGui::CollapsingHeader(headerName.c_str()))
|
||
{
|
||
XMVECTOR position = app->GetLightPosition(index);
|
||
XMVECTOR color = app->GetLightColor(index);
|
||
float pos[3] = { XMVectorGetX(position), XMVectorGetY(position), XMVectorGetZ(position) };
|
||
float col[3] = { XMVectorGetX(color), XMVectorGetY(color), XMVectorGetZ(color) };
|
||
|
||
std::string posLabel = "Position##" + std::to_string(index);
|
||
std::string colLabel = "Color##" + std::to_string(index);
|
||
|
||
if (ImGui::DragFloat3(posLabel.c_str(), pos))
|
||
{
|
||
app->SetLightPosition(index, XMVectorSet(pos[0], pos[1], pos[2], 0.0f));
|
||
}
|
||
|
||
if (ImGui::ColorEdit3(colLabel.c_str(), col))
|
||
{
|
||
app->SetLightColor(index, XMVectorSet(col[0], col[1], col[2], 0.0f));
|
||
}
|
||
|
||
}
|
||
index++;
|
||
};
|
||
|
||
ImGui::End();
|
||
}
|
||
|
||
void imguiManager::WidgetEngineSettingsWindow(ApplicationClass* app)
|
||
{
|
||
ImGui::Begin("Engine Settings", &showEngineSettingsWindow);
|
||
|
||
// Begining Of General Setting
|
||
ImGui::Text("General");
|
||
|
||
// Checkbox for toggling vsync globally in the application class by calling the SetVsync function in the application class when the checkbox state changes
|
||
bool vsync = app->GetVsync();
|
||
if (ImGui::Checkbox("Vsync", &vsync))
|
||
{
|
||
app->SetVsync(vsync);
|
||
}
|
||
|
||
// End Of General Setting
|
||
ImGui::Separator();
|
||
// culling section
|
||
ImGui::Text("Culling");
|
||
|
||
// float input for frustum tolerance
|
||
float frustumTolerance = app->GetFrustumTolerance();
|
||
if (ImGui::DragFloat("Frustum Tolerance", &frustumTolerance, 0.1f, 0.0f, 100.0f))
|
||
{
|
||
app->SetFrustumTolerance(frustumTolerance);
|
||
}
|
||
|
||
// End Of Culling Setting
|
||
ImGui::Separator();
|
||
|
||
// Physics section
|
||
ImGui::Text("Physics");
|
||
|
||
// Input To set the Fixed Update Interval
|
||
int physicsInterval = app->GetPhysicsTickRate();
|
||
if (ImGui::InputInt("Physics Tick Rate", &physicsInterval))
|
||
{
|
||
app->SetPhysicsTickRate(physicsInterval);
|
||
}
|
||
|
||
// Input to change the gravity on same line
|
||
XMVECTOR gravity = app->GetPhysics()->GetGravity();
|
||
float gravityValues[3] = { XMVectorGetX(gravity), XMVectorGetY(gravity), XMVectorGetZ(gravity) };
|
||
if (ImGui::DragFloat3("Gravity", gravityValues))
|
||
{
|
||
app->GetPhysics()->SetGravity(XMVectorSet(gravityValues[0], gravityValues[1], gravityValues[2], 0.0f));
|
||
}
|
||
|
||
ImGui::End();
|
||
}
|
||
|
||
void imguiManager::WidgetLogWindow(ApplicationClass* app)
|
||
{
|
||
ImGui::Begin("Log Window");
|
||
|
||
// Filtre de recherche
|
||
static ImGuiTextFilter filter;
|
||
filter.Draw("Filter ", 180);
|
||
|
||
ImGui::SameLine();
|
||
|
||
// Bouton pour ouvrir le fichier de log
|
||
if (ImGui::Button("Open Log File"))
|
||
{
|
||
ShellExecuteA(NULL, "open", Logger::Get().m_logFilePath.c_str(), NULL, NULL, SW_SHOWNORMAL);
|
||
}
|
||
|
||
// Place the menu on the same line as the filter
|
||
ImGui::SameLine();
|
||
|
||
// Menu d<>roulant pour les niveaux de log
|
||
if (ImGui::BeginMenu("Log Levels"))
|
||
{
|
||
for (size_t i = 0; i < Logger::LogLevelCount; ++i)
|
||
{
|
||
bool isVisible = !Logger::Get().m_disabledLogLevels[i];
|
||
if (ImGui::Checkbox(Logger::Get().GetLogLevelInfo(static_cast<Logger::LogLevel>(i)).name, &isVisible))
|
||
{
|
||
Logger::Get().m_disabledLogLevels[i] = !isVisible;
|
||
}
|
||
}
|
||
ImGui::EndMenu();
|
||
}
|
||
|
||
const auto& logBuffer = Logger::Get().GetLogBuffer();
|
||
std::vector<Logger::LogEntry> logfiltered;
|
||
int logCount = logBuffer.size();
|
||
|
||
// Affichage des logs filtr<74>s
|
||
ImGui::BeginChild("Log");
|
||
|
||
for (const auto& log : logBuffer)
|
||
{
|
||
if (filter.PassFilter(log.message.c_str()) && !Logger::Get().m_disabledLogLevels[static_cast<size_t>(log.level)])
|
||
{
|
||
logfiltered.push_back(log);
|
||
}
|
||
}
|
||
|
||
if (logfiltered.size() == 0)
|
||
{
|
||
ImGui::Text("No logs to display.");
|
||
}
|
||
else
|
||
{
|
||
ImGuiListClipper clipper;
|
||
clipper.Begin(logCount);
|
||
while (clipper.Step())
|
||
{
|
||
for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)
|
||
{
|
||
if (i < logfiltered.size()) {
|
||
const auto& log = logfiltered[i];
|
||
ImGui::TextColored(Logger::Get().GetLogLevelInfo(log.level).color, log.message.c_str());
|
||
}
|
||
|
||
}
|
||
}
|
||
clipper.End();
|
||
}
|
||
|
||
// Scroll to the bottom
|
||
if (ImGui::GetScrollY() >= ImGui::GetScrollMaxY())
|
||
{
|
||
ImGui::SetScrollHereY(1.0f);
|
||
}
|
||
|
||
ImGui::EndChild();
|
||
|
||
ImGui::End();
|
||
}
|
||
|
||
|
||
void imguiManager::WidgetRenderWindow(ApplicationClass* app, ImVec2 availableSize)
|
||
{
|
||
ImGui::Begin("Render Window");
|
||
|
||
windowSize = ImGui::GetContentRegionAvail();
|
||
app->SetWindowSize(windowSize);
|
||
|
||
// Assurez-vous que la texture est valide
|
||
RenderTextureClass* renderTexture = app->GetRenderTexture();
|
||
if (renderTexture)
|
||
{
|
||
// Obtenez la vue de la ressource shader de la texture rendue
|
||
ID3D11ShaderResourceView* texture = renderTexture->GetShaderResourceView();
|
||
|
||
// Affichez la texture dans une fen<65>tre ImGui
|
||
ImGui::Image((ImTextureID)texture, windowSize);
|
||
}
|
||
else
|
||
{
|
||
ImGui::Text("Render texture is not available.");
|
||
}
|
||
|
||
ImGui::End();
|
||
} |