Java tutorial
/* * Copyright (c) 2008 Golden T Studios. * * This program 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 3 of the License, or * (at your option) any later version. * * This program 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 program. If not, see <http://www.gnu.org/licenses/>. */ package com.golden.gamedev.engine.lwjgl; import java.awt.Color; import java.awt.Graphics; import java.awt.Transparency; import java.awt.color.ColorSpace; import java.awt.image.BufferedImage; import java.awt.image.ColorModel; import java.awt.image.ComponentColorModel; import java.awt.image.DataBuffer; import java.awt.image.DataBufferByte; import java.awt.image.Raster; import java.awt.image.WritableRaster; import java.io.BufferedInputStream; import java.io.IOException; import java.net.URL; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.nio.IntBuffer; import java.util.Hashtable; import java.util.WeakHashMap; import javax.imageio.ImageIO; import org.lwjgl.BufferUtils; import org.lwjgl.opengl.GL11; /** * A utility class to load textures for OpenGL. This source is based on a * texture that can be found in the Java Gaming (www.javagaming.org) Wiki. It * has been simplified slightly for explicit 2D graphics use. * * OpenGL uses a particular image format. Since the images that are loaded from * disk may not match this format this loader introduces a intermediate image * which the source image is copied into. In turn, this image is used as source * for the OpenGL texture. * * @author Kevin Glass * @author Brian Matzon */ public class TextureLoader { // the table of textures that have been loaded in this loader private WeakHashMap table = new WeakHashMap(); // the color model including alpha for the GL image private ColorModel glAlphaColorModel; // the color model for the GL image private ColorModel glColorModel; // scratch buffer for texture ID's private IntBuffer textureIDBuffer = BufferUtils.createIntBuffer(1); /** * Create a new texture loader based on the game panel * * @param gl The GL content in which the textures should be loaded */ public TextureLoader() { this.glAlphaColorModel = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), new int[] { 8, 8, 8, 8 }, true, false, Transparency.TRANSLUCENT, DataBuffer.TYPE_BYTE); this.glColorModel = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), new int[] { 8, 8, 8, 0 }, false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE); } /** * Create a new texture ID * * @return A new texture ID */ private int createTextureID() { GL11.glGenTextures(this.textureIDBuffer); return this.textureIDBuffer.get(0); } /** * Load a texture. * * @param resourceName The location of the resource to load * @return The loaded texture * @throws IOException Indicates a failure to access the resource */ public Texture getTexture(BufferedImage image) { Texture texture = (Texture) this.table.get(image); if (texture == null) { texture = this.getTexture(image, GL11.GL_TEXTURE_2D, // target GL11.GL_RGBA, // dst pixel format GL11.GL_LINEAR, // min filter (unused) GL11.GL_LINEAR); this.table.put(image, texture); } return texture; } /** * Load a texture into OpenGL from a image reference on disk. * * @param resourceName The location of the resource to load * @param target The GL target to load the texture against * @param dstPixelFormat The pixel format of the screen * @param minFilter The minimising filter * @param magFilter The magnification filter * @return The loaded texture * @throws IOException Indicates a failure to access the resource */ public Texture getTexture(BufferedImage image, int target, int dstPixelFormat, int minFilter, int magFilter) { int srcPixelFormat = 0; // create the texture ID for this texture int textureID = this.createTextureID(); Texture texture = new Texture(target, textureID); // bind this texture GL11.glBindTexture(target, textureID); texture.setWidth(image.getWidth()); texture.setHeight(image.getHeight()); srcPixelFormat = (image.getColorModel().hasAlpha()) ? GL11.GL_RGBA : GL11.GL_RGB; // convert that image into a byte buffer of texture data ByteBuffer textureBuffer = this.convertImageData(image, texture); if (target == GL11.GL_TEXTURE_2D) { GL11.glTexParameteri(target, GL11.GL_TEXTURE_MIN_FILTER, minFilter); GL11.glTexParameteri(target, GL11.GL_TEXTURE_MAG_FILTER, magFilter); } // produce a texture from the byte buffer GL11.glTexImage2D(target, 0, dstPixelFormat, this.get2Fold(image.getWidth()), this.get2Fold(image.getHeight()), 0, srcPixelFormat, GL11.GL_UNSIGNED_BYTE, textureBuffer); return texture; } /** * Get the closest greater power of 2 to the fold number * * @param fold The target number * @return The power of 2 */ private int get2Fold(int fold) { int ret = 2; while (ret < fold) { ret *= 2; } return ret; } /** * Convert the buffered image to a texture * * @param bufferedImage The image to convert to a texture * @param texture The texture to store the data into * @return A buffer containing the data */ private ByteBuffer convertImageData(BufferedImage bufferedImage, Texture texture) { ByteBuffer imageBuffer = null; WritableRaster raster; BufferedImage texImage; int texWidth = 2; int texHeight = 2; // find the closest power of 2 for the width and height // of the produced texture while (texWidth < bufferedImage.getWidth()) { texWidth *= 2; } while (texHeight < bufferedImage.getHeight()) { texHeight *= 2; } texture.setTextureHeight(texHeight); texture.setTextureWidth(texWidth); // create a raster that can be used by OpenGL as a source // for a texture if (bufferedImage.getColorModel().hasAlpha()) { raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, texWidth, texHeight, 4, null); texImage = new BufferedImage(this.glAlphaColorModel, raster, false, new Hashtable()); } else { raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, texWidth, texHeight, 3, null); texImage = new BufferedImage(this.glColorModel, raster, false, new Hashtable()); } // copy the source image into the produced image Graphics g = texImage.getGraphics(); g.setColor(new Color(0f, 0f, 0f, 0f)); g.fillRect(0, 0, texWidth, texHeight); g.drawImage(bufferedImage, 0, 0, null); // build a byte buffer from the temporary image // that be used by OpenGL to produce a texture. byte[] data = ((DataBufferByte) texImage.getRaster().getDataBuffer()).getData(); imageBuffer = ByteBuffer.allocateDirect(data.length); imageBuffer.order(ByteOrder.nativeOrder()); imageBuffer.put(data, 0, data.length); imageBuffer.flip(); return imageBuffer; } /** * Load a given resource as a buffered image * * @param ref The location of the resource to load * @return The loaded buffered image * @throws IOException Indicates a failure to find a resource */ private BufferedImage loadImage(String ref) throws IOException { URL url = TextureLoader.class.getClassLoader().getResource(ref); if (url == null) { throw new IOException("Cannot find: " + ref); } BufferedImage bufferedImage = ImageIO .read(new BufferedInputStream(this.getClass().getClassLoader().getResourceAsStream(ref))); return bufferedImage; } }