Shaders adapted for Legacy GL

src/duskgl/display/shader/shadergl.c

@@ -7,7 +7,13 @@
 
 #include "shadergl.h"
 #include "util/memory.h"
+#include "util/string.h"
 #include "assert/assertgl.h"
+#include "display/shader/shaderunlit.h"
+
+#ifdef DUSK_OPENGL_LEGACY
+  shaderlegacygl_t SHADER_LEGACY = { 0 };
+#endif
 
 errorret_t shaderInitGL(shadergl_t *shader, const shaderdefinitiongl_t *def) {
   assertNotNull(shader, "Shader cannot be null");
@@ -15,7 +21,11 @@ errorret_t shaderInitGL(shadergl_t *shader, const shaderdefinitiongl_t *def) {
   memoryZero(shader, sizeof(shadergl_t));
 
   #ifdef DUSK_OPENGL_LEGACY
-    // No initialization needed for legacy shader
+    glm_mat4_identity(shader->view);
+    glm_mat4_identity(shader->proj);
+    glm_mat4_identity(shader->model);
+
+    SHADER_LEGACY.boundShader = NULL;
     errorOk();
   #else
     // Create vertex shader
@@ -139,12 +149,16 @@ errorret_t shaderParamGetLocationGL(
   assertStrLenMin(name, 1, "Uniform name cannot be empty");
   assertNotNull(location, "Location cannot be null");
 
-  shadergl_t *shaderGL = (shadergl_t *)shader;
-  *location = glGetUniformLocation(shaderGL->shaderProgramId, name);
-  errorret_t err = errorGLCheck();
-  if(err.code != ERROR_OK) {
-    errorChain(err);
-  }
+  #ifdef DUSK_OPENGL_LEGACY
+    assertUnreachable("Cannot get uniform locations on legacy opengl.");
+  #else
+    shadergl_t *shaderGL = (shadergl_t *)shader;
+    *location = glGetUniformLocation(shaderGL->shaderProgramId, name);
+    errorret_t err = errorGLCheck();
+    if(err.code != ERROR_OK) {
+      errorChain(err);
+    }
+  #endif
   
   errorOk();
 }
@@ -152,27 +166,58 @@ errorret_t shaderParamGetLocationGL(
 errorret_t shaderSetMatrixGL(
   shadergl_t *shader,
   const char_t *name,
-  const mat4 mat
+  mat4 mat
 ) {
   assertNotNull(shader, "Shader cannot be null");
   assertNotNull(mat, "Matrix data cannot be null");
   assertStrLenMin(name, 1, "Uniform name cannot be empty");
 
-  GLint location;
-  errorChain(shaderParamGetLocationGL(shader, name, &location));
+  #ifdef DUSK_OPENGL_LEGACY
+    assertTrue(
+      SHADER_LEGACY.boundShader == shader,
+      "Shader must be bound to set legacy matrices."
+    );
+    if(stringCompare(name, SHADER_UNLIT_PROJECTION) == 0) {
+      SHADER_LEGACY.dirty |= SHADER_LEGACY_DIRTY_PROJ;
+      glm_mat4_copy(mat, shader->proj);
 
-  glUniformMatrix4fv(location, 1, GL_FALSE, (const GLfloat *)mat);
-  errorChain(errorGLCheck());
+    } else if(stringCompare(name, SHADER_UNLIT_VIEW) == 0) {
+      SHADER_LEGACY.dirty |= SHADER_LEGACY_DIRTY_VIEW;
+      glm_mat4_copy(mat, shader->view);
+
+    } else if(stringCompare(name, SHADER_UNLIT_MODEL) == 0) {
+      SHADER_LEGACY.dirty |= SHADER_LEGACY_DIRTY_MODEL;
+      glm_mat4_copy(mat, shader->model);
+      
+    } else {
+      assertUnreachable("Cannot use a custom matrix on legacy opengl.");
+    }
+  #else
+    GLint location;
+    errorChain(shaderParamGetLocationGL(shader, name, &location));
+
+    glUniformMatrix4fv(location, 1, GL_FALSE, (const GLfloat *)mat);
+    errorChain(errorGLCheck());
+  #endif
 
   errorOk();
 }
 
 
 errorret_t shaderBindGL(shadergl_t *shader) {
-  assertNotNull(shader, "Shader cannot be null");
-
-  glUseProgram(shader->shaderProgramId);
-  errorChain(errorGLCheck());
+  #ifdef DUSK_OPENGL_LEGACY
+    assertNotNull(shader, "Cannot bind a null shader.");
+    SHADER_LEGACY.boundShader = shader;
+    SHADER_LEGACY.dirty = (
+      SHADER_LEGACY_DIRTY_MODEL |
+      SHADER_LEGACY_DIRTY_PROJ |
+      SHADER_LEGACY_DIRTY_VIEW
+    );
+  #else
+    assertNotNull(shader, "Shader cannot be null");
+    glUseProgram(shader->shaderProgramId);
+    errorChain(errorGLCheck());
+  #endif
 
   errorOk();
 }
@@ -180,22 +225,58 @@ errorret_t shaderBindGL(shadergl_t *shader) {
 errorret_t shaderDisposeGL(shadergl_t *shader) {
   assertNotNull(shader, "Shader cannot be null");
 
-  if(shader->shaderProgramId != 0) {
-    glDeleteProgram(shader->shaderProgramId);
-    errorChain(errorGLCheck());
-  }
-  
-  if(shader->vertexShaderId != 0) {
-    glDeleteShader(shader->vertexShaderId);
-    errorChain(errorGLCheck());
-  }
+  #ifdef DUSK_OPENGL_LEGACY
+    SHADER_LEGACY.boundShader = NULL;
+  #else
+    if(shader->shaderProgramId != 0) {
+      glDeleteProgram(shader->shaderProgramId);
+    }
+    
+    if(shader->vertexShaderId != 0) {
+      glDeleteShader(shader->vertexShaderId);
+    }
 
-  if(shader->fragmentShaderId != 0) {
-    glDeleteShader(shader->fragmentShaderId);
-    errorChain(errorGLCheck());
-  }
+    if(shader->fragmentShaderId != 0) {
+      glDeleteShader(shader->fragmentShaderId);
+    }
+
+    assertNoGLError("Failed disposing shader");
+  #endif
 
-  assertNoGLError("Failed disposing shader");
   memoryZero(shader, sizeof(shadergl_t));
   errorOk();
 }
+
+#ifdef DUSK_OPENGL_LEGACY
+  errorret_t shaderLegacyMatrixUpdate() {
+    assertNotNull(SHADER_LEGACY.boundShader, "No shader is currently bound.");
+
+    if((SHADER_LEGACY.dirty & SHADER_LEGACY_DIRTY_PROJ) != 0) {
+      glMatrixMode(GL_PROJECTION);
+      errorChain(errorGLCheck());
+      glLoadIdentity();
+      errorChain(errorGLCheck());
+      glMultMatrixf((const GLfloat *)SHADER_LEGACY.boundShader->proj);
+      errorChain(errorGLCheck());
+    }
+
+    if((SHADER_LEGACY.dirty & SHADER_LEGACY_DIRTY_VIEW) != 0) {
+      glMatrixMode(GL_MODELVIEW);
+      errorChain(errorGLCheck());
+      glLoadIdentity();
+      errorChain(errorGLCheck());
+      glMultMatrixf((const GLfloat *)SHADER_LEGACY.boundShader->view);
+      errorChain(errorGLCheck());
+    }
+
+    if((SHADER_LEGACY.dirty & SHADER_LEGACY_DIRTY_MODEL) != 0) {
+      glMatrixMode(GL_MODELVIEW);
+      errorChain(errorGLCheck());
+      glMultMatrixf((const GLfloat *)SHADER_LEGACY.boundShader->model);
+      errorChain(errorGLCheck());
+    }
+    
+    SHADER_LEGACY.dirty = 0;
+    errorOk();
+  }
+#endif