← Back to branch summary

~darkxst/ubuntu/raring/cogl/lp1163025

« back to all changes in this revision

Viewing changes to cogl/cogl-program.c

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2012-03-13 19:11:11 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20120313191111-3hgk529qkh9m6uk2
Tags: 1.9.8-0ubuntu1
https://launchpad.net/bugs/941617
* New upstream release (LP: #941617)
* Updated symbols & library name for soname update
* debian/control.in: Bump minimum glib to 2.28
* debian/patches/02_disable_armv5t_specific_optimization.patch: Disabled

Show diffs side-by-side

added added

removed removed

Lines of Context:
cogl/cogl-program.c
25
25
#include "config.h"
26
26
#endif
27
27
 
28
 
#include "cogl.h"
29
28
 
 
29
#include "cogl-util.h"
30
30
#include "cogl-internal.h"
31
31
#include "cogl-context-private.h"
32
32
#include "cogl-handle.h"
107
107
 
108
108
  /* Only one shader is allowed if the type is ARBfp */
109
109
  if (shader->language == COGL_SHADER_LANGUAGE_ARBFP)
110
 
    g_return_if_fail (program->attached_shaders == NULL);
 
110
    _COGL_RETURN_IF_FAIL (program->attached_shaders == NULL);
111
111
  else if (shader->language == COGL_SHADER_LANGUAGE_GLSL)
112
 
    g_return_if_fail (_cogl_program_get_language (program) ==
 
112
    _COGL_RETURN_IF_FAIL (_cogl_program_get_language (program) ==
113
113
                      COGL_SHADER_LANGUAGE_GLSL);
114
114
 
115
115
  program->attached_shaders
132
132
{
133
133
  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
134
134
 
135
 
  g_return_if_fail (handle == COGL_INVALID_HANDLE ||
 
135
  _COGL_RETURN_IF_FAIL (handle == COGL_INVALID_HANDLE ||
136
136
                    cogl_is_program (handle));
137
137
 
138
138
  if (ctx->current_program == 0 && handle != 0)
188
188
  return program->custom_uniforms->len - 1;
189
189
}
190
190
 
191
 
static void
192
 
cogl_program_uniform_x (CoglHandle handle,
193
 
                        int uniform_no,
194
 
                        int size,
195
 
                        int count,
196
 
                        CoglBoxedType type,
197
 
                        gsize value_size,
198
 
                        gconstpointer value,
199
 
                        gboolean transpose)
 
191
static CoglProgramUniform *
 
192
cogl_program_modify_uniform (CoglProgram *program,
 
193
                             int uniform_no)
200
194
{
201
 
  CoglProgram *program = handle;
202
 
 
203
 
  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
204
 
 
205
 
  g_return_if_fail (cogl_is_program (handle));
206
 
  g_return_if_fail (program != NULL);
207
 
 
208
 
  if (uniform_no >= 0 && uniform_no < program->custom_uniforms->len &&
209
 
      size >= 1 && size <= 4 && count >= 1)
210
 
    {
211
 
      CoglProgramUniform *uniform =
212
 
        &g_array_index (program->custom_uniforms,
213
 
                        CoglProgramUniform, uniform_no);
214
 
 
215
 
      if (count == 1)
216
 
        {
217
 
          if (uniform->value.count > 1)
218
 
            g_free (uniform->value.v.array);
219
 
 
220
 
          memcpy (uniform->value.v.float_value, value, value_size);
221
 
        }
222
 
      else
223
 
        {
224
 
          if (uniform->value.count > 1)
225
 
            {
226
 
              if (uniform->value.count != count ||
227
 
                  uniform->value.size != size ||
228
 
                  uniform->value.type != type)
229
 
                {
230
 
                  g_free (uniform->value.v.array);
231
 
                  uniform->value.v.array = g_malloc (count * value_size);
232
 
                }
233
 
            }
234
 
          else
235
 
            uniform->value.v.array = g_malloc (count * value_size);
236
 
 
237
 
          memcpy (uniform->value.v.array, value, count * value_size);
238
 
        }
239
 
 
240
 
      uniform->value.type = type;
241
 
      uniform->value.size = size;
242
 
      uniform->value.count = count;
243
 
      uniform->dirty = TRUE;
244
 
    }
 
195
  CoglProgramUniform *uniform;
 
196
 
 
197
  _COGL_RETURN_VAL_IF_FAIL (cogl_is_program (program), NULL);
 
198
  _COGL_RETURN_VAL_IF_FAIL (uniform_no >= 0 &&
 
199
                            uniform_no < program->custom_uniforms->len,
 
200
                            NULL);
 
201
 
 
202
  uniform = &g_array_index (program->custom_uniforms,
 
203
                            CoglProgramUniform, uniform_no);
 
204
  uniform->dirty = TRUE;
 
205
 
 
206
  return uniform;
245
207
}
246
208
 
247
209
void
248
210
cogl_program_uniform_1f (int uniform_no,
249
211
                         float  value)
250
212
{
 
213
  CoglProgramUniform *uniform;
 
214
 
251
215
  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
252
 
  cogl_program_uniform_x (ctx->current_program,
253
 
                          uniform_no, 1, 1, COGL_BOXED_FLOAT,
254
 
                          sizeof (float), &value, FALSE);
 
216
 
 
217
  uniform = cogl_program_modify_uniform (ctx->current_program, uniform_no);
 
218
  _cogl_boxed_value_set_1f (&uniform->value, value);
255
219
}
256
220
 
257
221
void
259
223
                             int uniform_location,
260
224
                             float value)
261
225
{
262
 
  cogl_program_uniform_x (handle,
263
 
                          uniform_location, 1, 1, COGL_BOXED_FLOAT,
264
 
                          sizeof (float), &value, FALSE);
 
226
  CoglProgramUniform *uniform;
 
227
 
 
228
  uniform = cogl_program_modify_uniform (handle, uniform_location);
 
229
  _cogl_boxed_value_set_1f (&uniform->value, value);
265
230
}
266
231
 
267
232
void
268
233
cogl_program_uniform_1i (int uniform_no,
269
234
                         int value)
270
235
{
 
236
  CoglProgramUniform *uniform;
 
237
 
271
238
  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
272
 
  cogl_program_uniform_x (ctx->current_program,
273
 
                          uniform_no, 1, 1, COGL_BOXED_INT,
274
 
                          sizeof (int), &value, FALSE);
 
239
 
 
240
  uniform = cogl_program_modify_uniform (ctx->current_program, uniform_no);
 
241
  _cogl_boxed_value_set_1i (&uniform->value, value);
275
242
}
276
243
 
277
244
void
279
246
                             int uniform_location,
280
247
                             int value)
281
248
{
282
 
  cogl_program_uniform_x (handle,
283
 
                          uniform_location, 1, 1, COGL_BOXED_INT,
284
 
                          sizeof (int), &value, FALSE);
 
249
  CoglProgramUniform *uniform;
 
250
 
 
251
  uniform = cogl_program_modify_uniform (handle, uniform_location);
 
252
  _cogl_boxed_value_set_1i (&uniform->value, value);
285
253
}
286
254
 
287
255
void
288
256
cogl_program_uniform_float (int uniform_no,
289
257
                            int size,
290
258
                            int count,
291
 
                            const GLfloat *value)
 
259
                            const float *value)
292
260
{
 
261
  CoglProgramUniform *uniform;
 
262
 
293
263
  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
294
 
  cogl_program_uniform_x (ctx->current_program,
295
 
                          uniform_no, size, count, COGL_BOXED_FLOAT,
296
 
                          sizeof (float) * size, value, FALSE);
 
264
 
 
265
  uniform = cogl_program_modify_uniform (ctx->current_program, uniform_no);
 
266
  _cogl_boxed_value_set_float (&uniform->value, size, count, value);
297
267
}
298
268
 
299
269
void
303
273
                                int count,
304
274
                                const float *value)
305
275
{
306
 
  cogl_program_uniform_x (handle,
307
 
                          uniform_location, n_components, count,
308
 
                          COGL_BOXED_FLOAT,
309
 
                          sizeof (float) * n_components, value, FALSE);
 
276
  CoglProgramUniform *uniform;
 
277
 
 
278
  uniform = cogl_program_modify_uniform (handle, uniform_location);
 
279
  _cogl_boxed_value_set_float (&uniform->value, n_components, count, value);
310
280
}
311
281
 
312
282
void
313
283
cogl_program_uniform_int (int uniform_no,
314
284
                          int size,
315
285
                          int count,
316
 
                          const GLint *value)
 
286
                          const int *value)
317
287
{
 
288
  CoglProgramUniform *uniform;
 
289
 
318
290
  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
319
 
  cogl_program_uniform_x (ctx->current_program,
320
 
                          uniform_no, size, count, COGL_BOXED_INT,
321
 
                          sizeof (int) * size, value, FALSE);
 
291
 
 
292
  uniform = cogl_program_modify_uniform (ctx->current_program, uniform_no);
 
293
  _cogl_boxed_value_set_int (&uniform->value, size, count, value);
322
294
}
323
295
 
324
296
void
328
300
                              int count,
329
301
                              const int *value)
330
302
{
331
 
  cogl_program_uniform_x (handle,
332
 
                          uniform_location, n_components, count,
333
 
                          COGL_BOXED_INT,
334
 
                          sizeof (int) * n_components, value, FALSE);
 
303
  CoglProgramUniform *uniform;
 
304
 
 
305
  uniform = cogl_program_modify_uniform (handle, uniform_location);
 
306
  _cogl_boxed_value_set_int (&uniform->value, n_components, count, value);
335
307
}
336
308
 
337
309
void
342
314
                                 gboolean transpose,
343
315
                                 const float *value)
344
316
{
345
 
  g_return_if_fail (cogl_is_program (handle));
 
317
  CoglProgramUniform *uniform;
346
318
 
347
 
  cogl_program_uniform_x (handle,
348
 
                          uniform_location, dimensions, count,
349
 
                          COGL_BOXED_MATRIX,
350
 
                          sizeof (float) * dimensions * dimensions,
351
 
                          value,
352
 
                          transpose);
 
319
  uniform = cogl_program_modify_uniform (handle, uniform_location);
 
320
  _cogl_boxed_value_set_matrix (&uniform->value,
 
321
                                dimensions,
 
322
                                count,
 
323
                                transpose,
 
324
                                value);
353
325
}
354
326
 
355
327
void
359
331
                             gboolean transpose,
360
332
                             const float *value)
361
333
{
 
334
  CoglProgramUniform *uniform;
 
335
 
362
336
  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
363
 
  cogl_program_set_uniform_matrix (ctx->current_program,
364
 
                                   uniform_no, size, count, transpose, value);
 
337
 
 
338
  uniform = cogl_program_modify_uniform (ctx->current_program, uniform_no);
 
339
  _cogl_boxed_value_set_matrix (&uniform->value, size, count, transpose, value);
365
340
}
366
341
 
367
342
/* ARBfp local parameters can be referenced like:
383
358
      *p++ = input[i];
384
359
  input[i] = '\0';
385
360
 
386
 
  g_return_val_if_fail (strncmp ("program.local[", input, 14) == 0, -1);
 
361
  _COGL_RETURN_VAL_IF_FAIL (strncmp ("program.local[", input, 14) == 0, -1);
387
362
 
388
363
  _index = g_ascii_strtoull (input + 14, &endptr, 10);
389
 
  g_return_val_if_fail (endptr != input + 14, -1);
390
 
  g_return_val_if_fail (*endptr == ']', -1);
 
364
  _COGL_RETURN_VAL_IF_FAIL (endptr != input + 14, -1);
 
365
  _COGL_RETURN_VAL_IF_FAIL (*endptr == ']', -1);
391
366
 
392
 
  g_return_val_if_fail (_index >= 0, -1);
 
367
  _COGL_RETURN_VAL_IF_FAIL (_index >= 0, -1);
393
368
 
394
369
  g_free (input);
395
370
 
396
371
  return _index;
397
372
}
398
373
 
399
 
static void
400
 
_cogl_program_flush_uniform_glsl (GLint location,
401
 
                                  CoglBoxedValue *value)
402
 
{
403
 
  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
404
 
 
405
 
  switch (value->type)
406
 
    {
407
 
    case COGL_BOXED_NONE:
408
 
      break;
409
 
 
410
 
    case COGL_BOXED_INT:
411
 
      {
412
 
        int *ptr;
413
 
 
414
 
        if (value->count == 1)
415
 
          ptr = value->v.int_value;
416
 
        else
417
 
          ptr = value->v.int_array;
418
 
 
419
 
        switch (value->size)
420
 
          {
421
 
          case 1: ctx->glUniform1iv (location, value->count, ptr); break;
422
 
          case 2: ctx->glUniform2iv (location, value->count, ptr); break;
423
 
          case 3: ctx->glUniform3iv (location, value->count, ptr); break;
424
 
          case 4: ctx->glUniform4iv (location, value->count, ptr); break;
425
 
          }
426
 
      }
427
 
      break;
428
 
 
429
 
    case COGL_BOXED_FLOAT:
430
 
      {
431
 
        float *ptr;
432
 
 
433
 
        if (value->count == 1)
434
 
          ptr = value->v.float_value;
435
 
        else
436
 
          ptr = value->v.float_array;
437
 
 
438
 
        switch (value->size)
439
 
          {
440
 
          case 1: ctx->glUniform1fv (location, value->count, ptr); break;
441
 
          case 2: ctx->glUniform2fv (location, value->count, ptr); break;
442
 
          case 3: ctx->glUniform3fv (location, value->count, ptr); break;
443
 
          case 4: ctx->glUniform4fv (location, value->count, ptr); break;
444
 
          }
445
 
      }
446
 
      break;
447
 
 
448
 
    case COGL_BOXED_MATRIX:
449
 
      {
450
 
        float *ptr;
451
 
 
452
 
        if (value->count == 1)
453
 
          ptr = value->v.matrix;
454
 
        else
455
 
          ptr = value->v.float_array;
456
 
 
457
 
        switch (value->size)
458
 
          {
459
 
          case 2:
460
 
            ctx->glUniformMatrix2fv (location, value->count,
461
 
                                     value->transpose, ptr);
462
 
            break;
463
 
          case 3:
464
 
            ctx->glUniformMatrix3fv (location, value->count,
465
 
                                     value->transpose, ptr);
466
 
            break;
467
 
          case 4:
468
 
            ctx->glUniformMatrix4fv (location, value->count,
469
 
                                     value->transpose, ptr);
470
 
            break;
471
 
          }
472
 
      }
473
 
      break;
474
 
    }
475
 
}
476
 
 
477
374
#ifdef HAVE_COGL_GL
478
375
 
479
376
static void
484
381
 
485
382
  if (value->type != COGL_BOXED_NONE)
486
383
    {
487
 
      g_return_if_fail (value->type == COGL_BOXED_FLOAT);
488
 
      g_return_if_fail (value->size == 4);
489
 
      g_return_if_fail (value->count == 1);
 
384
      _COGL_RETURN_IF_FAIL (value->type == COGL_BOXED_FLOAT);
 
385
      _COGL_RETURN_IF_FAIL (value->size == 4);
 
386
      _COGL_RETURN_IF_FAIL (value->count == 1);
490
387
 
491
388
      GE( ctx, glProgramLocalParameter4fv (GL_FRAGMENT_PROGRAM_ARB, location,
492
389
                                           value->v.float_value) );
505
402
 
506
403
  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
507
404
 
508
 
  g_return_if_fail (ctx->driver != COGL_DRIVER_GLES1);
 
405
  _COGL_RETURN_IF_FAIL (ctx->driver != COGL_DRIVER_GLES1);
509
406
 
510
407
  for (i = 0; i < program->custom_uniforms->len; i++)
511
408
    {
534
431
              switch (_cogl_program_get_language (program))
535
432
                {
536
433
                case COGL_SHADER_LANGUAGE_GLSL:
537
 
                  _cogl_program_flush_uniform_glsl (uniform->location,
538
 
                                                    &uniform->value);
 
434
                  _cogl_boxed_value_set_uniform (ctx,
 
435
                                                 uniform->location,
 
436
                                                 &uniform->value);
539
437
                  break;
540
438
 
541
439
                case COGL_SHADER_LANGUAGE_ARBFP: