This file is indexed.

/usr/share/gtk-doc/html/cogl-2.0-experimental/cogl-2.0-experimental-Sliced-Textures.html is in libcogl-doc 1.16.2-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
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
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Sliced Textures</title>
<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
<link rel="home" href="index.html" title="Cogl 2.0 Reference Manual">
<link rel="up" href="cogl-meta-textures.html" title="Meta Textures">
<link rel="prev" href="cogl-2.0-experimental-Sub-Textures.html" title="Sub Textures">
<link rel="next" href="cogl-2.0-experimental-X11-Texture-From-Pixmap.html" title="X11 Texture From Pixmap">
<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
<link rel="stylesheet" href="style.css" type="text/css">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" id="top" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2">
<tr valign="middle">
<td><a accesskey="p" href="cogl-2.0-experimental-Sub-Textures.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
<td><a accesskey="u" href="cogl-meta-textures.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<th width="100%" align="center">Cogl 2.0 Reference Manual</th>
<td><a accesskey="n" href="cogl-2.0-experimental-X11-Texture-From-Pixmap.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
</tr>
<tr><td colspan="5" class="shortcuts">
<a href="#cogl-2.0-experimental-Sliced-Textures.synopsis" class="shortcut">Top</a>
                   | 
                  <a href="#cogl-2.0-experimental-Sliced-Textures.description" class="shortcut">Description</a>
</td></tr>
</table>
<div class="refentry">
<a name="cogl-2.0-experimental-Sliced-Textures"></a><div class="titlepage"></div>
<div class="refnamediv"><table width="100%"><tr>
<td valign="top">
<h2><span class="refentrytitle"><a name="cogl-2.0-experimental-Sliced-Textures.top_of_page"></a>Sliced Textures</span></h2>
<p>Sliced Textures — Functions for creating and manipulating 2D meta
                    textures that may internally be comprised of
                    multiple 2D textures with power-of-two sizes.</p>
</td>
<td valign="top" align="right"></td>
</tr></table></div>
<div class="refsynopsisdiv">
<a name="cogl-2.0-experimental-Sliced-Textures.synopsis"></a><h2>Synopsis</h2>
<pre class="synopsis">                    <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced">CoglTexture2DSliced</a>;
<a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="returnvalue">CoglTexture2DSliced</span></a> * <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#cogl-texture-2d-sliced-new-with-size" title="cogl_texture_2d_sliced_new_with_size ()">cogl_texture_2d_sliced_new_with_size</a>
                                                        (<em class="parameter"><code><a class="link" href="cogl-2.0-experimental-The-Top-Level-Context.html#CoglContext" title="CoglContext"><span class="type">CoglContext</span></a> *ctx</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> width</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> height</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> max_waste</code></em>,
                                                         <em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Common-Types.html#CoglPixelFormat" title="enum CoglPixelFormat"><span class="type">CoglPixelFormat</span></a> internal_format</code></em>);
<a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="returnvalue">CoglTexture2DSliced</span></a> * <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#cogl-texture-2d-sliced-new-from-file" title="cogl_texture_2d_sliced_new_from_file ()">cogl_texture_2d_sliced_new_from_file</a>
                                                        (<em class="parameter"><code><a class="link" href="cogl-2.0-experimental-The-Top-Level-Context.html#CoglContext" title="CoglContext"><span class="type">CoglContext</span></a> *ctx</code></em>,
                                                         <em class="parameter"><code>const <span class="type">char</span> *filename</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> max_waste</code></em>,
                                                         <em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Common-Types.html#CoglPixelFormat" title="enum CoglPixelFormat"><span class="type">CoglPixelFormat</span></a> internal_format</code></em>,
                                                         <em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Exception-handling.html#CoglError" title="CoglError"><span class="type">CoglError</span></a> **error</code></em>);
<a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="returnvalue">CoglTexture2DSliced</span></a> * <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#cogl-texture-2d-sliced-new-from-data" title="cogl_texture_2d_sliced_new_from_data ()">cogl_texture_2d_sliced_new_from_data</a>
                                                        (<em class="parameter"><code><a class="link" href="cogl-2.0-experimental-The-Top-Level-Context.html#CoglContext" title="CoglContext"><span class="type">CoglContext</span></a> *ctx</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> width</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> height</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> max_waste</code></em>,
                                                         <em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Common-Types.html#CoglPixelFormat" title="enum CoglPixelFormat"><span class="type">CoglPixelFormat</span></a> format</code></em>,
                                                         <em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Common-Types.html#CoglPixelFormat" title="enum CoglPixelFormat"><span class="type">CoglPixelFormat</span></a> internal_format</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> rowstride</code></em>,
                                                         <em class="parameter"><code>const <span class="type">uint8_t</span> *data</code></em>,
                                                         <em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Exception-handling.html#CoglError" title="CoglError"><span class="type">CoglError</span></a> **error</code></em>);
<a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="returnvalue">CoglTexture2DSliced</span></a> * <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#cogl-texture-2d-sliced-new-from-bitmap" title="cogl_texture_2d_sliced_new_from_bitmap ()">cogl_texture_2d_sliced_new_from_bitmap</a>
                                                        (<em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Bitmap.html#CoglBitmap" title="CoglBitmap"><span class="type">CoglBitmap</span></a> *bmp</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> max_waste</code></em>,
                                                         <em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Common-Types.html#CoglPixelFormat" title="enum CoglPixelFormat"><span class="type">CoglPixelFormat</span></a> internal_format</code></em>,
                                                         <em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Exception-handling.html#CoglError" title="CoglError"><span class="type">CoglError</span></a> **error</code></em>);
<a class="link" href="cogl-2.0-experimental-Common-Types.html#CoglBool" title="CoglBool"><span class="returnvalue">CoglBool</span></a>            <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#cogl-is-texture-2d-sliced" title="cogl_is_texture_2d_sliced ()">cogl_is_texture_2d_sliced</a>           (<em class="parameter"><code><span class="type">void</span> *object</code></em>);
</pre>
</div>
<div class="refsect1">
<a name="cogl-2.0-experimental-Sliced-Textures.description"></a><h2>Description</h2>
<p>
These functions allow high-level meta textures (See the
<a class="link" href="cogl-2.0-experimental-High-Level-Meta-Textures.html#CoglMetaTexture" title="CoglMetaTexture"><span class="type">CoglMetaTexture</span></a> interface) to be allocated that may internally be
comprised of multiple 2D texture "slices" with power-of-two sizes.
</p>
<p>
This API can be useful when working with GPUs that don't have
native support for non-power-of-two textures or if you want to load
a texture that is larger than the GPUs maximum texture size limits.
</p>
<p>
The algorithm for slicing works by first trying to map a virtual
size to the next larger power-of-two size and then seeing how many
wasted pixels that would result in. For example if you have a
virtual texture that's 259 texels wide, the next pot size = 512 and
the amount of waste would be 253 texels. If the amount of waste is
above a max-waste threshold then we would next slice that texture
into one that's 256 texels and then looking at how many more texels
remain unallocated after that we choose the next power-of-two size.
For the example of a 259 texel image that would mean having a 256
texel wide texture, leaving 3 texels unallocated so we'd then
create a 4 texel wide texture - now there is only one texel of
waste. The algorithm continues to slice the right most textures
until the amount of waste is less than or equal to a specfied
max-waste threshold. The same logic for slicing from left to right
is also applied from top to bottom.
</p>
</div>
<div class="refsect1">
<a name="cogl-2.0-experimental-Sliced-Textures.details"></a><h2>Details</h2>
<div class="refsect2">
<a name="CoglTexture2DSliced"></a><h3>CoglTexture2DSliced</h3>
<pre class="programlisting">typedef struct _CoglTexture2DSliced CoglTexture2DSliced;</pre>
</div>
<hr>
<div class="refsect2">
<a name="cogl-texture-2d-sliced-new-with-size"></a><h3>cogl_texture_2d_sliced_new_with_size ()</h3>
<pre class="programlisting"><a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="returnvalue">CoglTexture2DSliced</span></a> * cogl_texture_2d_sliced_new_with_size
                                                        (<em class="parameter"><code><a class="link" href="cogl-2.0-experimental-The-Top-Level-Context.html#CoglContext" title="CoglContext"><span class="type">CoglContext</span></a> *ctx</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> width</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> height</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> max_waste</code></em>,
                                                         <em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Common-Types.html#CoglPixelFormat" title="enum CoglPixelFormat"><span class="type">CoglPixelFormat</span></a> internal_format</code></em>);</pre>
<p>
Creates a <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="type">CoglTexture2DSliced</span></a> that may internally be comprised of
1 or more <a class="link" href="cogl-2.0-experimental-2D-textures.html#CoglTexture2D" title="CoglTexture2D"><span class="type">CoglTexture2D</span></a> textures depending on GPU limitations.
For example if the GPU only supports power-of-two sized textures
then a sliced texture will turn a non-power-of-two size into a
combination of smaller power-of-two sized textures. If the
requested texture size is larger than is supported by the hardware
then the texture will be sliced into smaller textures that can be
accessed by the hardware.
</p>
<p>
<em class="parameter"><code>max_waste</code></em> is used as a threshold for recursively slicing the
right-most or bottom-most slices into smaller sizes until the
wasted padding at the bottom and right of the textures is less than
specified. A negative <em class="parameter"><code>max_waste</code></em> will disable slicing.
</p>
<p>
The storage for the texture is not allocated before this function
returns. You can call <code class="function">cogl_texture_allocate()</code> to explicitly
allocate the underlying storage or let Cogl automatically allocate
storage lazily.
</p>
<p>
</p>
<div class="note" style="margin-left: 0.5in; margin-right: 0.5in;">
<h3 class="title">Note</h3>It's possible for the allocation of a sliced texture to fail
later due to impossible slicing constraints if a negative
<em class="parameter"><code>max_waste</code></em> value is given. If the given virtual texture size size
is larger than is supported by the hardware but slicing is disabled
the texture size would be too large to handle.</div>
<p>
</p>
<div class="variablelist"><table border="0" class="variablelist">
<colgroup>
<col align="left" valign="top">
<col>
</colgroup>
<tbody>
<tr>
<td><p><span class="term"><em class="parameter"><code>ctx</code></em> :</span></p></td>
<td>A <a class="link" href="cogl-2.0-experimental-The-Top-Level-Context.html#CoglContext" title="CoglContext"><span class="type">CoglContext</span></a>
</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>width</code></em> :</span></p></td>
<td>The virtual width of your sliced texture.</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>height</code></em> :</span></p></td>
<td>The virtual height of your sliced texture.</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>max_waste</code></em> :</span></p></td>
<td>The threshold of how wide a strip of wasted texels
are allowed along the right and bottom textures before
they must be sliced to reduce the amount of waste. A
negative can be passed to disable slicing.</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>internal_format</code></em> :</span></p></td>
<td>The format of the texture</td>
</tr>
<tr>
<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
<td>A new <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="type">CoglTexture2DSliced</span></a> object with no storage
allocated yet. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
</td>
</tr>
</tbody>
</table></div>
<p class="since">Since 1.10</p>
<p class="stability">Stability Level: Unstable</p>
</div>
<hr>
<div class="refsect2">
<a name="cogl-texture-2d-sliced-new-from-file"></a><h3>cogl_texture_2d_sliced_new_from_file ()</h3>
<pre class="programlisting"><a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="returnvalue">CoglTexture2DSliced</span></a> * cogl_texture_2d_sliced_new_from_file
                                                        (<em class="parameter"><code><a class="link" href="cogl-2.0-experimental-The-Top-Level-Context.html#CoglContext" title="CoglContext"><span class="type">CoglContext</span></a> *ctx</code></em>,
                                                         <em class="parameter"><code>const <span class="type">char</span> *filename</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> max_waste</code></em>,
                                                         <em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Common-Types.html#CoglPixelFormat" title="enum CoglPixelFormat"><span class="type">CoglPixelFormat</span></a> internal_format</code></em>,
                                                         <em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Exception-handling.html#CoglError" title="CoglError"><span class="type">CoglError</span></a> **error</code></em>);</pre>
<p>
Creates a <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="type">CoglTexture2DSliced</span></a> from an image file.
</p>
<p>
A <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="type">CoglTexture2DSliced</span></a> may internally be comprised of 1 or more
<a class="link" href="cogl-2.0-experimental-2D-textures.html#CoglTexture2D" title="CoglTexture2D"><span class="type">CoglTexture2D</span></a> textures depending on GPU limitations.  For example
if the GPU only supports power-of-two sized textures then a sliced
texture will turn a non-power-of-two size into a combination of
smaller power-of-two sized textures. If the requested texture size
is larger than is supported by the hardware then the texture will
be sliced into smaller textures that can be accessed by the
hardware.
</p>
<p>
<em class="parameter"><code>max_waste</code></em> is used as a threshold for recursively slicing the
right-most or bottom-most slices into smaller sizes until the
wasted padding at the bottom and right of the textures is less than
specified. A negative <em class="parameter"><code>max_waste</code></em> will disable slicing.
</p>
<p>
</p>
<div class="note" style="margin-left: 0.5in; margin-right: 0.5in;">
<h3 class="title">Note</h3>It's possible for the allocation of a sliced texture to fail
later due to impossible slicing constraints if a negative
<em class="parameter"><code>max_waste</code></em> value is given. If the given virtual texture size is
larger than is supported by the hardware but slicing is disabled
the texture size would be too large to handle.</div>
<p>
</p>
<div class="variablelist"><table border="0" class="variablelist">
<colgroup>
<col align="left" valign="top">
<col>
</colgroup>
<tbody>
<tr>
<td><p><span class="term"><em class="parameter"><code>ctx</code></em> :</span></p></td>
<td>A <a class="link" href="cogl-2.0-experimental-The-Top-Level-Context.html#CoglContext" title="CoglContext"><span class="type">CoglContext</span></a>
</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>filename</code></em> :</span></p></td>
<td>the file to load</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>max_waste</code></em> :</span></p></td>
<td>The threshold of how wide a strip of wasted texels
are allowed along the right and bottom textures before
they must be sliced to reduce the amount of waste. A
negative can be passed to disable slicing.</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>internal_format</code></em> :</span></p></td>
<td>the <a class="link" href="cogl-2.0-experimental-Common-Types.html#CoglPixelFormat" title="enum CoglPixelFormat"><span class="type">CoglPixelFormat</span></a> to use for the GPU storage of the
texture. If <a class="link" href="cogl-2.0-experimental-Common-Types.html#COGL-PIXEL-FORMAT-ANY:CAPS"><code class="literal">COGL_PIXEL_FORMAT_ANY</code></a> is given then a premultiplied
format similar to the format of the source data will be used. The
default blending equations of Cogl expect premultiplied color data;
the main use of passing a non-premultiplied format here is if you
have non-premultiplied source data and are going to adjust the blend
mode (see <code class="function">cogl_material_set_blend()</code>) or use the data for something
other than straight blending.</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>error</code></em> :</span></p></td>
<td>A <a class="link" href="cogl-2.0-experimental-Exception-handling.html#CoglError" title="CoglError"><span class="type">CoglError</span></a> to catch exceptional errors or <code class="literal">NULL</code>
</td>
</tr>
<tr>
<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
<td>A newly created <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="type">CoglTexture2DSliced</span></a>
or <code class="literal">NULL</code> on failure and <em class="parameter"><code>error</code></em> will be updated. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
</td>
</tr>
</tbody>
</table></div>
<p class="since">Since 1.16</p>
</div>
<hr>
<div class="refsect2">
<a name="cogl-texture-2d-sliced-new-from-data"></a><h3>cogl_texture_2d_sliced_new_from_data ()</h3>
<pre class="programlisting"><a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="returnvalue">CoglTexture2DSliced</span></a> * cogl_texture_2d_sliced_new_from_data
                                                        (<em class="parameter"><code><a class="link" href="cogl-2.0-experimental-The-Top-Level-Context.html#CoglContext" title="CoglContext"><span class="type">CoglContext</span></a> *ctx</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> width</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> height</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> max_waste</code></em>,
                                                         <em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Common-Types.html#CoglPixelFormat" title="enum CoglPixelFormat"><span class="type">CoglPixelFormat</span></a> format</code></em>,
                                                         <em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Common-Types.html#CoglPixelFormat" title="enum CoglPixelFormat"><span class="type">CoglPixelFormat</span></a> internal_format</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> rowstride</code></em>,
                                                         <em class="parameter"><code>const <span class="type">uint8_t</span> *data</code></em>,
                                                         <em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Exception-handling.html#CoglError" title="CoglError"><span class="type">CoglError</span></a> **error</code></em>);</pre>
<p>
Creates a new <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="type">CoglTexture2DSliced</span></a> texture based on data residing
in memory.
</p>
<p>
A <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="type">CoglTexture2DSliced</span></a> may internally be comprised of 1 or more
<a class="link" href="cogl-2.0-experimental-2D-textures.html#CoglTexture2D" title="CoglTexture2D"><span class="type">CoglTexture2D</span></a> textures depending on GPU limitations.  For example
if the GPU only supports power-of-two sized textures then a sliced
texture will turn a non-power-of-two size into a combination of
smaller power-of-two sized textures. If the requested texture size
is larger than is supported by the hardware then the texture will
be sliced into smaller textures that can be accessed by the
hardware.
</p>
<p>
<em class="parameter"><code>max_waste</code></em> is used as a threshold for recursively slicing the
right-most or bottom-most slices into smaller sizes until the
wasted padding at the bottom and right of the textures is less than
specified. A negative <em class="parameter"><code>max_waste</code></em> will disable slicing.
</p>
<p>
</p>
<div class="note" style="margin-left: 0.5in; margin-right: 0.5in;">
<h3 class="title">Note</h3>It's possible for the allocation of a sliced texture to fail
later due to impossible slicing constraints if a negative
<em class="parameter"><code>max_waste</code></em> value is given. If the given virtual texture size is
larger than is supported by the hardware but slicing is disabled
the texture size would be too large to handle.</div>
<p>
</p>
<div class="variablelist"><table border="0" class="variablelist">
<colgroup>
<col align="left" valign="top">
<col>
</colgroup>
<tbody>
<tr>
<td><p><span class="term"><em class="parameter"><code>ctx</code></em> :</span></p></td>
<td>A <a class="link" href="cogl-2.0-experimental-The-Top-Level-Context.html#CoglContext" title="CoglContext"><span class="type">CoglContext</span></a>
</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>width</code></em> :</span></p></td>
<td>width of texture in pixels</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>height</code></em> :</span></p></td>
<td>height of texture in pixels</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>format</code></em> :</span></p></td>
<td>the <a class="link" href="cogl-2.0-experimental-Common-Types.html#CoglPixelFormat" title="enum CoglPixelFormat"><span class="type">CoglPixelFormat</span></a> the buffer is stored in in RAM</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>max_waste</code></em> :</span></p></td>
<td>The threshold of how wide a strip of wasted texels
are allowed along the right and bottom textures before
they must be sliced to reduce the amount of waste. A
negative can be passed to disable slicing.</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>internal_format</code></em> :</span></p></td>
<td>the <a class="link" href="cogl-2.0-experimental-Common-Types.html#CoglPixelFormat" title="enum CoglPixelFormat"><span class="type">CoglPixelFormat</span></a> to use for the GPU storage of the
texture. If <a class="link" href="cogl-2.0-experimental-Common-Types.html#COGL-PIXEL-FORMAT-ANY:CAPS"><code class="literal">COGL_PIXEL_FORMAT_ANY</code></a> is given then a premultiplied
format similar to the format of the source data will be used. The
default blending equations of Cogl expect premultiplied color data;
the main use of passing a non-premultiplied format here is if you
have non-premultiplied source data and are going to adjust the blend
mode (see <code class="function">cogl_material_set_blend()</code>) or use the data for something
other than straight blending.</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>rowstride</code></em> :</span></p></td>
<td>the memory offset in bytes between the start of each
row in <em class="parameter"><code>data</code></em>. A value of 0 will make Cogl automatically
calculate <em class="parameter"><code>rowstride</code></em> from <em class="parameter"><code>width</code></em> and <em class="parameter"><code>format</code></em>.</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>data</code></em> :</span></p></td>
<td>pointer the memory region where the source buffer resides</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>error</code></em> :</span></p></td>
<td>A <a class="link" href="cogl-2.0-experimental-Exception-handling.html#CoglError" title="CoglError"><span class="type">CoglError</span></a> to catch exceptional errors or <code class="literal">NULL</code>
</td>
</tr>
<tr>
<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
<td>A newly created <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="type">CoglTexture2DSliced</span></a>
or <code class="literal">NULL</code> on failure and <em class="parameter"><code>error</code></em> will be updated. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
</td>
</tr>
</tbody>
</table></div>
<p class="since">Since 1.16</p>
</div>
<hr>
<div class="refsect2">
<a name="cogl-texture-2d-sliced-new-from-bitmap"></a><h3>cogl_texture_2d_sliced_new_from_bitmap ()</h3>
<pre class="programlisting"><a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="returnvalue">CoglTexture2DSliced</span></a> * cogl_texture_2d_sliced_new_from_bitmap
                                                        (<em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Bitmap.html#CoglBitmap" title="CoglBitmap"><span class="type">CoglBitmap</span></a> *bmp</code></em>,
                                                         <em class="parameter"><code><span class="type">int</span> max_waste</code></em>,
                                                         <em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Common-Types.html#CoglPixelFormat" title="enum CoglPixelFormat"><span class="type">CoglPixelFormat</span></a> internal_format</code></em>,
                                                         <em class="parameter"><code><a class="link" href="cogl-2.0-experimental-Exception-handling.html#CoglError" title="CoglError"><span class="type">CoglError</span></a> **error</code></em>);</pre>
<p>
Creates a new <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="type">CoglTexture2DSliced</span></a> texture based on data residing
in a bitmap.
</p>
<p>
A <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="type">CoglTexture2DSliced</span></a> may internally be comprised of 1 or more
<a class="link" href="cogl-2.0-experimental-2D-textures.html#CoglTexture2D" title="CoglTexture2D"><span class="type">CoglTexture2D</span></a> textures depending on GPU limitations.  For example
if the GPU only supports power-of-two sized textures then a sliced
texture will turn a non-power-of-two size into a combination of
smaller power-of-two sized textures. If the requested texture size
is larger than is supported by the hardware then the texture will
be sliced into smaller textures that can be accessed by the
hardware.
</p>
<p>
<em class="parameter"><code>max_waste</code></em> is used as a threshold for recursively slicing the
right-most or bottom-most slices into smaller sizes until the
wasted padding at the bottom and right of the textures is less than
specified. A negative <em class="parameter"><code>max_waste</code></em> will disable slicing.
</p>
<p>
</p>
<div class="note" style="margin-left: 0.5in; margin-right: 0.5in;">
<h3 class="title">Note</h3>It's possible for the allocation of a sliced texture to fail
later due to impossible slicing constraints if a negative
<em class="parameter"><code>max_waste</code></em> value is given. If the given virtual texture size is
larger than is supported by the hardware but slicing is disabled
the texture size would be too large to handle.</div>
<p>
</p>
<div class="variablelist"><table border="0" class="variablelist">
<colgroup>
<col align="left" valign="top">
<col>
</colgroup>
<tbody>
<tr>
<td><p><span class="term"><em class="parameter"><code>bmp</code></em> :</span></p></td>
<td>A <a class="link" href="cogl-2.0-experimental-Bitmap.html#CoglBitmap" title="CoglBitmap"><span class="type">CoglBitmap</span></a>
</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>max_waste</code></em> :</span></p></td>
<td>The threshold of how wide a strip of wasted texels
are allowed along the right and bottom textures before
they must be sliced to reduce the amount of waste. A
negative can be passed to disable slicing.</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>internal_format</code></em> :</span></p></td>
<td>the <a class="link" href="cogl-2.0-experimental-Common-Types.html#CoglPixelFormat" title="enum CoglPixelFormat"><span class="type">CoglPixelFormat</span></a> to use for the GPU storage of the
texture. If <a class="link" href="cogl-2.0-experimental-Common-Types.html#COGL-PIXEL-FORMAT-ANY:CAPS"><code class="literal">COGL_PIXEL_FORMAT_ANY</code></a> is given then a premultiplied
format similar to the format of the source data will be used. The
default blending equations of Cogl expect premultiplied color data;
the main use of passing a non-premultiplied format here is if you
have non-premultiplied source data and are going to adjust the blend
mode (see <code class="function">cogl_material_set_blend()</code>) or use the data for something
other than straight blending.</td>
</tr>
<tr>
<td><p><span class="term"><em class="parameter"><code>error</code></em> :</span></p></td>
<td>A <a class="link" href="cogl-2.0-experimental-Exception-handling.html#CoglError" title="CoglError"><span class="type">CoglError</span></a> to catch exceptional errors or <code class="literal">NULL</code>
</td>
</tr>
<tr>
<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
<td>A newly created <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="type">CoglTexture2DSliced</span></a>
or <code class="literal">NULL</code> on failure and <em class="parameter"><code>error</code></em> will be updated. <span class="annotation">[<acronym title="Free data after the code is done."><span class="acronym">transfer full</span></acronym>]</span>
</td>
</tr>
</tbody>
</table></div>
<p class="since">Since 1.16</p>
</div>
<hr>
<div class="refsect2">
<a name="cogl-is-texture-2d-sliced"></a><h3>cogl_is_texture_2d_sliced ()</h3>
<pre class="programlisting"><a class="link" href="cogl-2.0-experimental-Common-Types.html#CoglBool" title="CoglBool"><span class="returnvalue">CoglBool</span></a>            cogl_is_texture_2d_sliced           (<em class="parameter"><code><span class="type">void</span> *object</code></em>);</pre>
<p>
Gets whether the given object references a <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="type">CoglTexture2DSliced</span></a>.
</p>
<div class="variablelist"><table border="0" class="variablelist">
<colgroup>
<col align="left" valign="top">
<col>
</colgroup>
<tbody>
<tr>
<td><p><span class="term"><em class="parameter"><code>object</code></em> :</span></p></td>
<td>A <a class="link" href="cogl-2.0-experimental-The-Object-Interface.html#CoglObject" title="CoglObject"><span class="type">CoglObject</span></a> pointer</td>
</tr>
<tr>
<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
<td>
<code class="literal">TRUE</code> if the object references a <a class="link" href="cogl-2.0-experimental-Sliced-Textures.html#CoglTexture2DSliced" title="CoglTexture2DSliced"><span class="type">CoglTexture2DSliced</span></a>
and <code class="literal">FALSE</code> otherwise.</td>
</tr>
</tbody>
</table></div>
<p class="since">Since 1.10</p>
<p class="stability">Stability Level: Unstable</p>
</div>
</div>
</div>
<div class="footer">
<hr>
          Generated by GTK-Doc V1.19</div>
</body>
</html>