1 /*
2  * Cogl
3  *
4  * A Low Level GPU Graphics and Utilities API
5  *
6  * Copyright (C) 2011 Intel Corporation.
7  *
8  * Permission is hereby granted, free of charge, to any person
9  * obtaining a copy of this software and associated documentation
10  * files (the "Software"), to deal in the Software without
11  * restriction, including without limitation the rights to use, copy,
12  * modify, merge, publish, distribute, sublicense, and/or sell copies
13  * of the Software, and to permit persons to whom the Software is
14  * furnished to do so, subject to the following conditions:
15  *
16  * The above copyright notice and this permission notice shall be
17  * included in all copies or substantial portions of the Software.
18  *
19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
20  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
22  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
23  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
24  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
25  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26  * SOFTWARE.
27  *
28  *
29  * Authors:
30  *  Robert Bragg   <robert@linux.intel.com>
31  */
32 
33 #ifdef HAVE_CONFIG_H
34 #include "cogl-config.h"
35 #endif
36 
37 #include "cogl-texture.h"
38 #include "cogl-matrix.h"
39 #include "cogl-spans.h"
40 #include "cogl-meta-texture.h"
41 #include "cogl-texture-rectangle-private.h"
42 
43 #include <string.h>
44 #include <math.h>
45 
46 typedef struct _ForeachData
47 {
48   float meta_region_coords[4];
49   CoglPipelineWrapMode wrap_s;
50   CoglPipelineWrapMode wrap_t;
51   CoglMetaTextureCallback callback;
52   void *user_data;
53 
54   int width;
55   int height;
56 
57   CoglTexture *padded_textures[9];
58   const float *grid_slice_texture_coords;
59   float slice_offset_s;
60   float slice_offset_t;
61   float slice_range_s;
62   float slice_range_t;
63 } ForeachData;
64 
65 static void
padded_grid_repeat_cb(CoglTexture * slice_texture,const float * slice_texture_coords,const float * meta_coords,void * user_data)66 padded_grid_repeat_cb (CoglTexture *slice_texture,
67                        const float *slice_texture_coords,
68                        const float *meta_coords,
69                        void *user_data)
70 {
71   ForeachData *data;
72   float mapped_coords[4];
73 
74   /* Ignore padding slices for the current grid */
75   if (!slice_texture)
76     return;
77 
78   data = user_data;
79 
80   /* NB: the slice_texture_coords[] we get here will always be
81    * normalized.
82    *
83    * We now need to map the normalized slice_texture_coords[] we have
84    * here back to the real slice coordinates we saved in the previous
85    * stage...
86    */
87   mapped_coords[0] =
88     slice_texture_coords[0] * data->slice_range_s + data->slice_offset_s;
89   mapped_coords[1] =
90     slice_texture_coords[1] * data->slice_range_t + data->slice_offset_t;
91   mapped_coords[2] =
92     slice_texture_coords[2] * data->slice_range_s + data->slice_offset_s;
93   mapped_coords[3] =
94     slice_texture_coords[3] * data->slice_range_t + data->slice_offset_t;
95 
96   data->callback (slice_texture,
97                   mapped_coords, meta_coords, data->user_data);
98 }
99 
100 static int
setup_padded_spans(CoglSpan * spans,float start,float end,float range,int * real_index)101 setup_padded_spans (CoglSpan *spans,
102                     float start,
103                     float end,
104                     float range,
105                     int *real_index)
106 {
107   int span_index = 0;
108 
109   if (start > 0)
110     {
111       spans[0].start = 0;
112       spans[0].size = start;
113       spans[0].waste = 0;
114       span_index++;
115       spans[1].start = spans[0].size;
116     }
117   else
118     spans[span_index].start = 0;
119 
120   spans[span_index].size = end - start;
121   spans[span_index].waste = 0;
122   *real_index = span_index;
123   span_index++;
124 
125   if (end < range)
126     {
127       spans[span_index].start =
128         spans[span_index - 1].start + spans[span_index - 1].size;
129       spans[span_index].size = range - end;
130       spans[span_index].waste = 0;
131       span_index++;
132     }
133 
134   return span_index;
135 }
136 
137 /* This handles each sub-texture within the range [0,1] of our
138  * original meta texture and repeats each one separately across the
139  * users requested virtual texture coordinates.
140  *
141  * A notable advantage of this approach is that we will batch
142  * together callbacks corresponding to the same underlying slice
143  * together.
144  */
145 static void
create_grid_and_repeat_cb(CoglTexture * slice_texture,const float * slice_texture_coords,const float * meta_coords,void * user_data)146 create_grid_and_repeat_cb (CoglTexture *slice_texture,
147                            const float *slice_texture_coords,
148                            const float *meta_coords,
149                            void *user_data)
150 {
151   ForeachData *data = user_data;
152   CoglSpan x_spans[3];
153   int n_x_spans;
154   int x_real_index;
155   CoglSpan y_spans[3];
156   int n_y_spans;
157   int y_real_index;
158 
159   /* NB: This callback is called for each slice of the meta-texture
160    * in the range [0,1].
161    *
162    * We define a "padded grid" for each slice of the meta-texture in
163    * the range [0,1]. The x axis and y axis grid lines are defined
164    * using CoglSpans.
165    *
166    * The padded grid maps over the meta-texture coordinates in the
167    * range [0,1] but only contains one valid cell that corresponds to
168    * current slice being iterated and all the surrounding cells just
169    * provide padding.
170    *
171    * Once we've defined our padded grid we then repeat that across
172    * the user's original region, calling their callback whenever
173    * we see our current slice - ignoring padding.
174    *
175    * NB: we can assume meta_coords[] are normalized at this point
176    * since TextureRectangles aren't iterated with this code-path.
177    *
178    * NB: spans are always defined using non-normalized coordinates
179    */
180   n_x_spans = setup_padded_spans (x_spans,
181                                   meta_coords[0] * data->width,
182                                   meta_coords[2] * data->width,
183                                   data->width,
184                                   &x_real_index);
185   n_y_spans = setup_padded_spans (y_spans,
186                                   meta_coords[1] * data->height,
187                                   meta_coords[3] * data->height,
188                                   data->height,
189                                   &y_real_index);
190 
191   data->padded_textures[n_x_spans * y_real_index + x_real_index] =
192     slice_texture;
193 
194   /* Our callback is going to be passed normalized slice texture
195    * coordinates, and we will need to map the range [0,1] to the real
196    * slice_texture_coords we have here... */
197   data->grid_slice_texture_coords = slice_texture_coords;
198   data->slice_range_s = fabs (data->grid_slice_texture_coords[2] -
199                               data->grid_slice_texture_coords[0]);
200   data->slice_range_t = fabs (data->grid_slice_texture_coords[3] -
201                               data->grid_slice_texture_coords[1]);
202   data->slice_offset_s = MIN (data->grid_slice_texture_coords[0],
203                               data->grid_slice_texture_coords[2]);
204   data->slice_offset_t = MIN (data->grid_slice_texture_coords[1],
205                               data->grid_slice_texture_coords[3]);
206 
207   /* Now actually iterate the region the user originally requested
208    * using the current padded grid */
209   _cogl_texture_spans_foreach_in_region (x_spans,
210                                          n_x_spans,
211                                          y_spans,
212                                          n_y_spans,
213                                          data->padded_textures,
214                                          data->meta_region_coords,
215                                          data->width,
216                                          data->height,
217                                          data->wrap_s,
218                                          data->wrap_t,
219                                          padded_grid_repeat_cb,
220                                          data);
221 
222   /* Clear the padded_textures ready for the next iteration */
223   data->padded_textures[n_x_spans * y_real_index + x_real_index] = NULL;
224 }
225 
226 #define SWAP(A,B) do { float tmp = B; B = A; A = tmp; } while (0)
227 
228 typedef struct _ClampData
229 {
230   float start;
231   float end;
232   CoglBool s_flipped;
233   CoglBool t_flipped;
234   CoglMetaTextureCallback callback;
235   void *user_data;
236 } ClampData;
237 
238 static void
clamp_s_cb(CoglTexture * sub_texture,const float * sub_texture_coords,const float * meta_coords,void * user_data)239 clamp_s_cb (CoglTexture *sub_texture,
240             const float *sub_texture_coords,
241             const float *meta_coords,
242             void *user_data)
243 {
244   ClampData *clamp_data = user_data;
245   float mapped_meta_coords[4] = {
246     clamp_data->start,
247     meta_coords[1],
248     clamp_data->end,
249     meta_coords[3]
250   };
251   if (clamp_data->s_flipped)
252     SWAP (mapped_meta_coords[0], mapped_meta_coords[2]);
253   /* NB: we never need to flip the t coords when dealing with
254    * s-axis clamping so no need to check if ->t_flipped */
255   clamp_data->callback (sub_texture,
256                         sub_texture_coords, mapped_meta_coords,
257                         clamp_data->user_data);
258 }
259 
260 static void
clamp_t_cb(CoglTexture * sub_texture,const float * sub_texture_coords,const float * meta_coords,void * user_data)261 clamp_t_cb (CoglTexture *sub_texture,
262             const float *sub_texture_coords,
263             const float *meta_coords,
264             void *user_data)
265 {
266   ClampData *clamp_data = user_data;
267   float mapped_meta_coords[4] = {
268     meta_coords[0],
269     clamp_data->start,
270     meta_coords[2],
271     clamp_data->end,
272   };
273   if (clamp_data->s_flipped)
274     SWAP (mapped_meta_coords[0], mapped_meta_coords[2]);
275   if (clamp_data->t_flipped)
276     SWAP (mapped_meta_coords[1], mapped_meta_coords[3]);
277   clamp_data->callback (sub_texture,
278                         sub_texture_coords, mapped_meta_coords,
279                         clamp_data->user_data);
280 }
281 
282 static CoglBool
foreach_clamped_region(CoglMetaTexture * meta_texture,float * tx_1,float * ty_1,float * tx_2,float * ty_2,CoglPipelineWrapMode wrap_s,CoglPipelineWrapMode wrap_t,CoglMetaTextureCallback callback,void * user_data)283 foreach_clamped_region (CoglMetaTexture *meta_texture,
284                         float *tx_1,
285                         float *ty_1,
286                         float *tx_2,
287                         float *ty_2,
288                         CoglPipelineWrapMode wrap_s,
289                         CoglPipelineWrapMode wrap_t,
290                         CoglMetaTextureCallback callback,
291                         void *user_data)
292 {
293   float width = cogl_texture_get_width (COGL_TEXTURE (meta_texture));
294   ClampData clamp_data;
295 
296   /* Consider that *tx_1 may be > *tx_2 and to simplify things
297    * we just flip them around if that's the case and keep a note
298    * of the fact that they are flipped. */
299   if (*tx_1 > *tx_2)
300     {
301       SWAP (*tx_1, *tx_2);
302       clamp_data.s_flipped = TRUE;
303     }
304   else
305     clamp_data.s_flipped = FALSE;
306 
307   /* The same goes for ty_1 and ty_2... */
308   if (*ty_1 > *ty_2)
309     {
310       SWAP (*ty_1, *ty_2);
311       clamp_data.t_flipped = TRUE;
312     }
313   else
314     clamp_data.t_flipped = FALSE;
315 
316   clamp_data.callback = callback;
317   clamp_data.user_data = user_data;
318 
319   if (wrap_s == COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE)
320     {
321       float max_s_coord;
322       float half_texel_width;
323 
324       /* Consider that rectangle textures have non-normalized
325        * coordinates... */
326       if (cogl_is_texture_rectangle (meta_texture))
327         max_s_coord = width;
328       else
329         max_s_coord = 1.0;
330 
331       half_texel_width = max_s_coord / (width * 2);
332 
333       /* Handle any left clamped region */
334       if (*tx_1 < 0)
335         {
336           clamp_data.start = *tx_1;
337           clamp_data.end = MIN (0, *tx_2);;
338           cogl_meta_texture_foreach_in_region (meta_texture,
339                                                half_texel_width, *ty_1,
340                                                half_texel_width, *ty_2,
341                                                COGL_PIPELINE_WRAP_MODE_REPEAT,
342                                                wrap_t,
343                                                clamp_s_cb,
344                                                &clamp_data);
345           /* Have we handled everything? */
346           if (*tx_2 <= 0)
347             return TRUE;
348 
349           /* clamp tx_1 since we've handled everything with x < 0 */
350           *tx_1 = 0;
351         }
352 
353       /* Handle any right clamped region - including the corners */
354       if (*tx_2 > max_s_coord)
355         {
356           clamp_data.start = MAX (max_s_coord, *tx_1);
357           clamp_data.end = *tx_2;
358           cogl_meta_texture_foreach_in_region (meta_texture,
359                                                max_s_coord - half_texel_width,
360                                                *ty_1,
361                                                max_s_coord - half_texel_width,
362                                                *ty_2,
363                                                COGL_PIPELINE_WRAP_MODE_REPEAT,
364                                                wrap_t,
365                                                clamp_s_cb,
366                                                &clamp_data);
367           /* Have we handled everything? */
368           if (*tx_1 >= max_s_coord)
369             return TRUE;
370 
371           /* clamp tx_2 since we've handled everything with x >
372            * max_s_coord */
373           *tx_2 = max_s_coord;
374         }
375     }
376 
377   if (wrap_t == COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE)
378     {
379       float height = cogl_texture_get_height (COGL_TEXTURE (meta_texture));
380       float max_t_coord;
381       float half_texel_height;
382 
383       /* Consider that rectangle textures have non-normalized
384        * coordinates... */
385       if (cogl_is_texture_rectangle (meta_texture))
386         max_t_coord = height;
387       else
388         max_t_coord = 1.0;
389 
390       half_texel_height = max_t_coord / (height * 2);
391 
392       /* Handle any top clamped region */
393       if (*ty_1 < 0)
394         {
395           clamp_data.start = *ty_1;
396           clamp_data.end = MIN (0, *ty_2);;
397           cogl_meta_texture_foreach_in_region (meta_texture,
398                                                *tx_1, half_texel_height,
399                                                *tx_2, half_texel_height,
400                                                wrap_s,
401                                                COGL_PIPELINE_WRAP_MODE_REPEAT,
402                                                clamp_t_cb,
403                                                &clamp_data);
404           /* Have we handled everything? */
405           if (*tx_2 <= 0)
406             return TRUE;
407 
408           /* clamp ty_1 since we've handled everything with y < 0 */
409           *ty_1 = 0;
410         }
411 
412       /* Handle any bottom clamped region */
413       if (*ty_2 > max_t_coord)
414         {
415           clamp_data.start = MAX (max_t_coord, *ty_1);;
416           clamp_data.end = *ty_2;
417           cogl_meta_texture_foreach_in_region (meta_texture,
418                                                *tx_1,
419                                                max_t_coord - half_texel_height,
420                                                *tx_2,
421                                                max_t_coord - half_texel_height,
422                                                wrap_s,
423                                                COGL_PIPELINE_WRAP_MODE_REPEAT,
424                                                clamp_t_cb,
425                                                &clamp_data);
426           /* Have we handled everything? */
427           if (*ty_1 >= max_t_coord)
428             return TRUE;
429 
430           /* clamp ty_2 since we've handled everything with y >
431            * max_t_coord */
432           *ty_2 = max_t_coord;
433         }
434     }
435 
436   if (clamp_data.s_flipped)
437     SWAP (*tx_1, *tx_2);
438   if (clamp_data.t_flipped)
439     SWAP (*ty_1, *ty_2);
440 
441   return FALSE;
442 }
443 
444 typedef struct _NormalizeData
445 {
446   CoglMetaTextureCallback callback;
447   void *user_data;
448   float s_normalize_factor;
449   float t_normalize_factor;
450 } NormalizeData;
451 
452 static void
normalize_meta_coords_cb(CoglTexture * slice_texture,const float * slice_coords,const float * meta_coords,void * user_data)453 normalize_meta_coords_cb (CoglTexture *slice_texture,
454                           const float *slice_coords,
455                           const float *meta_coords,
456                           void *user_data)
457 {
458   NormalizeData *data = user_data;
459   float normalized_meta_coords[4] = {
460       meta_coords[0] * data->s_normalize_factor,
461       meta_coords[1] * data->t_normalize_factor,
462       meta_coords[2] * data->s_normalize_factor,
463       meta_coords[3] * data->t_normalize_factor
464   };
465 
466   data->callback (slice_texture,
467                   slice_coords, normalized_meta_coords,
468                   data->user_data);
469 }
470 
471 typedef struct _UnNormalizeData
472 {
473   CoglMetaTextureCallback callback;
474   void *user_data;
475   float width;
476   float height;
477 } UnNormalizeData;
478 
479 static void
un_normalize_slice_coords_cb(CoglTexture * slice_texture,const float * slice_coords,const float * meta_coords,void * user_data)480 un_normalize_slice_coords_cb (CoglTexture *slice_texture,
481                               const float *slice_coords,
482                               const float *meta_coords,
483                               void *user_data)
484 {
485   UnNormalizeData *data = user_data;
486   float un_normalized_slice_coords[4] = {
487     slice_coords[0] * data->width,
488     slice_coords[1] * data->height,
489     slice_coords[2] * data->width,
490     slice_coords[3] * data->height
491   };
492 
493   data->callback (slice_texture,
494                   un_normalized_slice_coords, meta_coords,
495                   data->user_data);
496 }
497 
498 void
cogl_meta_texture_foreach_in_region(CoglMetaTexture * meta_texture,float tx_1,float ty_1,float tx_2,float ty_2,CoglPipelineWrapMode wrap_s,CoglPipelineWrapMode wrap_t,CoglMetaTextureCallback callback,void * user_data)499 cogl_meta_texture_foreach_in_region (CoglMetaTexture *meta_texture,
500                                      float tx_1,
501                                      float ty_1,
502                                      float tx_2,
503                                      float ty_2,
504                                      CoglPipelineWrapMode wrap_s,
505                                      CoglPipelineWrapMode wrap_t,
506                                      CoglMetaTextureCallback callback,
507                                      void *user_data)
508 {
509   CoglTexture *texture = COGL_TEXTURE (meta_texture);
510   float width = cogl_texture_get_width (texture);
511   float height = cogl_texture_get_height (texture);
512   NormalizeData normalize_data;
513 
514   if (wrap_s == COGL_PIPELINE_WRAP_MODE_AUTOMATIC)
515     wrap_s = COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE;
516   if (wrap_t == COGL_PIPELINE_WRAP_MODE_AUTOMATIC)
517     wrap_t = COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE;
518 
519   if (wrap_s == COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE ||
520       wrap_t == COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE)
521     {
522       CoglBool finished = foreach_clamped_region (meta_texture,
523                                                   &tx_1, &ty_1, &tx_2, &ty_2,
524                                                   wrap_s, wrap_t,
525                                                   callback,
526                                                   user_data);
527       if (finished)
528         return;
529 
530       /* Since clamping has been handled we now want to normalize our
531        * wrap modes we se can assume from this point on we don't
532        * need to consider CLAMP_TO_EDGE. (NB: The spans code will
533        * assert that CLAMP_TO_EDGE isn't requested) */
534       if (wrap_s == COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE)
535         wrap_s = COGL_PIPELINE_WRAP_MODE_REPEAT;
536       if (wrap_t == COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE)
537         wrap_t = COGL_PIPELINE_WRAP_MODE_REPEAT;
538     }
539 
540   /* It makes things simpler to deal with non-normalized region
541    * coordinates beyond this point and only re-normalize just before
542    * calling the user's callback... */
543 
544   if (!cogl_is_texture_rectangle (COGL_TEXTURE (meta_texture)))
545     {
546       normalize_data.callback = callback;
547       normalize_data.user_data = user_data;
548       normalize_data.s_normalize_factor = 1.0f / width;
549       normalize_data.t_normalize_factor = 1.0f / height;
550       callback = normalize_meta_coords_cb;
551       user_data = &normalize_data;
552       tx_1 *= width;
553       ty_1 *= height;
554       tx_2 *= width;
555       ty_2 *= height;
556     }
557 
558   /* XXX: at some point this wont be routed through the CoglTexture
559    * vtable, instead there will be a separate CoglMetaTexture
560    * interface vtable. */
561 
562   if (texture->vtable->foreach_sub_texture_in_region)
563     {
564       ForeachData data;
565 
566       data.meta_region_coords[0] = tx_1;
567       data.meta_region_coords[1] = ty_1;
568       data.meta_region_coords[2] = tx_2;
569       data.meta_region_coords[3] = ty_2;
570       data.wrap_s = wrap_s;
571       data.wrap_t = wrap_t;
572       data.callback = callback;
573       data.user_data = user_data;
574 
575       data.width = width;
576       data.height = height;
577 
578       memset (data.padded_textures, 0, sizeof (data.padded_textures));
579 
580       /*
581        * 1) We iterate all the slices of the meta-texture only within
582        *    the range [0,1].
583        *
584        * 2) We define a "padded grid" for each slice of the
585        *    meta-texture in the range [0,1].
586        *
587        *    The padded grid maps over the meta-texture coordinates in
588        *    the range [0,1] but only contains one valid cell that
589        *    corresponds to current slice being iterated and all the
590        *    surrounding cells just provide padding.
591        *
592        * 3) Once we've defined our padded grid we then repeat that
593        *    across the user's original region, calling their callback
594        *    whenever we see our current slice - ignoring padding.
595        *
596        * A notable benefit of this design is that repeating a texture
597        * made of multiple slices will result in us repeating each
598        * slice in-turn so the user gets repeat callbacks for the same
599        * texture batched together. For manual emulation of texture
600        * repeats done by drawing geometry this makes it more likely
601        * that we can batch geometry.
602        */
603 
604       texture->vtable->foreach_sub_texture_in_region (texture,
605                                                       0, 0, 1, 1,
606                                                       create_grid_and_repeat_cb,
607                                                       &data);
608     }
609   else
610     {
611       CoglSpan x_span = { 0, width, 0 };
612       CoglSpan y_span = { 0, height, 0 };
613       float meta_region_coords[4] = { tx_1, ty_1, tx_2, ty_2 };
614       UnNormalizeData un_normalize_data;
615 
616       /* If we are dealing with a CoglTextureRectangle then we need a shim
617        * callback that un_normalizes the slice coordinates we get from
618        * _cogl_texture_spans_foreach_in_region before passing them to
619        * the user's callback. */
620       if (cogl_is_texture_rectangle (meta_texture))
621         {
622           un_normalize_data.callback = callback;
623           un_normalize_data.user_data = user_data;
624           un_normalize_data.width = width;
625           un_normalize_data.height = height;
626           callback = un_normalize_slice_coords_cb;
627           user_data = &un_normalize_data;
628         }
629 
630       _cogl_texture_spans_foreach_in_region (&x_span, 1,
631                                              &y_span, 1,
632                                              &texture,
633                                              meta_region_coords,
634                                              width,
635                                              height,
636                                              wrap_s,
637                                              wrap_t,
638                                              callback,
639                                              user_data);
640     }
641 }
642 #undef SWAP
643