cogl-primitives.c 25.9 KB
Newer Older
1
/*
2
 * Cogl
3
 *
4
 * A Low-Level GPU Graphics and Utilities API
5
 *
6
 * Copyright (C) 2007,2008,2009,2010 Intel Corporation.
7
 *
8
9
10
11
12
13
14
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy,
 * modify, merge, publish, distribute, sublicense, and/or sell copies
 * of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
15
 *
16
17
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
18
 *
19
20
21
22
23
24
25
26
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
27
28
 *
 *
29
30
31
32
33
34
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

35
#include "cogl-debug.h"
36
#include "cogl-context-private.h"
37
#include "cogl-journal-private.h"
38
#include "cogl-texture-private.h"
39
40
#include "cogl-pipeline-private.h"
#include "cogl-pipeline-opengl-private.h"
41
#include "cogl-framebuffer-private.h"
42
#include "cogl-attribute-private.h"
43
#include "cogl-private.h"
44
#include "cogl-meta-texture.h"
45
#include "cogl-framebuffer-private.h"
46
#include "cogl-primitives-private.h"
47
48

#include <string.h>
49
#include <math.h>
50
51
52

#define _COGL_MAX_BEZ_RECURSE_DEPTH 16

53
54
typedef struct _TextureSlicedQuadState
{
55
  CoglFramebuffer *framebuffer;
56
  CoglPipeline *pipeline;
57
  CoglTexture *main_texture;
58
59
60
61
62
63
64
65
  float tex_virtual_origin_x;
  float tex_virtual_origin_y;
  float quad_origin_x;
  float quad_origin_y;
  float v_to_q_scale_x;
  float v_to_q_scale_y;
  float quad_len_x;
  float quad_len_y;
66
67
  CoglBool flipped_x;
  CoglBool flipped_y;
68
69
} TextureSlicedQuadState;

70
static void
71
log_quad_sub_textures_cb (CoglTexture *texture,
72
73
                          const float *subtexture_coords,
                          const float *virtual_coords,
74
                          void *user_data)
75
{
76
  TextureSlicedQuadState *state = user_data;
77
  CoglFramebuffer *framebuffer = state->framebuffer;
78
  CoglTexture *texture_override;
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
  float quad_coords[4];

#define TEX_VIRTUAL_TO_QUAD(V, Q, AXIS) \
    do { \
	Q = V - state->tex_virtual_origin_##AXIS; \
	Q *= state->v_to_q_scale_##AXIS; \
	if (state->flipped_##AXIS) \
	    Q = state->quad_len_##AXIS - Q; \
	Q += state->quad_origin_##AXIS; \
    } while (0);

  TEX_VIRTUAL_TO_QUAD (virtual_coords[0], quad_coords[0], x);
  TEX_VIRTUAL_TO_QUAD (virtual_coords[1], quad_coords[1], y);

  TEX_VIRTUAL_TO_QUAD (virtual_coords[2], quad_coords[2], x);
  TEX_VIRTUAL_TO_QUAD (virtual_coords[3], quad_coords[3], y);

#undef TEX_VIRTUAL_TO_QUAD

  COGL_NOTE (DRAW,
             "~~~~~ slice\n"
             "qx1: %f\t"
             "qy1: %f\n"
             "qx2: %f\t"
             "qy2: %f\n"
             "tx1: %f\t"
             "ty1: %f\n"
             "tx2: %f\t"
             "ty2: %f\n",
             quad_coords[0], quad_coords[1],
             quad_coords[2], quad_coords[3],
             subtexture_coords[0], subtexture_coords[1],
             subtexture_coords[2], subtexture_coords[3]);

113
114
  /* We only need to override the texture if it's different from the
     main texture */
115
116
  if (texture == state->main_texture)
    texture_override = NULL;
117
  else
118
    texture_override = texture;
119

120
121
  _cogl_journal_log_quad (framebuffer->journal,
                          quad_coords,
122
                          state->pipeline,
123
                          1, /* one layer */
124
                          texture_override, /* replace the layer0 texture */
125
126
127
128
                          subtexture_coords,
                          4);
}

129
130
131
132
133
typedef struct _ValidateFirstLayerState
{
  CoglPipeline *override_pipeline;
} ValidateFirstLayerState;

134
static CoglBool
135
136
137
138
139
140
141
validate_first_layer_cb (CoglPipeline *pipeline,
                         int layer_index,
                         void *user_data)
{
  ValidateFirstLayerState *state = user_data;
  CoglPipelineWrapMode clamp_to_edge =
    COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE;
142
143
  CoglPipelineWrapMode wrap_s;
  CoglPipelineWrapMode wrap_t;
144
145
146
147

  /* We can't use hardware repeat so we need to set clamp to edge
   * otherwise it might pull in edge pixels from the other side. By
   * default WRAP_MODE_AUTOMATIC becomes CLAMP_TO_EDGE so we only need
148
149
   * to override if the wrap mode isn't already automatic or
   * clamp_to_edge.
150
   */
151
152
153
  wrap_s = cogl_pipeline_get_layer_wrap_mode_s (pipeline, layer_index);
  if (wrap_s != COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE &&
      wrap_s != COGL_PIPELINE_WRAP_MODE_AUTOMATIC)
154
155
156
    {
      if (!state->override_pipeline)
        state->override_pipeline = cogl_pipeline_copy (pipeline);
157
158
      cogl_pipeline_set_layer_wrap_mode_s (state->override_pipeline,
                                           layer_index, clamp_to_edge);
159
    }
160
161
162
163

  wrap_t = cogl_pipeline_get_layer_wrap_mode_t (pipeline, layer_index);
  if (wrap_t != COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE &&
      wrap_t != COGL_PIPELINE_WRAP_MODE_AUTOMATIC)
164
165
166
    {
      if (!state->override_pipeline)
        state->override_pipeline = cogl_pipeline_copy (pipeline);
167
168
      cogl_pipeline_set_layer_wrap_mode_t (state->override_pipeline,
                                           layer_index, clamp_to_edge);
169
170
171
172
173
    }

  return FALSE;
}

174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
/* This path doesn't currently support multitexturing but is used for
 * CoglTextures that don't support repeating using the GPU so we need to
 * manually emit extra geometry to fake the repeating. This includes:
 *
 * - CoglTexture2DSliced: when made of > 1 slice or if the users given
 *   texture coordinates require repeating,
 * - CoglTexture2DAtlas: if the users given texture coordinates require
 *   repeating,
 * - CoglTextureRectangle: if the users given texture coordinates require
 *   repeating,
 * - CoglTexturePixmap: if the users given texture coordinates require
 *   repeating
 */
/* TODO: support multitexturing */
static void
189
_cogl_texture_quad_multiple_primitives (CoglFramebuffer *framebuffer,
190
                                        CoglPipeline *pipeline,
191
                                        CoglTexture *texture,
192
193
194
195
196
197
                                        int layer_index,
                                        const float *position,
                                        float tx_1,
                                        float ty_1,
                                        float tx_2,
                                        float ty_2)
198
199
{
  TextureSlicedQuadState state;
200
201
202
203
  CoglBool tex_virtual_flipped_x;
  CoglBool tex_virtual_flipped_y;
  CoglBool quad_flipped_x;
  CoglBool quad_flipped_y;
204
  ValidateFirstLayerState validate_first_layer_state;
205
  CoglPipelineWrapMode wrap_s, wrap_t;
206

207
208
209
  wrap_s = cogl_pipeline_get_layer_wrap_mode_s (pipeline, layer_index);
  wrap_t = cogl_pipeline_get_layer_wrap_mode_t (pipeline, layer_index);

210
211
212
213
  validate_first_layer_state.override_pipeline = NULL;
  cogl_pipeline_foreach_layer (pipeline,
                               validate_first_layer_cb,
                               &validate_first_layer_state);
214

215
  state.framebuffer = framebuffer;
216
  state.main_texture = texture;
217

218
219
220
221
  if (validate_first_layer_state.override_pipeline)
    state.pipeline = validate_first_layer_state.override_pipeline;
  else
    state.pipeline = pipeline;
222

223
224
225
226
227
228
229
  /* Get together the data we need to transform the virtual texture
   * coordinates of each slice into quad coordinates...
   *
   * NB: We need to consider that the quad coordinates and the texture
   * coordinates may be inverted along the x or y axis, and must preserve the
   * inversions when we emit the final geometry.
   */
230

231
232
233
234
235
#define X0 0
#define Y0 1
#define X1 2
#define Y1 3

236
237
238
239
240
  tex_virtual_flipped_x = (tx_1 > tx_2) ? TRUE : FALSE;
  tex_virtual_flipped_y = (ty_1 > ty_2) ? TRUE : FALSE;
  state.tex_virtual_origin_x = tex_virtual_flipped_x ? tx_2 : tx_1;
  state.tex_virtual_origin_y = tex_virtual_flipped_y ? ty_2 : ty_1;

241
242
243
244
  quad_flipped_x = (position[X0] > position[X1]) ? TRUE : FALSE;
  quad_flipped_y = (position[Y0] > position[Y1]) ? TRUE : FALSE;
  state.quad_origin_x = quad_flipped_x ? position[X1] : position[X0];
  state.quad_origin_y = quad_flipped_y ? position[Y1] : position[Y0];
245
246
247
248
249
250
251
252

  /* flatten the two forms of coordinate inversion into one... */
  state.flipped_x = tex_virtual_flipped_x ^ quad_flipped_x;
  state.flipped_y = tex_virtual_flipped_y ^ quad_flipped_y;

  /* We use the _len_AXIS naming here instead of _width and _height because
   * log_quad_slice_cb uses a macro with symbol concatenation to handle both
   * axis, so this is more convenient... */
253
254
255
256
257
258
259
  state.quad_len_x = fabs (position[X1] - position[X0]);
  state.quad_len_y = fabs (position[Y1] - position[Y0]);

#undef X0
#undef Y0
#undef X1
#undef Y1
260
261
262
263

  state.v_to_q_scale_x = fabs (state.quad_len_x / (tx_2 - tx_1));
  state.v_to_q_scale_y = fabs (state.quad_len_y / (ty_2 - ty_1));

264
265
266
  /* For backwards compatablity the default wrap mode for cogl_rectangle() is
   * _REPEAT... */
  if (wrap_s == COGL_PIPELINE_WRAP_MODE_AUTOMATIC)
267
    wrap_s = COGL_PIPELINE_WRAP_MODE_REPEAT;
268
  if (wrap_t == COGL_PIPELINE_WRAP_MODE_AUTOMATIC)
269
270
271
272
273
274
275
276
    wrap_t = COGL_PIPELINE_WRAP_MODE_REPEAT;

  cogl_meta_texture_foreach_in_region (COGL_META_TEXTURE (texture),
                                       tx_1, ty_1, tx_2, ty_2,
                                       wrap_s,
                                       wrap_t,
                                       log_quad_sub_textures_cb,
                                       &state);
277
278
279

  if (validate_first_layer_state.override_pipeline)
    cogl_object_unref (validate_first_layer_state.override_pipeline);
280
281
}

282
283
284
285
286
287
288
289
typedef struct _ValidateTexCoordsState
{
  int i;
  int n_layers;
  const float *user_tex_coords;
  int user_tex_coords_len;
  float *final_tex_coords;
  CoglPipeline *override_pipeline;
290
  CoglBool needs_multiple_primitives;
291
292
293
294
295
} ValidateTexCoordsState;

/*
 * Validate the texture coordinates for this rectangle.
 */
296
static CoglBool
297
298
299
300
301
validate_tex_coords_cb (CoglPipeline *pipeline,
                        int layer_index,
                        void *user_data)
{
  ValidateTexCoordsState *state = user_data;
302
  CoglTexture *texture;
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
  const float *in_tex_coords;
  float *out_tex_coords;
  float default_tex_coords[4] = {0.0, 0.0, 1.0, 1.0};
  CoglTransformResult transform_result;

  state->i++;

  /* FIXME: we should be able to avoid this copying when no
   * transform is required by the texture backend and the user
   * has supplied enough coordinates for all the layers.
   */

  /* If the user didn't supply texture coordinates for this layer
     then use the default coords */
  if (state->i >= state->user_tex_coords_len / 4)
    in_tex_coords = default_tex_coords;
  else
    in_tex_coords = &state->user_tex_coords[state->i * 4];

  out_tex_coords = &state->final_tex_coords[state->i * 4];

  memcpy (out_tex_coords, in_tex_coords, sizeof (float) * 4);

326
327
328
329
330
331
  texture = cogl_pipeline_get_layer_texture (pipeline, layer_index);

  /* NB: NULL textures are handled by _cogl_pipeline_flush_gl_state */
  if (!texture)
    return TRUE;

332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
  /* Convert the texture coordinates to GL.
   */
  transform_result =
    _cogl_texture_transform_quad_coords_to_gl (texture,
                                               out_tex_coords);
  /* If the texture has waste or we are using GL_TEXTURE_RECT we
   * can't handle texture repeating so we can't use the layer if
   * repeating is required.
   *
   * NB: We already know that no texture matrix is being used if the
   * texture doesn't support hardware repeat.
   */
  if (transform_result == COGL_TRANSFORM_SOFTWARE_REPEAT)
    {
      if (state->i == 0)
        {
          if (state->n_layers > 1)
            {
350
              static CoglBool warning_seen = FALSE;
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
              if (!warning_seen)
                g_warning ("Skipping layers 1..n of your material since "
                           "the first layer doesn't support hardware "
                           "repeat (e.g. because of waste or use of "
                           "GL_TEXTURE_RECTANGLE_ARB) and you supplied "
                           "texture coordinates outside the range [0,1]."
                           "Falling back to software repeat assuming "
                           "layer 0 is the most important one keep");
              warning_seen = TRUE;
            }

          if (state->override_pipeline)
            cogl_object_unref (state->override_pipeline);
          state->needs_multiple_primitives = TRUE;
          return FALSE;
        }
      else
        {
369
          static CoglBool warning_seen = FALSE;
370
371
372
373
374
375
376
377
378
379
          if (!warning_seen)
            g_warning ("Skipping layer %d of your material "
                       "since you have supplied texture coords "
                       "outside the range [0,1] but the texture "
                       "doesn't support hardware repeat (e.g. "
                       "because of waste or use of "
                       "GL_TEXTURE_RECTANGLE_ARB). This isn't "
                       "supported with multi-texturing.", state->i);
          warning_seen = TRUE;

380
          cogl_pipeline_set_layer_texture (pipeline, layer_index, NULL);
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
        }
    }

  /* By default WRAP_MODE_AUTOMATIC becomes to CLAMP_TO_EDGE. If
     the texture coordinates need repeating then we'll override
     this to GL_REPEAT. Otherwise we'll leave it at CLAMP_TO_EDGE
     so that it won't blend in pixels from the opposite side when
     the full texture is drawn with GL_LINEAR filter mode */
  if (transform_result == COGL_TRANSFORM_HARDWARE_REPEAT)
    {
      if (cogl_pipeline_get_layer_wrap_mode_s (pipeline, layer_index) ==
          COGL_PIPELINE_WRAP_MODE_AUTOMATIC)
        {
          if (!state->override_pipeline)
            state->override_pipeline = cogl_pipeline_copy (pipeline);
          cogl_pipeline_set_layer_wrap_mode_s (state->override_pipeline,
                                               layer_index,
                                               COGL_PIPELINE_WRAP_MODE_REPEAT);
        }
      if (cogl_pipeline_get_layer_wrap_mode_t (pipeline, layer_index) ==
          COGL_PIPELINE_WRAP_MODE_AUTOMATIC)
        {
          if (!state->override_pipeline)
            state->override_pipeline = cogl_pipeline_copy (pipeline);
          cogl_pipeline_set_layer_wrap_mode_t (state->override_pipeline,
                                               layer_index,
                                               COGL_PIPELINE_WRAP_MODE_REPEAT);
        }
    }

  return TRUE;
}

414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
/* This path supports multitexturing but only when each of the layers is
 * handled with a single GL texture. Also if repeating is necessary then
 * _cogl_texture_can_hardware_repeat() must return TRUE.
 * This includes layers made from:
 *
 * - CoglTexture2DSliced: if only comprised of a single slice with optional
 *   waste, assuming the users given texture coordinates don't require
 *   repeating.
 * - CoglTexture{1D,2D,3D}: always.
 * - CoglTexture2DAtlas: assuming the users given texture coordinates don't
 *   require repeating.
 * - CoglTextureRectangle: assuming the users given texture coordinates don't
 *   require repeating.
 * - CoglTexturePixmap: assuming the users given texture coordinates don't
 *   require repeating.
 */
430
static CoglBool
431
_cogl_multitexture_quad_single_primitive (CoglFramebuffer *framebuffer,
432
                                          CoglPipeline *pipeline,
433
                                          const float  *position,
434
                                          const float  *user_tex_coords,
435
                                          int user_tex_coords_len)
436
{
437
438
439
  int n_layers = cogl_pipeline_get_n_layers (pipeline);
  ValidateTexCoordsState state;
  float *final_tex_coords = alloca (sizeof (float) * 4 * n_layers);
440

441
442
443
444
445
446
447
  state.i = -1;
  state.n_layers = n_layers;
  state.user_tex_coords = user_tex_coords;
  state.user_tex_coords_len = user_tex_coords_len;
  state.final_tex_coords = final_tex_coords;
  state.override_pipeline = NULL;
  state.needs_multiple_primitives = FALSE;
448

449
450
451
  cogl_pipeline_foreach_layer (pipeline,
                               validate_tex_coords_cb,
                               &state);
452

453
454
  if (state.needs_multiple_primitives)
    return FALSE;
455

456
457
  if (state.override_pipeline)
    pipeline = state.override_pipeline;
458

459
460
  _cogl_journal_log_quad (framebuffer->journal,
                          position,
461
                          pipeline,
462
                          n_layers,
463
                          NULL, /* no texture override */
464
465
466
                          final_tex_coords,
                          n_layers * 4);

467
468
469
  if (state.override_pipeline)
    cogl_object_unref (state.override_pipeline);

470
471
472
  return TRUE;
}

473
474
typedef struct _ValidateLayerState
{
475
  CoglContext *ctx;
476
477
478
  int i;
  int first_layer;
  CoglPipeline *override_source;
479
  CoglBool all_use_sliced_quad_fallback;
480
481
} ValidateLayerState;

482
static CoglBool
483
484
485
486
487
_cogl_rectangles_validate_layer_cb (CoglPipeline *pipeline,
                                    int layer_index,
                                    void *user_data)
{
  ValidateLayerState *state = user_data;
488
  CoglTexture *texture;
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533

  state->i++;

  /* We need to ensure the mipmaps are ready before deciding
   * anything else about the texture because the texture storage
   * could completely change if it needs to be migrated out of the
   * atlas and will affect how we validate the layer.
   *
   * FIXME: this needs to be generalized. There could be any
   * number of things that might require a shuffling of the
   * underlying texture storage. We could add two mechanisms to
   * generalize this a bit...
   *
   * 1) add a _cogl_pipeline_layer_update_storage() function that
   * would for instance consider if mipmapping is necessary and
   * potentially migrate the texture from an atlas.
   *
   * 2) allow setting of transient primitive-flags on a pipeline
   * that may affect the outcome of _update_storage(). One flag
   * could indicate that we expect to sample beyond the bounds of
   * the texture border.
   *
   *   flags = COGL_PIPELINE_PRIMITIVE_FLAG_VALID_BORDERS;
   *   _cogl_pipeline_layer_assert_primitive_flags (layer, flags)
   *   _cogl_pipeline_layer_update_storage (layer)
   *   enqueue primitive in journal
   *
   *   when the primitive is dequeued and drawn we should:
   *   _cogl_pipeline_flush_gl_state (pipeline)
   *   draw primitive
   *   _cogl_pipeline_unassert_primitive_flags (layer, flags);
   *
   * _cogl_pipeline_layer_update_storage should take into
   * consideration all the asserted primitive requirements.  (E.g.
   * there could be multiple primitives in the journal - or in a
   * renderlist in the future - that need mipmaps or that need
   * valid contents beyond their borders (for cogl_polygon)
   * meaning they can't work with textures in an atas, so
   * _cogl_pipeline_layer_update_storage would pass on these
   * requirements to the texture atlas backend which would make
   * sure the referenced texture is migrated out of the atlas and
   * mipmaps are generated.)
   */
  _cogl_pipeline_pre_paint_for_layer (pipeline, layer_index);

534
  texture = cogl_pipeline_get_layer_texture (pipeline, layer_index);
535

536
  /* NULL textures are handled by
537
   * _cogl_pipeline_flush_gl_state */
538
  if (texture == NULL)
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
    return TRUE;

  if (state->i == 0)
    state->first_layer = layer_index;

  /* XXX:
   * For now, if the first layer is sliced then all other layers are
   * ignored since we currently don't support multi-texturing with
   * sliced textures. If the first layer is not sliced then any other
   * layers found to be sliced will be skipped. (with a warning)
   *
   * TODO: Add support for multi-texturing rectangles with sliced
   * textures if no texture matrices are in use.
   */
  if (cogl_texture_is_sliced (texture))
    {
      if (state->i == 0)
        {
557
558
          if (cogl_pipeline_get_n_layers (pipeline) > 1)
            {
559
              static CoglBool warning_seen = FALSE;
560

561
562
563
              if (!state->override_source)
                state->override_source = cogl_pipeline_copy (pipeline);
              _cogl_pipeline_prune_to_n_layers (state->override_source, 1);
564

565
566
567
568
569
570
571
572
573
574
              if (!warning_seen)
                g_warning ("Skipping layers 1..n of your pipeline since "
                           "the first layer is sliced. We don't currently "
                           "support any multi-texturing with sliced "
                           "textures but assume layer 0 is the most "
                           "important to keep");
              warning_seen = TRUE;
            }

          state->all_use_sliced_quad_fallback = TRUE;
575
576
577
578
579

          return FALSE;
        }
      else
        {
580
          static CoglBool warning_seen = FALSE;
581
          CoglTexture2D *tex_2d;
582
583
584
585
586
587
588
589

          if (!warning_seen)
            g_warning ("Skipping layer %d of your pipeline consisting of "
                       "a sliced texture (unsuported for multi texturing)",
                       state->i);
          warning_seen = TRUE;

          /* Note: currently only 2D textures can be sliced. */
590
          tex_2d = state->ctx->default_gl_texture_2d_tex;
591
          cogl_pipeline_set_layer_texture (pipeline, layer_index,
592
                                           COGL_TEXTURE (tex_2d));
593
594
595
596
597
598
599
          return TRUE;
        }
    }

  return TRUE;
}

600
601
602
603
604
void
_cogl_framebuffer_draw_multitextured_rectangles (
                                        CoglFramebuffer *framebuffer,
                                        CoglPipeline *pipeline,
                                        CoglMultiTexturedRect *rects,
Neil Roberts's avatar
Neil Roberts committed
605
                                        int n_rects)
606
{
607
608
  CoglContext *ctx = framebuffer->context;
  CoglPipeline *original_pipeline;
609
  ValidateLayerState state;
610
  int i;
611

612
  original_pipeline = pipeline;
613
614

  /*
615
   * Validate all the layers of the current source pipeline...
616
   */
617
  state.ctx = ctx;
618
619
620
621
622
623
624
  state.i = -1;
  state.first_layer = 0;
  state.override_source = NULL;
  state.all_use_sliced_quad_fallback = FALSE;
  cogl_pipeline_foreach_layer (pipeline,
                               _cogl_rectangles_validate_layer_cb,
                               &state);
625

626
627
  if (state.override_source)
    pipeline = state.override_source;
628
629
630
631
632
633
634

  /*
   * Emit geometry for each of the rectangles...
   */

  for (i = 0; i < n_rects; i++)
    {
635
      CoglTexture *texture;
636
      const float default_tex_coords[4] = {0.0, 0.0, 1.0, 1.0};
637
638
      const float *tex_coords;

639
      if (!state.all_use_sliced_quad_fallback)
640
        {
641
          CoglBool success =
642
            _cogl_multitexture_quad_single_primitive (framebuffer,
643
                                                      pipeline,
644
                                                      rects[i].position,
645
646
647
648
649
650
651
652
653
                                                      rects[i].tex_coords,
                                                      rects[i].tex_coords_len);

          /* NB: If _cogl_multitexture_quad_single_primitive fails then it
           * means the user tried to use texture repeat with a texture that
           * can't be repeated by the GPU (e.g. due to waste or use of
           * GL_TEXTURE_RECTANGLE_ARB) */
          if (success)
            continue;
654
        }
655
656
657

      /* If multitexturing failed or we are drawing with a sliced texture
       * then we only support a single layer so we pluck out the texture
658
       * from the first pipeline layer... */
659
      texture = cogl_pipeline_get_layer_texture (pipeline, state.first_layer);
660
661
662
663
664
665

      if (rects[i].tex_coords)
        tex_coords = rects[i].tex_coords;
      else
        tex_coords = default_tex_coords;

666
667
      COGL_NOTE (DRAW, "Drawing Tex Quad (Multi-Prim Mode)");

668
      _cogl_texture_quad_multiple_primitives (framebuffer,
669
                                              pipeline,
670
                                              texture,
671
                                              state.first_layer,
672
                                              rects[i].position,
673
674
675
676
                                              tex_coords[0],
                                              tex_coords[1],
                                              tex_coords[2],
                                              tex_coords[3]);
677
678
    }

679
  if (pipeline != original_pipeline)
680
    cogl_object_unref (pipeline);
681
682
}

683
void
684
685
686
_cogl_rectangle_immediate (CoglFramebuffer *framebuffer,
                           CoglPipeline *pipeline,
                           float x_1,
687
688
689
690
691
692
693
694
                           float y_1,
                           float x_2,
                           float y_2)
{
  /* Draw a rectangle using the vertex array API to avoid going
     through the journal. This should only be used in cases where the
     code might be called while the journal is already being flushed
     such as when flushing the clip state */
695
  CoglContext *ctx = framebuffer->context;
696
697
698
699
700
701
702
  float vertices[8] =
    {
      x_1, y_1,
      x_1, y_2,
      x_2, y_1,
      x_2, y_2
    };
703
  CoglAttributeBuffer *attribute_buffer;
704
  CoglAttribute *attributes[1];
705

706
707
  attribute_buffer =
    cogl_attribute_buffer_new (ctx, sizeof (vertices), vertices);
708
  attributes[0] = cogl_attribute_new (attribute_buffer,
709
710
711
712
713
                                      "cogl_position_in",
                                      sizeof (float) * 2, /* stride */
                                      0, /* offset */
                                      2, /* n_components */
                                      COGL_ATTRIBUTE_TYPE_FLOAT);
714

715
716
717
718
719
720
721
722
723
  _cogl_framebuffer_draw_attributes (framebuffer,
                                     pipeline,
                                     COGL_VERTICES_MODE_TRIANGLE_STRIP,
                                     0, /* first_index */
                                     4, /* n_vertices */
                                     attributes,
                                     1,
                                     COGL_DRAW_SKIP_JOURNAL_FLUSH |
                                     COGL_DRAW_SKIP_PIPELINE_VALIDATION |
Neil Roberts's avatar
Neil Roberts committed
724
                                     COGL_DRAW_SKIP_FRAMEBUFFER_FLUSH);
725

726
727

  cogl_object_unref (attributes[0]);
728
  cogl_object_unref (attribute_buffer);
729
}