opengl_shader_editor.hpp

Go to the documentation of this file.

#pragma once
 
#include "../../debug_ui.h"
 
namespace Blam::DebugUI::Windows
{
    class GLShaderEditor : public Blam::DebugUI::ImGUIDrawingGroup
    {
    private:
        /*BlamGLSLShaderProgram* active_program = NULL;
 
        void GenerateUniformControl(BlamGLSLShaderUniform* uniform)
        {
            switch (uniform->GetType())
            {
                case BlamShaderUniformType::U_Float1:
                {
                    BlamShaderUniform1F* uniform_1f = (BlamShaderUniform1F*)uniform;
                    ImGui::DragFloat(uniform->GetName().c_str(), &uniform_1f->x);
                    break;
                }
                default:
                {
                    ImGui::TextColored(ImVec4(1, 0, 0, 1), std::string("unsupported uniform type, cannot modify uniform '" + uniform->GetName() + "'").c_str());
                    break;
                }
            }
        }
 
        void GenerateShaderProgramControl(BlamGLSLShaderProgram* program)
        {
            if (ImGui::BeginTabBar("shader_editor_tabs"))
            {
                if (ImGui::BeginTabItem("shader information"))
                {
                    std::string shader_id = "id: " + program->GetID();
                    std::string shader_program_id = "gl program id: " + std::to_string(program->GetGLProgramID());
 
                    ImGui::Text(shader_id.c_str());
                    ImGui::Text(shader_program_id.c_str());
 
                    ImGui::EndTabItem();
                }
 
                if (ImGui::BeginTabItem("shader settings"))
                {
                    if (ImGui::Button("update uniforms"))
                    {
                        program->UpdateUniforms();
                    }
 
                    ImGui::Separator();
 
                    if (ImGui::CollapsingHeader("uniforms"))
                    {
                        for (int i = 0; i < program->GetUniforms()->size(); i++)
                        {
                            GenerateUniformControl(program->GetUniforms()->at(i));
                        }
                    }
 
                    if (ImGui::CollapsingHeader("vertex attributes"))
                    {
                        ImGui::Text("not yet implemented");
                    }
 
                    ImGui::EndTabItem();
                }
 
                ImGui::EndTabBar();
            }
        }*/
 
    public:
        void Draw()
        {
            if (show)
            {
                if (ImGui::Begin("Shader Editor", &show))
                {
                    ImGui::Columns(2);
 
                    ImGui::SetColumnWidth(0, (200.0f * *Blam::Globals::GetGlobalAsFloat("ui_scale_factor")));
 
                    if (ImGui::ListBoxHeader("", ImVec2(ImGui::GetColumnWidth() - 15, -1)))
                    {
                        /*std::map<std::string, BlamGLSLShaderProgram*>* programs = Blam::Rendering::OpenGL::GetShaderPrograms();
                        std::map<std::string, BlamGLSLShaderProgram*>::iterator it;
 
                        for (it = programs->begin(); it != programs->end(); it++)
                        {
                            bool is_active_item = false;
 
                            if (it->second == active_program)
                            {
                                is_active_item = true;
                            }
 
                            if (ImGui::Selectable(it->second->GetID().c_str(), is_active_item))
                            {
                                active_program = it->second;
                            }
 
                            if (ImGui::IsItemHovered())
                            {
                                ImGui::BeginTooltip();
                                ImGui::PushTextWrapPos(450.0f);
                                ImGui::Text("shader information");
                                ImGui::Separator();
 
                                std::string shader_id = "id: " + it->second->GetID();
                                std::string shader_program_id = "gl program id: " + std::to_string(it->second->GetGLProgramID());
 
                                ImGui::Text(shader_id.c_str());
                                ImGui::Text(shader_program_id.c_str());
 
                                ImGui::PopTextWrapPos();
                                ImGui::EndTooltip();
                            }
                        }*/
 
                        ImGui::ListBoxFooter();
                    }
 
                    ImGui::NextColumn();
 
                    ImGui::Text("opengl shader editor is no longer usable (todo: rework this to work with bgfx shaders)");
                    /*if (!active_program)
                    {
                        ImGui::Text("select a shader to modify");
                    }
                    else
                    {
                        GenerateShaderProgramControl(active_program);
                    }*/
                }
                ImGui::End();
            }
        }
    };
}