bc155e7a05
of default tiles and their zoomed counterparts (saves reloading the default tile, and keeps the scale levels of the map consistent during a fullrender and otherwise)
283 lines
8.8 KiB
Java
283 lines
8.8 KiB
Java
package org.dynmap.kzedmap;
|
|
|
|
import java.awt.Color;
|
|
import java.awt.Graphics2D;
|
|
import java.awt.RenderingHints;
|
|
import java.awt.image.BufferedImage;
|
|
import java.awt.image.WritableRaster;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.util.HashSet;
|
|
import java.util.Map;
|
|
|
|
import javax.imageio.ImageIO;
|
|
|
|
import org.bukkit.World;
|
|
import org.dynmap.Client;
|
|
import org.dynmap.ColorScheme;
|
|
import org.dynmap.MapManager;
|
|
import org.dynmap.MapTile;
|
|
import org.dynmap.debug.Debug;
|
|
|
|
public class DefaultTileRenderer implements MapTileRenderer {
|
|
protected static final Color translucent = new Color(0, 0, 0, 0);
|
|
protected String name;
|
|
protected int maximumHeight = 127;
|
|
protected ColorScheme colorScheme;
|
|
|
|
protected HashSet<Integer> highlightBlocks = new HashSet<Integer>();
|
|
protected Color highlightColor = new Color(255, 0, 0);
|
|
|
|
private static final Color[] woolshades = {
|
|
Color.WHITE,
|
|
Color.ORANGE,
|
|
Color.MAGENTA,
|
|
new Color(51,204,255),
|
|
Color.YELLOW,
|
|
new Color(102,255,102),
|
|
Color.PINK,
|
|
Color.GRAY,
|
|
Color.LIGHT_GRAY,
|
|
Color.CYAN,
|
|
new Color(255,0,255),
|
|
Color.BLUE,
|
|
new Color(102,51,51),
|
|
Color.GREEN,
|
|
Color.RED,
|
|
Color.BLACK
|
|
};
|
|
|
|
@Override
|
|
public String getName() {
|
|
return name;
|
|
}
|
|
|
|
public DefaultTileRenderer(Map<String, Object> configuration) {
|
|
name = (String) configuration.get("prefix");
|
|
Object o = configuration.get("maximumheight");
|
|
if (o != null) {
|
|
maximumHeight = Integer.parseInt(String.valueOf(o));
|
|
if (maximumHeight > 127)
|
|
maximumHeight = 127;
|
|
}
|
|
colorScheme = ColorScheme.getScheme((String)configuration.get("colorscheme"));
|
|
}
|
|
|
|
public boolean render(KzedMapTile tile, File outputFile) {
|
|
World world = tile.getWorld();
|
|
BufferedImage im = new BufferedImage(KzedMap.tileWidth, KzedMap.tileHeight, BufferedImage.TYPE_INT_RGB);
|
|
|
|
WritableRaster r = im.getRaster();
|
|
boolean isempty = true;
|
|
|
|
int ix = KzedMap.anchorx + tile.px / 2 + tile.py / 2 - ((127-maximumHeight)/2);
|
|
int iy = maximumHeight;
|
|
int iz = KzedMap.anchorz + tile.px / 2 - tile.py / 2 + ((127-maximumHeight)/2);
|
|
|
|
int jx, jz;
|
|
|
|
int x, y;
|
|
|
|
/* draw the map */
|
|
for (y = 0; y < KzedMap.tileHeight;) {
|
|
jx = ix;
|
|
jz = iz;
|
|
|
|
for (x = KzedMap.tileWidth - 1; x >= 0; x -= 2) {
|
|
Color c1 = scan(world, jx, iy, jz, 0);
|
|
Color c2 = scan(world, jx, iy, jz, 2);
|
|
isempty = isempty && c1 == translucent && c2 == translucent;
|
|
r.setPixel(x, y, new int[] {
|
|
c1.getRed(),
|
|
c1.getGreen(),
|
|
c1.getBlue() });
|
|
r.setPixel(x - 1, y, new int[] {
|
|
c2.getRed(),
|
|
c2.getGreen(),
|
|
c2.getBlue() });
|
|
|
|
jx++;
|
|
jz++;
|
|
|
|
}
|
|
|
|
y++;
|
|
|
|
jx = ix;
|
|
jz = iz - 1;
|
|
|
|
for (x = KzedMap.tileWidth - 1; x >= 0; x -= 2) {
|
|
Color c1 = scan(world, jx, iy, jz, 2);
|
|
jx++;
|
|
jz++;
|
|
Color c2 = scan(world, jx, iy, jz, 0);
|
|
isempty = isempty && c1 == translucent && c2 == translucent;
|
|
r.setPixel(x, y, new int[] {
|
|
c1.getRed(),
|
|
c1.getGreen(),
|
|
c1.getBlue() });
|
|
r.setPixel(x - 1, y, new int[] {
|
|
c2.getRed(),
|
|
c2.getGreen(),
|
|
c2.getBlue() });
|
|
}
|
|
|
|
y++;
|
|
|
|
ix++;
|
|
iz--;
|
|
}
|
|
|
|
/* Hand encoding and writing file off to MapManager */
|
|
final File fname = outputFile;
|
|
final KzedMapTile mtile = tile;
|
|
final BufferedImage img = im;
|
|
final KzedZoomedMapTile zmtile = new KzedZoomedMapTile(mtile.getWorld(),
|
|
(KzedMap) mtile.getMap(), mtile);
|
|
final File zoomFile = MapManager.mapman.getTileFile(zmtile);
|
|
|
|
MapManager.mapman.enqueueImageWrite(new Runnable() {
|
|
public void run() {
|
|
doFileWrites(fname, mtile, img, zmtile, zoomFile);
|
|
}
|
|
});
|
|
|
|
return !isempty;
|
|
}
|
|
|
|
private void doFileWrites(final File fname, final KzedMapTile mtile,
|
|
final BufferedImage img, final KzedZoomedMapTile zmtile, final File zoomFile) {
|
|
Debug.debug("saving image " + fname.getPath());
|
|
try {
|
|
ImageIO.write(img, "png", fname);
|
|
} catch (IOException e) {
|
|
Debug.error("Failed to save image: " + fname.getPath(), e);
|
|
} catch (java.lang.NullPointerException e) {
|
|
Debug.error("Failed to save image (NullPointerException): " + fname.getPath(), e);
|
|
}
|
|
mtile.file = fname;
|
|
// Since we've already got the new tile, and we're on an async thread, just
|
|
// make the zoomed tile here
|
|
int px = mtile.px;
|
|
int py = mtile.py;
|
|
int zpx = zmtile.getTileX();
|
|
int zpy = zmtile.getTileY();
|
|
|
|
/* scaled size */
|
|
int scw = KzedMap.tileWidth / 2;
|
|
int sch = KzedMap.tileHeight / 2;
|
|
|
|
/* origin in zoomed-out tile */
|
|
int ox = 0;
|
|
int oy = 0;
|
|
|
|
if (zpx != px)
|
|
ox = scw;
|
|
if (zpy != py)
|
|
oy = sch;
|
|
|
|
BufferedImage zIm = null;
|
|
try {
|
|
zIm = ImageIO.read(zoomFile);
|
|
} catch (IOException e) {
|
|
} catch (IndexOutOfBoundsException e) {
|
|
}
|
|
|
|
if (zIm == null) {
|
|
/* create new one */
|
|
zIm = new BufferedImage(KzedMap.tileWidth, KzedMap.tileHeight, BufferedImage.TYPE_INT_RGB);
|
|
Debug.debug("New zoom-out tile created " + zmtile.getFilename());
|
|
} else {
|
|
Debug.debug("Loaded zoom-out tile from " + zmtile.getFilename());
|
|
}
|
|
|
|
/* blit scaled rendered tile onto zoom-out tile */
|
|
Graphics2D g2 = zIm.createGraphics();
|
|
g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
|
|
g2.drawImage(img, ox, oy, scw, sch, null);
|
|
|
|
img.flush();
|
|
|
|
/* save zoom-out tile */
|
|
|
|
try {
|
|
ImageIO.write(zIm, "png", zoomFile);
|
|
Debug.debug("Saved zoom-out tile at " + zoomFile.getName());
|
|
} catch (IOException e) {
|
|
Debug.error("Failed to save zoom-out tile: " + zoomFile.getName(), e);
|
|
} catch (java.lang.NullPointerException e) {
|
|
Debug.error("Failed to save zoom-out tile (NullPointerException): " + zoomFile.getName(), e);
|
|
}
|
|
zIm.flush();
|
|
/* Push updates for both files.*/
|
|
MapManager.mapman.pushUpdate(mtile.getWorld(),
|
|
new Client.Tile(mtile.getFilename()));
|
|
MapManager.mapman.pushUpdate(zmtile.getWorld(),
|
|
new Client.Tile(zmtile.getFilename()));
|
|
}
|
|
|
|
|
|
protected Color scan(World world, int x, int y, int z, int seq) {
|
|
for (;;) {
|
|
if (y < 0)
|
|
return translucent;
|
|
|
|
int id = world.getBlockTypeIdAt(x, y, z);
|
|
byte data = 0;
|
|
if(colorScheme.datacolors[id] != null) { /* If data colored */
|
|
data = world.getBlockAt(x, y, z).getData();
|
|
}
|
|
switch (seq) {
|
|
case 0:
|
|
x--;
|
|
break;
|
|
case 1:
|
|
y--;
|
|
break;
|
|
case 2:
|
|
z++;
|
|
break;
|
|
case 3:
|
|
y--;
|
|
break;
|
|
}
|
|
|
|
seq = (seq + 1) & 3;
|
|
|
|
if (id != 0) {
|
|
if (highlightBlocks.contains(id)) {
|
|
return highlightColor;
|
|
}
|
|
Color[] colors;
|
|
if(data != 0)
|
|
colors = colorScheme.datacolors[id][data];
|
|
else
|
|
colors = colorScheme.colors[id];
|
|
if (colors != null) {
|
|
Color c = colors[seq];
|
|
if (c.getAlpha() > 0) {
|
|
/* we found something that isn't transparent! */
|
|
if (c.getAlpha() == 255) {
|
|
/* it's opaque - the ray ends here */
|
|
return c;
|
|
}
|
|
|
|
/* this block is transparent, so recurse */
|
|
Color bg = scan(world, x, y, z, seq);
|
|
|
|
int cr = c.getRed();
|
|
int cg = c.getGreen();
|
|
int cb = c.getBlue();
|
|
int ca = c.getAlpha();
|
|
cr *= ca;
|
|
cg *= ca;
|
|
cb *= ca;
|
|
int na = 255 - ca;
|
|
|
|
return new Color((bg.getRed() * na + cr) >> 8, (bg.getGreen() * na + cg) >> 8, (bg.getBlue() * na + cb) >> 8);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|