[Feat] (MG_State/Program, MG_Impl/Program): skeleton and initial impl of program/shader state machine

MobileGL/MG_State/GLState/ProgramState/ProgramObject.cpp

@@ -0,0 +1,51 @@
+#include "../../../Includes.h"
+
+namespace MobileGL {
+    namespace MG_State {
+        namespace GLState {
+            void ProgramObject::AttachShader(SharedPtr<ShaderObject> shader) {
+                m_shaders.emplace_back(shader);
+            }
+
+            void ProgramObject::DetachShader(SharedPtr<ShaderObject> shader) {
+                auto count = std::erase_if(m_shaders,
+                    [shader](const SharedPtr<ShaderObject>& s) {
+                        return s.get() == shader.get();
+                    });
+
+                if (count == 0) {
+                    // FIXME: handle error here
+                    THROW_EXCEPTION("Program object does not have such shader object attached");
+                }
+            }
+
+            void ProgramObject::Link() {
+                Vector<GLenum> shaderTypes(m_shaders.size());
+                Vector<SharedPtr<glslang::TShader>> shaders(m_shaders.size());
+                for (SizeT i = 0; i < m_shaders.size(); i++) {
+                    shaderTypes[i] = GetGLShaderTypeByMGLShaderStage(m_shaders[i]->m_stage);
+                    shaders[i] = m_shaders[i]->m_shader;
+                }
+
+                MG_Util::ShaderTranspiler::ProgramAttrib attrib {
+                    .shaderTypes = Move(shaderTypes),
+                    .shaders = Move(shaders),
+                };
+
+                auto result = MG_Util::ShaderTranspiler::ShaderCompiler::LinkProgram(attrib);
+                if (result) {
+                    m_linkStatus = true;
+                    m_programBinary = Move(result.value());
+                } else {
+                    m_linkStatus = false;
+                    m_infoLog = result.error().log;
+
+                    const std::string e =
+                        std::format("Shader link failed: \nerrc: {}\nmsg: {}\n",
+                            result.error().errc, result.error().log);
+                    THROW_EXCEPTION(e);
+                }
+            }
+        }
+    }
+}

MobileGL/MG_State/GLState/ProgramState/ProgramObject.h

@@ -0,0 +1,23 @@
+#pragma once
+#include "MG_Util/Types.h"
+
+namespace MobileGL {
+	namespace MG_State {
+		namespace GLState {
+			class ProgramObject {
+			public:
+				void AttachShader(SharedPtr<ShaderObject> shader);
+				void DetachShader(SharedPtr<ShaderObject> shader);
+				void Link();
+			private:
+				Vector<SharedPtr<ShaderObject>> m_shaders;
+				// basically this contains SPIR-V in binary format
+				Vector<Vector<Uint>> m_programBinary;
+				String m_infoLog;
+				bool m_deleteStatus = false;
+				bool m_linkStatus = true;
+				bool m_validateStatus = true;
+			};
+		}
+	}
+}

MobileGL/MG_State/GLState/ProgramState/ProgramState.cpp

@@ -0,0 +1,27 @@
+#include "../../../Includes.h"
+
+namespace MobileGL {
+    namespace MG_State {
+        namespace GLState {
+            Uint ProgramState::CreateProgram() {
+                Uint programId = 0;
+                m_indexGenerator.Generate(1, &programId);
+                EnsureIndexAvail(programId);
+                m_programObjects[programId] = MakeShared<ProgramObject>();
+                return programId;
+            }
+
+            SharedPtr<ProgramObject> ProgramState::GetProgramObject(Uint id) {
+                if (!CheckIndexAvail(id))
+                    return nullptr; // FIXME: add error reporting here
+                return m_programObjects[id];
+            }
+
+            void ProgramState::DeleteProgram(Uint id) {
+                if (!CheckIndexAvail(id))
+                    return; // FIXME: add error reporting here
+                m_programObjects[id].reset();
+            }
+        }
+    }
+}

MobileGL/MG_State/GLState/ProgramState/ProgramState.h

@@ -0,0 +1,30 @@
+#pragma once
+
+namespace MobileGL {
+    namespace MG_State {
+        namespace GLState {
+            class ProgramState {
+            public:
+                // This function WILL actually create the program object.
+                // To retrieve created program object, use GetProgramObject()
+                Uint CreateProgram();
+                SharedPtr<ProgramObject> GetProgramObject(Uint id);
+                void DeleteProgram(Uint program);
+            private:
+                bool CheckIndexAvail(SizeT idx) {
+                    return idx < m_programObjects.size();
+                }
+
+                void EnsureIndexAvail(SizeT idx) {
+                    if (CheckIndexAvail(idx)) return;
+
+                    m_programObjects.reserve(std::bit_ceil(idx));
+                    m_programObjects.resize(idx + 1);
+                }
+
+                IndexGenerator<Uint> m_indexGenerator;
+                Vector<SharedPtr<ProgramObject>> m_programObjects;
+            };
+        }
+    }
+}

MobileGL/MG_State/GLState/ProgramState/ShaderObject.cpp

@@ -0,0 +1,34 @@
+#include "../../../Includes.h"
+
+namespace MobileGL {
+    namespace MG_State {
+        namespace GLState {
+            void ShaderObject::SetShaderSource(const std::string& source) {
+                m_source = source;
+            }
+
+            void ShaderObject::Compile() {
+                using namespace MG_Util::ShaderTranspiler;
+                ShaderAttrib attrib {
+                    .sourceStr =  m_source,
+                    .shaderType = GetGLShaderTypeByMGLShaderStage(m_stage),
+                    .flags = 0
+                };
+
+                auto result = ShaderCompiler::CompileShader(attrib);
+                if (result) {
+                    m_compileStatus = true;
+                    m_shader = result.value();
+                } else {
+                    m_compileStatus = false;
+                    m_infoLog = result.error().log;
+
+                    const std::string e =
+                        std::format("Shader compilation failed: \nerrc: {}\nmsg: {}\n",
+                            result.error().errc, result.error().log);
+                    THROW_EXCEPTION(e);
+                }
+            }
+        }
+    }
+}

MobileGL/MG_State/GLState/ProgramState/ShaderObject.h

@@ -0,0 +1,52 @@
+#pragma once
+#include "MG_Util/Types.h"
+
+namespace MobileGL {
+    namespace MG_State {
+        namespace GLState {
+            enum class ShaderStage {
+                Vertex,
+                TessControl,
+                TessEval,
+                Geometry,
+                Fragment,
+                Compute
+            };
+
+            inline static GLenum GetGLShaderTypeByMGLShaderStage(ShaderStage stage) {
+                switch (stage) {
+                    case ShaderStage::Vertex:
+                        return GL_VERTEX_SHADER;
+                    case ShaderStage::TessControl:
+                        return GL_TESS_CONTROL_SHADER;
+                    case ShaderStage::TessEval:
+                        return GL_TESS_EVALUATION_SHADER;
+                    case ShaderStage::Geometry:
+                        return GL_GEOMETRY_SHADER;
+                    case ShaderStage::Fragment:
+                        return GL_FRAGMENT_SHADER;
+                    case ShaderStage::Compute:
+                        return GL_COMPUTE_SHADER;
+                    default:
+                        assert(false);
+                        return 0;
+                }
+            }
+
+            class ShaderObject {
+            public:
+                ShaderObject(const ShaderStage stage): m_stage(stage) {}
+                void SetShaderSource(const std::string& source);
+                void Compile();
+
+                const ShaderStage m_stage;
+                std::string m_source;
+                SharedPtr<glslang::TShader> m_shader;
+                std::string m_infoLog;
+
+                bool m_deleteStatus = false;
+                bool m_compileStatus = false;
+            };
+        }
+    }
+}