Java tutorial
/******************************************************************************* * Copyright 2011 See AUTHORS file. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ package com.badlogic.gdx.graphics.g2d; import static com.badlogic.gdx.graphics.Texture.TextureWrap.*; import com.badlogic.gdx.Files.FileType; import com.badlogic.gdx.Gdx; import com.badlogic.gdx.files.FileHandle; import com.badlogic.gdx.graphics.Pixmap.Format; import com.badlogic.gdx.graphics.Texture; import com.badlogic.gdx.graphics.Texture.TextureFilter; import com.badlogic.gdx.graphics.Texture.TextureWrap; import com.badlogic.gdx.graphics.g2d.TextureAtlas.TextureAtlasData.Page; import com.badlogic.gdx.graphics.g2d.TextureAtlas.TextureAtlasData.Region; import com.badlogic.gdx.utils.Array; import com.badlogic.gdx.utils.Disposable; import com.badlogic.gdx.utils.GdxRuntimeException; import com.badlogic.gdx.utils.ObjectMap; import com.badlogic.gdx.utils.ObjectSet; import com.badlogic.gdx.utils.Sort; import com.badlogic.gdx.utils.StreamUtils; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.Comparator; import java.util.HashSet; import java.util.Set; /** Loads images from texture atlases created by TexturePacker.<br> * <br> * A TextureAtlas must be disposed to free up the resources consumed by the backing textures. * @author Nathan Sweet */ public class TextureAtlas implements Disposable { static final String[] tuple = new String[4]; private final ObjectSet<Texture> textures = new ObjectSet(4); private final Array<AtlasRegion> regions = new Array(); public static class TextureAtlasData { public static class Page { public final FileHandle textureFile; public Texture texture; public final float width, height; public final boolean useMipMaps; public final Format format; public final TextureFilter minFilter; public final TextureFilter magFilter; public final TextureWrap uWrap; public final TextureWrap vWrap; public Page(FileHandle handle, float width, float height, boolean useMipMaps, Format format, TextureFilter minFilter, TextureFilter magFilter, TextureWrap uWrap, TextureWrap vWrap) { this.width = width; this.height = height; this.textureFile = handle; this.useMipMaps = useMipMaps; this.format = format; this.minFilter = minFilter; this.magFilter = magFilter; this.uWrap = uWrap; this.vWrap = vWrap; } } public static class Region { public Page page; public int index; public String name; public float offsetX; public float offsetY; public int originalWidth; public int originalHeight; public boolean rotate; public int left; public int top; public int width; public int height; public boolean flip; public int[] splits; public int[] pads; } final Array<Page> pages = new Array(); final Array<Region> regions = new Array(); public TextureAtlasData(FileHandle packFile, FileHandle imagesDir, boolean flip) { BufferedReader reader = new BufferedReader(new InputStreamReader(packFile.read()), 64); try { Page pageImage = null; while (true) { String line = reader.readLine(); if (line == null) break; if (line.trim().length() == 0) pageImage = null; else if (pageImage == null) { FileHandle file = imagesDir.child(line); float width = 0, height = 0; if (readTuple(reader) == 2) { // size is only optional for an atlas packed with an old TexturePacker. width = Integer.parseInt(tuple[0]); height = Integer.parseInt(tuple[1]); readTuple(reader); } Format format = Format.valueOf(tuple[0]); readTuple(reader); TextureFilter min = TextureFilter.valueOf(tuple[0]); TextureFilter max = TextureFilter.valueOf(tuple[1]); String direction = readValue(reader); TextureWrap repeatX = ClampToEdge; TextureWrap repeatY = ClampToEdge; if (direction.equals("x")) repeatX = Repeat; else if (direction.equals("y")) repeatY = Repeat; else if (direction.equals("xy")) { repeatX = Repeat; repeatY = Repeat; } pageImage = new Page(file, width, height, min.isMipMap(), format, min, max, repeatX, repeatY); pages.add(pageImage); } else { boolean rotate = Boolean.valueOf(readValue(reader)); readTuple(reader); int left = Integer.parseInt(tuple[0]); int top = Integer.parseInt(tuple[1]); readTuple(reader); int width = Integer.parseInt(tuple[0]); int height = Integer.parseInt(tuple[1]); Region region = new Region(); region.page = pageImage; region.left = left; region.top = top; region.width = width; region.height = height; region.name = line; region.rotate = rotate; if (readTuple(reader) == 4) { // split is optional region.splits = new int[] { Integer.parseInt(tuple[0]), Integer.parseInt(tuple[1]), Integer.parseInt(tuple[2]), Integer.parseInt(tuple[3]) }; if (readTuple(reader) == 4) { // pad is optional, but only present with splits region.pads = new int[] { Integer.parseInt(tuple[0]), Integer.parseInt(tuple[1]), Integer.parseInt(tuple[2]), Integer.parseInt(tuple[3]) }; readTuple(reader); } } region.originalWidth = Integer.parseInt(tuple[0]); region.originalHeight = Integer.parseInt(tuple[1]); readTuple(reader); region.offsetX = Integer.parseInt(tuple[0]); region.offsetY = Integer.parseInt(tuple[1]); region.index = Integer.parseInt(readValue(reader)); if (flip) region.flip = true; regions.add(region); } } } catch (Exception ex) { throw new GdxRuntimeException("Error reading pack file: " + packFile, ex); } finally { StreamUtils.closeQuietly(reader); } regions.sort(indexComparator); } public Array<Page> getPages() { return pages; } public Array<Region> getRegions() { return regions; } } /** Creates an empty atlas to which regions can be added. */ public TextureAtlas() { } /** Loads the specified pack file using {@link FileType#Internal}, using the parent directory of the pack file to find the page * images. */ public TextureAtlas(String internalPackFile) { this(Gdx.files.internal(internalPackFile)); } /** Loads the specified pack file, using the parent directory of the pack file to find the page images. */ public TextureAtlas(FileHandle packFile) { this(packFile, packFile.parent()); } /** @param flip If true, all regions loaded will be flipped for use with a perspective where 0,0 is the upper left corner. * @see #TextureAtlas(FileHandle) */ public TextureAtlas(FileHandle packFile, boolean flip) { this(packFile, packFile.parent(), flip); } public TextureAtlas(FileHandle packFile, FileHandle imagesDir) { this(packFile, imagesDir, false); } /** @param flip If true, all regions loaded will be flipped for use with a perspective where 0,0 is the upper left corner. */ public TextureAtlas(FileHandle packFile, FileHandle imagesDir, boolean flip) { this(new TextureAtlasData(packFile, imagesDir, flip)); } /** @param data May be null. */ public TextureAtlas(TextureAtlasData data) { if (data != null) load(data); } private void load(TextureAtlasData data) { ObjectMap<Page, Texture> pageToTexture = new ObjectMap<Page, Texture>(); for (Page page : data.pages) { Texture texture = null; if (page.texture == null) { texture = new Texture(page.textureFile, page.format, page.useMipMaps); texture.setFilter(page.minFilter, page.magFilter); texture.setWrap(page.uWrap, page.vWrap); } else { texture = page.texture; texture.setFilter(page.minFilter, page.magFilter); texture.setWrap(page.uWrap, page.vWrap); } textures.add(texture); pageToTexture.put(page, texture); } for (Region region : data.regions) { int width = region.width; int height = region.height; AtlasRegion atlasRegion = new AtlasRegion(pageToTexture.get(region.page), region.left, region.top, region.rotate ? height : width, region.rotate ? width : height); atlasRegion.index = region.index; atlasRegion.name = region.name; atlasRegion.offsetX = region.offsetX; atlasRegion.offsetY = region.offsetY; atlasRegion.originalHeight = region.originalHeight; atlasRegion.originalWidth = region.originalWidth; atlasRegion.rotate = region.rotate; atlasRegion.splits = region.splits; atlasRegion.pads = region.pads; if (region.flip) atlasRegion.flip(false, true); regions.add(atlasRegion); } } /** Adds a region to the atlas. The specified texture will be disposed when the atlas is disposed. */ public AtlasRegion addRegion(String name, Texture texture, int x, int y, int width, int height) { textures.add(texture); AtlasRegion region = new AtlasRegion(texture, x, y, width, height); region.name = name; region.originalWidth = width; region.originalHeight = height; region.index = -1; regions.add(region); return region; } /** Adds a region to the atlas. The texture for the specified region will be disposed when the atlas is disposed. */ public AtlasRegion addRegion(String name, TextureRegion textureRegion) { return addRegion(name, textureRegion.texture, textureRegion.getRegionX(), textureRegion.getRegionY(), textureRegion.getRegionWidth(), textureRegion.getRegionHeight()); } /** Returns all regions in the atlas. */ public Array<AtlasRegion> getRegions() { return regions; } /** Returns the first region found with the specified name. This method uses string comparison to find the region, so the result * should be cached rather than calling this method multiple times. * @return The region, or null. */ public AtlasRegion findRegion(String name) { for (int i = 0, n = regions.size; i < n; i++) if (regions.get(i).name.equals(name)) return regions.get(i); return null; } /** Returns the first region found with the specified name and index. This method uses string comparison to find the region, so * the result should be cached rather than calling this method multiple times. * @return The region, or null. */ public AtlasRegion findRegion(String name, int index) { for (int i = 0, n = regions.size; i < n; i++) { AtlasRegion region = regions.get(i); if (!region.name.equals(name)) continue; if (region.index != index) continue; return region; } return null; } /** Returns all regions with the specified name, ordered by smallest to largest {@link AtlasRegion#index index}. This method * uses string comparison to find the regions, so the result should be cached rather than calling this method multiple times. */ public Array<AtlasRegion> findRegions(String name) { Array<AtlasRegion> matched = new Array(); for (int i = 0, n = regions.size; i < n; i++) { AtlasRegion region = regions.get(i); if (region.name.equals(name)) matched.add(new AtlasRegion(region)); } return matched; } /** Returns all regions in the atlas as sprites. This method creates a new sprite for each region, so the result should be * stored rather than calling this method multiple times. * @see #createSprite(String) */ public Array<Sprite> createSprites() { Array sprites = new Array(regions.size); for (int i = 0, n = regions.size; i < n; i++) sprites.add(newSprite(regions.get(i))); return sprites; } /** Returns the first region found with the specified name as a sprite. If whitespace was stripped from the region when it was * packed, the sprite is automatically positioned as if whitespace had not been stripped. This method uses string comparison to * find the region and constructs a new sprite, so the result should be cached rather than calling this method multiple times. * @return The sprite, or null. */ public Sprite createSprite(String name) { for (int i = 0, n = regions.size; i < n; i++) if (regions.get(i).name.equals(name)) return newSprite(regions.get(i)); return null; } /** Returns the first region found with the specified name and index as a sprite. This method uses string comparison to find the * region and constructs a new sprite, so the result should be cached rather than calling this method multiple times. * @return The sprite, or null. * @see #createSprite(String) */ public Sprite createSprite(String name, int index) { for (int i = 0, n = regions.size; i < n; i++) { AtlasRegion region = regions.get(i); if (!region.name.equals(name)) continue; if (region.index != index) continue; return newSprite(regions.get(i)); } return null; } /** Returns all regions with the specified name as sprites, ordered by smallest to largest {@link AtlasRegion#index index}. This * method uses string comparison to find the regions and constructs new sprites, so the result should be cached rather than * calling this method multiple times. * @see #createSprite(String) */ public Array<Sprite> createSprites(String name) { Array<Sprite> matched = new Array(); for (int i = 0, n = regions.size; i < n; i++) { AtlasRegion region = regions.get(i); if (region.name.equals(name)) matched.add(newSprite(region)); } return matched; } private Sprite newSprite(AtlasRegion region) { if (region.packedWidth == region.originalWidth && region.packedHeight == region.originalHeight) { if (region.rotate) { Sprite sprite = new Sprite(region); sprite.setBounds(0, 0, region.getRegionHeight(), region.getRegionWidth()); sprite.rotate90(true); return sprite; } return new Sprite(region); } return new AtlasSprite(region); } /** Returns the first region found with the specified name as a {@link NinePatch}. The region must have been packed with * ninepatch splits. This method uses string comparison to find the region and constructs a new ninepatch, so the result should * be cached rather than calling this method multiple times. * @return The ninepatch, or null. */ public NinePatch createPatch(String name) { for (int i = 0, n = regions.size; i < n; i++) { AtlasRegion region = regions.get(i); if (region.name.equals(name)) { int[] splits = region.splits; if (splits == null) throw new IllegalArgumentException("Region does not have ninepatch splits: " + name); NinePatch patch = new NinePatch(region, splits[0], splits[1], splits[2], splits[3]); if (region.pads != null) patch.setPadding(region.pads[0], region.pads[1], region.pads[2], region.pads[3]); return patch; } } return null; } /** @return the textures of the pages, unordered */ public ObjectSet<Texture> getTextures() { return textures; } /** Releases all resources associated with this TextureAtlas instance. This releases all the textures backing all TextureRegions * and Sprites, which should no longer be used after calling dispose. */ public void dispose() { for (Texture texture : textures) texture.dispose(); textures.clear(); } static final Comparator<Region> indexComparator = new Comparator<Region>() { public int compare(Region region1, Region region2) { int i1 = region1.index; if (i1 == -1) i1 = Integer.MAX_VALUE; int i2 = region2.index; if (i2 == -1) i2 = Integer.MAX_VALUE; return i1 - i2; } }; static String readValue(BufferedReader reader) throws IOException { String line = reader.readLine(); int colon = line.indexOf(':'); if (colon == -1) throw new GdxRuntimeException("Invalid line: " + line); return line.substring(colon + 1).trim(); } /** Returns the number of tuple values read (1, 2 or 4). */ static int readTuple(BufferedReader reader) throws IOException { String line = reader.readLine(); int colon = line.indexOf(':'); if (colon == -1) throw new GdxRuntimeException("Invalid line: " + line); int i = 0, lastMatch = colon + 1; for (i = 0; i < 3; i++) { int comma = line.indexOf(',', lastMatch); if (comma == -1) break; tuple[i] = line.substring(lastMatch, comma).trim(); lastMatch = comma + 1; } tuple[i] = line.substring(lastMatch).trim(); return i + 1; } /** Describes the region of a packed image and provides information about the original image before it was packed. */ static public class AtlasRegion extends TextureRegion { /** The number at the end of the original image file name, or -1 if none.<br> * <br> * When sprites are packed, if the original file name ends with a number, it is stored as the index and is not considered as * part of the sprite's name. This is useful for keeping animation frames in order. * @see TextureAtlas#findRegions(String) */ public int index; /** The name of the original image file, up to the first underscore. Underscores denote special instructions to the texture * packer. */ public String name; /** The offset from the left of the original image to the left of the packed image, after whitespace was removed for packing. */ public float offsetX; /** The offset from the bottom of the original image to the bottom of the packed image, after whitespace was removed for * packing. */ public float offsetY; /** The width of the image, after whitespace was removed for packing. */ public int packedWidth; /** The height of the image, after whitespace was removed for packing. */ public int packedHeight; /** The width of the image, before whitespace was removed and rotation was applied for packing. */ public int originalWidth; /** The height of the image, before whitespace was removed for packing. */ public int originalHeight; /** If true, the region has been rotated 90 degrees counter clockwise. */ public boolean rotate; /** The ninepatch splits, or null if not a ninepatch. Has 4 elements: left, right, top, bottom. */ public int[] splits; /** The ninepatch pads, or null if not a ninepatch or the has no padding. Has 4 elements: left, right, top, bottom. */ public int[] pads; public AtlasRegion(Texture texture, int x, int y, int width, int height) { super(texture, x, y, width, height); originalWidth = width; originalHeight = height; packedWidth = width; packedHeight = height; } public AtlasRegion(AtlasRegion region) { setRegion(region); index = region.index; name = region.name; offsetX = region.offsetX; offsetY = region.offsetY; packedWidth = region.packedWidth; packedHeight = region.packedHeight; originalWidth = region.originalWidth; originalHeight = region.originalHeight; rotate = region.rotate; splits = region.splits; } @Override /** Flips the region, adjusting the offset so the image appears to be flip as if no whitespace has been removed for packing. */ public void flip(boolean x, boolean y) { super.flip(x, y); if (x) offsetX = originalWidth - offsetX - getRotatedPackedWidth(); if (y) offsetY = originalHeight - offsetY - getRotatedPackedHeight(); } /** Returns the packed width considering the rotate value, if it is true then it returns the packedHeight, otherwise it * returns the packedWidth. */ public float getRotatedPackedWidth() { return rotate ? packedHeight : packedWidth; } /** Returns the packed height considering the rotate value, if it is true then it returns the packedWidth, otherwise it * returns the packedHeight. */ public float getRotatedPackedHeight() { return rotate ? packedWidth : packedHeight; } public String toString() { return name; } } /** A sprite that, if whitespace was stripped from the region when it was packed, is automatically positioned as if whitespace * had not been stripped. */ static public class AtlasSprite extends Sprite { final AtlasRegion region; float originalOffsetX, originalOffsetY; public AtlasSprite(AtlasRegion region) { this.region = new AtlasRegion(region); originalOffsetX = region.offsetX; originalOffsetY = region.offsetY; setRegion(region); setOrigin(region.originalWidth / 2f, region.originalHeight / 2f); int width = region.getRegionWidth(); int height = region.getRegionHeight(); if (region.rotate) { super.rotate90(true); super.setBounds(region.offsetX, region.offsetY, height, width); } else super.setBounds(region.offsetX, region.offsetY, width, height); setColor(1, 1, 1, 1); } public AtlasSprite(AtlasSprite sprite) { region = sprite.region; this.originalOffsetX = sprite.originalOffsetX; this.originalOffsetY = sprite.originalOffsetY; set(sprite); } @Override public void setPosition(float x, float y) { super.setPosition(x + region.offsetX, y + region.offsetY); } @Override public void setX(float x) { super.setX(x + region.offsetX); } @Override public void setY(float y) { super.setY(y + region.offsetY); } @Override public void setBounds(float x, float y, float width, float height) { float widthRatio = width / region.originalWidth; float heightRatio = height / region.originalHeight; region.offsetX = originalOffsetX * widthRatio; region.offsetY = originalOffsetY * heightRatio; int packedWidth = region.rotate ? region.packedHeight : region.packedWidth; int packedHeight = region.rotate ? region.packedWidth : region.packedHeight; super.setBounds(x + region.offsetX, y + region.offsetY, packedWidth * widthRatio, packedHeight * heightRatio); } @Override public void setSize(float width, float height) { setBounds(getX(), getY(), width, height); } @Override public void setOrigin(float originX, float originY) { super.setOrigin(originX - region.offsetX, originY - region.offsetY); } @Override public void setOriginCenter() { super.setOrigin(width / 2 - region.offsetX, height / 2 - region.offsetY); } @Override public void flip(boolean x, boolean y) { // Flip texture. if (region.rotate) super.flip(y, x); else super.flip(x, y); float oldOriginX = getOriginX(); float oldOriginY = getOriginY(); float oldOffsetX = region.offsetX; float oldOffsetY = region.offsetY; float widthRatio = getWidthRatio(); float heightRatio = getHeightRatio(); region.offsetX = originalOffsetX; region.offsetY = originalOffsetY; region.flip(x, y); // Updates x and y offsets. originalOffsetX = region.offsetX; originalOffsetY = region.offsetY; region.offsetX *= widthRatio; region.offsetY *= heightRatio; // Update position and origin with new offsets. translate(region.offsetX - oldOffsetX, region.offsetY - oldOffsetY); setOrigin(oldOriginX, oldOriginY); } @Override public void rotate90(boolean clockwise) { // Rotate texture. super.rotate90(clockwise); float oldOriginX = getOriginX(); float oldOriginY = getOriginY(); float oldOffsetX = region.offsetX; float oldOffsetY = region.offsetY; float widthRatio = getWidthRatio(); float heightRatio = getHeightRatio(); if (clockwise) { region.offsetX = oldOffsetY; region.offsetY = region.originalHeight * heightRatio - oldOffsetX - region.packedWidth * widthRatio; } else { region.offsetX = region.originalWidth * widthRatio - oldOffsetY - region.packedHeight * heightRatio; region.offsetY = oldOffsetX; } // Update position and origin with new offsets. translate(region.offsetX - oldOffsetX, region.offsetY - oldOffsetY); setOrigin(oldOriginX, oldOriginY); } @Override public float getX() { return super.getX() - region.offsetX; } @Override public float getY() { return super.getY() - region.offsetY; } @Override public float getOriginX() { return super.getOriginX() + region.offsetX; } @Override public float getOriginY() { return super.getOriginY() + region.offsetY; } @Override public float getWidth() { return super.getWidth() / region.getRotatedPackedWidth() * region.originalWidth; } @Override public float getHeight() { return super.getHeight() / region.getRotatedPackedHeight() * region.originalHeight; } public float getWidthRatio() { return super.getWidth() / region.getRotatedPackedWidth(); } public float getHeightRatio() { return super.getHeight() / region.getRotatedPackedHeight(); } public AtlasRegion getAtlasRegion() { return region; } public String toString() { return region.toString(); } } }