gdx-studio

/*******************************************************************************

 * 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.tools.imagepacker;

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Set;

import javax.imageio.IIOImage;

import javax.imageio.ImageIO;

import javax.imageio.ImageWriteParam;

import javax.imageio.ImageWriter;

import javax.imageio.stream.ImageOutputStream;

import com.badlogic.gdx.files.FileHandle;

import com.badlogic.gdx.graphics.Pixmap.Format;

import com.badlogic.gdx.graphics.Texture.TextureFilter;

import com.badlogic.gdx.graphics.Texture.TextureWrap;

import com.badlogic.gdx.graphics.g2d.TextureAtlas.TextureAtlasData;

import com.badlogic.gdx.graphics.g2d.TextureAtlas.TextureAtlasData.Region;

import com.badlogic.gdx.math.MathUtils;

import com.badlogic.gdx.utils.Array;

import com.badlogic.gdx.utils.GdxRuntimeException;

/** @author Nathan Sweet */

public class TexturePacker2 {

	private final Settings settings;

	private final MaxRectsPacker maxRectsPacker;

	private final ImageProcessor imageProcessor;

	/** @param rootDir Can be null. */

	public TexturePacker2 (File rootDir, Settings settings) {

		this.settings = settings;

		if (settings.pot) {

			if (settings.maxWidth != MathUtils.nextPowerOfTwo(settings.maxWidth))

				throw new RuntimeException("If pot is true, maxWidth must be a power of two: " + settings.maxWidth);

			if (settings.maxHeight != MathUtils.nextPowerOfTwo(settings.maxHeight))

				throw new RuntimeException("If pot is true, maxHeight must be a power of two: " + settings.maxHeight);

		}

		maxRectsPacker = new MaxRectsPacker(settings);

		imageProcessor = new ImageProcessor(rootDir, settings);

	}

	public TexturePacker2 (Settings settings) {

		this(null, settings);

	}

	public void addImage (File file) {

		imageProcessor.addImage(file);

	}

	public void addImage (BufferedImage image, String name) {

		imageProcessor.addImage(image, name);

	}

	public void pack (File outputDir, String packFileName) {

		outputDir.mkdirs();

		if (packFileName.indexOf('.') == -1) packFileName += ".atlas";

		Array<Page> pages = maxRectsPacker.pack(imageProcessor.getImages());

		writeImages(outputDir, pages, packFileName);

		try {

			writePackFile(outputDir, pages, packFileName);

		} catch (IOException ex) {

			throw new RuntimeException("Error writing pack file.", ex);

		}

	}

	private void writeImages (File outputDir, Array<Page> pages, String packFileName) {

		String imageName = packFileName;

		int dotIndex = imageName.lastIndexOf('.');

		if (dotIndex != -1) imageName = imageName.substring(0, dotIndex);

		int fileIndex = 0;

		for (Page page : pages) {

			int width = page.width, height = page.height;

			int paddingX = settings.paddingX;

			int paddingY = settings.paddingY;

			if (settings.duplicatePadding) {

				paddingX /= 2;

				paddingY /= 2;

			}

			width -= settings.paddingX;

			height -= settings.paddingY;

			if (settings.edgePadding) {

				page.x = paddingX;

				page.y = paddingY;

				width += paddingX * 2;

				height += paddingY * 2;

			}

			if (settings.pot) {

				width = MathUtils.nextPowerOfTwo(width);

				height = MathUtils.nextPowerOfTwo(height);

			}

			width = Math.max(settings.minWidth, width);

			height = Math.max(settings.minHeight, height);

			if (settings.forceSquareOutput) {

				if (width > height) {

					height = width;

				} else {

					width = height;

				}

			}

			File outputFile;

			while (true) {

				outputFile = new File(outputDir, imageName + (fileIndex++ == 0 ? "" : fileIndex) + "." + settings.outputFormat);

				if (!outputFile.exists()) break;

			}

			page.imageName = outputFile.getName();

			BufferedImage canvas = new BufferedImage(width, height, getBufferedImageType(settings.format));

			Graphics2D g = (Graphics2D)canvas.getGraphics();

			System.out.println("Writing " + canvas.getWidth() + "x" + canvas.getHeight() + ": " + outputFile);

			for (Rect rect : page.outputRects) {

				BufferedImage image = rect.image;

				int iw = image.getWidth();

				int ih = image.getHeight();

				int rectX = page.x + rect.x, rectY = page.y + page.height - rect.y - rect.height;

				if (settings.duplicatePadding) {

					int amountX = settings.paddingX / 2;

					int amountY = settings.paddingY / 2;

					if (rect.rotated) {

						// Copy corner pixels to fill corners of the padding.

						for (int i = 1; i <= amountX; i++) {

							for (int j = 1; j <= amountY; j++) {

								plot(canvas, rectX - j, rectY + iw - 1 + i, image.getRGB(0, 0));

								plot(canvas, rectX + ih - 1 + j, rectY + iw - 1 + i, image.getRGB(0, ih - 1));

								plot(canvas, rectX - j, rectY - i, image.getRGB(iw - 1, 0));

								plot(canvas, rectX + ih - 1 + j, rectY - i, image.getRGB(iw - 1, ih - 1));

							}

						}

						// Copy edge pixels into padding.

						for (int i = 1; i <= amountY; i++) {

							for (int j = 0; j < iw; j++) {

								plot(canvas, rectX - i, rectY + iw - 1 - j, image.getRGB(j, 0));

								plot(canvas, rectX + ih - 1 + i, rectY + iw - 1 - j, image.getRGB(j, ih - 1));

							}

						}

						for (int i = 1; i <= amountX; i++) {

							for (int j = 0; j < ih; j++) {

								plot(canvas, rectX + j, rectY - i, image.getRGB(iw - 1, j));

								plot(canvas, rectX + j, rectY + iw - 1 + i, image.getRGB(0, j));

							}

						}

					} else {

						// Copy corner pixels to fill corners of the padding.

						for (int i = 1; i <= amountX; i++) {

							for (int j = 1; j <= amountY; j++) {

								canvas.setRGB(rectX - i, rectY - j, image.getRGB(0, 0));

								canvas.setRGB(rectX - i, rectY + ih - 1 + j, image.getRGB(0, ih - 1));

								canvas.setRGB(rectX + iw - 1 + i, rectY - j, image.getRGB(iw - 1, 0));

								canvas.setRGB(rectX + iw - 1 + i, rectY + ih - 1 + j, image.getRGB(iw - 1, ih - 1));

							}

						}

						// Copy edge pixels into padding.

						for (int i = 1; i <= amountY; i++) {

							copy(image, 0, 0, iw, 1, canvas, rectX, rectY - i, rect.rotated);

							copy(image, 0, ih - 1, iw, 1, canvas, rectX, rectY + ih - 1 + i, rect.rotated);

						}

						for (int i = 1; i <= amountX; i++) {

							copy(image, 0, 0, 1, ih, canvas, rectX - i, rectY, rect.rotated);

							copy(image, iw - 1, 0, 1, ih, canvas, rectX + iw - 1 + i, rectY, rect.rotated);

						}

					}

				}				

				copy(image, 0, 0, iw, ih, canvas, rectX, rectY, rect.rotated);

				if (settings.debug) {

					g.setColor(Color.magenta);

					g.drawRect(rectX, rectY, rect.width - settings.paddingX - 1, rect.height - settings.paddingY - 1);

				}

			}

			if (settings.bleed && !settings.premultiplyAlpha && !settings.outputFormat.equalsIgnoreCase("jpg")) {

				canvas = new ColorBleedEffect().processImage(canvas, 2);

				g = (Graphics2D)canvas.getGraphics();

			}

			if (settings.debug) {

				g.setColor(Color.magenta);

				g.drawRect(0, 0, width - 1, height - 1);

			}

			ImageOutputStream ios = null;

			try {

				if (settings.outputFormat.equalsIgnoreCase("jpg")) {

					BufferedImage newImage = new BufferedImage(canvas.getWidth(), canvas.getHeight(), BufferedImage.TYPE_3BYTE_BGR);

					newImage.getGraphics().drawImage(canvas, 0, 0, null);

					canvas = newImage;

					Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("jpg");

					ImageWriter writer = writers.next();

					ImageWriteParam param = writer.getDefaultWriteParam();

					param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);

					param.setCompressionQuality(settings.jpegQuality);

					ios = ImageIO.createImageOutputStream(outputFile);

					writer.setOutput(ios);

					writer.write(null, new IIOImage(canvas, null, null), param);

				} else {

					if (settings.premultiplyAlpha) canvas.getColorModel().coerceData(canvas.getRaster(), true);

					ImageIO.write(canvas, "png", outputFile);

				}

			} catch (IOException ex) {

				throw new RuntimeException("Error writing file: " + outputFile, ex);

			} finally {

				if (ios != null) {

					try {

						ios.close();

					} catch (Exception ignored) {

					}

				}

			}

		}

	}

	private static void plot (BufferedImage dst, int x, int y, int argb) {

		if (0 <= x && x < dst.getWidth() && 0 <= y && y < dst.getHeight()) dst.setRGB(x, y, argb);

	}

	private static void copy (BufferedImage src, int x, int y, int w, int h, BufferedImage dst, int dx, int dy, boolean rotated) {

		if (rotated) {

			for (int i = 0; i < w; i++)

				for (int j = 0; j < h; j++)

					dst.setRGB(dx + j, dy + w - i - 1, src.getRGB(x + i, y + j));

		} else {

			for (int i = 0; i < w; i++)

				for (int j = 0; j < h; j++)

					dst.setRGB(dx + i, dy + j, src.getRGB(x + i, y + j));

		}

	}

	private void writePackFile (File outputDir, Array<Page> pages, String packFileName) throws IOException {

		File packFile = new File(outputDir, packFileName);

		if (packFile.exists()) {

			// Make sure there aren't duplicate names.

			TextureAtlasData textureAtlasData = new TextureAtlasData(new FileHandle(packFile), new FileHandle(packFile), false);

			for (Page page : pages) {

				for (Rect rect : page.outputRects) {

					String rectName = Rect.getAtlasName(rect.name, settings.flattenPaths);

					for (Region region : textureAtlasData.getRegions()) {

						if (region.name.equals(rectName)) {

							throw new GdxRuntimeException("A region with the name \"" + rectName + "\" has already been packed: "

								+ rect.name);

						}

					}

				}

			}

		}

		FileWriter writer = new FileWriter(packFile, true);

// if (settings.jsonOutput) {

// } else {

		for (Page page : pages) {

			writer.write("\n" + page.imageName + "\n");

			writer.write("format: " + settings.format + "\n");

			writer.write("filter: " + settings.filterMin + "," + settings.filterMag + "\n");

			writer.write("repeat: " + getRepeatValue() + "\n");

			for (Rect rect : page.outputRects) {

				writeRect(writer, page, rect, rect.name);

				for (Alias alias : rect.aliases) {

					Rect aliasRect = new Rect();

					aliasRect.set(rect);

					alias.apply(aliasRect);

					writeRect(writer, page, aliasRect, alias.name);

				}

			}

		}

// }

		writer.close();

	}

	private void writeRect (FileWriter writer, Page page, Rect rect, String name) throws IOException {

		writer.write(Rect.getAtlasName(name, settings.flattenPaths) + "\n");

		writer.write("  rotate: " + rect.rotated + "\n");

		writer.write("  xy: " + (page.x + rect.x) + ", " + (page.y + page.height - rect.height - rect.y) + "\n");

		writer.write("  size: " + rect.image.getWidth() + ", " + rect.image.getHeight() + "\n");

		if (rect.splits != null) {

			writer

				.write("  split: " + rect.splits[0] + ", " + rect.splits[1] + ", " + rect.splits[2] + ", " + rect.splits[3] + "\n");

		}

		if (rect.pads != null) {

			if (rect.splits == null) writer.write("  split: 0, 0, 0, 0\n");

			writer.write("  pad: " + rect.pads[0] + ", " + rect.pads[1] + ", " + rect.pads[2] + ", " + rect.pads[3] + "\n");

		}

		writer.write("  orig: " + rect.originalWidth + ", " + rect.originalHeight + "\n");

		writer.write("  offset: " + rect.offsetX + ", " + (rect.originalHeight - rect.image.getHeight() - rect.offsetY) + "\n");

		writer.write("  index: " + rect.index + "\n");

	}

	private String getRepeatValue () {

		if (settings.wrapX == TextureWrap.Repeat && settings.wrapY == TextureWrap.Repeat) return "xy";

		if (settings.wrapX == TextureWrap.Repeat && settings.wrapY == TextureWrap.ClampToEdge) return "x";

		if (settings.wrapX == TextureWrap.ClampToEdge && settings.wrapY == TextureWrap.Repeat) return "y";

		return "none";

	}

	private int getBufferedImageType (Format format) {

		switch (settings.format) {

		case RGBA8888:

		case RGBA4444:

			return BufferedImage.TYPE_INT_ARGB;

		case RGB565:

		case RGB888:

			return BufferedImage.TYPE_INT_RGB;

		case Alpha:

			return BufferedImage.TYPE_BYTE_GRAY;

		default:

			throw new RuntimeException("Unsupported format: " + settings.format);

		}

	}

	/** @author Nathan Sweet */

	public static class Page {

		public String imageName;

		public Array<Rect> outputRects, remainingRects;

		public float occupancy;

		public int x, y, width, height;

	}

	/** @author Regnarock

	 * @author Nathan Sweet */

	public static class Alias {

		public String name;

		public int index;

		public int[] splits;

		public int[] pads;

		public int offsetX, offsetY, originalWidth, originalHeight;

		public Alias (Rect rect) {

			name = rect.name;

			index = rect.index;

			splits = rect.splits;

			pads = rect.pads;

			offsetX = rect.offsetX;

			offsetY = rect.offsetY;

			originalWidth = rect.originalWidth;

			originalHeight = rect.originalHeight;

		}

		public void apply (Rect rect) {

			rect.name = name;

			rect.index = index;

			rect.splits = splits;

			rect.pads = pads;

			rect.offsetX = offsetX;

			rect.offsetY = offsetY;

			rect.originalWidth = originalWidth;

			rect.originalHeight = originalHeight;

		}

	}

	/** @author Nathan Sweet */

	public static class Rect {

		public String name;

		public BufferedImage image;

		public int offsetX, offsetY, originalWidth, originalHeight;

		public int x, y, width, height;

		public int index;

		public boolean rotated;

		public Set<Alias> aliases = new HashSet<Alias>();

		public int[] splits;

		public int[] pads;

		public boolean canRotate = true;

		int score1, score2;

		Rect (BufferedImage source, int left, int top, int newWidth, int newHeight) {

			image = new BufferedImage(source.getColorModel(), source.getRaster().createWritableChild(left, top, newWidth, newHeight,

				0, 0, null), source.getColorModel().isAlphaPremultiplied(), null);

			offsetX = left;

			offsetY = top;

			originalWidth = source.getWidth();

			originalHeight = source.getHeight();

			width = newWidth;

			height = newHeight;

		}

		Rect () {

		}

		Rect (Rect rect) {

			setSize(rect);

		}

		void setSize (Rect rect) {

			x = rect.x;

			y = rect.y;

			width = rect.width;

			height = rect.height;

		}

		void set (Rect rect) {

			name = rect.name;

			image = rect.image;

			offsetX = rect.offsetX;

			offsetY = rect.offsetY;

			originalWidth = rect.originalWidth;

			originalHeight = rect.originalHeight;

			x = rect.x;

			y = rect.y;

			width = rect.width;

			height = rect.height;

			index = rect.index;

			rotated = rect.rotated;

			aliases = rect.aliases;

			splits = rect.splits;

			pads = rect.pads;

			canRotate = rect.canRotate;

			score1 = rect.score1;

			score2 = rect.score2;

		}

		@Override

		public boolean equals (Object obj) {

			if (this == obj) return true;

			if (obj == null) return false;

			if (getClass() != obj.getClass()) return false;

			Rect other = (Rect)obj;

			if (name == null) {

				if (other.name != null) return false;

			} else if (!name.equals(other.name)) return false;

			return true;

		}

		@Override

		public String toString () {

			return name + "[" + x + "," + y + " " + width + "x" + height + "]";

		}

		static public String getAtlasName (String name, boolean flattenPaths) {

			return flattenPaths ? new FileHandle(name).name() : name;

		}

	}

	/** @author Nathan Sweet */

	static public class Settings {

		public boolean pot = true;

		public int paddingX = 2, paddingY = 2;

		public boolean edgePadding = true;

		public boolean duplicatePadding = false;

		public boolean rotation;

		public int minWidth = 16, minHeight = 16;

		public int maxWidth = 1024, maxHeight = 1024;

		public boolean forceSquareOutput = false;

		public boolean stripWhitespaceX, stripWhitespaceY;

		public int alphaThreshold;

		public TextureFilter filterMin = TextureFilter.Nearest, filterMag = TextureFilter.Nearest;

		public TextureWrap wrapX = TextureWrap.ClampToEdge, wrapY = TextureWrap.ClampToEdge;

		public Format format = Format.RGBA8888;

		public boolean alias = true;

		public String outputFormat = "png";

		public float jpegQuality = 0.9f;

		public boolean ignoreBlankImages = true;

		public boolean fast;

		public boolean debug;

		public boolean combineSubdirectories;

		public boolean flattenPaths;

		public boolean premultiplyAlpha;

		public boolean useIndexes = true;

		public boolean bleed = true;

		public Settings () {

		}

		public Settings (Settings settings) {

			fast = settings.fast;

			rotation = settings.rotation;

			pot = settings.pot;

			minWidth = settings.minWidth;

			minHeight = settings.minHeight;

			maxWidth = settings.maxWidth;

			maxHeight = settings.maxHeight;

			paddingX = settings.paddingX;

			paddingY = settings.paddingY;

			edgePadding = settings.edgePadding;

			duplicatePadding = settings.duplicatePadding;

			alphaThreshold = settings.alphaThreshold;

			ignoreBlankImages = settings.ignoreBlankImages;

			stripWhitespaceX = settings.stripWhitespaceX;

			stripWhitespaceY = settings.stripWhitespaceY;

			alias = settings.alias;

			format = settings.format;

			jpegQuality = settings.jpegQuality;

			outputFormat = settings.outputFormat;

			filterMin = settings.filterMin;

			filterMag = settings.filterMag;

			wrapX = settings.wrapX;

			wrapY = settings.wrapY;

			debug = settings.debug;

			combineSubdirectories = settings.combineSubdirectories;

			flattenPaths = settings.flattenPaths;

			premultiplyAlpha = settings.premultiplyAlpha;

			forceSquareOutput = settings.forceSquareOutput;

			useIndexes = settings.useIndexes;

			bleed = settings.bleed;

		}

	}

	static public void process (String input, String output, String packFileName) {

		try {

			new TexturePackerFileProcessor(new Settings(), packFileName).process(new File(input), new File(output));

		} catch (Exception ex) {

			throw new RuntimeException("Error packing files.", ex);

		}

	}

	static public void process (Settings settings, String input, String output, String packFileName) {

		try {

			new TexturePackerFileProcessor(settings, packFileName).process(new File(input), new File(output));

		} catch (Exception ex) {

			throw new RuntimeException("Error packing files.", ex);

		}

	}

	/** @return true if the output file does not yet exist or its last modification date is before the last modification date of the

	 *         input file */

	static public boolean isModified (String input, String output, String packFileName) {

		String packFullFileName = output;

		if (!packFullFileName.endsWith("/")) packFullFileName += "/";

		packFullFileName += packFileName;

		File outputFile = new File(packFullFileName);

		if (!outputFile.exists()) return true;

		File inputFile = new File(input);

		if (!inputFile.exists()) throw new IllegalArgumentException("Input file does not exist: " + inputFile.getAbsolutePath());

		return inputFile.lastModified() > outputFile.lastModified();

	}

	static public void processIfModified (String input, String output, String packFileName) {

		if (isModified(input, output, packFileName)) process(input, output, packFileName);

	}

	static public void processIfModified (Settings settings, String input, String output, String packFileName) {

		if (isModified(input, output, packFileName)) process(settings, input, output, packFileName);

	}

}