| 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: */ |