| /* |
| * Copyright (c) 2009-2012 jMonkeyEngine |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * * Redistributions 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 'jMonkeyEngine' nor the names of its contributors |
| * may be used to endorse or promote products derived from this software |
| * without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED |
| * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
| * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
| * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| package jme3tools.optimize; |
| |
| import com.jme3.asset.AssetKey; |
| import com.jme3.asset.AssetManager; |
| import com.jme3.material.MatParamTexture; |
| import com.jme3.material.Material; |
| import com.jme3.math.Vector2f; |
| import com.jme3.scene.Geometry; |
| import com.jme3.scene.Mesh; |
| import com.jme3.scene.Spatial; |
| import com.jme3.scene.VertexBuffer; |
| import com.jme3.scene.VertexBuffer.Type; |
| import com.jme3.texture.Image; |
| import com.jme3.texture.Image.Format; |
| import com.jme3.texture.Texture; |
| import com.jme3.texture.Texture2D; |
| import com.jme3.util.BufferUtils; |
| import java.lang.reflect.InvocationTargetException; |
| import java.nio.ByteBuffer; |
| import java.nio.FloatBuffer; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.TreeMap; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| |
| /** |
| * <b><code>TextureAtlas</code></b> allows combining multiple textures to one texture atlas. |
| * |
| * <p>After the TextureAtlas has been created with a certain size, textures can be added for |
| * freely chosen "map names". The textures are automatically placed on the atlas map and the |
| * image data is stored in a byte array for each map name. Later each map can be retrieved as |
| * a Texture to be used further in materials.</p> |
| * |
| * <p>The first map name used is the "master map" that defines new locations on the atlas. Secondary |
| * textures (other map names) have to reference a texture of the master map to position the texture |
| * on the secondary map. This is necessary as the maps share texture coordinates and thus need to be |
| * placed at the same location on both maps.</p> |
| * |
| * <p>The helper methods that work with <code>Geometry</code> objects handle the <em>DiffuseMap</em> or <em>ColorMap</em> as the master map and |
| * additionally handle <em>NormalMap</em> and <em>SpecularMap</em> as secondary maps.</p> |
| * |
| * <p>The textures are referenced by their <b>asset key name</b> and for each texture the location |
| * inside the atlas is stored. A texture with an existing key name is never added more than once |
| * to the atlas. You can access the information for each texture or geometry texture via helper methods.</p> |
| * |
| * <p>The TextureAtlas also allows you to change the texture coordinates of a mesh or geometry |
| * to point at the new locations of its texture inside the atlas (if the texture exists inside the atlas).</p> |
| * |
| * <p>Note that models that use texture coordinates outside the 0-1 range (repeating/wrapping textures) |
| * will not work correctly as their new coordinates leak into other parts of the atlas and thus display |
| * other textures instead of repeating the texture.</p> |
| * |
| * <p>Also note that textures are not scaled and the atlas needs to be large enough to hold all textures. |
| * All methods that allow adding textures return false if the texture could not be added due to the |
| * atlas being full. Furthermore secondary textures (normal, spcular maps etc.) have to be the same size |
| * as the main (e.g. DiffuseMap) texture.</p> |
| * |
| * <p><b>Usage examples</b></p> |
| * Create one geometry out of several geometries that are loaded from a j3o file: |
| * <pre> |
| * Node scene = assetManager.loadModel("Scenes/MyScene.j3o"); |
| * Geometry geom = TextureAtlas.makeAtlasBatch(scene); |
| * rootNode.attachChild(geom); |
| * </pre> |
| * Create a texture atlas and change the texture coordinates of one geometry: |
| * <pre> |
| * Node scene = assetManager.loadModel("Scenes/MyScene.j3o"); |
| * //either auto-create from node: |
| * TextureAtlas atlas = TextureAtlas.createAtlas(scene); |
| * //or create manually by adding textures or geometries with textures |
| * TextureAtlas atlas = new TextureAtlas(1024,1024); |
| * atlas.addTexture(myTexture, "DiffuseMap"); |
| * atlas.addGeometry(myGeometry); |
| * //create material and set texture |
| * Material mat = new Material(mgr, "Common/MatDefs/Light/Lighting.j3md"); |
| * mat.setTexture("DiffuseMap", atlas.getAtlasTexture("DiffuseMap")); |
| * //change one geometry to use atlas, apply texture coordinates and replace material. |
| * Geometry geom = scene.getChild("MyGeometry"); |
| * atlas.applyCoords(geom); |
| * geom.setMaterial(mat); |
| * </pre> |
| * |
| * @author normenhansen, Lukasz Bruun - lukasz.dk |
| */ |
| public class TextureAtlas { |
| |
| private static final Logger logger = Logger.getLogger(TextureAtlas.class.getName()); |
| private Map<String, byte[]> images; |
| private int atlasWidth, atlasHeight; |
| private Format format = Format.ABGR8; |
| private Node root; |
| private Map<String, TextureAtlasTile> locationMap; |
| private Map<String, String> mapNameMap; |
| private String rootMapName; |
| |
| public TextureAtlas(int width, int height) { |
| this.atlasWidth = width; |
| this.atlasHeight = height; |
| root = new Node(0, 0, width, height); |
| locationMap = new TreeMap<String, TextureAtlasTile>(); |
| mapNameMap = new HashMap<String, String>(); |
| } |
| |
| /** |
| * Add a geometries DiffuseMap (or ColorMap), NormalMap and SpecularMap to the atlas. |
| * @param geometry |
| * @return false if the atlas is full. |
| */ |
| public boolean addGeometry(Geometry geometry) { |
| Texture diffuse = getMaterialTexture(geometry, "DiffuseMap"); |
| Texture normal = getMaterialTexture(geometry, "NormalMap"); |
| Texture specular = getMaterialTexture(geometry, "SpecularMap"); |
| if (diffuse == null) { |
| diffuse = getMaterialTexture(geometry, "ColorMap"); |
| |
| } |
| if (diffuse != null && diffuse.getKey() != null) { |
| String keyName = diffuse.getKey().toString(); |
| if (!addTexture(diffuse, "DiffuseMap")) { |
| return false; |
| } else { |
| if (normal != null && normal.getKey() != null) { |
| addTexture(diffuse, "NormalMap", keyName); |
| } |
| if (specular != null && specular.getKey() != null) { |
| addTexture(specular, "SpecularMap", keyName); |
| } |
| } |
| return true; |
| } |
| return true; |
| } |
| |
| /** |
| * Add a texture for a specific map name |
| * @param texture A texture to add to the atlas. |
| * @param mapName A freely chosen map name that can be later retrieved as a Texture. The first map name supplied will be the master map. |
| * @return false if the atlas is full. |
| */ |
| public boolean addTexture(Texture texture, String mapName) { |
| if (texture == null) { |
| throw new IllegalStateException("Texture cannot be null!"); |
| } |
| String name = textureName(texture); |
| if (texture.getImage() != null && name != null) { |
| return addImage(texture.getImage(), name, mapName, null); |
| } else { |
| throw new IllegalStateException("Texture has no asset key name!"); |
| } |
| } |
| |
| /** |
| * Add a texture for a specific map name at the location of another existing texture on the master map. |
| * @param texture A texture to add to the atlas. |
| * @param mapName A freely chosen map name that can be later retrieved as a Texture. |
| * @param masterTexture The master texture for determining the location, it has to exist in tha master map. |
| */ |
| public void addTexture(Texture texture, String mapName, Texture masterTexture) { |
| String sourceTextureName = textureName(masterTexture); |
| if (sourceTextureName == null) { |
| throw new IllegalStateException("Supplied master map texture has no asset key name!"); |
| } else { |
| addTexture(texture, mapName, sourceTextureName); |
| } |
| } |
| |
| /** |
| * Add a texture for a specific map name at the location of another existing texture (on the master map). |
| * @param texture A texture to add to the atlas. |
| * @param mapName A freely chosen map name that can be later retrieved as a Texture. |
| * @param sourceTextureName Name of the master map used for the location. |
| */ |
| public void addTexture(Texture texture, String mapName, String sourceTextureName) { |
| if (texture == null) { |
| throw new IllegalStateException("Texture cannot be null!"); |
| } |
| String name = textureName(texture); |
| if (texture.getImage() != null && name != null) { |
| addImage(texture.getImage(), name, mapName, sourceTextureName); |
| } else { |
| throw new IllegalStateException("Texture has no asset key name!"); |
| } |
| } |
| |
| private String textureName(Texture texture) { |
| if (texture == null) { |
| return null; |
| } |
| AssetKey key = texture.getKey(); |
| if (key != null) { |
| return key.toString(); |
| } else { |
| return null; |
| } |
| } |
| |
| private boolean addImage(Image image, String name, String mapName, String sourceTextureName) { |
| if (rootMapName == null) { |
| rootMapName = mapName; |
| } |
| if (sourceTextureName == null && !rootMapName.equals(mapName)) { |
| throw new IllegalStateException("Atlas already has a master map called " + rootMapName + "." |
| + " Textures for new maps have to use a texture from the master map for their location."); |
| } |
| TextureAtlasTile location = locationMap.get(name); |
| if (location != null) { |
| //have location for texture |
| if (!mapName.equals(mapNameMap.get(name))) { |
| logger.log(Level.WARNING, "Same texture " + name + " is used in different maps! (" + mapName + " and " + mapNameMap.get(name) + "). Location will be based on location in " + mapNameMap.get(name) + "!"); |
| drawImage(image, location.getX(), location.getY(), mapName); |
| return true; |
| } else { |
| return true; |
| } |
| } else if (sourceTextureName == null) { |
| //need to make new tile |
| Node node = root.insert(image); |
| if (node == null) { |
| return false; |
| } |
| location = node.location; |
| } else { |
| //got old tile to align to |
| location = locationMap.get(sourceTextureName); |
| if (location == null) { |
| throw new IllegalStateException("Cannot find master map texture for " + name + "."); |
| } else if (location.width != image.getWidth() || location.height != image.getHeight()) { |
| throw new IllegalStateException(mapName + " " + name + " does not fit " + rootMapName + " tile size. Make sure all textures (diffuse, normal, specular) for one model are the same size."); |
| } |
| } |
| mapNameMap.put(name, mapName); |
| locationMap.put(name, location); |
| drawImage(image, location.getX(), location.getY(), mapName); |
| return true; |
| } |
| |
| private void drawImage(Image source, int x, int y, String mapName) { |
| if (images == null) { |
| images = new HashMap<String, byte[]>(); |
| } |
| byte[] image = images.get(mapName); |
| if (image == null) { |
| image = new byte[atlasWidth * atlasHeight * 4]; |
| images.put(mapName, image); |
| } |
| //TODO: all buffers? |
| ByteBuffer sourceData = source.getData(0); |
| int height = source.getHeight(); |
| int width = source.getWidth(); |
| Image newImage = null; |
| for (int yPos = 0; yPos < height; yPos++) { |
| for (int xPos = 0; xPos < width; xPos++) { |
| int i = ((xPos + x) + (yPos + y) * atlasWidth) * 4; |
| if (source.getFormat() == Format.ABGR8) { |
| int j = (xPos + yPos * width) * 4; |
| image[i] = sourceData.get(j); //a |
| image[i + 1] = sourceData.get(j + 1); //b |
| image[i + 2] = sourceData.get(j + 2); //g |
| image[i + 3] = sourceData.get(j + 3); //r |
| } else if (source.getFormat() == Format.BGR8) { |
| int j = (xPos + yPos * width) * 3; |
| image[i] = 1; //a |
| image[i + 1] = sourceData.get(j); //b |
| image[i + 2] = sourceData.get(j + 1); //g |
| image[i + 3] = sourceData.get(j + 2); //r |
| } else if (source.getFormat() == Format.RGB8) { |
| int j = (xPos + yPos * width) * 3; |
| image[i] = 1; //a |
| image[i + 1] = sourceData.get(j + 2); //b |
| image[i + 2] = sourceData.get(j + 1); //g |
| image[i + 3] = sourceData.get(j); //r |
| } else if (source.getFormat() == Format.RGBA8) { |
| int j = (xPos + yPos * width) * 4; |
| image[i] = sourceData.get(j + 3); //a |
| image[i + 1] = sourceData.get(j + 2); //b |
| image[i + 2] = sourceData.get(j + 1); //g |
| image[i + 3] = sourceData.get(j); //r |
| } else if (source.getFormat() == Format.Luminance8) { |
| int j = (xPos + yPos * width) * 1; |
| image[i] = 1; //a |
| image[i + 1] = sourceData.get(j); //b |
| image[i + 2] = sourceData.get(j); //g |
| image[i + 3] = sourceData.get(j); //r |
| } else if (source.getFormat() == Format.Luminance8Alpha8) { |
| int j = (xPos + yPos * width) * 2; |
| image[i] = sourceData.get(j + 1); //a |
| image[i + 1] = sourceData.get(j); //b |
| image[i + 2] = sourceData.get(j); //g |
| image[i + 3] = sourceData.get(j); //r |
| } else { |
| //ImageToAwt conversion |
| if (newImage == null) { |
| newImage = convertImageToAwt(source); |
| if (newImage != null) { |
| source = newImage; |
| sourceData = source.getData(0); |
| int j = (xPos + yPos * width) * 4; |
| image[i] = sourceData.get(j); //a |
| image[i + 1] = sourceData.get(j + 1); //b |
| image[i + 2] = sourceData.get(j + 2); //g |
| image[i + 3] = sourceData.get(j + 3); //r |
| }else{ |
| throw new UnsupportedOperationException("Cannot draw or convert textures with format " + source.getFormat()); |
| } |
| } else { |
| throw new UnsupportedOperationException("Cannot draw textures with format " + source.getFormat()); |
| } |
| } |
| } |
| } |
| } |
| |
| private Image convertImageToAwt(Image source) { |
| //use awt dependent classes without actual dependency via reflection |
| try { |
| Class clazz = Class.forName("jme3tools.converters.ImageToAwt"); |
| if (clazz == null) { |
| return null; |
| } |
| Image newImage = new Image(format, source.getWidth(), source.getHeight(), BufferUtils.createByteBuffer(source.getWidth() * source.getHeight() * 4)); |
| clazz.getMethod("convert", Image.class, Image.class).invoke(clazz.newInstance(), source, newImage); |
| return newImage; |
| } catch (InstantiationException ex) { |
| } catch (IllegalAccessException ex) { |
| } catch (IllegalArgumentException ex) { |
| } catch (InvocationTargetException ex) { |
| } catch (NoSuchMethodException ex) { |
| } catch (SecurityException ex) { |
| } catch (ClassNotFoundException ex) { |
| } |
| return null; |
| } |
| |
| /** |
| * Get the <code>TextureAtlasTile</code> for the given Texture |
| * @param texture The texture to retrieve the <code>TextureAtlasTile</code> for. |
| * @return |
| */ |
| public TextureAtlasTile getAtlasTile(Texture texture) { |
| String sourceTextureName = textureName(texture); |
| if (sourceTextureName != null) { |
| return getAtlasTile(sourceTextureName); |
| } |
| return null; |
| } |
| |
| /** |
| * Get the <code>TextureAtlasTile</code> for the given Texture |
| * @param assetName The texture to retrieve the <code>TextureAtlasTile</code> for. |
| * @return |
| */ |
| private TextureAtlasTile getAtlasTile(String assetName) { |
| return locationMap.get(assetName); |
| } |
| |
| /** |
| * Creates a new atlas texture for the given map name. |
| * @param mapName |
| * @return |
| */ |
| public Texture getAtlasTexture(String mapName) { |
| if (images == null) { |
| return null; |
| } |
| byte[] image = images.get(mapName); |
| if (image != null) { |
| Texture2D tex = new Texture2D(new Image(format, atlasWidth, atlasHeight, BufferUtils.createByteBuffer(image))); |
| tex.setMagFilter(Texture.MagFilter.Bilinear); |
| tex.setMinFilter(Texture.MinFilter.BilinearNearestMipMap); |
| tex.setWrap(Texture.WrapMode.Clamp); |
| return tex; |
| } |
| return null; |
| } |
| |
| /** |
| * Applies the texture coordinates to the given geometry |
| * if its DiffuseMap or ColorMap exists in the atlas. |
| * @param geom The geometry to change the texture coordinate buffer on. |
| * @return true if texture has been found and coords have been changed, false otherwise. |
| */ |
| public boolean applyCoords(Geometry geom) { |
| return applyCoords(geom, 0, geom.getMesh()); |
| } |
| |
| /** |
| * Applies the texture coordinates to the given output mesh |
| * if the DiffuseMap or ColorMap of the input geometry exist in the atlas. |
| * @param geom The geometry to change the texture coordinate buffer on. |
| * @param offset Target buffer offset. |
| * @param outMesh The mesh to set the coords in (can be same as input). |
| * @return true if texture has been found and coords have been changed, false otherwise. |
| */ |
| public boolean applyCoords(Geometry geom, int offset, Mesh outMesh) { |
| Mesh inMesh = geom.getMesh(); |
| geom.computeWorldMatrix(); |
| |
| VertexBuffer inBuf = inMesh.getBuffer(Type.TexCoord); |
| VertexBuffer outBuf = outMesh.getBuffer(Type.TexCoord); |
| |
| if (inBuf == null || outBuf == null) { |
| throw new IllegalStateException("Geometry mesh has no texture coordinate buffer."); |
| } |
| |
| Texture tex = getMaterialTexture(geom, "DiffuseMap"); |
| if (tex == null) { |
| tex = getMaterialTexture(geom, "ColorMap"); |
| |
| } |
| if (tex != null) { |
| TextureAtlasTile tile = getAtlasTile(tex); |
| if (tile != null) { |
| FloatBuffer inPos = (FloatBuffer) inBuf.getData(); |
| FloatBuffer outPos = (FloatBuffer) outBuf.getData(); |
| tile.transformTextureCoords(inPos, offset, outPos); |
| return true; |
| } else { |
| return false; |
| } |
| } else { |
| throw new IllegalStateException("Geometry has no proper texture."); |
| } |
| } |
| |
| /** |
| * Create a texture atlas for the given root node, containing DiffuseMap, NormalMap and SpecularMap. |
| * @param root The rootNode to create the atlas for. |
| * @param atlasSize The size of the atlas (width and height). |
| * @return Null if the atlas cannot be created because not all textures fit. |
| */ |
| public static TextureAtlas createAtlas(Spatial root, int atlasSize) { |
| List<Geometry> geometries = new ArrayList<Geometry>(); |
| GeometryBatchFactory.gatherGeoms(root, geometries); |
| TextureAtlas atlas = new TextureAtlas(atlasSize, atlasSize); |
| for (Geometry geometry : geometries) { |
| if (!atlas.addGeometry(geometry)) { |
| logger.log(Level.WARNING, "Texture atlas size too small, cannot add all textures"); |
| return null; |
| } |
| } |
| return atlas; |
| } |
| |
| /** |
| * Creates one geometry out of the given root spatial and merges all single |
| * textures into one texture of the given size. |
| * @param spat The root spatial of the scene to batch |
| * @param mgr An assetmanager that can be used to create the material. |
| * @param atlasSize A size for the atlas texture, it has to be large enough to hold all single textures. |
| * @return A new geometry that uses the generated texture atlas and merges all meshes of the root spatial, null if the atlas cannot be created because not all textures fit. |
| */ |
| public static Geometry makeAtlasBatch(Spatial spat, AssetManager mgr, int atlasSize) { |
| List<Geometry> geometries = new ArrayList<Geometry>(); |
| GeometryBatchFactory.gatherGeoms(spat, geometries); |
| TextureAtlas atlas = createAtlas(spat, atlasSize); |
| if (atlas == null) { |
| return null; |
| } |
| Geometry geom = new Geometry(); |
| Mesh mesh = new Mesh(); |
| GeometryBatchFactory.mergeGeometries(geometries, mesh); |
| applyAtlasCoords(geometries, mesh, atlas); |
| mesh.updateCounts(); |
| mesh.updateBound(); |
| geom.setMesh(mesh); |
| |
| Material mat = new Material(mgr, "Common/MatDefs/Light/Lighting.j3md"); |
| mat.getAdditionalRenderState().setAlphaTest(true); |
| Texture diffuseMap = atlas.getAtlasTexture("DiffuseMap"); |
| Texture normalMap = atlas.getAtlasTexture("NormalMap"); |
| Texture specularMap = atlas.getAtlasTexture("SpecularMap"); |
| if (diffuseMap != null) { |
| mat.setTexture("DiffuseMap", diffuseMap); |
| } |
| if (normalMap != null) { |
| mat.setTexture("NormalMap", normalMap); |
| } |
| if (specularMap != null) { |
| mat.setTexture("SpecularMap", specularMap); |
| } |
| mat.setFloat("Shininess", 16.0f); |
| |
| geom.setMaterial(mat); |
| return geom; |
| } |
| |
| private static void applyAtlasCoords(List<Geometry> geometries, Mesh outMesh, TextureAtlas atlas) { |
| int globalVertIndex = 0; |
| |
| for (Geometry geom : geometries) { |
| Mesh inMesh = geom.getMesh(); |
| geom.computeWorldMatrix(); |
| |
| int geomVertCount = inMesh.getVertexCount(); |
| |
| VertexBuffer inBuf = inMesh.getBuffer(Type.TexCoord); |
| VertexBuffer outBuf = outMesh.getBuffer(Type.TexCoord); |
| |
| if (inBuf == null || outBuf == null) { |
| continue; |
| } |
| |
| atlas.applyCoords(geom, globalVertIndex, outMesh); |
| |
| globalVertIndex += geomVertCount; |
| } |
| } |
| |
| private static Texture getMaterialTexture(Geometry geometry, String mapName) { |
| Material mat = geometry.getMaterial(); |
| if (mat == null || mat.getParam(mapName) == null || !(mat.getParam(mapName) instanceof MatParamTexture)) { |
| return null; |
| } |
| MatParamTexture param = (MatParamTexture) mat.getParam(mapName); |
| Texture texture = param.getTextureValue(); |
| if (texture == null) { |
| return null; |
| } |
| return texture; |
| |
| |
| } |
| |
| private class Node { |
| |
| public TextureAtlasTile location; |
| public Node child[]; |
| public boolean occupied; |
| |
| public Node(int x, int y, int width, int height) { |
| location = new TextureAtlasTile(x, y, width, height); |
| child = new Node[2]; |
| child[0] = null; |
| child[1] = null; |
| occupied = false; |
| } |
| |
| public boolean isLeaf() { |
| return child[0] == null && child[1] == null; |
| } |
| |
| // Algorithm from http://www.blackpawn.com/texts/lightmaps/ |
| public Node insert(Image image) { |
| if (!isLeaf()) { |
| Node newNode = child[0].insert(image); |
| |
| if (newNode != null) { |
| return newNode; |
| } |
| |
| return child[1].insert(image); |
| } else { |
| if (occupied) { |
| return null; // occupied |
| } |
| |
| if (image.getWidth() > location.getWidth() || image.getHeight() > location.getHeight()) { |
| return null; // does not fit |
| } |
| |
| if (image.getWidth() == location.getWidth() && image.getHeight() == location.getHeight()) { |
| occupied = true; // perfect fit |
| return this; |
| } |
| |
| int dw = location.getWidth() - image.getWidth(); |
| int dh = location.getHeight() - image.getHeight(); |
| |
| if (dw > dh) { |
| child[0] = new Node(location.getX(), location.getY(), image.getWidth(), location.getHeight()); |
| child[1] = new Node(location.getX() + image.getWidth(), location.getY(), location.getWidth() - image.getWidth(), location.getHeight()); |
| } else { |
| child[0] = new Node(location.getX(), location.getY(), location.getWidth(), image.getHeight()); |
| child[1] = new Node(location.getX(), location.getY() + image.getHeight(), location.getWidth(), location.getHeight() - image.getHeight()); |
| } |
| |
| return child[0].insert(image); |
| } |
| } |
| } |
| |
| public class TextureAtlasTile { |
| |
| private int x; |
| private int y; |
| private int width; |
| private int height; |
| |
| public TextureAtlasTile(int x, int y, int width, int height) { |
| this.x = x; |
| this.y = y; |
| this.width = width; |
| this.height = height; |
| } |
| |
| /** |
| * Get the transformed texture coordinate for a given input location. |
| * @param previousLocation The old texture coordinate. |
| * @return The new texture coordinate inside the atlas. |
| */ |
| public Vector2f getLocation(Vector2f previousLocation) { |
| float x = (float) getX() / (float) atlasWidth; |
| float y = (float) getY() / (float) atlasHeight; |
| float w = (float) getWidth() / (float) atlasWidth; |
| float h = (float) getHeight() / (float) atlasHeight; |
| Vector2f location = new Vector2f(x, y); |
| float prevX = previousLocation.x; |
| float prevY = previousLocation.y; |
| location.addLocal(prevX * w, prevY * h); |
| return location; |
| } |
| |
| /** |
| * Transforms a whole texture coordinates buffer. |
| * @param inBuf The input texture buffer. |
| * @param offset The offset in the output buffer |
| * @param outBuf The output buffer. |
| */ |
| public void transformTextureCoords(FloatBuffer inBuf, int offset, FloatBuffer outBuf) { |
| Vector2f tex = new Vector2f(); |
| |
| // offset is given in element units |
| // convert to be in component units |
| offset *= 2; |
| |
| for (int i = 0; i < inBuf.capacity() / 2; i++) { |
| tex.x = inBuf.get(i * 2 + 0); |
| tex.y = inBuf.get(i * 2 + 1); |
| Vector2f location = getLocation(tex); |
| //TODO: add proper texture wrapping for atlases.. |
| outBuf.put(offset + i * 2 + 0, location.x); |
| outBuf.put(offset + i * 2 + 1, location.y); |
| } |
| } |
| |
| public int getX() { |
| return x; |
| } |
| |
| public int getY() { |
| return y; |
| } |
| |
| public int getWidth() { |
| return width; |
| } |
| |
| public int getHeight() { |
| return height; |
| } |
| } |
| } |
