/**
* Reads an image from an archived file and return it as ByteBuffer object.
*
* @author Mike Butler, Kiet Le
*/
private ByteBuffer readImage(String filename, Dimension dim) {
if (dim == null) dim = new Dimension(0, 0);
ByteBuffer bytes = null;
try {
DataInputStream dis =
new DataInputStream(getClass().getClassLoader().getResourceAsStream(filename));
dim.width = dis.readInt();
dim.height = dis.readInt();
System.out.println("Creating buffer, width: " + dim.width + " height: " + dim.height);
// byte[] buf = new byte[3 * dim.height * dim.width];
bytes = BufferUtil.newByteBuffer(3 * dim.width * dim.height);
for (int i = 0; i < bytes.capacity(); i++) {
bytes.put(dis.readByte());
}
dis.close();
} catch (Exception e) {
e.printStackTrace();
}
bytes.rewind();
return bytes;
}
/**
* Returns a ByteBuffer of BufferedImage data. Ensure BufferedImage is of 4BYTE_ABGR type. If
* imageFormat is set to GL_RGBA, byte stream will be converted.
*/
private ByteBuffer getByteBuffer(final BufferedImage _image) {
final DataBuffer buffer = _image.getRaster().getDataBuffer();
final int type = buffer.getDataType();
if (type == DataBuffer.TYPE_BYTE) {
final byte[] data = ((DataBufferByte) buffer).getData();
if (imageFormat == GL3.GL_RGBA) {
convertABGRtoRGBA(data);
}
return ByteBuffer.wrap(data);
}
System.out.println("Failed to determine DataBuffer type.");
return null;
}
protected void fill(GOut g) {
BGL gl = g.gl;
Coord dim = new Coord(tdim, tdim);
for (int i = 0; i < order.length; i++) {
ByteBuffer data =
ByteBuffer.wrap(
TexI.convert(back, dim, new Coord(order[i][0] * tdim, order[i][1] * tdim), dim));
gl.glTexImage2D(
GL.GL_TEXTURE_CUBE_MAP_POSITIVE_X + i,
0,
GL.GL_RGBA,
tdim,
tdim,
0,
GL.GL_RGBA,
GL.GL_UNSIGNED_BYTE,
data);
}
}
public void init(GLAutoDrawable drawable) {
GL gl = drawable.getGL();
float m[] = {
0.0f, 1.0f, 0.0f, 0.0f, //
0.0f, 0.0f, 1.0f, 0.0f, //
1.0f, 0.0f, 0.0f, 0.0f, //
0.0f, 0.0f, 0.0f, 1.0f
};
pixels = readImage("Data/leeds.bin", dim);
System.out.println(pixels.toString());
gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, 1);
gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
gl.glMatrixMode(GL.GL_COLOR);
gl.glLoadMatrixf(m, 0);
gl.glMatrixMode(GL.GL_MODELVIEW);
}
/**
* Updates the content area of the specified target of this texture using the data in the given
* image. In general this is intended for construction of cube maps.
*
* @throws GLException if no OpenGL context was current or if any OpenGL-related errors occurred
*/
public void updateImage(TextureData data, int target) throws GLException {
GL gl = GLU.getCurrentGL();
imgWidth = data.getWidth();
imgHeight = data.getHeight();
aspectRatio = (float) imgWidth / (float) imgHeight;
mustFlipVertically = data.getMustFlipVertically();
int texTarget = 0;
int texParamTarget = this.target;
// See whether we have automatic mipmap generation support
boolean haveAutoMipmapGeneration =
(gl.isExtensionAvailable("GL_VERSION_1_4")
|| gl.isExtensionAvailable("GL_SGIS_generate_mipmap"));
// Indicate to the TextureData what functionality is available
data.setHaveEXTABGR(gl.isExtensionAvailable("GL_EXT_abgr"));
data.setHaveGL12(gl.isExtensionAvailable("GL_VERSION_1_2"));
// Note that automatic mipmap generation doesn't work for
// GL_ARB_texture_rectangle
if ((!isPowerOfTwo(imgWidth) || !isPowerOfTwo(imgHeight)) && !haveNPOT(gl)) {
haveAutoMipmapGeneration = false;
}
boolean expandingCompressedTexture = false;
if (data.getMipmap() && !haveAutoMipmapGeneration) {
// GLU always scales the texture's dimensions to be powers of
// two. It also doesn't really matter exactly what the texture
// width and height are because the texture coords are always
// between 0.0 and 1.0.
imgWidth = nextPowerOfTwo(imgWidth);
imgHeight = nextPowerOfTwo(imgHeight);
texWidth = imgWidth;
texHeight = imgHeight;
texTarget = GL.GL_TEXTURE_2D;
} else if ((isPowerOfTwo(imgWidth) && isPowerOfTwo(imgHeight)) || haveNPOT(gl)) {
if (DEBUG) {
if (isPowerOfTwo(imgWidth) && isPowerOfTwo(imgHeight)) {
System.err.println("Power-of-two texture");
} else {
System.err.println("Using GL_ARB_texture_non_power_of_two");
}
}
texWidth = imgWidth;
texHeight = imgHeight;
texTarget = GL.GL_TEXTURE_2D;
} else if (haveTexRect(gl) && !data.isDataCompressed()) {
// GL_ARB_texture_rectangle does not work for compressed textures
if (DEBUG) {
System.err.println("Using GL_ARB_texture_rectangle");
}
texWidth = imgWidth;
texHeight = imgHeight;
texTarget = GL.GL_TEXTURE_RECTANGLE_ARB;
} else {
// If we receive non-power-of-two compressed texture data and
// don't have true hardware support for compressed textures, we
// can fake this support by producing an empty "compressed"
// texture image, using glCompressedTexImage2D with that to
// allocate the texture, and glCompressedTexSubImage2D with the
// incoming data.
if (data.isDataCompressed()) {
if (data.getMipmapData() != null) {
// We don't currently support expanding of compressed,
// mipmapped non-power-of-two textures to the nearest power
// of two; the obvious port of the non-mipmapped code didn't
// work
throw new GLException(
"Mipmapped non-power-of-two compressed textures only supported on OpenGL 2.0 hardware (GL_ARB_texture_non_power_of_two)");
}
expandingCompressedTexture = true;
}
if (DEBUG) {
System.err.println("Expanding texture to power-of-two dimensions");
}
if (data.getBorder() != 0) {
throw new RuntimeException(
"Scaling up a non-power-of-two texture which has a border won't work");
}
texWidth = nextPowerOfTwo(imgWidth);
texHeight = nextPowerOfTwo(imgHeight);
texTarget = GL.GL_TEXTURE_2D;
}
texParamTarget = texTarget;
setImageSize(imgWidth, imgHeight, texTarget);
if (target != 0) {
// Allow user to override auto detection and skip bind step (for
// cubemap construction)
texTarget = target;
if (this.target == 0) {
throw new GLException("Override of target failed; no target specified yet");
}
texParamTarget = this.target;
gl.glBindTexture(texParamTarget, texID);
} else {
gl.glBindTexture(texTarget, texID);
}
if (data.getMipmap() && !haveAutoMipmapGeneration) {
int[] align = new int[1];
gl.glGetIntegerv(GL.GL_UNPACK_ALIGNMENT, align, 0); // save alignment
gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, data.getAlignment());
if (data.isDataCompressed()) {
throw new GLException("May not request mipmap generation for compressed textures");
}
try {
GLU glu = new GLU();
glu.gluBuild2DMipmaps(
texTarget,
data.getInternalFormat(),
data.getWidth(),
data.getHeight(),
data.getPixelFormat(),
data.getPixelType(),
data.getBuffer());
} finally {
gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, align[0]); // restore alignment
}
} else {
checkCompressedTextureExtensions(data);
Buffer[] mipmapData = data.getMipmapData();
if (mipmapData != null) {
int width = texWidth;
int height = texHeight;
for (int i = 0; i < mipmapData.length; i++) {
if (data.isDataCompressed()) {
// Need to use glCompressedTexImage2D directly to allocate and fill this image
// Avoid spurious memory allocation when possible
gl.glCompressedTexImage2D(
texTarget,
i,
data.getInternalFormat(),
width,
height,
data.getBorder(),
mipmapData[i].remaining(),
mipmapData[i]);
} else {
// Allocate texture image at this level
gl.glTexImage2D(
texTarget,
i,
data.getInternalFormat(),
width,
height,
data.getBorder(),
data.getPixelFormat(),
data.getPixelType(),
null);
updateSubImageImpl(data, texTarget, i, 0, 0, 0, 0, data.getWidth(), data.getHeight());
}
width = Math.max(width / 2, 1);
height = Math.max(height / 2, 1);
}
} else {
if (data.isDataCompressed()) {
if (!expandingCompressedTexture) {
// Need to use glCompressedTexImage2D directly to allocate and fill this image
// Avoid spurious memory allocation when possible
gl.glCompressedTexImage2D(
texTarget,
0,
data.getInternalFormat(),
texWidth,
texHeight,
data.getBorder(),
data.getBuffer().capacity(),
data.getBuffer());
} else {
ByteBuffer buf =
DDSImage.allocateBlankBuffer(texWidth, texHeight, data.getInternalFormat());
gl.glCompressedTexImage2D(
texTarget,
0,
data.getInternalFormat(),
texWidth,
texHeight,
data.getBorder(),
buf.capacity(),
buf);
updateSubImageImpl(data, texTarget, 0, 0, 0, 0, 0, data.getWidth(), data.getHeight());
}
} else {
if (data.getMipmap() && haveAutoMipmapGeneration) {
// For now, only use hardware mipmapping for uncompressed 2D
// textures where the user hasn't explicitly specified
// mipmap data; don't know about interactions between
// GL_GENERATE_MIPMAP and glCompressedTexImage2D
gl.glTexParameteri(texParamTarget, GL.GL_GENERATE_MIPMAP, GL.GL_TRUE);
usingAutoMipmapGeneration = true;
}
gl.glTexImage2D(
texTarget,
0,
data.getInternalFormat(),
texWidth,
texHeight,
data.getBorder(),
data.getPixelFormat(),
data.getPixelType(),
null);
updateSubImageImpl(data, texTarget, 0, 0, 0, 0, 0, data.getWidth(), data.getHeight());
}
}
}
int minFilter = (data.getMipmap() ? GL.GL_LINEAR_MIPMAP_LINEAR : GL.GL_LINEAR);
int magFilter = GL.GL_LINEAR;
int wrapMode = (gl.isExtensionAvailable("GL_VERSION_1_2") ? GL.GL_CLAMP_TO_EDGE : GL.GL_CLAMP);
// REMIND: figure out what to do for GL_TEXTURE_RECTANGLE_ARB
if (texTarget != GL.GL_TEXTURE_RECTANGLE_ARB) {
gl.glTexParameteri(texParamTarget, GL.GL_TEXTURE_MIN_FILTER, minFilter);
gl.glTexParameteri(texParamTarget, GL.GL_TEXTURE_MAG_FILTER, magFilter);
gl.glTexParameteri(texParamTarget, GL.GL_TEXTURE_WRAP_S, wrapMode);
gl.glTexParameteri(texParamTarget, GL.GL_TEXTURE_WRAP_T, wrapMode);
if (this.target == GL.GL_TEXTURE_CUBE_MAP) {
gl.glTexParameteri(texParamTarget, GL.GL_TEXTURE_WRAP_R, wrapMode);
}
}
// Don't overwrite target if we're loading e.g. faces of a cube
// map
if ((this.target == 0)
|| (this.target == GL.GL_TEXTURE_2D)
|| (this.target == GL.GL_TEXTURE_RECTANGLE_ARB)) {
this.target = texTarget;
}
// This estimate will be wrong for cube maps
estimatedMemorySize = data.getEstimatedMemorySize();
}
