src/vg/vg_shader.h

   1 /* Copyright (C) 2021-2022 Harry Godden (hgn) - All Rights Reserved */
   2
   3 const char *vg_shader_gl_ver = "#version 330 core\n";
   4
   5 #pragma GCC diagnostic push
   6 #pragma GCC diagnostic ignored "-Wreturn-type"
   7 static inline int static_str_index( const char *list[], int len,
   8       const char *str )
   9 {
  10     for( int i = 0; i < len; i ++ )
  11     {
  12         if( !strcmp(list[i],str) )
  13             return i;
  14     }
  15
  16     #ifndef VG_RELEASE
  17     fprintf( stderr, "That was not a static string index!! (%s)\n", str );
  18     abort();
  19     #endif
  20 }
  21 #pragma GCC diagnostic pop
  22
  23 #define SHADER_NAME( NAME ) (NAME##_static_shader.program)
  24 #define SHADER_USE( NAME ) glUseProgram( NAME##_static_shader.program )
  25
  26 #define SHADER_UNIFORM( NAME, U ) \
  27    NAME##_shader_uniforms[ STR_STATIC_INDEX( NAME##_shader_names, U ) ]
  28 #define SHADER_UNIFORM_NAME( NAME, UID ) NAME##_shader_names[ UID ]
  29 #define STR_STATIC_INDEX( LIST, STR ) \
  30    static_str_index( LIST, vg_list_size(LIST), STR )
  31
  32 #define UNIFORMS(...) __VA_ARGS__
  33
  34 #define SHADER_DEFINE( NAME, VERT, FRAG, UNIFORMS )                                                     \
  35         const char * NAME##_shader_names[] = UNIFORMS;                                                          \
  36         GLint NAME##_shader_uniforms[ vg_list_size( NAME##_shader_names ) ];    \
  37         struct vg_shader NAME##_static_shader = {                                                                               \
  38                 .src_vert = VERT, .src_frag = FRAG,                                                                                     \
  39                 .sym = #NAME "_static.shader",                                                                                          \
  40                 .uniform_names = NAME##_shader_names,                                                                           \
  41                 .uniforms = NAME##_shader_uniforms,                                                                                     \
  42                 .uniform_count = vg_list_size( NAME##_shader_names ),                                   \
  43         };
  44
  45 #define SHADER_INIT( NAME ) arrpush( vg_shaders_active, &NAME##_static_shader )
  46
  47 #define SHADER_STATUS_NONE 0x00
  48 #define SHADER_STATUS_COMPILED 0x1
  49
  50 struct vg_shader
  51 {
  52         GLuint program;
  53
  54         const char *src_vert;
  55         const char *src_frag;
  56         const char *src_geo;
  57         const char *sym;
  58
  59         const char **uniform_names;
  60         GLint *uniforms;
  61         u32 uniform_count;
  62         u32 status;
  63 }
  64 ** vg_shaders_active = NULL;
  65
  66 static GLuint vg_shader_subshader( const char *src, GLint gliShaderType )
  67 {
  68         GLint shader = glCreateShader( gliShaderType );
  69         glShaderSource( shader, 2, (const char *[2]){ vg_shader_gl_ver, src }, NULL );
  70         glCompileShader( shader );
  71
  72         int success;
  73         char infoLog[512];
  74         glGetShaderiv( shader, GL_COMPILE_STATUS, &success );
  75
  76         if( !success )
  77         {
  78                 glGetShaderInfoLog( shader, 512, NULL, infoLog );
  79                 vg_error( "Error info:\n%s\n", infoLog );
  80                 return 0;
  81         }
  82
  83         return shader;
  84 }
  85
  86 static int vg_shader_compile( struct vg_shader *shader )
  87 {
  88         vg_info( "Compile shader '%s'\n", shader->sym );
  89
  90         GLuint vert, frag, geo = 0;
  91
  92         vert = vg_shader_subshader( shader->src_vert, GL_VERTEX_SHADER );
  93         frag = vg_shader_subshader( shader->src_frag, GL_FRAGMENT_SHADER );
  94
  95         if( !vert || !frag )
  96                 return 0;
  97
  98         if( shader->src_geo )
  99         {
 100                 geo = vg_shader_subshader( shader->src_geo, GL_GEOMETRY_SHADER );
 101
 102                 if( !geo )
 103                         return 0;
 104         }
 105
 106         shader->program = glCreateProgram();
 107         if( geo )
 108                 glAttachShader( shader->program, geo );
 109
 110         glAttachShader( shader->program, vert );
 111         glAttachShader( shader->program, frag );
 112         glLinkProgram( shader->program );
 113
 114         glDeleteShader( vert );
 115         glDeleteShader( frag );
 116
 117         if( geo )
 118                 glDeleteShader( geo );
 119
 120         /* Check for link errors */
 121         char infoLog[ 512 ];
 122         int success_link = 1;
 123
 124         glGetProgramiv( shader->program, GL_LINK_STATUS, &success_link );
 125         if( !success_link )
 126         {
 127                 glGetProgramInfoLog( shader->program, 512, NULL, infoLog );
 128                 vg_error( "Link failed: %s\n", infoLog );
 129                 glDeleteProgram( shader->program );
 130
 131                 return 0;
 132         }
 133
 134         /* Complete linkeage */
 135         for( int i = 0; i < shader->uniform_count; i ++ )
 136    {
 137                 shader->uniforms[ i ] =
 138          glGetUniformLocation( shader->program, shader->uniform_names[i] );
 139    }
 140
 141         shader->status |= SHADER_STATUS_COMPILED;
 142         return 1;
 143 }
 144
 145 static void vg_shaders_free(void)
 146 {
 147         for( int i = 0; i < arrlen( vg_shaders_active ); i ++ )
 148         {
 149                 struct vg_shader *shader = vg_shaders_active[i];
 150
 151                 if( shader->status & SHADER_STATUS_COMPILED )
 152                         glDeleteProgram( shader->program );
 153         }
 154
 155         arrfree( vg_shaders_active );
 156 }
 157
 158 static int vg_shaders_compile(void)
 159 {
 160         vg_info( "Compiling shaders\n" );
 161
 162         for( int i = 0; i < arrlen( vg_shaders_active ); i ++ )
 163         {
 164                 struct vg_shader *shader = vg_shaders_active[i];
 165                 if( !vg_shader_compile( shader ) )
 166                 {
 167                         vg_shaders_free();
 168                         return 0;
 169                 }
 170         }
 171
 172         vg_register_exit( &vg_shaders_free, "vg_shaders_free" );
 173         return 1;
 174 }