blob: 363d6d8e9fd4ab8182e3e4bf5a50c5c23f024e0c (
plain)
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
|
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2011 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*
*
* Authors:
* Robert Bragg <robert@linux.intel.com>
*/
#ifndef __COGL_TEXURE_2D_SLICED_H
#define __COGL_TEXURE_2D_SLICED_H
#include "cogl-context.h"
#include "cogl-types.h"
/**
* SECTION:cogl-texture-2d-sliced
* @short_description: Functions for creating and manipulating 2D meta
* textures that may internally be comprised of
* multiple 2D textures with power-of-two sizes.
*
* These functions allow high-level meta textures (See the
* #CoglMetaTexture interface) to be allocated that may internally be
* comprised of multiple 2D texture "slices" with power-of-two sizes.
*
* 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.
*
* 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.
*/
typedef struct _CoglTexture2DSliced CoglTexture2DSliced;
#define COGL_TEXTURE_2D_SLICED(X) ((CoglTexture2DSliced *)X)
/**
* cogl_texture_2d_sliced_new_with_size:
* @ctx: A #CoglContext
* @width: The virtual width of your sliced texture.
* @height: The virtual height of your sliced texture.
* @max_waste: The threshold of how wide a strip of wasted texels
* are allowed in the non-power-of-two textures before
* they must be sliced to reduce the amount of waste.
* @internal_format: The format of the texture
* @error: A #CoglError for exceptions.
*
* Creates a #CoglTexture2DSliced that may internally be comprised of
* 1 or more #CoglTexture2D textures with power-of-two sizes.
* @max_waste is used as a threshold for recursively slicing the
* right-most or bottom-most slices into smaller power-of-two sizes
* until the wasted padding at the bottom and right of the
* power-of-two textures is less than specified.
*
* Returns: A newly allocated #CoglTexture2DSliced or if there was
* an error allocating any of the internal slices %NULL is
* returned and @error is updated.
*
* Since: 1.10
* Stability: unstable
*/
CoglTexture2DSliced *
cogl_texture_2d_sliced_new_with_size (CoglContext *ctx,
unsigned int width,
unsigned int height,
int max_waste,
CoglPixelFormat internal_format,
CoglError **error);
/**
* cogl_is_texture_2d_sliced:
* @object: A #CoglObject pointer
*
* Gets whether the given object references a #CoglTexture2dSliced.
*
* Return value: %TRUE if the object references a #CoglTexture2dSliced
* and %FALSE otherwise.
* Since: 1.10
* Stability: unstable
*/
CoglBool
cogl_is_texture_2d_sliced (void *object);
#endif /* __COGL_TEXURE_2D_SLICED_H */
|
