More work to drivers

- Add gfx_test
- add texture loading to GfxOpenGL
- add full submit code
- add debug logging
- add construct and destroy functionality to Pool
- add command functionality
- add vertex and index pools to lithium (static and not threadsafe yet)
- Update GfxDriver Matrix with SetViewPort
- Add glfw (only dependency of gfx_test) maybe later required for input driver

backends/CMakeLists.txt

@@ -7,15 +7,23 @@ option(PD_ENABLE_OPENGL3 "Enable OpenGL 3.3 (On Supported Hardware)" ON)
 option(PD_ENABLE_VULKAN "Not implemented yet" OFF)
 
 add_library(pd-system STATIC
-    ${CMAKE_CURRENT_SOURCE_DIR}/source/gfx_opengl.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/source/gfx_opengl.cpp
 )
+
 target_include_directories(pd-system
-    PUBLIC
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-    $<INSTALL_INTERFACE:include>
+	PUBLIC
+		$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+		$<INSTALL_INTERFACE:include>
 )
+
+target_compile_options(pd-system
+	PUBLIC
+		-fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}/source=source
+		-fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}/include=include
+)
+
 target_link_libraries(pd-system
-    PUBLIC
-    palladium::palladium
-    glad
+	PUBLIC
+		palladium::palladium
+		glad
 )

backends/include/gfx_opengl.hpp

@@ -17,7 +17,7 @@ struct GfxOpenGLConfig {
 };
 class GfxOpenGL : public GfxDriverBase<GfxOpenGLConfig> {
  public:
-  GfxOpenGL() {}
+  GfxOpenGL(): GfxDriverBase("OpenGL2") {}
   ~GfxOpenGL() {}
 
   void SysInit() override;

backends/source/gfx_opengl.cpp

@@ -2,6 +2,9 @@
 
 #include <gfx_opengl.hpp>
 
+#include "pd/common.hpp"
+#include "pd/drivers/gfx.hpp"
+
 namespace PD {
 GLuint compileShader(const std::string& source, GLenum type) {
   GLuint shader = glCreateShader(type);
@@ -42,6 +45,8 @@ GLuint createShaderProgram(const std::string& vertexShaderSource,
   glDeleteShader(vertexShader);
   glDeleteShader(fragmentShader);
 
+  if (success) PDLOG("Shader [{}] compiled sucessfully", shaderProgram);
+
   return shaderProgram;
 }
 
@@ -118,16 +123,36 @@ void GfxOpenGL::SysInit() {
 
   glBindBuffer(GL_ARRAY_BUFFER, 0);
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+  PDLOG(
+      "GfxOpenGL::SysInit():\n  pShader = {}\n  pLocTex = {}\n  pLocAlfa = "
+      "{}\n  pLocProjection = {}\n  VBO = {}\n  IBO = {}",
+      pShader, pLocTex, pLocAlfa, pLocProjection, VBO, IBO);
 }
 
 void GfxOpenGL::SysDeinit() {
   glDeleteBuffers(1, &VBO);
   glDeleteBuffers(1, &IBO);
+  PDLOG("GfxOpenGL::SysDeinit()");
 }
 
 void GfxOpenGL::Submit(size_t count, size_t start) {
+  BindTexture(CurrentTex);
+  glUseProgram(pShader);
+  pSetupShaderAttribs(pShader);
+  glUniformMatrix4fv(pLocProjection, 1, GL_FALSE, Projection.m.data());
+  glBindBuffer(GL_ARRAY_BUFFER, VBO);
+  glBufferData(GL_ARRAY_BUFFER, CurrentVertex * sizeof(PD::Li::Vertex),
+               GetVertexBufPtr(0), GL_DYNAMIC_DRAW);
+
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
+  glBufferData(GL_ELEMENT_ARRAY_BUFFER, CurrentIndex * sizeof(PD::u16),
+               GetIndexBufPtr(0), GL_DYNAMIC_DRAW);
+
   glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_INT,
-                 (void*)GetIndexBufPtr(start));
+                 reinterpret_cast<void*>(start * sizeof(u16)));
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+  BindTexture(0);
 }
 
 void GfxOpenGL::BindTexture(TextureID id) {
@@ -139,12 +164,37 @@ void GfxOpenGL::BindTexture(TextureID id) {
   glUniform1i(pLocAlfa, fmt == GL_ALPHA);
 }
 
-void GfxOpenGL::SysReset() {}
+void GfxOpenGL::SysReset() {
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+}
 
 TextureID GfxOpenGL::LoadTexture(const std::vector<PD::u8>& pixels, int w,
                                  int h, TextureFormat type,
                                  TextureFilter filter) {
-  return 0;
+  GLuint texID;
+  glGenTextures(1, &texID);
+  glBindTexture(GL_TEXTURE_2D, texID);
+
+  // Set base format (Always using RGBA as base)
+  GLenum fmt = GL_RGBA;
+  /*if (type == PD::Li::Texture::Type::RGB24) {
+    fmt = GL_RGB;
+  } else if (type == PD::Li::Texture::Type::A8) {
+    fmt = GL_ALPHA;
+  }*/
+  glTexImage2D(GL_TEXTURE_2D, 0, fmt, w, h, 0, fmt, GL_UNSIGNED_BYTE,
+               pixels.data());
+  if (filter == TextureFilter::Linear) {
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  } else if (filter == TextureFilter::Nearest) {
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  }
+  glBindTexture(GL_TEXTURE_2D, 0);
+  PDLOG("GfxOpenGL::LoadTexture -> [{}] {}", PD::ivec2(w, h), texID);
+  return texID;
 }
 
 void GfxOpenGL::DeleteTexture(const TextureID& tex) {