imguiManager Class Reference

Public Member Functions
	imguiManager ()
bool	Initialize (HWND hwnd, ID3D11Device *device, ID3D11DeviceContext *deviceContext)
void	Shutdown ()
void	Render ()
void	NewFrame ()
void	SetupDockspace ()
void	WidgetSpeedSlider (float *speed)
void	WidgetButton ()
void	WidgetFPS ()
void	WidgetAddObject ()
void	WidgetObjectWindow ()
void	WidgetTerrainWindow ()
void	WidgetLightWindow ()
void	WidgetEngineSettingsWindow ()
void	WidgetRenderWindow (ImVec2 availableSize)
void	WidgetLogWindow ()
void	WidgetRenderStats ()
bool	ImGuiWidgetRenderer ()
void	SetWindowSize (ImVec2 size)
ImVec2	GetWindowSize () const
void	SetApp (std::shared_ptr< application_class > app)

Public Attributes
bool	m_EnableCelShading

Detailed Description

Definition at line 33 of file imguiManager.h.

Constructor & Destructor Documentation

imguiManager()

imguiManager::imguiManager

(

)

Constructor for imguiManager class. Initializes the ImGui manager with default values.

Definition at line 7 of file imguiManager.cpp.

{
    io = nullptr;
    m_frameTimeHistoryIndex = 0;
 
    current_fps_ = 0;
    min_fps_ = 0;
    max_fps_ = 0;
    draw_calls_ = 0;
    total_vertex_count_ = 0;
    total_triangle_count_ = 0;
    visible_triangle_count_ = 0;
    current_frame_time_ = 0;
 
    showObjectWindow = false;
    showTerrainWindow = false;
    showLightWindow = false;
    showOldSceneWindow = false;
    showEngineSettingsWindow = false;
    showLogWindow = false;
    showStatsWindow = false;
    
    // Initialiser l'historique des frametimes à zéro
    for (int i = 0; i < FRAME_HISTORY_COUNT; i++)
    {
        m_frameTimeHistory[i] = 0.0f;
    }
 
    widgets_ = {
        {&showObjectWindow, [&](){WidgetObjectWindow();}},
        {&showEngineSettingsWindow, [&](){WidgetEngineSettingsWindow();}},
        {&showTerrainWindow, [&](){WidgetTerrainWindow();}},
        {&showLightWindow, [&](){WidgetLightWindow();}},
        {&showLogWindow, [&](){WidgetLogWindow();}},
        {&showOldSceneWindow, [&](){WidgetRenderWindow(ImVec2(800, 600));}},
        {&showStatsWindow, [&](){WidgetRenderStats();}}
    };
}

~imguiManager()

imguiManager::~imguiManager

(

)

Definition at line 46 of file imguiManager.cpp.

{
}

Member Function Documentation

GetWindowSize()

ImVec2 imguiManager::GetWindowSize ( ) const

inline

Get the current window size.

Returns

The current window size as an ImVec2.

Definition at line 136 of file imguiManager.h.

{ return windowSize; }

ImGuiWidgetRenderer()

bool imguiManager::ImGuiWidgetRenderer

(

)

Function to render the ImGui widgets. This function use the struct widget_entry to render the widgets that are registered.

Returns

True if the ImGui widgets were rendered successfully, otherwise false.

Definition at line 744 of file imguiManager.cpp.

{
    // Start the Dear ImGui frame
    NewFrame();
 
    // Setup the dockspace
    SetupDockspace();
 
    //ImGui Widget
    ImGui::Begin("Khaotic Engine", NULL);
 
    float speed = app_->get_speed();
    
    WidgetSpeedSlider(&speed);
    app_->set_speed(speed);
    WidgetButton();
    WidgetAddObject();
 
    ImGui::End();
 
    // Read the widget list and call the function if the show variable is true
    for (const auto& entry : widgets_)
    {
        if (*entry.show == true) {entry.func();}
    }
    
    //render imgui
    Render();
 
    return true;
}

Initialize()

bool imguiManager::Initialize	(	HWND	hwnd,
		ID3D11Device *	device,
		ID3D11DeviceContext *	deviceContext )

Initializes the ImGui manager.

Parameters

hwnd	Handle to the window where ImGui will be rendered.
device	Pointer to the Direct3D 11 device.
deviceContext	Pointer to the Direct3D 11 device context.

Returns

True if initialization was successful, otherwise false.

Definition at line 50 of file imguiManager.cpp.

{
    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;
    io->ConfigFlags |= ImGuiConfigFlags_DockingEnable;
    io->FontGlobalScale = 1.0f;
 
    ImGui_ImplWin32_Init(hwnd);
    ImGui_ImplDX11_Init(m_device, m_deviceContext);
 
    // Appliquer un thème sombre de base
    ImGui::StyleColorsDark();
    
    // Définir les couleurs pour une interface de type éditeur sobre
    ImGuiStyle& style = ImGui::GetStyle();
    
    // Palette de couleurs sobres inspirée des éditeurs modernes
    ImVec4 background_dark = ImVec4(0.10f, 0.10f, 0.10f, 1.00f);    // Fond foncé
    ImVec4 background = ImVec4(0.15f, 0.15f, 0.15f, 1.00f);         // Fond principal
    ImVec4 background_light = ImVec4(0.20f, 0.20f, 0.20f, 1.00f);   // Fond clair
    ImVec4 accent = ImVec4(0.14f, 0.44f, 0.80f, 0.50f);             // Accent bleu
    ImVec4 accent_light = ImVec4(0.14f, 0.44f, 0.80f, 1.00f);       // Accent bleu vif
    ImVec4 text = ImVec4(1.0f, 1.0f, 1.0f, 1.00f);                // Texte plus blanc
    ImVec4 text_dim = ImVec4(0.70f, 0.70f, 0.70f, 1.00f);
    
    // Ajustements de style généraux
    style.WindowPadding = ImVec2(4.0f, 4.0f);       // Moins de padding dans les fenêtres
    style.FramePadding = ImVec2(4.0f, 3.0f);        // Moins de padding dans les cadres
    style.ItemSpacing = ImVec2(4.0f, 3.0f);         // Moins d'espace entre les widgets
    style.ItemInnerSpacing = ImVec2(3.0f, 3.0f);    // Moins d'espace interne
    style.DisplayWindowPadding = ImVec2(0.0f, 0.0f); // Pas de padding pour l'affichage
    style.DisplaySafeAreaPadding = ImVec2(0.0f, 0.0f);
    style.TouchExtraPadding = ImVec2(0.0f, 0.0f);
    style.IndentSpacing = 20.0f;
    style.ScrollbarSize = 14.0f;
    style.GrabMinSize = 10.0f;
    
    // Arrondis
    style.WindowRounding = 4.0f;
    style.ChildRounding = 4.0f;
    style.FrameRounding = 3.0f;
    style.PopupRounding = 4.0f;
    style.ScrollbarRounding = 9.0f;
    style.GrabRounding = 3.0f;
    style.TabRounding = 4.0f;
    
    // Couleurs principales
    style.Colors[ImGuiCol_Text] = text;
    style.Colors[ImGuiCol_TextDisabled] = text_dim;
    style.Colors[ImGuiCol_WindowBg] = background;
    style.Colors[ImGuiCol_ChildBg] = background_dark;
    style.Colors[ImGuiCol_PopupBg] = background_dark;
    style.Colors[ImGuiCol_Border] = ImVec4(0.25f, 0.25f, 0.27f, 1.00f);
    style.Colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
    
    // Encadrements
    style.Colors[ImGuiCol_FrameBg] = background_light;
    style.Colors[ImGuiCol_FrameBgHovered] = ImVec4(0.25f, 0.25f, 0.25f, 1.00f);
    style.Colors[ImGuiCol_FrameBgActive] = ImVec4(0.30f, 0.30f, 0.30f, 1.00f);
    
    // Titres
    style.Colors[ImGuiCol_TitleBg] = background_dark;
    style.Colors[ImGuiCol_TitleBgActive] = accent;
    style.Colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.12f, 0.12f, 0.12f, 0.90f);
    
    // Éléments de menu
    style.Colors[ImGuiCol_MenuBarBg] = background_dark;
    style.Colors[ImGuiCol_ScrollbarBg] = background_dark;
    style.Colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.40f, 0.40f, 0.40f, 1.00f);
    style.Colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);
    style.Colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.60f, 0.60f, 0.60f, 1.00f);
    
    // Boutons et interactions
    style.Colors[ImGuiCol_CheckMark] = accent_light;
    style.Colors[ImGuiCol_SliderGrab] = accent;
    style.Colors[ImGuiCol_SliderGrabActive] = accent_light;
    style.Colors[ImGuiCol_Button] = background_light;
    style.Colors[ImGuiCol_ButtonHovered] = ImVec4(0.30f, 0.30f, 0.30f, 1.00f);
    style.Colors[ImGuiCol_ButtonActive] = accent;
    
    // En-têtes et onglets
    style.Colors[ImGuiCol_Header] = ImVec4(0.20f, 0.20f, 0.20f, 1.00f);
    style.Colors[ImGuiCol_HeaderHovered] = ImVec4(0.25f, 0.25f, 0.25f, 1.00f);
    style.Colors[ImGuiCol_HeaderActive] = accent;
    
    style.Colors[ImGuiCol_Separator] = ImVec4(0.28f, 0.28f, 0.28f, 1.00f);
    style.Colors[ImGuiCol_SeparatorHovered] = ImVec4(0.45f, 0.45f, 0.45f, 1.00f);
    style.Colors[ImGuiCol_SeparatorActive] = accent;
    
    style.Colors[ImGuiCol_Tab] = background_dark;
    style.Colors[ImGuiCol_TabHovered] = accent;
    style.Colors[ImGuiCol_TabActive] = accent;
    style.Colors[ImGuiCol_TabUnfocused] = background_dark;
    style.Colors[ImGuiCol_TabUnfocusedActive] = background;
    
    // Autres éléments 
    style.Colors[ImGuiCol_DockingPreview] = accent;
    style.Colors[ImGuiCol_DockingEmptyBg] = background_light;
 
    // Charger une police avec une meilleure netteté
    ImFontConfig fontConfig;
    fontConfig.OversampleH = 2; // Suréchantillonnage horizontal
    fontConfig.OversampleV = 2; // Suréchantillonnage vertical
    fontConfig.PixelSnapH = true; // Alignement sur la grille de pixels
    fontConfig.RasterizerMultiply = 1.2f; // Légère augmentation de l'épaisseur
    io->Fonts->AddFontDefault(&fontConfig);
 
    io->Fonts->Build();
 
    // OU charger une police personnalisée (décommenter si vous avez la police)
    // io->Fonts->AddFontFromFileTTF("assets/fonts/roboto.ttf", 16.0f, &fontConfig);
    
 
    unsigned char* pixels;
    int width, height;
    io->Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
 
    // initialize the scene manager
    scene_manager_ = new scene_manager;
    if (!scene_manager_->initialize(app_.get())) {
        Logger::Get().Log("Failed to initialize scene manager", __FILE__, __LINE__, Logger::LogLevel::Error);
        return false;
    }
 
    stats_ = app_->get_stats();
 
    total_triangle_count_ = stats_->get_triangle_count_ptr();
    total_vertex_count_ = stats_->get_vertex_count_ptr();
    
    Logger::Get().Log("imgui initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
    
    return true;
}

NewFrame()

void imguiManager::NewFrame

(

)

Starts a new ImGui frame.

Definition at line 213 of file imguiManager.cpp.

{
    ImGui_ImplDX11_NewFrame();
    ImGui_ImplWin32_NewFrame();
    ImGui::NewFrame();
}

Render()

void imguiManager::Render

(

)

Renders the ImGui interface.

Definition at line 200 of file imguiManager.cpp.

{
    ImGui::Render();
 
    //app->get_direct_3d()->turn_z_buffer_off();
    //app->get_direct_3d()->enable_alpha_blending();
    
    ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
 
    //app->get_direct_3d()->disable_alpha_blending();
    //app->get_direct_3d()->turn_z_buffer_on();
}

SetApp()

void imguiManager::SetApp ( std::shared_ptr< application_class > app )

inline

Set the application class pointer for the ImGui manager.

Parameters

app

Definition at line 142 of file imguiManager.h.

{ app_ = app; }

SetupDockspace()

void imguiManager::SetupDockspace

(

)

Sets up the ImGui dockspace. This function creates a dockspace for the ImGui interface.

Definition at line 220 of file imguiManager.cpp.

                                  {
    // Configuration du style pour supprimer l'espace autour des fenêtres dockées
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
    
    // Configuration du style pour les nœuds de dock
    ImGui::PushStyleVar(ImGuiStyleVar_DockingSeparatorSize, 1.0f); // Réduit l'épaisseur des séparateurs
    
    // Configuration de la fenêtre principale
    ImGuiWindowFlags window_flags = ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoDocking;
    ImGuiViewport* viewport = ImGui::GetMainViewport();
    ImGui::SetNextWindowPos(viewport->Pos);
    ImGui::SetNextWindowSize(viewport->Size);
    ImGui::SetNextWindowViewport(viewport->ID);
    window_flags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove;
    window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus;
 
    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0, 0, 0, 0));
    
    ImGui::Begin("DockSpace", nullptr, window_flags);
    
    // Pop des styles après avoir créé la fenêtre principale
    ImGui::PopStyleVar(4); // 4 car nous avons poussé 4 variables de style
    ImGui::PopStyleColor();
 
    // Configuration du DockSpace
    ImGuiID dockspace_id = ImGui::GetID("MainDockSpace");
    ImGuiDockNodeFlags dockspace_flags = ImGuiDockNodeFlags_PassthruCentralNode;
    ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), dockspace_flags);
 
    if (ImGui::BeginMenuBar()) {
        if (ImGui::BeginMenu("Windows")) {
            ImGui::MenuItem("Object Window", NULL, &showObjectWindow);
            ImGui::MenuItem("Terrain Window", NULL, &showTerrainWindow);
            ImGui::MenuItem("Light Window", NULL, &showLightWindow);
            ImGui::MenuItem("Engine Settings Window", NULL, &showEngineSettingsWindow);
            ImGui::MenuItem("Log Window", NULL, &showLogWindow);
            ImGui::MenuItem("render Stats", NULL, &showStatsWindow);
            ImGui::EndMenu();
        }
 
        if (ImGui::BeginMenu("Scene")) {
            if (ImGui::MenuItem("Save Scene")) {
                scene_manager_->save_scene();
            }
            if (ImGui::MenuItem("Save Scene As...")) {
                scene_manager_->save_scene_as();
            }
            if (ImGui::MenuItem("Load Scene")) {
                scene_manager_->load_scene();
            }
            ImGui::EndMenu();
        }
 
        ImGui::EndMenuBar();
    }
 
    ImGui::End();
}

SetWindowSize()

void imguiManager::SetWindowSize ( ImVec2 size )

inline

set the Old scene window size.

Parameters

size

Definition at line 131 of file imguiManager.h.

{ windowSize = size; }

Shutdown()

void imguiManager::Shutdown

(

)

Shuts down the ImGui manager.

Definition at line 191 of file imguiManager.cpp.

{
    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);
}

WidgetAddObject()

void imguiManager::WidgetAddObject

(

)

Create a widget to add a button wich will add an object to the scene.

Definition at line 296 of file imguiManager.cpp.

{
    if (ImGui::CollapsingHeader("Objects"))
    {
        if (ImGui::Button("Add Cube"))
        {
            app_->add_cube();
        }
        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))
            {
                std::wstring filepath = ofn.lpstrFile;
 
                WCHAR exePath[MAX_PATH];
                GetModuleFileName(NULL,exePath,MAX_PATH);
                std::wstring exeDir = exePath;
                size_t pos = exeDir.find_last_of(L"\\/");
                if(pos != std::wstring::npos)
                {
                    exeDir = exeDir.substr(0, pos);
                }
 
                std::wstring targetDir = exeDir + L"\\Content\\Assets\\Kobject";
 
 
                DWORD ftyp = GetFileAttributesW(targetDir.c_str());
                if( ftyp == INVALID_FILE_ATTRIBUTES)
                {
                    std::wstring contentDir = exeDir + L"\\Content";
                    if (GetFileAttributes(contentDir.c_str()) == INVALID_FILE_ATTRIBUTES)
                    {
                        CreateDirectory(contentDir.c_str(), NULL);
                    }
                    std::wstring assetsDir = contentDir + L"\\Assets";
                    if (GetFileAttributes(assetsDir.c_str()) == INVALID_FILE_ATTRIBUTES)
                    {
                        CreateDirectory(assetsDir.c_str(), NULL);
                    }
                    std::wstring kobjectDir = assetsDir + L"\\Kobject";
                    if (GetFileAttributes(kobjectDir.c_str()) == INVALID_FILE_ATTRIBUTES)
                    {
                        CreateDirectory(kobjectDir.c_str(), NULL);
                    }
                }
 
                size_t posFile = filepath.find_last_of(L"\\/");
                std::wstring filename = (posFile != std::wstring::npos) ? filepath.substr(posFile + 1) : filepath;
 
                std::wstring targetPath = targetDir + L"\\" + filename;
 
                if (!CopyFile(filepath.c_str(), targetPath.c_str(), FALSE))
                {
                    // En cas d'erreur, vous pouvez gérer ici l'erreur (par exemple afficher un message)
                    MessageBox(NULL, L"Erreur lors de la copie du fichier.", L"Erreur", MB_OK);
                }
                else
                {
                    // On récupère le chemin relatif par rapport à exeDir
                    std::wstring relativePath = targetPath.substr(exeDir.size());
        
                    // Suppression du premier caractère s'il s'agit d'un antislash
                    if (!relativePath.empty() && (relativePath[0] == L'\\' || relativePath[0] == L'/'))
                    {
                        relativePath.erase(0, 1);
                    }
        
                    // Remplacer les antislashs par des slashs
                    std::replace(relativePath.begin(), relativePath.end(), L'\\', L'/');
                    app_->add_kobject(relativePath);
                }
                
            }
 
        }
        ImGui::SameLine();
        ImGui::Text("Number of cubes: %d", app_->get_entity_manager()->GetEntityCount());
    }
}

WidgetButton()

void imguiManager::WidgetButton

(

)

Creates a button widget.

Definition at line 286 of file imguiManager.cpp.

{
    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);
}

WidgetEngineSettingsWindow()

void imguiManager::WidgetEngineSettingsWindow

(

)

Create a window to display the Engine settings.

Definition at line 841 of file imguiManager.cpp.

{
    ImGui::Begin("Engine Settings", &showEngineSettingsWindow);
 
    // Begining Of General Setting
    ImGui::Text("General");
 
    // Checkbox for toggling vsync globally in the application class by calling the set_vsync function in the application class when the checkbox state changes
    bool vsync = app_->get_vsync();
    if (ImGui::Checkbox("Vsync", &vsync))
    {
        app_->set_vsync(vsync);
    }
 
    // End Of General Setting
    ImGui::Separator();
    // culling section
    ImGui::Text("Culling");
 
    // float input for frustum tolerance
    float frustumTolerance = app_->get_frustum_tolerance();
    if (ImGui::DragFloat("Frustum Tolerance", &frustumTolerance, 0.1f, 0.0f, 100.0f))
    {
        app_->set_frustum_tolerance(frustumTolerance);
    }
 
    // End Of Culling Setting
    ImGui::Separator();
 
    // physics section
    ImGui::Text("physics");
 
    // Input To set the Fixed Update Interval
    int physicsInterval = app_->get_physics_tick_rate();
    if (ImGui::InputInt("physics Tick Rate", &physicsInterval))
    {
        app_->set_physics_tick_rate(physicsInterval);
    }
 
    // Input to change the gravity on same line
    XMVECTOR gravity = app_->get_physics()->GetGravity();
    float gravityValues[3] = { XMVectorGetX(gravity), XMVectorGetY(gravity), XMVectorGetZ(gravity) };
    if (ImGui::DragFloat3("Gravity", gravityValues))
    {
        app_->get_physics()->SetGravity(XMVectorSet(gravityValues[0], gravityValues[1], gravityValues[2], 0.0f));
    }
 
    ImGui::End();
}

WidgetFPS()

void imguiManager::WidgetFPS

(

)

Shows the FPS in a widget.

WidgetLightWindow()

void imguiManager::WidgetLightWindow

(

)

Create a window to display the light settings.

Definition at line 776 of file imguiManager.cpp.

{
    ImGui::Begin("Light", &showLightWindow);
    
 
    // Sun light settings
    light_class* sunLight = app_->get_sun_light();
    // Direction input
    XMFLOAT3 direction = sunLight->GetDirection();
    float dir[3] = { direction.x, direction.y, direction.z };
    if (ImGui::DragFloat3("Sun Direction", dir))
    {
        sunLight->SetDirection(dir[0], dir[1], dir[2]);
    }
    // Color input
    XMFLOAT4 color = sunLight->GetDiffuseColor();
    float col[3] = { color.x, color.y, color.z };
    if (ImGui::ColorEdit3("Sun Color", col))
    {
        sunLight->SetDiffuseColor(col[0], col[1], col[2], 1.0f);
    }
    // Intensity input
    float intensity = sunLight->GetIntensity();
    if (ImGui::DragFloat("Sun Intensity", &intensity, 0.1f, 0.0f, 100.0f))
    {
        sunLight->SetIntensity(intensity);
    }
 
 
    ImGui::Separator();
 
    int index = 0;
 
    // Area light settings
 
    for(auto& light : app_->get_lights())
    {
        std::string headerName = "Light " + std::to_string(index);
        if (ImGui::CollapsingHeader(headerName.c_str()))
        {
            XMVECTOR position = app_->get_light_position(index);
            XMVECTOR color = app_->get_light_color(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_->set_light_position(index, XMVectorSet(pos[0], pos[1], pos[2], 0.0f));
            }
 
            if (ImGui::ColorEdit3(colLabel.c_str(), col))
            {
                app_->set_light_color(index, XMVectorSet(col[0], col[1], col[2], 0.0f));
            }
 
        }
        index++;
    };
 
    ImGui::End();
}

WidgetLogWindow()

void imguiManager::WidgetLogWindow

(

)

Create a window to display the log messages from the Logger.

Definition at line 891 of file imguiManager.cpp.

{
    ImGui::Begin("Log Window" , &showLogWindow);
 
    // 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é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();
}

WidgetObjectWindow()

void imguiManager::WidgetObjectWindow

(

)

create a window to display the object list and their properties.

Definition at line 393 of file imguiManager.cpp.

{
    ImGui::Begin("Objects", &showObjectWindow);
 
    // Obtenir toutes les entités avec un composant d'identité et de transformation
    auto entities = app_->get_entity_manager()->GetEntitiesWithComponent<ecs::IdentityComponent>();
    
    int index = 0;
    for (auto& entity : entities)
    {
        auto identity = entity->GetComponent<ecs::IdentityComponent>();
        auto transform = entity->GetComponent<ecs::TransformComponent>();
        auto render = entity->GetComponent<ecs::RenderComponent>();
        auto shader = entity->GetComponent<ecs::ShaderComponent>();
        auto physics = entity->GetComponent<ecs::PhysicsComponent>();
        
        if (identity && transform)
        {
            std::string headerName = identity->GetName() + " " + std::to_string(identity->GetId());
            if (ImGui::CollapsingHeader(headerName.c_str()))
            {
                // Position, Rotation, Scale
                XMVECTOR position = transform->GetPosition();
                XMVECTOR rotation = transform->GetRotation();
                XMVECTOR scale = transform->GetScale();
 
                float pos[3] = { XMVectorGetX(position), XMVectorGetY(position), XMVectorGetZ(position) };
                std::string posLabel = "Position##" + std::to_string(identity->GetId());
                if (ImGui::DragFloat3(posLabel.c_str(), pos))
                {
                    transform->SetPosition(XMVectorSet(pos[0], pos[1], pos[2], 0.0f));
                    transform->UpdateWorldMatrix();
                }
 
                float rot[3] = { XMVectorGetX(rotation), XMVectorGetY(rotation), XMVectorGetZ(rotation) };
                std::string rotLabel = "Rotation##" + std::to_string(identity->GetId());
                if (ImGui::DragFloat3(rotLabel.c_str(), rot))
                {
                    transform->SetRotation(XMVectorSet(rot[0], rot[1], rot[2], 0.0f));
                    transform->UpdateWorldMatrix();
                }
 
                float scl[3] = { XMVectorGetX(scale), XMVectorGetY(scale), XMVectorGetZ(scale) };
                std::string sclLabel = "Scale##" + std::to_string(identity->GetId());
                if (ImGui::DragFloat3(sclLabel.c_str(), scl))
                {
                    transform->SetScale(XMVectorSet(scl[0], scl[1], scl[2], 0.0f));
                    transform->UpdateWorldMatrix();
                }
                
                ImGui::Separator();
 
                // Textures - Seulement si le composant de rendu existe
                if (render && render->GetModel())
                {
                    // Définir les types de textures_
                    std::vector<std::string> textureCategories = {
                        "Diffuse", "Normal", "Specular", "Alpha"
                    };
 
                    std::vector<TextureType> textureTypes = {
                        TextureType::Diffuse, TextureType::Normal, 
                        TextureType::Specular, TextureType::Alpha
                    };
 
                    // Créer un espace pour afficher les textures_ avec défilement
                    std::string textureChildId = "TextureChild##" + std::to_string(identity->GetId());
                    ImGui::BeginChild(textureChildId.c_str(), ImVec2(0, 200), true, ImGuiWindowFlags_HorizontalScrollbar);
                    
                    // Pour chaque type de texture
                    for (int typeIndex = 0; typeIndex < textureCategories.size(); typeIndex++)
                    {
                        TextureType type = textureTypes[typeIndex];
                        std::string typeName = textureCategories[typeIndex];
                        
                        // Afficher le titre de la catégorie
                        std::string categoryLabel = typeName + "##" + std::to_string(identity->GetId());
                        ImGui::Text("%s:", typeName.c_str());
                        ImGui::SameLine();
 
                        // Compter combien de textures_ de ce type existent
                        int textureCount = 0;
                        while (render->GetModel()->GetTexture(type, textureCount) != nullptr)
                        {
                            textureCount++;
                        }
 
                        // Afficher toutes les textures_ existantes
                        std::string groupId = "TextureGroup_" + std::to_string(identity->GetId()) + "_" + std::to_string(typeIndex);
                        ImGui::BeginGroup();
                        for (int texIndex = 0; texIndex < textureCount; texIndex++)
                        {
                            ID3D11ShaderResourceView* texture = render->GetModel()->GetTexture(type, texIndex);
                            if (texture)
                            {
                                // ID unique pour chaque bouton de texture
                                std::string buttonId = "tex##" + std::to_string(identity->GetId()) + "_" + 
                                                    std::to_string(typeIndex) + "_" + 
                                                    std::to_string(texIndex);
                                
                                if (ImGui::ImageButton(buttonId.c_str(), (ImTextureID)texture, ImVec2(48, 48)))
                                {
                                    // Ouvrir une boîte de dialogue pour changer la texture
                                    OPENFILENAME ofn;
                                    WCHAR szFile[260] = {0};
                                    ZeroMemory(&ofn, sizeof(ofn));
                                    ofn.lStructSize = sizeof(ofn);
                                    ofn.hwndOwner = NULL;
                                    ofn.lpstrFile = szFile;
                                    ofn.nMaxFile = sizeof(szFile);
                                    ofn.lpstrFilter = L"Texture\0*.png;*.jpg;*.dds\0";
                                    ofn.nFilterIndex = 1;
                                    ofn.lpstrInitialDir = NULL;
                                    ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
 
                                    if (GetOpenFileName(&ofn))
                                    {
                                        // Changer la texture existante
                                        render->GetModel()->ChangeTexture(m_device, m_deviceContext, ofn.lpstrFile, type, texIndex);
                                    }
                                }
                                
                                // Afficher l'indice de texture et prévisualisation au survol
                                if (ImGui::IsItemHovered())
                                {
                                    ImGui::BeginTooltip();
                                    ImGui::Text("%s %d", typeName.c_str(), texIndex);
                                    ImGui::Image((ImTextureID)texture, ImVec2(192, 192));
                                    ImGui::EndTooltip();
                                }
                                
                                ImGui::SameLine();
                            }
                        }
                        
                        // Bouton pour ajouter une nouvelle texture
                        std::string addButtonLabel = "+##" + std::to_string(identity->GetId()) + "_" + std::to_string(typeIndex);
                        if (ImGui::Button(addButtonLabel.c_str(), ImVec2(48, 48)))
                        {
                            // Ouvrir une boîte de dialogue pour ajouter une texture
                            OPENFILENAME ofn;
                            WCHAR szFile[260] = {0};
                            ZeroMemory(&ofn, sizeof(ofn));
                            ofn.lStructSize = sizeof(ofn);
                            ofn.hwndOwner = NULL;
                            ofn.lpstrFile = szFile;
                            ofn.nMaxFile = sizeof(szFile);
                            ofn.lpstrFilter = L"Texture\0*.png;*.jpg;*.dds\0";
                            ofn.nFilterIndex = 1;
                            ofn.lpstrInitialDir = NULL;
                            ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
 
                            if (GetOpenFileName(&ofn))
                            {
                                // Ajouter une nouvelle texture
                                render->GetModel()->AddTexture(m_device, m_deviceContext, ofn.lpstrFile, type);
                            }
                        }
                        
                        ImGui::EndGroup();
                        ImGui::Separator();
                    }
                    
                    ImGui::EndChild();
                }
 
                ImGui::Separator();
 
                // Delete button
                std::string deleteLabel = "Delete##" + std::to_string(identity->GetId());
                if (ImGui::Button(deleteLabel.c_str()))
                {
                    app_->delete_entity_by_id(identity->GetId());
                    // Sortir du boucle après suppression pour éviter des accès invalides
                    break;
                }
 
                ImGui::Separator();
 
                // Shader options
                if (shader)
                {
                    // Liste des options de shader
                    const char* shaderOptions[] = {
                        "Enable Global Lighting",
                        "Enable Lighting",
                        "Enable Cel Shading",
                        "Enable Normal Mapping",
                        "Enable Specular Mapping",
                        "Enable Alpha Mapping"
                    };
                    
                    std::vector<ecs::ShaderType> shaderTypes = {
                        ecs::ShaderType::SUNLIGHT,
                        ecs::ShaderType::LIGHTING,
                        ecs::ShaderType::CEL_SHADING,
                        ecs::ShaderType::NORMAL_MAPPING,
                        ecs::ShaderType::SPECULAR_MAPPING,
                        ecs::ShaderType::ALPHA_MAPPING
                    };
 
                    // Trouver l'index actuel du shader pour cette entité spécifique
                    int currentShader = 0;
                    ecs::ShaderType activeShader = shader->GetActiveShader();
                    for (size_t i = 0; i < shaderTypes.size(); i++)
                    {
                        if (shaderTypes[i] == activeShader)
                        {
                            currentShader = static_cast<int>(i);
                            break;
                        }
                    }
 
                    // Création du menu déroulant avec un ID unique pour chaque entité
                    std::string shaderComboId = "Shader Options##" + std::to_string(identity->GetId());
                    if (ImGui::BeginCombo(shaderComboId.c_str(), shaderOptions[currentShader]))
                    {
                        for (int i = 0; i < IM_ARRAYSIZE(shaderOptions); i++)
                        {
                            // Crée une option sélectionnable pour chaque shader avec ID unique
                            std::string shaderSelectableId = std::to_string(i) + "##shader_" + std::to_string(identity->GetId());
                            bool isSelected = (currentShader == i);
                            if (ImGui::Selectable(shaderOptions[i], isSelected))
                            {
                                // Met à jour l'option sélectionnée uniquement pour cette entité
                                currentShader = i;
                                shader->SetActiveShader(shaderTypes[i]);
                            }
 
                            // Si l'option sélectionnée est active, nous mettons en surbrillance
                            if (isSelected)
                                ImGui::SetItemDefaultFocus();
                        }
                        ImGui::EndCombo();
                    }
                }
                
                ImGui::Separator();
 
                // Physics
                bool isPhysicsEnabled = (physics != nullptr);
                std::string physicsLabel = "Physics##" + std::to_string(identity->GetId());
                
                if (ImGui::Checkbox(physicsLabel.c_str(), &isPhysicsEnabled)) 
                {
                    if (isPhysicsEnabled && !physics)
                    {
                        // Ajouter un composant de physique
                        physics = entity->AddComponent<ecs::PhysicsComponent>();
                        physics->Initialize();
                    }
                    else if (!isPhysicsEnabled && physics)
                    {
                        // Retirer le composant de physique
                        entity->RemoveComponent<ecs::PhysicsComponent>();
                        physics = nullptr;
                    }
                }
 
                if (physics)
                {
                    // Gravity Enabled checkbox
                    bool gravityEnabled = physics->IsGravityEnabled();
                    std::string gravityLabel = "Gravity##" + std::to_string(identity->GetId());
                    if (ImGui::Checkbox(gravityLabel.c_str(), &gravityEnabled))
                    {
                        physics->SetGravityEnabled(gravityEnabled);
                    }
 
                    // 3 radio buttons pour le type d'objet physique avec IDs uniques
                    std::string typeLabel = "Type##" + std::to_string(identity->GetId());
                    ecs::ObjectType type = identity->GetType();
 
                    if (ImGui::RadioButton(("None##" + std::to_string(identity->GetId())).c_str(), 
                        type == ecs::ObjectType::Unknown))
                    {
                        identity->SetType(ecs::ObjectType::Unknown);
                    }
                    ImGui::SameLine();
                    if (ImGui::RadioButton(("Cube##" + std::to_string(identity->GetId())).c_str(), 
                        type == ecs::ObjectType::Cube))
                    {
                        identity->SetType(ecs::ObjectType::Cube);
                    }
                    ImGui::SameLine();
                    if (ImGui::RadioButton(("Sphere##" + std::to_string(identity->GetId())).c_str(), 
                        type == ecs::ObjectType::Sphere))
                    {
                        identity->SetType(ecs::ObjectType::Sphere);
                    }
                    ImGui::SameLine();
                    if (ImGui::RadioButton(("Terrain##" + std::to_string(identity->GetId())).c_str(), 
                        type == ecs::ObjectType::Terrain))
                    {
                        identity->SetType(ecs::ObjectType::Terrain);
                    }
 
                }
 
                ImGui::Separator();
            }
            index++;
        }
    }
    
    ImGui::End();
}

WidgetRenderStats()

void imguiManager::WidgetRenderStats

(

)

Create a window to display the stats of the engine. This includes FPS, draw calls, triangle count, etc. As well as the GPU, CPU information and RAM information.

Definition at line 1018 of file imguiManager.cpp.

{
    ImGui::Begin("render Stats");
 
    current_fps_ = stats_->get_current_fps();
    min_fps_ = stats_->get_min_fps();
    max_fps_ = stats_->get_max_fps();
    draw_calls_ = stats_->get_draw_calls();
 
    
    // total_vertex_count_ = stats_->get_total_vertex_count();
    // total_triangle_count_ = stats_->get_total_triangle_count();
    
    visible_triangle_count_ = stats_->get_visible_triangle_count();
    current_frame_time_ = stats_->get_frame_time();
    
    m_frameTimeHistory[m_frameTimeHistoryIndex] = current_frame_time_;
    m_frameTimeHistoryIndex = (m_frameTimeHistoryIndex + 1) % FRAME_HISTORY_COUNT;
 
    ImGui::Text("FPS: %d", current_fps_);
    ImGui::SameLine();
    ImGui::Text("Min Fps: %d", min_fps_);
    ImGui::SameLine();
    ImGui::Text("Max Fps: %d", max_fps_);
 
    ImGui::Separator();
 
    // Trouver les valeurs min/max pour l'échelle du graphique
    float frameTimeMin = FLT_MAX;
    float frameTimeMax = 0.0f;
    for (int i = 0; i < FRAME_HISTORY_COUNT; i++) {
        if (m_frameTimeHistory[i] > 0.0f) {
            frameTimeMin = min(frameTimeMin, m_frameTimeHistory[i]);
            frameTimeMax = max(frameTimeMax, m_frameTimeHistory[i]);
        }
    }
    // S'assurer d'avoir au moins une petite plage
    if (frameTimeMax == 0.0f) frameTimeMax = 0.033f; // ~30 FPS
    if (frameTimeMin == FLT_MAX) frameTimeMin = 0.0f;
    
    // Ajouter 10% de marge pour la lisibilité
    float margin = (frameTimeMax - frameTimeMin) * 0.1f;
    frameTimeMin = max(0.0f, frameTimeMin - margin);
    frameTimeMax += margin;
 
    // Afficher le graphique
    ImGui::Text("Frame Time: %.3f ms", current_frame_time_ * 1000.0f);
    ImGui::PlotLines("FrameTimeGraph", // Au lieu de chaîne vide ""
                 m_frameTimeHistory, 
                 FRAME_HISTORY_COUNT, 
                 m_frameTimeHistoryIndex, 
                 "", 
                 frameTimeMin, 
                 frameTimeMax, 
                 ImVec2(0, 80));
 
    ImGui::Text("Draw Calls: %d", draw_calls_);
 
    ImGui::Separator();
 
    ImGui::Text("Statistiques de rendu:");
    ImGui::Text("Vertices total: %d", *total_vertex_count_);
 
    ImGui::Text("Triangles total: %d", *total_triangle_count_);
    ImGui::SameLine();
    ImGui::Text("Triangles visibles: %d", visible_triangle_count_);
 
    app_->get_direct_3d()->get_video_card_info(card_name_, video_memory_);
    cpu_name_ = stats_->get_cpu_name();
    version_driver_ = stats_->get_gpu_driver_version(app_->get_direct_3d()->get_device());
    
    ImGui::Columns(3, "GPUCPURAMColumns", false);
    ImGui::SetColumnWidth(0, ImGui::GetWindowWidth() * 0.33f);
    ImGui::SetColumnWidth(1, ImGui::GetWindowWidth() * 0.33f);
 
    // Premier collapsing header pour les informations GPU
    if (ImGui::CollapsingHeader("Informations GPU"))
    {
        ImGui::Text("Carte graphique: %s", card_name_);
        ImGui::Text("Memoire video: %d Mo", video_memory_);
        ImGui::Text("Pilote: %s", version_driver_.c_str());
    }
 
    ImGui::NextColumn();
 
    // Second collapsing header pour les informations CPU
    if (ImGui::CollapsingHeader("Informations CPU"))
    {
        SYSTEM_INFO sysInfo;
        GetSystemInfo(&sysInfo);
        ImGui::Text("Processeur: %s", cpu_name_.c_str());
        ImGui::Text("Nombre de coeurs: %u", sysInfo.dwNumberOfProcessors);
        ImGui::Text("Architecture: %s", (sysInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) ? "x64" : "x86");
        ImGui::Text("Taille de la page: %u octets", sysInfo.dwPageSize);
        ImGui::Text("Taille du cache: %u octets", sysInfo.dwAllocationGranularity);
        ImGui::Text("Type de processeur: %u", sysInfo.wProcessorLevel);
        ImGui::Text("Version du processeur: %u", sysInfo.wProcessorRevision);
    }
 
    ImGui::NextColumn();
 
    if (ImGui::CollapsingHeader("Informations RAM"))
    {
        MEMORYSTATUSEX mem_info;
        mem_info.dwLength = sizeof(MEMORYSTATUSEX);
        GlobalMemoryStatusEx(&mem_info);
        ImGui::Text("Memoire totale: %llu Mo", mem_info.ullTotalPhys / (1024 * 1024));
        ImGui::Text("Memoire disponible: %llu Mo", mem_info.ullAvailPhys / (1024 * 1024));
        ImGui::Text("Memoire utilisee: %llu Mo", (mem_info.ullTotalPhys - mem_info.ullAvailPhys) / (1024 * 1024));
    }
 
    ImGui::Columns(1);
 
    ImGui::End();
}

WidgetRenderWindow()

void imguiManager::WidgetRenderWindow

(

ImVec2

availableSize

)

Create a window to display the scene. This window isn't used anymore.

Definition at line 972 of file imguiManager.cpp.

{
    ImGui::Begin("render Window");
 
    ImVec2 oldWindowSize = windowSize;
    windowSize = ImGui::GetContentRegionAvail();
    
    // Si la taille de la fenêtre a changé, ajustez la taille de la fenêtre de l'application
    if (oldWindowSize.x != windowSize.x || oldWindowSize.y != windowSize.y)
    {
        app_->set_window_size(windowSize);
    }
    
 
    // Get the aspect ratio of the scene in app
    float aspectRatio = app_->get_aspect_ratio();
    // calculate the size of the window
    if (windowSize.x / windowSize.y > aspectRatio)
    {
        windowSize.x = windowSize.y * aspectRatio;
    }
    else
    {
        windowSize.y = windowSize.x / aspectRatio;
    }
    
    ID3D11ShaderResourceView* texture = app_->get_scene_texture()->GetShaderResourceView();
    if (texture)
    {
        
        // Affichez la scenne projeté sur texture dans une fenêtre ImGui
        // alpha blend is not enable to render the texture
 
        app_->get_direct_3d()->turn_z_buffer_off();
        app_->get_direct_3d()->enable_alpha_blending();
        
        ImGui::Image((ImTextureID)texture, windowSize, ImVec2(0, 0), ImVec2(1, 1), ImVec4(1, 1, 1, 1));
    }
    else
    {
        ImGui::Text("render texture is not available.");
    }
 
    ImGui::End();
}

WidgetSpeedSlider()

void imguiManager::WidgetSpeedSlider

(

float *

speed

)

Creates a slider widget to control the speed of the demo spinning cube.

Parameters

speed

Definition at line 281 of file imguiManager.cpp.

{
    ImGui::SliderFloat("Speed", speed, 0.0f, 100.0f);
}

WidgetTerrainWindow()

void imguiManager::WidgetTerrainWindow

(

)

Create a window to display the terrain generation options.

Definition at line 701 of file imguiManager.cpp.

{
    ImGui::Begin("Terrain", &showTerrainWindow);
 
    ImGui::Text("Number of terrain cubes: %d", app_->get_terrain_entity_count());
 
    ImGui::Separator();
 
    if (ImGui::Button("Generate Flat Terrain"))
    {
        app_->generate_terrain();
    }
    
    ImGui::Separator();
 
    // Input for the number of cubes on each side
    ImGui::Text("Number of cubes on each side: ");
    ImGui::SameLine();
    ImGui::InputInt("##SideCount", &m_SideCount);
    if (m_SideCount < 1)
    {
        m_SideCount = 1;
    }
    
    ImGui::Separator();
 
    if (ImGui::Button("Generate BigCube Terrain"))
    {
        app_->create_big_cube(m_SideCount);
    }
 
    ImGui::Separator();
 
    if (ImGui::Button("Delete All Terrain Cubes"))
    {
        app_->delete_terrain();
    }
 
 
    
    ImGui::End();
}

Member Data Documentation

m_EnableCelShading

bool imguiManager::m_EnableCelShading

Definition at line 146 of file imguiManager.h.

---

The documentation for this class was generated from the following files:

• enginecustom/src/inc/system/imguiManager.h
• enginecustom/src/src/system/imguiManager.cpp