Refactor, GLFW->SDL

[vg.git] / vg_shader.h

diff --git a/vg_shader.h b/vg_shader.h
new file mode 100644 (file)
index 0000000..516d1a8
--- /dev/null
+++ b/vg_shader.h
@@ -0,0 +1,219 @@
+/* Copyright (C) 2021-2022 Harry Godden (hgn) - All Rights Reserved */
+
+#ifndef VG_SHADER_H
+#define VG_SHADER_H
+
+#include "vg/vg.h"
+#include "vg/vg_platform.h"
+
+#if 0
+#define STB_INCLUDE_IMPLEMENTATION
+#define STB_INCLUDE_LINE_GLSL
+#define STB_MALLOC  vg_alloc
+#define STB_FREE    vg_free
+#define STB_REALLOC vg_realloc
+#include "stb/stb_include.h"
+#endif
+
+const char *vg_shader_gl_ver = "#version 330 core\n";
+
+typedef struct vg_shader vg_shader;
+
+struct
+{
+   struct vg_shader
+   {
+      GLuint id;
+      const char *name;
+
+      struct vg_subshader
+      {
+         const char *orig_file,
+                    *static_src;
+      }
+      vs, fs;
+
+      void (*link)(void);
+      int compiled;
+   }
+   * shaders[32];
+   u32 count;
+}
+static vg_shaders;
+
+VG_STATIC GLuint vg_shader_subshader( const char *src, GLint gliShaderType )
+{
+       GLint shader = glCreateShader( gliShaderType );
+
+   if( shader == GL_NONE )
+   {
+      vg_error( "Could not 'glCreateShader()'\n" );
+      return 0;
+   }
+
+       glShaderSource( shader, 2, (const char*[2]){ vg_shader_gl_ver, src }, NULL );
+       glCompileShader( shader );
+
+       GLint status;
+       glGetShaderiv( shader, GL_COMPILE_STATUS, &status );
+
+       if( status != GL_TRUE )
+       {
+      GLchar info[1024];
+      GLsizei len;
+
+               glGetShaderInfoLog( shader, sizeof(info), &len, info );
+               vg_error( "Error info:\n%s\n", info );
+               return 0;
+       }
+
+       return shader;
+}
+
+VG_STATIC int vg_shader_compile( struct vg_shader *shader )
+{
+       vg_info( "Compile shader '%s'\n", shader->name );
+       
+       GLuint program, vert, frag;
+   const char *svs, *sfs;
+   char *avs, *afs;
+
+   int static_src = 1;
+   
+   /* If we are compiling this again, we obviously need to try to take the src
+    * from the disk instead.
+    *
+    * Only do this if we have filenames set on the shader, so engine shaders 
+    * dont have to do it (text.. etc).
+    */
+   if( shader->compiled )
+   {
+      if( shader->vs.orig_file && shader->fs.orig_file )
+         static_src = 0;
+      else return 1;
+   }
+
+   if( static_src )
+   {
+      svs = shader->vs.static_src;
+      sfs = shader->fs.static_src;
+   }
+   else
+   {
+      vg_fatal_exit_loop( "Unimplemented" );
+
+#if 0
+      char error[260];
+      char path[260];
+      strcpy( path, shader->vs.orig_file );
+      avs = stb_include_file( path, "", "../../shaders", error );
+
+      strcpy( path, shader->fs.orig_file );
+      afs = stb_include_file( path, "", "../../shaders", error );
+   
+      if( !avs || !afs )
+      {
+         vg_error( "Could not find shader source files (%s)\n",
+               shader->vs.orig_file );
+
+         vg_free( avs );
+         vg_free( afs );
+         return 0;
+      }
+
+      svs = avs;
+      sfs = afs;
+#endif
+   }
+       
+       vert = vg_shader_subshader( svs, GL_VERTEX_SHADER );
+       frag = vg_shader_subshader( sfs, GL_FRAGMENT_SHADER );
+       
+#if 0
+   if( !static_src )
+   {
+      free( avs );
+      free( afs );
+   }
+#endif
+
+       if( !vert || !frag )
+               return 0;
+       
+       program = glCreateProgram();
+               
+       glAttachShader( program, vert );
+       glAttachShader( program, frag );
+       glLinkProgram( program );
+       
+       glDeleteShader( vert );
+       glDeleteShader( frag );
+               
+       /* Check for link errors */
+       char infoLog[ 512 ];
+       int success_link = 1;
+       
+       glGetProgramiv( program, GL_LINK_STATUS, &success_link );
+       if( !success_link )
+       {
+               glGetProgramInfoLog( program, 512, NULL, infoLog );
+               vg_error( "Link failed: %s\n", infoLog );
+               glDeleteProgram( program );
+               return 0;
+       }
+       
+   if( shader->compiled )
+      glDeleteProgram( shader->id );
+   
+   shader->id = program;
+       shader->compiled = 1;
+   if( shader->link ) 
+      shader->link();
+       return 1;
+}
+
+VG_STATIC void vg_free_shader( struct vg_shader *shader )
+{
+   if( shader->compiled )
+   {
+      glDeleteProgram( shader->id );
+      shader->compiled = 0;
+   }
+}
+
+VG_STATIC void vg_shaders_compile(void)
+{
+       vg_info( "Compiling shaders\n" );
+
+       for( int i=0; i<vg_shaders.count; i ++ )
+       {
+               vg_shader *shader = vg_shaders.shaders[i];
+
+               if( !vg_shader_compile( shader ) )
+         vg_fatal_exit_loop( "Failed to compile shader" );
+       }
+}
+
+VG_STATIC int vg_shaders_live_recompile(int argc, const char *argv[])
+{
+   vg_info( "Recompiling shaders\n" );
+   for( int i=0; i<vg_shaders.count; i ++ )
+   {
+      struct vg_shader *shader = vg_shaders.shaders[i];
+      vg_shader_compile( shader );
+   }
+
+   return 0;
+}
+
+VG_STATIC void vg_shader_register( struct vg_shader *shader )
+{
+   if( vg_shaders.count == vg_list_size(vg_shaders.shaders) )
+      vg_fatal_exit_loop( "Too many shaders" );
+
+   shader->compiled = 0;
+   shader->id = 0;         /* TODO: make this an error shader */
+   vg_shaders.shaders[ vg_shaders.count ++ ] = shader;
+}
+
+#endif /* VG_SHADER_H */