Debian Codegraph @

src/opengl/ogl_shader.c

raw
1 /* ______ ___ ___
2 * /\ _ \ /\_ \ /\_ \
3 * \ \ \L\ \\//\ \ \//\ \ __ __ _ __ ___
4 * \ \ __ \ \ \ \ \ \ \ /'__`\ /'_ `\/\`'__\/ __`\
5 * \ \ \/\ \ \_\ \_ \_\ \_/\ __//\ \L\ \ \ \//\ \L\ \
6 * \ \_\ \_\/\____\/\____\ \____\ \____ \ \_\\ \____/
7 * \/_/\/_/\/____/\/____/\/____/\/___L\ \/_/ \/___/
8 * /\____/
9 * \_/__/
10 *
11 * OpenGL shader support.
12 *
13 * See LICENSE.txt for copyright information.
14 */
15
16 #include <stdio.h>
17
18 #include "allegro5/allegro.h"
19 #include "allegro5/allegro_opengl.h"
20 #include "allegro5/internal/aintern_bitmap.h"
21 #include "allegro5/internal/aintern_display.h"
22 #include "allegro5/internal/aintern_opengl.h"
23 #include "allegro5/internal/aintern_shader.h"
24
25 #ifdef ALLEGRO_MSVC
26 #define snprintf _snprintf
27 #endif
28
29 #ifdef ALLEGRO_CFG_SHADER_GLSL
30
31 ALLEGRO_DEBUG_CHANNEL("shader")
32
33 static _AL_VECTOR shaders;
34 static ALLEGRO_MUTEX *shaders_mutex;
35
36 typedef struct ALLEGRO_SHADER_GLSL_S ALLEGRO_SHADER_GLSL_S;
37
38 struct ALLEGRO_SHADER_GLSL_S
39 {
40 ALLEGRO_SHADER shader;
41 GLuint vertex_shader;
42 GLuint pixel_shader;
43 GLuint program_object;
44 ALLEGRO_OGL_VARLOCS varlocs;
45 };
46
47
48 /* forward declarations */
49 static struct ALLEGRO_SHADER_INTERFACE shader_glsl_vt;
50 static void lookup_varlocs(ALLEGRO_OGL_VARLOCS *varlocs, GLuint program);
51
52
53 static bool check_gl_error(const char* name)
54 {
55 GLenum err = glGetError();
56 if (err != 0) {
57 ALLEGRO_WARN("%s (%s)\n", name, _al_gl_error_string(err));
58 return false;
59 }
60 return true;
61 }
62
63
64 ALLEGRO_SHADER *_al_create_shader_glsl(ALLEGRO_SHADER_PLATFORM platform)
65 {
66 ALLEGRO_SHADER_GLSL_S *shader = al_calloc(1, sizeof(ALLEGRO_SHADER_GLSL_S));
67
68 if (!shader)
69 return NULL;
70
71 shader->shader.platform = platform;
72 shader->shader.vt = &shader_glsl_vt;
73 _al_vector_init(&shader->shader.bitmaps, sizeof(ALLEGRO_BITMAP *));
74
75 al_lock_mutex(shaders_mutex);
76 {
77 ALLEGRO_SHADER **back = (ALLEGRO_SHADER **)_al_vector_alloc_back(&shaders);
78 *back = (ALLEGRO_SHADER *)shader;
79 }
80 al_unlock_mutex(shaders_mutex);
81
82 return (ALLEGRO_SHADER *)shader;
83 }
84
85 static bool glsl_attach_shader_source(ALLEGRO_SHADER *shader,
86 ALLEGRO_SHADER_TYPE type, const char *source)
87 {
88 GLint status;
89 GLchar error_buf[4096];
90 ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;
91 ALLEGRO_DISPLAY *display = al_get_current_display();
92 ASSERT(display);
93 ASSERT(display->flags & ALLEGRO_OPENGL);
94
95 if (source == NULL) {
96 if (type == ALLEGRO_VERTEX_SHADER) {
97 if (gl_shader->vertex_shader) {
98 glDetachShader(gl_shader->program_object, gl_shader->vertex_shader);
99 glDeleteShader(gl_shader->vertex_shader);
100 gl_shader->vertex_shader = 0;
101 }
102 }
103 else {
104 if (gl_shader->pixel_shader) {
105 glDetachShader(gl_shader->program_object, gl_shader->pixel_shader);
106 glDeleteShader(gl_shader->pixel_shader);
107 gl_shader->pixel_shader = 0;
108 }
109 }
110 return true;
111 }
112 else {
113 GLuint *handle;
114 GLenum gl_type;
115 if (type == ALLEGRO_VERTEX_SHADER) {
116 handle = &(gl_shader->vertex_shader);
117 gl_type = GL_VERTEX_SHADER;
118 }
119 else {
120 handle = &(gl_shader->pixel_shader);
121 gl_type = GL_FRAGMENT_SHADER;
122 }
123 *handle = glCreateShader(gl_type);
124 if ((*handle) == 0) {
125 return false;
126 }
127 glShaderSource(*handle, 1, &source, NULL);
128 glCompileShader(*handle);
129 glGetShaderiv(*handle, GL_COMPILE_STATUS, &status);
130 if (status == 0) {
131 glGetShaderInfoLog(*handle, sizeof(error_buf), NULL, error_buf);
132 if (shader->log) {
133 al_ustr_truncate(shader->log, 0);
134 al_ustr_append_cstr(shader->log, error_buf);
135 }
136 else {
137 shader->log = al_ustr_new(error_buf);
138 }
139 ALLEGRO_ERROR("Compile error: %s\n", error_buf);
140 glDeleteShader(*handle);
141 return false;
142 }
143 }
144
145 return true;
146 }
147
148 static bool glsl_build_shader(ALLEGRO_SHADER *shader)
149 {
150 GLint status;
151 ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;
152 GLchar error_buf[4096];
153
154 if (gl_shader->vertex_shader == 0 && gl_shader->pixel_shader == 0)
155 return false;
156
157 if (gl_shader->program_object != 0) {
158 glDeleteProgram(gl_shader->program_object);
159 }
160
161 gl_shader->program_object = glCreateProgram();
162 if (gl_shader->program_object == 0)
163 return false;
164
165 if (gl_shader->vertex_shader)
166 glAttachShader(gl_shader->program_object, gl_shader->vertex_shader);
167 if (gl_shader->pixel_shader)
168 glAttachShader(gl_shader->program_object, gl_shader->pixel_shader);
169
170 glLinkProgram(gl_shader->program_object);
171
172 glGetProgramiv(gl_shader->program_object, GL_LINK_STATUS, &status);
173
174 if (status == 0) {
175 glGetProgramInfoLog(gl_shader->program_object, sizeof(error_buf), NULL,
176 error_buf);
177 if (shader->log) {
178 al_ustr_truncate(shader->log, 0);
179 al_ustr_append_cstr(shader->log, error_buf);
180 }
181 else {
182 shader->log = al_ustr_new(error_buf);
183 }
184 ALLEGRO_ERROR("Link error: %s\n", error_buf);
185 glDeleteProgram(gl_shader->program_object);
186 return false;
187 }
188
189 /* Look up variable locations. */
190 lookup_varlocs(&gl_shader->varlocs, gl_shader->program_object);
191
192 return true;
193 }
194
195 static bool glsl_use_shader(ALLEGRO_SHADER *shader, ALLEGRO_DISPLAY *display,
196 bool set_projview_matrix_from_display)
197 {
198 ALLEGRO_SHADER_GLSL_S *gl_shader;
199 GLuint program_object;
200 GLenum err;
201
202 if (!(display->flags & ALLEGRO_OPENGL)) {
203 return false;
204 }
205
206 gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;
207 program_object = gl_shader->program_object;
208
209 glGetError(); /* clear error */
210 glUseProgram(program_object);
211 err = glGetError();
212 if (err != GL_NO_ERROR) {
213 ALLEGRO_WARN("glUseProgram(%u) failed: %s\n", program_object,
214 _al_gl_error_string(err));
215 display->ogl_extras->program_object = 0;
216 return false;
217 }
218
219 display->ogl_extras->program_object = program_object;
220
221 /* Copy variable locations. */
222 display->ogl_extras->varlocs = gl_shader->varlocs;
223
224 /* Optionally set projview matrix. We skip this when it is known that the
225 * matrices in the display are out of date and are about to be clobbered
226 * itself.
227 */
228 if (set_projview_matrix_from_display) {
229 _al_glsl_set_projview_matrix(
230 display->ogl_extras->varlocs.projview_matrix_loc, &display->projview_transform);
231 }
232
233 /* Alpha testing may be done in the shader and so when a shader is
234 * set the uniforms need to be synchronized.
235 */
236 _al_ogl_update_render_state(display);
237
238 return true;
239 }
240
241 static void glsl_unuse_shader(ALLEGRO_SHADER *shader, ALLEGRO_DISPLAY *display)
242 {
243 (void)shader;
244 (void)display;
245 glUseProgram(0);
246 }
247
248 static void glsl_destroy_shader(ALLEGRO_SHADER *shader)
249 {
250 ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;
251
252 al_lock_mutex(shaders_mutex);
253 _al_vector_find_and_delete(&shaders, &shader);
254 al_unlock_mutex(shaders_mutex);
255
256 glDeleteShader(gl_shader->vertex_shader);
257 glDeleteShader(gl_shader->pixel_shader);
258 glDeleteProgram(gl_shader->program_object);
259 al_free(shader);
260 }
261
262 static bool glsl_set_shader_sampler(ALLEGRO_SHADER *shader,
263 const char *name, ALLEGRO_BITMAP *bitmap, int unit)
264 {
265 ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;
266 GLint handle;
267 GLuint texture;
268
269 if (bitmap && al_get_bitmap_flags(bitmap) & ALLEGRO_MEMORY_BITMAP) {
270 ALLEGRO_WARN("Cannot use memory bitmap for sampler\n");
271 return false;
272 }
273
274 handle = glGetUniformLocation(gl_shader->program_object, name);
275
276 if (handle < 0) {
277 ALLEGRO_WARN("No uniform variable '%s' in shader program\n", name);
278 return false;
279 }
280
281 glActiveTexture(GL_TEXTURE0 + unit);
282
283 texture = bitmap ? al_get_opengl_texture(bitmap) : 0;
284 glBindTexture(GL_TEXTURE_2D, texture);
285
286 glUniform1i(handle, unit);
287
288 return check_gl_error(name);
289 }
290
291 static bool glsl_set_shader_matrix(ALLEGRO_SHADER *shader,
292 const char *name, const ALLEGRO_TRANSFORM *matrix)
293 {
294 ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;
295 GLint handle;
296
297 handle = glGetUniformLocation(gl_shader->program_object, name);
298
299 if (handle < 0) {
300 ALLEGRO_WARN("No uniform variable '%s' in shader program\n", name);
301 return false;
302 }
303
304 glUniformMatrix4fv(handle, 1, false, (const float *)matrix->m);
305
306 return check_gl_error(name);
307 }
308
309 static bool glsl_set_shader_int(ALLEGRO_SHADER *shader,
310 const char *name, int i)
311 {
312 ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;
313 GLint handle;
314
315 handle = glGetUniformLocation(gl_shader->program_object, name);
316
317 if (handle < 0) {
318 ALLEGRO_WARN("No uniform variable '%s' in shader program\n", name);
319 return false;
320 }
321
322 glUniform1i(handle, i);
323
324 return check_gl_error(name);
325 }
326
327 static bool glsl_set_shader_float(ALLEGRO_SHADER *shader,
328 const char *name, float f)
329 {
330 ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;
331 GLint handle;
332
333 handle = glGetUniformLocation(gl_shader->program_object, name);
334
335 if (handle < 0) {
336 ALLEGRO_WARN("No uniform variable '%s' in shader program\n", name);
337 return false;
338 }
339
340 glUniform1f(handle, f);
341
342 return check_gl_error(name);
343 }
344
345 static bool glsl_set_shader_int_vector(ALLEGRO_SHADER *shader,
346 const char *name, int num_components, const int *i, int num_elems)
347 {
348 ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;
349 GLint handle;
350
351 handle = glGetUniformLocation(gl_shader->program_object, name);
352
353 if (handle < 0) {
354 ALLEGRO_WARN("No uniform variable '%s' in shader program\n", name);
355 return false;
356 }
357
358 switch (num_components) {
359 case 1:
360 glUniform1iv(handle, num_elems, i);
361 break;
362 case 2:
363 glUniform2iv(handle, num_elems, i);
364 break;
365 case 3:
366 glUniform3iv(handle, num_elems, i);
367 break;
368 case 4:
369 glUniform4iv(handle, num_elems, i);
370 break;
371 default:
372 ASSERT(false);
373 break;
374 }
375
376 return check_gl_error(name);
377 }
378
379 static bool glsl_set_shader_float_vector(ALLEGRO_SHADER *shader,
380 const char *name, int num_components, const float *f, int num_elems)
381 {
382 ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;
383 GLint handle;
384
385 handle = glGetUniformLocation(gl_shader->program_object, name);
386
387 if (handle < 0) {
388 ALLEGRO_WARN("No uniform variable '%s' in shader program\n", name);
389 return false;
390 }
391
392 switch (num_components) {
393 case 1:
394 glUniform1fv(handle, num_elems, f);
395 break;
396 case 2:
397 glUniform2fv(handle, num_elems, f);
398 break;
399 case 3:
400 glUniform3fv(handle, num_elems, f);
401 break;
402 case 4:
403 glUniform4fv(handle, num_elems, f);
404 break;
405 default:
406 ASSERT(false);
407 break;
408 }
409
410 return check_gl_error(name);
411 }
412
413 static bool glsl_set_shader_bool(ALLEGRO_SHADER *shader,
414 const char *name, bool b)
415 {
416 return glsl_set_shader_int(shader, name, b);
417 }
418
419 static struct ALLEGRO_SHADER_INTERFACE shader_glsl_vt =
420 {
421 glsl_attach_shader_source,
422 glsl_build_shader,
423 glsl_use_shader,
424 glsl_unuse_shader,
425 glsl_destroy_shader,
426 NULL, /* on_lost_device */
427 NULL, /* on_reset_device */
428 glsl_set_shader_sampler,
429 glsl_set_shader_matrix,
430 glsl_set_shader_int,
431 glsl_set_shader_float,
432 glsl_set_shader_int_vector,
433 glsl_set_shader_float_vector,
434 glsl_set_shader_bool
435 };
436
437 static void lookup_varlocs(ALLEGRO_OGL_VARLOCS *varlocs, GLuint program)
438 {
439 unsigned i;
440
441 varlocs->pos_loc = glGetAttribLocation(program, ALLEGRO_SHADER_VAR_POS);
442 varlocs->color_loc = glGetAttribLocation(program, ALLEGRO_SHADER_VAR_COLOR);
443 varlocs->projview_matrix_loc = glGetUniformLocation(program, ALLEGRO_SHADER_VAR_PROJVIEW_MATRIX);
444 varlocs->texcoord_loc = glGetAttribLocation(program, ALLEGRO_SHADER_VAR_TEXCOORD);
445 varlocs->use_tex_loc = glGetUniformLocation(program, ALLEGRO_SHADER_VAR_USE_TEX);
446 varlocs->tex_loc = glGetUniformLocation(program, ALLEGRO_SHADER_VAR_TEX);
447 varlocs->use_tex_matrix_loc = glGetUniformLocation(program, ALLEGRO_SHADER_VAR_USE_TEX_MATRIX);
448 varlocs->tex_matrix_loc = glGetUniformLocation(program, ALLEGRO_SHADER_VAR_TEX_MATRIX);
449 varlocs->alpha_test_loc = glGetUniformLocation(program, ALLEGRO_SHADER_VAR_ALPHA_TEST);
450 varlocs->alpha_func_loc = glGetUniformLocation(program, ALLEGRO_SHADER_VAR_ALPHA_FUNCTION);
451 varlocs->alpha_test_val_loc = glGetUniformLocation(program, ALLEGRO_SHADER_VAR_ALPHA_TEST_VALUE);
452
453 for (i = 0; i < ALLEGRO_PRIM_MAX_USER_ATTR; i++) {
454 /* al_user_attr_##0 */
455 char user_attr_name[sizeof(ALLEGRO_SHADER_VAR_USER_ATTR "999")];
456
457 snprintf(user_attr_name, sizeof(user_attr_name), ALLEGRO_SHADER_VAR_USER_ATTR "%d", i);
458 varlocs->user_attr_loc[i] = glGetAttribLocation(program, user_attr_name);
459 }
460
461 check_gl_error("glGetAttribLocation, glGetUniformLocation");
462 }
463
464 bool _al_glsl_set_projview_matrix(GLint projview_matrix_loc,
465 const ALLEGRO_TRANSFORM *t)
466 {
467 if (projview_matrix_loc >= 0) {
468 glUniformMatrix4fv(projview_matrix_loc, 1, false, (float *)t->m);
469 return true;
470 }
471
472 return false;
473 }
474
475 void _al_glsl_init_shaders(void)
476 {
477 _al_vector_init(&shaders, sizeof(ALLEGRO_SHADER *));
478 shaders_mutex = al_create_mutex();
479 }
480
481 void _al_glsl_shutdown_shaders(void)
482 {
483 _al_vector_free(&shaders);
484 al_destroy_mutex(shaders_mutex);
485 shaders_mutex = NULL;
486 }
487
488 /* Look through all the bitmaps associated with all the shaders and c;ear their
489 * shader field */
490 void _al_glsl_unuse_shaders(void)
491 {
492 unsigned i;
493 al_lock_mutex(shaders_mutex);
494 for (i = 0; i < _al_vector_size(&shaders); i++) {
495 unsigned j;
496 ALLEGRO_SHADER *shader = *((ALLEGRO_SHADER **)_al_vector_ref(&shaders, i));
497
498 for (j = 0; j < _al_vector_size(&shader->bitmaps); j++) {
499 ALLEGRO_BITMAP *bitmap =
500 *((ALLEGRO_BITMAP **)_al_vector_ref(&shader->bitmaps, j));
501 _al_set_bitmap_shader_field(bitmap, NULL);
502 }
503 }
504 al_unlock_mutex(shaders_mutex);
505 }
506
507 #endif
508
509 /* Function: al_get_opengl_program_object
510 */
511 GLuint al_get_opengl_program_object(ALLEGRO_SHADER *shader)
512 {
513 ASSERT(shader);
514 #ifdef ALLEGRO_CFG_SHADER_GLSL
515 if (shader->platform != ALLEGRO_SHADER_GLSL)
516 return 0;
517
518 return ((ALLEGRO_SHADER_GLSL_S *)shader)->program_object;
519 #else
520 return 0;
521 #endif
522 }
523
524
525 /* vim: set sts=3 sw=3 et: */