.. _program_listing_file_Src_GraphicsEngineOpenGL_gui_GUI.cpp:

Program Listing for File GUI.cpp
================================

|exhale_lsh| :ref:`Return to documentation for file <file_Src_GraphicsEngineOpenGL_gui_GUI.cpp>` (``Src/GraphicsEngineOpenGL/gui/GUI.cpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #include "gui/GUI.hpp"
   
   #include <imgui.h>
   #include <imgui_impl_glfw.h>
   #include <imgui_impl_opengl3.h>
   
   #include <filesystem>
   #include <sstream>
   
   #include "hostDevice/host_device_shared.hpp"
   #include "renderer/OpenGLRendererConfig.hpp"
   #include "scene/atmospheric_effects/clouds/Clouds.hpp"
   #include "scene/texture/RepeatMode.hpp"
   
   GUI::GUI()
   {
       // give some arbitrary values; we will update these values after 1 frame :)
       this->direcional_light_radiance = 4.0f;
   
       this->directional_light_color[0] = 1;
       this->directional_light_color[1] = 1;
       this->directional_light_color[2] = 1;
   
       this->directional_light_direction[0] = -0.1f;
       this->directional_light_direction[1] = -1.f;
       this->directional_light_direction[2] = -0.1f;
   
       this->cloud_speed = 6;
       this->cloud_scale = 0.63f;
       this->cloud_density = 0.493f;
       this->cloud_pillowness = 0.966f;
       this->cloud_cirrus_effect = 0.034f;
   
       this->cloud_mesh_scale[0] = 1000.f;
       this->cloud_mesh_scale[1] = 5.f;
       this->cloud_mesh_scale[2] = 1000.f;
   
       this->cloud_mesh_offset[0] = -.364f;
       this->cloud_mesh_offset[1] = 367.f;
       this->cloud_mesh_offset[2] = -18.351f;
   
       this->cloud_powder_effect = true;
   
       this->cloud_movement_direction[0] = 1.f;
       this->cloud_movement_direction[1] = 1.f;
       this->cloud_movement_direction[2] = 1.f;
   
       this->cloud_num_march_steps = 8;
       this->cloud_num_march_steps_to_light = 3;
   
       this->shadow_map_res_index = 3;
       this->shadow_resolution_changed = false;
       this->num_shadow_cascades = NUM_CASCADES;
       this->pcf_radius = 2;
       this->cascaded_shadow_intensity = 0.65f;
   
       this->available_shadow_map_resolutions[0] = "512";
       this->available_shadow_map_resolutions[1] = "1024";
       this->available_shadow_map_resolutions[2] = "2048";
       this->available_shadow_map_resolutions[3] = "4096";
   
       std::stringstream texture_base_dir;
       std::filesystem::path cwd = std::filesystem::current_path();
       texture_base_dir << cwd.string();
       texture_base_dir << RELATIVE_RESOURCE_PATH;
       texture_base_dir << "Textures/";
   
       std::stringstream texture_logo;
       texture_logo << texture_base_dir.str() << "Loading_Screen/Engine_logo.png";
       logo_tex = Texture(texture_logo.str().c_str(), std::make_shared<RepeatMode>());
       logo_tex.load_texture_with_alpha_channel();
   }
   
   void GUI::init(std::shared_ptr<Window> main_window)
   {
       // Setup Dear ImGui context
       IMGUI_CHECKVERSION();
       ImGui::CreateContext();
       // ImGuiIO& io = ImGui::GetIO();
       const ImGuiStyle &style = ImGui::GetStyle();
       // Setup Platform/Renderer bindings
       ImGui_ImplGlfw_InitForOpenGL(main_window->get_window(), false);
       const char *glsl_version = "#version 460";
       ImGui_ImplOpenGL3_Init(glsl_version);
       // Setup Dear ImGui style
       ImGui::StyleColorsDark();
       ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 10);
       ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 10);
       ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1);
   }
   
   void GUI::render(bool loading_in_progress, float progress, bool &shader_hot_reload_triggered)
   {
       // feed inputs to dear imgui, start new frame
       // UI.start_new_frame();
       ImGui_ImplOpenGL3_NewFrame();
       ImGui_ImplGlfw_NewFrame();
       ImGui::NewFrame();
       // render your GUI
       ImGui::Begin("GUI v1.3.3");
   
       if (loading_in_progress) {
           ImGui::ProgressBar(progress, ImVec2(0.0f, 0.0f));
           ImGui::SameLine(0.0f, ImGui::GetStyle().ItemInnerSpacing.x);
           ImGui::Text("Loading scene");
           ImGui::Separator();
       }
   
       if (ImGui::CollapsingHeader("Hot shader reload")) {
           if (ImGui::Button("Hot reload ALL shaders!")) { shader_hot_reload_triggered = true; }
       }
   
       ImGui::Separator();
   
       if (ImGui::CollapsingHeader("Graphic Settings")) {
           if (ImGui::TreeNode("Directional Light")) {
               ImGui::Separator();
               ImGui::SliderFloat("Radiance", &direcional_light_radiance, 0.0f, 50.0f);
               ImGui::Separator();
               // Edit a color (stored as ~4 floats)
               ImGui::ColorEdit3("Directional Light Color", directional_light_color);
               ImGui::Separator();
               ImGui::SliderFloat3("Light Direction", directional_light_direction, -1.f, 1.0f);
   
               if (ImGui::TreeNode("Shadows")) {
                   int shadow_map_res_index_before = shadow_map_res_index;
                   ImGui::Combo("Shadow Map Resolution",
                     &shadow_map_res_index,
                     available_shadow_map_resolutions,
                     IM_ARRAYSIZE(available_shadow_map_resolutions));
                   if (shadow_map_res_index_before != shadow_map_res_index) shadow_resolution_changed = true;
   
                   int num_cascades_before = num_shadow_cascades;
                   ImGui::SliderInt("# cascades", &num_shadow_cascades, NUM_MIN_CASCADES, NUM_CASCADES);
                   if (num_cascades_before != num_shadow_cascades) shadow_resolution_changed = true;
   
                   ImGui::SliderInt("PCF radius", &pcf_radius, 1, 20);
                   ImGui::SliderFloat("Shadow intensity", &cascaded_shadow_intensity, 0.0f, 1.0f);
   
                   ImGui::TreePop();
               }
   
               ImGui::TreePop();
           }
   
           if (ImGui::TreeNode("Cloud Settings")) {
               ImGui::SliderInt("Speed", &cloud_speed, 0, 30);
               ImGui::SliderInt("# march steps", &cloud_num_march_steps, 1, 128);
               ImGui::SliderInt("# march steps to light", &cloud_num_march_steps_to_light, 1, 128);
               ImGui::SliderFloat3("Movement Direction", cloud_movement_direction, -10.f, 10.0f);
               ImGui::SliderFloat("Illumination intensity", &cloud_scale, 0.f, 1.0f);
               ImGui::SliderFloat("Density", &cloud_density, 0.f, 1.0f);
               ImGui::SliderFloat("Pillowness", &cloud_pillowness, 0.f, 1.0f);
               ImGui::SliderFloat("Cirrus effect", &cloud_cirrus_effect, 0.f, 1.0f);
               ImGui::Checkbox("Powder effect", &cloud_powder_effect);
               ImGui::SliderFloat3("Scale", cloud_mesh_scale, 0.f, 1000.0f);
               ImGui::SliderFloat3("Translation", cloud_mesh_offset, -200.f, 400.0f);
   
               ImGui::TreePop();
           }
       }
   
       ImGui::Separator();
   
       /*if (ImGui::CollapsingHeader("Audio Settings")) {
   
             ImGui::SliderFloat("Volume", &sound_volume, 0.0f, 1.0f);
   
         }*/
   
       ImGui::Separator();
   
       if (ImGui::CollapsingHeader("GUI Settings")) {
           ImGuiStyle &style = ImGui::GetStyle();
           if (ImGui::SliderFloat("Frame Rounding", &style.FrameRounding, 0.0f, 12.0f, "%.0f")) {
               style.GrabRounding = style.FrameRounding;// Make GrabRounding always the
                                                        // same value as FrameRounding
           }
           {
               bool border = (style.FrameBorderSize > 0.0f);
               if (ImGui::Checkbox("FrameBorder", &border)) { style.FrameBorderSize = border ? 1.0f : 0.0f; }
           }
           ImGui::SliderFloat("WindowRounding", &style.WindowRounding, 0.0f, 12.0f, "%.0f");
       }
   
       ImGui::Separator();
   
       if (ImGui::CollapsingHeader("KEY Bindings")) {
           ImGui::Text("WASD for moving Forward, backward and to the side\n QE for rotating ");
       }
   
       ImGui::Separator();
   
       ImGui::Text(
         "Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
       // ImGui::ShowDemoWindow();
       // (void*)(intptr_t)
       ImGui::Image(logo_tex.get_id(), ImVec2(200, 200), ImVec2(0, 1), ImVec2(1, 0));
   
       ImGui::End();
   
       // feed inputs to dear imgui, start new frame
       ImGui::Render();
       ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
   }
   
   void GUI::update_user_input(std::shared_ptr<Scene> scene)
   {
       std::shared_ptr<DirectionalLight> main_light = scene->get_sun();
       main_light->set_radiance(direcional_light_radiance);
       main_light->get_shadow_map()->set_intensity(cascaded_shadow_intensity);
       main_light->get_shadow_map()->set_pcf_radius(pcf_radius);
   
       glm::vec3 new_main_light_color(directional_light_color[0], directional_light_color[1], directional_light_color[2]);
   
       main_light->set_color(new_main_light_color);
   
       glm::vec3 new_main_light_pos(
         directional_light_direction[0], directional_light_direction[1], directional_light_direction[2]);
   
       main_light->set_direction(new_main_light_pos);
   
       glm::vec3 cloud_move(cloud_movement_direction[0], cloud_movement_direction[1], cloud_movement_direction[2]);
   
       std::shared_ptr<Clouds> clouds = scene->get_clouds();
   
       clouds->set_movement_direction(cloud_move);
       clouds->set_movement_speed(static_cast<float>(cloud_speed));
       clouds->set_density(cloud_density);
       clouds->set_scale(cloud_scale);
       clouds->set_pillowness(cloud_pillowness);
       clouds->set_cirrus_effect(cloud_cirrus_effect);
       clouds->set_powder_effect(cloud_powder_effect);
   
       clouds->set_scale(glm::vec3(cloud_mesh_scale[0], cloud_mesh_scale[1], cloud_mesh_scale[2]));
   
       clouds->set_translation(glm::vec3(cloud_mesh_offset[0], cloud_mesh_offset[1], cloud_mesh_offset[2]));
   
       GLfloat shadow_map_resolution = 4096.f;
   
       if (shadow_resolution_changed) {
           switch (shadow_map_res_index) {
           case 0:
               shadow_map_resolution = 512.f;
               break;
           case 1:
               shadow_map_resolution = 1024.f;
               break;
           case 2:
               shadow_map_resolution = 2048.f;
               break;
           case 3:
               shadow_map_resolution = 4096.f;
           }
   
           main_light->update_shadow_map(shadow_map_resolution, shadow_map_resolution, NUM_CASCADES);
   
           shadow_resolution_changed = false;
       }
   }
   
   GUI::~GUI()
   {
       ImGui_ImplOpenGL3_Shutdown();
       ImGui_ImplGlfw_Shutdown();
       ImGui::DestroyContext();
   }