root/trunk/TiledMap.java

 //* TiledMap.java
 //*loaded on demand.
// */
 //* This is a map that is implemented as a grid of MapTiles, l

import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
import java.io.*;
import java.net.*;

public class TiledMap extends BackgroundMap implements Serializable {
        static final long serialVersionUID = 3890326970229567605L;


        /**
         * Creates a map which has a grid of rows x cols which covers an area
         * of the world specified by realRectangle (in real coordinates).
         */

        public TiledMap(int rows, int columns, int rowHeight, int columnWidth, AffineTransform imageToReal) {
                this.rows = rows;
                this.columns = columns;
                this.rowHeight = rowHeight;
                this.columnWidth = columnWidth;

                setImageToReal(imageToReal);

                images = new Image[rows][columns];
        }

        public void setImageToReal(AffineTransform imageToReal) {
                this.imageToReal = imageToReal;
                try {
                        realToImage = imageToReal.createInverse();
                } catch(NoninvertibleTransformException e) {
                        throw new IllegalArgumentException("Couldn't invert the transform");
                }
        }

        public AffineTransform getImageToReal() { return imageToReal; }
        public AffineTransform getRealToImage() { return realToImage; }

        public Rectangle2D getRealBoundingRectangle() {
                return imageToReal
                        .createTransformedShape(new Rectangle(0, 0, columns * columnWidth, rows * rowHeight))
                        .getBounds2D();
        };

        /**
         * Paints the map onto the given Graphics2D object, using realToScreen
         * to transform the real coordinates the map knows about to screen
         * coordinates it uses to draw on the Graphics2D.
         */
        public void paint(Graphics2D g, AffineTransform realToScreen, ImageObserver observer) {
                // determine the clipping region in real coordinates

                // figure out what it is in screen coordinates
                Rectangle2D screenClip = g.getClipBounds();
                if(screenClip == null) {
System.out.println("no clipping region");
                        screenClip = new Rectangle2D.Double(
                                Double.NEGATIVE_INFINITY,
                                Double.NEGATIVE_INFINITY,
                                Double.POSITIVE_INFINITY,
                                Double.POSITIVE_INFINITY
                        );
                }

                // get the transform
                AffineTransform screenToReal;
                try {
                        screenToReal = realToScreen.createInverse();
                } catch(NoninvertibleTransformException e) {
                        throw new IllegalArgumentException("Couldn't invert the transform");
                }

                // use transforms to figure out the clipping region in image coordinates
                Shape imageClip = realToImage.createTransformedShape(screenToReal.createTransformedShape(screenClip));

                // we use this to test for intersection
                Rectangle imageRectangle = new Rectangle(0, 0, columnWidth, rowHeight);

                // for all of our objects...
                for(int row = 0; row < rows; row++) {
                        for(int column = 0; column < columns; column++) {
                                // skip if it isn't visible
                                imageRectangle.x = column * columnWidth;
                                imageRectangle.y = row * rowHeight;
                                if(!imageClip.intersects(imageRectangle)) continue;


                                // This is the place to implement more aggressive preloading
                                Image image = images[row][column];
                                if(image == null) {
                                        image = getImage(row, column);
                                        images[row][column] = image;
                                }

                                // tile (translate)-> image (imageToReal)-> real (realToScreen)-> screen
                                AffineTransform tileToScreen = new AffineTransform(realToScreen);
                                tileToScreen.concatenate(imageToReal);
                                tileToScreen.translate(imageRectangle.x, imageRectangle.y);

                                // ok, draw it.
                                g.drawImage(image, tileToScreen, observer);

                        }
                }
        }

        private Image getImage(int row, int column) {
System.out.println("loading " + getUrl(row, column));
                return Toolkit.getDefaultToolkit().getImage(getUrl(row, column));
        }

        /**
         * This returns the filename (no path components) for an image file at
         * the given row and column in the grid.  It will be concatenated with
         * the base and tree URIs.  It can be overridden for flexibility, though
         * it may be easier in the long run not to.  The rows and columns start
         * at 0, like arrays do.
         *
         * Note that it cannot be declared as static, because then even if
         * subclasses override it, the subclass's version won't be run because
         * the call will be resolved at compile time to this implementation.
         */

        public String getFilename(int row, int column) {
                return new String("row" + row + "column" + column + "." + extension);
        }

        public URL getUrl(int row, int column) {
                try {
                        if(rootUri == null) rootUri = (new File(".")).toURI();
                        if(treeUri == null) treeUri = new URI("");
                        return rootUri.resolve(treeUri).resolve(new URI(getFilename(row, column))).toURL();
                } catch(Exception e) {
                        throw new RuntimeException(e);
                }
        }

        public URI getRootUri() { return rootUri; }
        public void setRootUri(String rootUri) {
                if(rootUri == null || rootUri.equals("")) {
                        this.rootUri = null;
                        return;
                }
                try {
                        this.rootUri = new URI(rootUri);
                } catch(URISyntaxException e) {
                        throw new IllegalArgumentException("malformed URI " + rootUri);
                }
        }

        public URI getTreeUri() { return treeUri; }
        public void setTreeUri(String treeUri) {
                try {
                        this.treeUri = new URI(treeUri);
                } catch(URISyntaxException e) {
                        throw new IllegalArgumentException("malformed URI " + treeUri);
                }
        }

        public String getExtension() { return extension; }
        public void setExtension(String extension) {
                this.extension = extension;
        }

        private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
                in.defaultReadObject();
                images = new Image[rows][columns];
        }

        // in pixels per meter
        public double getPixelForPixelScale() {
                Rectangle2D boundingRect = getRealBoundingRectangle();
                double xScale = columns * columnWidth / boundingRect.getWidth();
                double yScale = rows * rowHeight / boundingRect.getHeight();
                return (xScale + yScale) / 2.0;
        }

        /**
         * Where we get our pictures from.  This can be blank for the filesystem,
         * or http://example.com/pathways/, for example.  Essentially the
         * document root.
         */
        private transient URI rootUri;
        /**
         * The location in the tree our pictures come from.  For example,
         * images/uiucmap/.  This is so that a map knows were to get its
         * pictures, but we can move the directory tree between servers without
         * changing code.
         */
        private URI treeUri;
        /**
         * The extension for the image files
         */
        private String extension;

        // these must be kept inverse of each other
        private AffineTransform imageToReal;
        private AffineTransform realToImage;

        /// how many rows and columns we have
        private int rows, columns;
        /// how big the rows and columns are
        private int rowHeight, columnWidth;
        /// our images, in [row][column]
        private transient Image[][] images;
}