4 * GLSL wrapper code to hide the differences between the different gl/sl APIs.
6 * Copyright (c) 2007-2010 Nathan Keynes.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
23 #include "pvr2/glutil.h"
25 #define MAX_ERROR_BUF 4096
26 #define INVALID_SHADER 0
27 #define INVALID_PROGRAM 0
29 #ifdef HAVE_OPENGL_SHADER_ARB
30 typedef GLhandleARB gl_program_t;
31 typedef GLhandleARB gl_shader_t;
33 typedef GLuint gl_program_t;
34 typedef GLuint gl_shader_t;
37 gboolean glsl_is_supported();
38 gl_shader_t glsl_create_vertex_shader( const char *source );
39 gl_shader_t glsl_create_fragment_shader( const char *source );
40 gl_program_t glsl_create_program( gl_shader_t *shaderv );
41 void glsl_use_program(gl_program_t program);
42 void glsl_destroy_shader(gl_shader_t shader);
43 void glsl_destroy_program(gl_program_t program);
45 #ifdef HAVE_OPENGL_SHADER_ARB
47 gboolean glsl_is_supported()
49 return isGLExtensionSupported("GL_ARB_fragment_shader") &&
50 isGLExtensionSupported("GL_ARB_vertex_shader") &&
51 isGLExtensionSupported("GL_ARB_shading_language_100");
54 const char *glsl_get_version()
56 return glGetString(GL_SHADING_LANGUAGE_VERSION_ARB);
59 void glsl_print_error( char *msg, GLhandleARB obj )
61 char buf[MAX_ERROR_BUF];
63 glGetInfoLogARB( obj, sizeof(buf), &length, buf );
64 ERROR( "%s: %s", msg, buf );
67 gboolean glsl_check_shader_error( char *msg, GLhandleARB obj )
71 glGetObjectParameterivARB(obj, GL_OBJECT_COMPILE_STATUS_ARB, &value);
73 glsl_print_error(msg, obj);
79 gboolean glsl_check_program_error( char *msg, GLhandleARB obj )
81 if( glGetError() != GL_NO_ERROR ) {
82 glsl_print_error(msg, obj);
87 gl_shader_t glsl_create_vertex_shader( const char *source )
90 gl_shader_t shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
92 glShaderSourceARB( shader, 1, &source, NULL );
93 glCompileShaderARB(shader);
94 ok = glsl_check_shader_error("Failed to compile vertex shader", shader);
96 glDeleteObjectARB(shader);
97 return INVALID_SHADER;
103 gl_shader_t glsl_create_fragment_shader( const char *source )
106 gl_shader_t shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
108 glShaderSourceARB( shader, 1, &source, NULL );
109 glCompileShaderARB(shader);
110 ok = glsl_check_shader_error("Failed to compile fragment shader", shader);
112 glDeleteObjectARB(shader);
113 return INVALID_SHADER;
119 gl_program_t glsl_create_program( gl_shader_t *shaderv )
123 gl_program_t program = glCreateProgramObjectARB();
125 for( i=0; shaderv[i] != INVALID_SHADER; i++ ) {
126 glAttachObjectARB(program, shaderv[i]);
129 glLinkProgramARB(program);
130 ok = glsl_check_program_error( "Failed to link shader program", program );
132 glDeleteObjectARB(program);
133 return INVALID_PROGRAM;
139 void glsl_use_program(gl_program_t program)
141 glUseProgramObjectARB(program);
144 void glsl_destroy_shader(gl_shader_t shader)
146 glDeleteObjectARB(shader);
149 void glsl_destroy_program(gl_program_t program)
151 glDeleteObjectARB(program);
154 static inline GLint glsl_get_uniform_location_prim(gl_program_t program, const char *name)
156 return glGetUniformLocationARB(program, name);
159 static inline void glsl_set_uniform_int_prim(GLint location, GLint value)
161 glUniform1iARB(location,value);
164 #elif HAVE_OPENGL_SHADER
166 gboolean glsl_is_supported()
168 return isGLExtensionSupported("GL_ARB_fragment_shader") &&
169 isGLExtensionSupported("GL_ARB_vertex_shader") &&
170 isGLExtensionSupported("GL_ARB_shading_language_100");
173 const char *glsl_get_version()
175 return glGetString(GL_SHADING_LANGUAGE_VERSION);
178 gboolean glsl_check_shader_error( char *msg, GLuint shader )
182 glGetShaderiv( shader, GL_COMPILE_STATUS, &value );
184 char buf[MAX_ERROR_BUF];
186 glGetShaderInfoLog( shader, sizeof(buf), &length, buf );
187 ERROR( "%s: %s", msg, buf );
193 gboolean glsl_check_program_error( char *msg, GLuint program )
195 if( glGetError() != GL_NO_ERROR ) {
196 char buf[MAX_ERROR_BUF];
198 glGetProgramInfoLog( program, sizeof(buf), &length, buf );
199 ERROR( "%s: %s", msg, buf );
205 gl_shader_t glsl_create_vertex_shader( const char *source )
208 gl_shader_t shader = glCreateShader(GL_VERTEX_SHADER);
210 glShaderSource( shader, 1, &source, NULL );
211 glCompileShader(shader);
212 ok = glsl_check_shader_error( "Failed to compile vertex shader", shader );
214 glDeleteShader(shader);
215 return INVALID_SHADER;
222 gl_shader_t glsl_create_fragment_shader( const char *source )
225 gl_shader_t shader = glCreateShader(GL_FRAGMENT_SHADER);
227 glShaderSource( shader, 1, &source, NULL );
228 glCompileShader(shader);
229 ok = glsl_check_shader_error( "Failed to compile fragment shader", shader );
231 glDeleteShader(shader);
232 return INVALID_SHADER;
238 gl_program_t glsl_create_program( gl_shader_t *shaderv )
242 gl_program_t program = glCreateProgram();
244 for( i=0; shaderv[i] != INVALID_SHADER; i++ ) {
245 glAttachShader(program, shaderv[i]);
247 glLinkProgram(program);
248 ok = glsl_check_program_error( "Failed to link shader program", program );
250 glDeleteProgram(program);
251 return INVALID_PROGRAM;
257 void glsl_use_program(gl_program_t program)
259 glUseProgram(program);
262 void glsl_destroy_shader(gl_shader_t shader)
264 glDeleteShader(shader);
267 void glsl_destroy_program(gl_program_t program)
269 glDeleteProgram(program);
272 static inline GLint glsl_get_uniform_location_prim(gl_program_t program, const char *name)
274 return glGetUniformLocation(program, name);
276 static inline void glsl_set_uniform_int_prim(GLint location, GLint value)
278 glUniform1i(location, value);
282 gboolean glsl_is_supported()
287 const char *glsl_get_version()
292 gl_shader_t glsl_create_vertex_shader( const char *source )
297 gl_shader_t glsl_create_fragment_shader( const char *source )
302 gl_program_t glsl_create_program( gl_shader_t *shaderv )
307 void glsl_use_program(gl_program_t program)
311 void glsl_destroy_shader(gl_shader_t shader)
315 void glsl_destroy_program(gl_program_t program)
319 static inline GLint glsl_get_uniform_location_prim(gl_program_t program, const char *name)
324 static inline void glsl_set_uniform_int_prim(GLint location, GLint value)
329 /****************************************************************************/
331 /* Pull in the auto-generated shader definitions */
333 #include "pvr2/shaders.def"
335 static gl_program_t program_array[GLSL_NUM_PROGRAMS];
337 gboolean glsl_load_shaders()
339 gl_shader_t shader_array[GLSL_NUM_SHADERS];
342 for( i=0; i<GLSL_NUM_SHADERS; i++ )
343 shader_array[i] = INVALID_SHADER;
344 for( i=0; i<GLSL_NUM_PROGRAMS; i++ )
345 program_array[i] = INVALID_PROGRAM;
347 /* Compile the shader fragments */
348 for( i=0; shader_source[i].type != GLSL_NO_SHADER; i++ ) {
349 gl_shader_t shader = INVALID_SHADER;
350 switch(shader_source[i].type) {
351 case GLSL_VERTEX_SHADER:
352 shader = glsl_create_vertex_shader(shader_source[i].source);
354 case GLSL_FRAGMENT_SHADER:
355 shader = glsl_create_fragment_shader(shader_source[i].source);
358 if( shader == INVALID_SHADER ) {
362 shader_array[i] = shader;
366 /* Link the programs */
367 if(ok) for( i=0; program_list[i][0] != GLSL_NO_SHADER; i++ ) {
368 gl_shader_t shaderv[GLSL_NUM_SHADERS+1];
369 for( j=0; program_list[i][j] != GLSL_NO_SHADER; j++ ) {
370 shaderv[j] = shader_array[program_list[i][j]];
372 shaderv[j] = INVALID_SHADER;
373 gl_program_t program = glsl_create_program(shaderv);
374 if( program == INVALID_PROGRAM ) {
378 /* Check that we can actually use the program (can this really fail?) */
379 glsl_use_program(program);
380 if( !glsl_check_program_error( "Failed to activate shader program", program ) ) {
383 program_array[i] = program;
388 * Destroy the compiled fragments (the linked programs don't need them
391 for( i=0; i<GLSL_NUM_SHADERS; i++ ) {
392 if( shader_array[i] != INVALID_SHADER )
393 glsl_destroy_shader(shader_array[i]);
397 * If we errored, delete the programs. It's all or nothing.
400 glsl_unload_shaders();
408 void glsl_unload_shaders()
411 for( i=0; i<GLSL_NUM_PROGRAMS; i++ ) {
412 if( program_array[i] != INVALID_PROGRAM ) {
413 glsl_destroy_program(program_array[i]);
414 program_array[i] = INVALID_PROGRAM;
419 gboolean glsl_set_shader(unsigned i)
421 assert( i >= 0 && i <= GLSL_LAST_PROGRAM );
423 if( program_array[i] != INVALID_PROGRAM ) {
424 glsl_use_program(program_array[i]);
431 GLint glsl_get_uniform_location( unsigned program, const char *name )
433 assert( program >= 0 && program <= GLSL_LAST_PROGRAM );
435 return glsl_get_uniform_location_prim(program_array[program], name);
438 void glsl_set_uniform_int( unsigned program, const char *name, GLint value )
440 assert( program >= 0 && program <= GLSL_LAST_PROGRAM );
441 GLint location = glsl_get_uniform_location_prim(program_array[program], name);
442 glsl_set_uniform_int_prim(location, value);
445 void glsl_clear_shader()
.