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
|
/*
* Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* - Redistribution of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistribution in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of Sun Microsystems, Inc. or the names of
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any kind. ALL
* EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
* INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
* MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
* ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
* DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
* ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
* DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
* DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
* ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
* SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed or intended for use
* in the design, construction, operation or maintenance of any nuclear
* facility.
*/
package com.sun.opengl.util.texture;
import java.nio.*;
import javax.media.opengl.*;
import javax.media.opengl.util.*;
import com.sun.opengl.util.*;
/**
* Represents the data for an OpenGL texture. This is separated from
* the notion of a Texture to support things like streaming in of
* textures in a background thread without requiring an OpenGL context
* to be current on that thread.
*
* @author Chris Campbell
* @author Kenneth Russell
*/
public class TextureData {
protected int width;
protected int height;
private int border;
protected int pixelFormat;
protected int pixelType;
protected int internalFormat; // perhaps inferred from pixelFormat?
protected boolean mipmap; // indicates whether mipmaps should be generated
// (ignored if mipmaps are supplied from the file)
private boolean dataIsCompressed;
protected boolean mustFlipVertically; // Must flip texture coordinates
// vertically to get OpenGL output
// to look correct
protected Buffer buffer; // the actual data...
private Buffer[] mipmapData; // ...or a series of mipmaps
private Flusher flusher;
protected int rowLength;
protected int alignment; // 1, 2, or 4 bytes
protected int estimatedMemorySize;
// These booleans are a concession to the AWTTextureData subclass
protected boolean haveEXTABGR;
protected boolean haveGL12;
/**
* Constructs a new TextureData object with the specified parameters
* and data contained in the given Buffer. The optional Flusher can
* be used to clean up native resources associated with this
* TextureData when processing is complete; for example, closing of
* memory-mapped files that might otherwise require a garbage
* collection to reclaim and close.
*
* @param internalFormat the OpenGL internal format for the
* resulting texture; must be specified, may
* not be 0
* @param width the width in pixels of the texture
* @param height the height in pixels of the texture
* @param border the number of pixels of border this texture
* data has (0 or 1)
* @param pixelFormat the OpenGL pixel format for the
* resulting texture; must be specified, may
* not be 0
* @param pixelType the OpenGL type of the pixels of the texture
* @param mipmap indicates whether mipmaps should be
* autogenerated (using GLU) for the resulting
* texture. Currently if mipmap is true then
* dataIsCompressed may not be true.
* @param dataIsCompressed indicates whether the texture data is in
* compressed form
* (e.g. GL_COMPRESSED_RGB_S3TC_DXT1_EXT)
* @param mustFlipVertically indicates whether the texture
* coordinates must be flipped vertically
* in order to properly display the
* texture
* @param buffer the buffer containing the texture data
* @param flusher optional flusher to perform cleanup tasks
* upon call to flush()
*
* @throws IllegalArgumentException if any parameters of the texture
* data were invalid, such as requesting mipmap generation for a
* compressed texture
*/
public TextureData(int internalFormat,
int width,
int height,
int border,
int pixelFormat,
int pixelType,
boolean mipmap,
boolean dataIsCompressed,
boolean mustFlipVertically,
Buffer buffer,
Flusher flusher) throws IllegalArgumentException {
if (mipmap && dataIsCompressed) {
throw new IllegalArgumentException("Can not generate mipmaps for compressed textures");
}
this.width = width;
this.height = height;
this.border = border;
this.pixelFormat = pixelFormat;
this.pixelType = pixelType;
this.internalFormat = internalFormat;
this.mipmap = mipmap;
this.dataIsCompressed = dataIsCompressed;
this.mustFlipVertically = mustFlipVertically;
this.buffer = buffer;
this.flusher = flusher;
alignment = 1; // FIXME: is this correct enough in all situations?
estimatedMemorySize = estimatedMemorySize(buffer);
}
/**
* Constructs a new TextureData object with the specified parameters
* and data for multiple mipmap levels contained in the given array
* of Buffers. The optional Flusher can be used to clean up native
* resources associated with this TextureData when processing is
* complete; for example, closing of memory-mapped files that might
* otherwise require a garbage collection to reclaim and close.
*
* @param internalFormat the OpenGL internal format for the
* resulting texture; must be specified, may
* not be 0
* @param width the width in pixels of the topmost mipmap
* level of the texture
* @param height the height in pixels of the topmost mipmap
* level of the texture
* @param border the number of pixels of border this texture
* data has (0 or 1)
* @param pixelFormat the OpenGL pixel format for the
* resulting texture; must be specified, may
* not be 0
* @param pixelType the OpenGL type of the pixels of the texture
* @param dataIsCompressed indicates whether the texture data is in
* compressed form
* (e.g. GL_COMPRESSED_RGB_S3TC_DXT1_EXT)
* @param mustFlipVertically indicates whether the texture
* coordinates must be flipped vertically
* in order to properly display the
* texture
* @param mipmapData the buffers containing all mipmap levels
* of the texture's data
* @param flusher optional flusher to perform cleanup tasks
* upon call to flush()
*
* @throws IllegalArgumentException if any parameters of the texture
* data were invalid, such as requesting mipmap generation for a
* compressed texture
*/
public TextureData(int internalFormat,
int width,
int height,
int border,
int pixelFormat,
int pixelType,
boolean dataIsCompressed,
boolean mustFlipVertically,
Buffer[] mipmapData,
Flusher flusher) throws IllegalArgumentException {
this.width = width;
this.height = height;
this.border = border;
this.pixelFormat = pixelFormat;
this.pixelType = pixelType;
this.internalFormat = internalFormat;
this.dataIsCompressed = dataIsCompressed;
this.mustFlipVertically = mustFlipVertically;
this.mipmapData = (Buffer[]) mipmapData.clone();
this.flusher = flusher;
alignment = 1; // FIXME: is this correct enough in all situations?
for (int i = 0; i < mipmapData.length; i++) {
estimatedMemorySize += estimatedMemorySize(mipmapData[i]);
}
}
/** Used only by subclasses */
protected TextureData() {
}
/** Returns the width in pixels of the texture data. */
public int getWidth() { return width; }
/** Returns the height in pixels of the texture data. */
public int getHeight() { return height; }
/** Returns the border in pixels of the texture data. */
public int getBorder() { return border; }
/** Returns the intended OpenGL pixel format of the texture data. */
public int getPixelFormat() {
return pixelFormat;
}
/** Returns the intended OpenGL pixel type of the texture data. */
public int getPixelType() {
return pixelType;
}
/** Returns the intended OpenGL internal format of the texture data. */
public int getInternalFormat() { return internalFormat; }
/** Returns whether mipmaps should be generated for the texture data. */
public boolean getMipmap() { return mipmap; }
/** Indicates whether the texture data is in compressed form. */
public boolean isDataCompressed() { return dataIsCompressed; }
/** Indicates whether the texture coordinates must be flipped
vertically for proper display. */
public boolean getMustFlipVertically() { return mustFlipVertically; }
/** Returns the texture data, or null if it is specified as a set of mipmaps. */
public Buffer getBuffer() {
return buffer;
}
/** Returns all mipmap levels for the texture data, or null if it is
specified as a single image. */
public Buffer[] getMipmapData() { return mipmapData; }
/** Returns the required byte alignment for the texture data. */
public int getAlignment() { return alignment; }
/** Returns the row length needed for correct GL_UNPACK_ROW_LENGTH
specification. This is currently only supported for
non-mipmapped, non-compressed textures. */
public int getRowLength() { return rowLength; }
/** Sets the width in pixels of the texture data. */
public void setWidth(int width) { this.width = width; }
/** Sets the height in pixels of the texture data. */
public void setHeight(int height) { this.height = height; }
/** Sets the border in pixels of the texture data. */
public void setBorder(int border) { this.border = border; }
/** Sets the intended OpenGL pixel format of the texture data. */
public void setPixelFormat(int pixelFormat) { this.pixelFormat = pixelFormat; }
/** Sets the intended OpenGL pixel type of the texture data. */
public void setPixelType(int pixelType) { this.pixelType = pixelType; }
/** Sets the intended OpenGL internal format of the texture data. */
public void setInternalFormat(int internalFormat) { this.internalFormat = internalFormat; }
/** Sets whether mipmaps should be generated for the texture data. */
public void setMipmap(boolean mipmap) { this.mipmap = mipmap; }
/** Sets whether the texture data is in compressed form. */
public void setIsDataCompressed(boolean compressed) { this.dataIsCompressed = compressed; }
/** Sets whether the texture coordinates must be flipped vertically
for proper display. */
public void setMustFlipVertically(boolean mustFlipVertically) { this.mustFlipVertically = mustFlipVertically; }
/** Sets the texture data. */
public void setBuffer(Buffer buffer) {
this.buffer = buffer;
estimatedMemorySize = estimatedMemorySize(buffer);
}
/** Sets the required byte alignment for the texture data. */
public void setAlignment(int alignment) { this.alignment = alignment; }
/** Sets the row length needed for correct GL_UNPACK_ROW_LENGTH
specification. This is currently only supported for
non-mipmapped, non-compressed textures. */
public void setRowLength(int rowLength) { this.rowLength = rowLength; }
/** Indicates to this TextureData whether the GL_EXT_abgr extension
is available. Used for optimization along some code paths to
avoid data copies. */
public void setHaveEXTABGR(boolean haveEXTABGR) {
this.haveEXTABGR = haveEXTABGR;
}
/** Indicates to this TextureData whether OpenGL version 1.2 is
available. If not, falls back to relatively inefficient code
paths for several input data types (several kinds of packed
pixel formats, in particular). */
public void setHaveGL12(boolean haveGL12) {
this.haveGL12 = haveGL12;
}
/** Returns an estimate of the amount of memory in bytes this
TextureData will consume once uploaded to the graphics card. It
should only be treated as an estimate; most applications should
not need to query this but instead let the OpenGL implementation
page textures in and out as necessary. */
public int getEstimatedMemorySize() {
return estimatedMemorySize;
}
/** Flushes resources associated with this TextureData by calling
Flusher.flush(). */
public void flush() {
if (flusher != null) {
flusher.flush();
flusher = null;
}
}
/** Defines a callback mechanism to allow the user to explicitly
deallocate native resources (memory-mapped files, etc.)
associated with a particular TextureData. */
public static interface Flusher {
/** Flushes any native resources associated with this
TextureData. */
public void flush();
}
public String toString() {
return "TextureData["+width+"x"+height+", internFormat "+internalFormat+", pixelFormat "+pixelFormat+", pixelType "+pixelType+", border "+border+", estSize "+estimatedMemorySize+", alignment "+alignment+", rowlen "+rowLength;
}
//----------------------------------------------------------------------
// Internals only below this point
//
protected static int estimatedMemorySize(Buffer buffer) {
if (buffer == null) {
return 0;
}
return buffer.capacity() * BufferUtil.sizeOfBufferElem(buffer);
}
}
|