502 lines
23 KiB
Java
502 lines
23 KiB
Java
package org.dynmap.hdmap;
|
|
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileOutputStream;
|
|
import java.io.FileReader;
|
|
import java.io.FileWriter;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.InputStreamReader;
|
|
import java.io.LineNumberReader;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
|
|
import org.bukkit.Material;
|
|
import org.dynmap.ConfigurationNode;
|
|
import org.dynmap.Log;
|
|
|
|
/**
|
|
* Custom block models - used for non-cube blocks to represent the physical volume associated with the block
|
|
* Used by perspectives to determine if rays have intersected a block that doesn't occupy its whole block
|
|
*/
|
|
public class HDBlockModels {
|
|
private int blockid;
|
|
private int databits;
|
|
private long blockflags[];
|
|
private int nativeres;
|
|
private HashMap<Integer, short[]> scaledblocks;
|
|
private static int linkalg[] = new int[256];
|
|
private static int linkmap[][] = new int[256][];
|
|
|
|
private static HashMap<Integer, HDBlockModels> models_by_id_data = new HashMap<Integer, HDBlockModels>();
|
|
|
|
public static class HDScaledBlockModels {
|
|
private short[][][] modelvectors;
|
|
|
|
public final short[] getScaledModel(int blocktype, int blockdata, int blockrenderdata) {
|
|
if(modelvectors[blocktype] == null) {
|
|
return null;
|
|
}
|
|
return modelvectors[blocktype][(blockrenderdata>=0)?blockrenderdata:blockdata];
|
|
}
|
|
}
|
|
|
|
private static HashMap<Integer, HDScaledBlockModels> scaled_models_by_scale = new HashMap<Integer, HDScaledBlockModels>();
|
|
|
|
/**
|
|
* Block definition - copy from other
|
|
*/
|
|
public HDBlockModels(Material blocktype, int databits, HDBlockModels m) {
|
|
this.blockid = blocktype.getId();
|
|
this.databits = databits;
|
|
this.nativeres = m.nativeres;
|
|
this.blockflags = m.blockflags;
|
|
}
|
|
/**
|
|
* Block definition - positions correspond to Bukkit coordinates (+X is south, +Y is up, +Z is west)
|
|
* @param blockid - block ID
|
|
* @param databits - bitmap of block data bits matching this model (bit N is set if data=N would match)
|
|
* @param nativeres - native subblocks per edge of cube (up to 64)
|
|
* @param blockflags - array of native^2 long integers representing volume of block (bit X of element (nativeres*Y+Z) is set if that subblock is filled)
|
|
* if array is short, other elements area are assumed to be zero (fills from bottom of block up)
|
|
*/
|
|
public HDBlockModels(Material blocktype, int databits, int nativeres, long[] blockflags) {
|
|
this(blocktype.getId(), databits, nativeres, blockflags);
|
|
}
|
|
/**
|
|
* Block definition - positions correspond to Bukkit coordinates (+X is south, +Y is up, +Z is west)
|
|
* @param blockid - block ID
|
|
* @param databits - bitmap of block data bits matching this model (bit N is set if data=N would match)
|
|
* @param nativeres - native subblocks per edge of cube (up to 64)
|
|
* @param blockflags - array of native^2 long integers representing volume of block (bit X of element (nativeres*Y+Z) is set if that subblock is filled)
|
|
* if array is short, other elements area are assumed to be zero (fills from bottom of block up)
|
|
*/
|
|
public HDBlockModels(int blockid, int databits, int nativeres, long[] blockflags) {
|
|
this.blockid = blockid;
|
|
this.databits = databits;
|
|
this.nativeres = nativeres;
|
|
this.blockflags = new long[nativeres * nativeres];
|
|
System.arraycopy(blockflags, 0, this.blockflags, 0, blockflags.length);
|
|
for(int i = 0; i < 16; i++) {
|
|
if((databits & (1<<i)) != 0) {
|
|
models_by_id_data.put((blockid<<4)+i, this);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Test if given native block is filled
|
|
*/
|
|
public final boolean isSubblockSet(int x, int y, int z) {
|
|
return ((blockflags[nativeres*y+z] & (1 << x)) != 0);
|
|
}
|
|
/**
|
|
* Set subblock value
|
|
*/
|
|
public final void setSubblock(int x, int y, int z, boolean isset) {
|
|
if(isset)
|
|
blockflags[nativeres*y+z] |= (1 << x);
|
|
else
|
|
blockflags[nativeres*y+z] &= ~(1 << x);
|
|
}
|
|
/**
|
|
* Get link algorithm
|
|
* @param blkid - block ID
|
|
* @return 0=no link alg
|
|
*/
|
|
public static final int getLinkAlgID(int blkid) {
|
|
return linkalg[blkid];
|
|
}
|
|
/**
|
|
* Get link block IDs
|
|
* @param blkid - block ID
|
|
* @return array of block IDs to link with
|
|
*/
|
|
public static final int[] getLinkIDs(int blkid) {
|
|
return linkmap[blkid];
|
|
}
|
|
/**
|
|
* Get scaled map of block: will return array of alpha levels, corresponding to how much of the
|
|
* scaled subblocks are occupied by the original blocks (indexed by Y*res*res + Z*res + X)
|
|
* @param res - requested scale (res subblocks per edge of block)
|
|
* @return array of alpha values (0-255), corresponding to resXresXres subcubes of block
|
|
*/
|
|
public short[] getScaledMap(int res) {
|
|
if(scaledblocks == null) { scaledblocks = new HashMap<Integer, short[]>(); }
|
|
short[] map = scaledblocks.get(Integer.valueOf(res));
|
|
if(map == null) {
|
|
map = new short[res*res*res];
|
|
if(res == nativeres) {
|
|
for(int i = 0; i < blockflags.length; i++) {
|
|
for(int j = 0; j < nativeres; j++) {
|
|
if((blockflags[i] & (1 << j)) != 0)
|
|
map[res*i+j] = 255;
|
|
}
|
|
}
|
|
}
|
|
/* If scaling from smaller sub-blocks to larger, each subblock contributes to 1-2 blocks
|
|
* on each axis: need to calculate crossovers for each, and iterate through smaller
|
|
* blocks to accumulate contributions
|
|
*/
|
|
else if(res > nativeres) {
|
|
int weights[] = new int[res];
|
|
int offsets[] = new int[res];
|
|
/* LCM of resolutions is used as length of line (res * nativeres)
|
|
* Each native block is (res) long, each scaled block is (nativeres) long
|
|
* Each scaled block overlaps 1 or 2 native blocks: starting with native block 'offsets[]' with
|
|
* 'weights[]' of its (res) width in the first, and the rest in the second
|
|
*/
|
|
for(int v = 0, idx = 0; v < res*nativeres; v += nativeres, idx++) {
|
|
offsets[idx] = (v/res); /* Get index of the first native block we draw from */
|
|
if((v+nativeres-1)/res == offsets[idx]) { /* If scaled block ends in same native block */
|
|
weights[idx] = nativeres;
|
|
}
|
|
else { /* Else, see how much is in first one */
|
|
weights[idx] = (offsets[idx] + res) - v;
|
|
weights[idx] = (offsets[idx]*res + res) - v;
|
|
}
|
|
}
|
|
/* Now, use weights and indices to fill in scaled map */
|
|
for(int y = 0, off = 0; y < res; y++) {
|
|
int ind_y = offsets[y];
|
|
int wgt_y = weights[y];
|
|
for(int z = 0; z < res; z++) {
|
|
int ind_z = offsets[z];
|
|
int wgt_z = weights[z];
|
|
for(int x = 0; x < res; x++, off++) {
|
|
int ind_x = offsets[x];
|
|
int wgt_x = weights[x];
|
|
int raw_w = 0;
|
|
for(int xx = 0; xx < 2; xx++) {
|
|
int wx = (xx==0)?wgt_x:(nativeres-wgt_x);
|
|
if(wx == 0) continue;
|
|
for(int yy = 0; yy < 2; yy++) {
|
|
int wy = (yy==0)?wgt_y:(nativeres-wgt_y);
|
|
if(wy == 0) continue;
|
|
for(int zz = 0; zz < 2; zz++) {
|
|
int wz = (zz==0)?wgt_z:(nativeres-wgt_z);
|
|
if(wz == 0) continue;
|
|
if(isSubblockSet(ind_x+xx, ind_y+yy, ind_z+zz)) {
|
|
raw_w += wx*wy*wz;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
map[off] = (short)((255*raw_w) / (nativeres*nativeres*nativeres));
|
|
if(map[off] > 255) map[off] = 255;
|
|
if(map[off] < 0) map[off] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else { /* nativeres > res */
|
|
int weights[] = new int[nativeres];
|
|
int offsets[] = new int[nativeres];
|
|
/* LCM of resolutions is used as length of line (res * nativeres)
|
|
* Each native block is (res) long, each scaled block is (nativeres) long
|
|
* Each native block overlaps 1 or 2 scaled blocks: starting with scaled block 'offsets[]' with
|
|
* 'weights[]' of its (res) width in the first, and the rest in the second
|
|
*/
|
|
for(int v = 0, idx = 0; v < res*nativeres; v += res, idx++) {
|
|
offsets[idx] = (v/nativeres); /* Get index of the first scaled block we draw to */
|
|
if((v+res-1)/nativeres == offsets[idx]) { /* If native block ends in same scaled block */
|
|
weights[idx] = res;
|
|
}
|
|
else { /* Else, see how much is in first one */
|
|
weights[idx] = (offsets[idx]*nativeres + nativeres) - v;
|
|
}
|
|
}
|
|
/* Now, use weights and indices to fill in scaled map */
|
|
long accum[] = new long[map.length];
|
|
for(int y = 0; y < nativeres; y++) {
|
|
int ind_y = offsets[y];
|
|
int wgt_y = weights[y];
|
|
for(int z = 0; z < nativeres; z++) {
|
|
int ind_z = offsets[z];
|
|
int wgt_z = weights[z];
|
|
for(int x = 0; x < nativeres; x++) {
|
|
if(isSubblockSet(x, y, z)) {
|
|
int ind_x = offsets[x];
|
|
int wgt_x = weights[x];
|
|
for(int xx = 0; xx < 2; xx++) {
|
|
int wx = (xx==0)?wgt_x:(res-wgt_x);
|
|
if(wx == 0) continue;
|
|
for(int yy = 0; yy < 2; yy++) {
|
|
int wy = (yy==0)?wgt_y:(res-wgt_y);
|
|
if(wy == 0) continue;
|
|
for(int zz = 0; zz < 2; zz++) {
|
|
int wz = (zz==0)?wgt_z:(res-wgt_z);
|
|
if(wz == 0) continue;
|
|
accum[(ind_y+yy)*res*res + (ind_z+zz)*res + (ind_x+xx)] +=
|
|
wx*wy*wz;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for(int i = 0; i < map.length; i++) {
|
|
map[i] = (short)(accum[i]*255/nativeres/nativeres/nativeres);
|
|
if(map[i] > 255) map[i] = 255;
|
|
if(map[i] < 0) map[i] = 0;
|
|
}
|
|
}
|
|
scaledblocks.put(Integer.valueOf(res), map);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
/**
|
|
* Get scaled set of models for all modelled blocks
|
|
* @param scale
|
|
* @return
|
|
*/
|
|
public static HDScaledBlockModels getModelsForScale(int scale) {
|
|
HDScaledBlockModels model = scaled_models_by_scale.get(Integer.valueOf(scale));
|
|
if(model == null) {
|
|
model = new HDScaledBlockModels();
|
|
short[][][] blockmodels = new short[256][][];
|
|
for(HDBlockModels m : models_by_id_data.values()) {
|
|
short[][] row = blockmodels[m.blockid];
|
|
if(row == null) {
|
|
row = new short[16][];
|
|
blockmodels[m.blockid] = row;
|
|
}
|
|
short[] smod = null;
|
|
for(int i = 0; i < 16; i++) {
|
|
if((m.databits & (1 << i)) != 0) {
|
|
if(smod == null) smod = m.getScaledMap(scale);
|
|
row[i] = smod;
|
|
}
|
|
}
|
|
}
|
|
model.modelvectors = blockmodels;
|
|
scaled_models_by_scale.put(scale, model);
|
|
}
|
|
return model;
|
|
}
|
|
/**
|
|
* Load models
|
|
*/
|
|
public static void loadModels(File datadir, ConfigurationNode config) {
|
|
/* Reset models-by-ID-Data cache */
|
|
models_by_id_data.clear();
|
|
/* Reset scaled models by scale cache */
|
|
scaled_models_by_scale.clear();
|
|
|
|
/* Load block models */
|
|
InputStream in = TexturePack.class.getResourceAsStream("/models.txt");
|
|
if(in != null) {
|
|
loadModelFile(in, "models.txt", config);
|
|
try { in.close(); } catch (IOException iox) {} in = null;
|
|
}
|
|
File customdir = new File(datadir, "renderdata");
|
|
String[] files = customdir.list();
|
|
if(files != null) {
|
|
for(String fn : files) {
|
|
if(fn.endsWith("-models.txt") == false)
|
|
continue;
|
|
File custom = new File(customdir, fn);
|
|
if(custom.canRead()) {
|
|
try {
|
|
in = new FileInputStream(custom);
|
|
loadModelFile(in, custom.getPath(), config);
|
|
} catch (IOException iox) {
|
|
Log.severe("Error loading " + custom.getPath());
|
|
} finally {
|
|
if(in != null) {
|
|
try { in.close(); } catch (IOException iox) {}
|
|
in = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Load models from file
|
|
*/
|
|
private static void loadModelFile(InputStream in, String fname, ConfigurationNode config) {
|
|
LineNumberReader rdr = null;
|
|
int cnt = 0;
|
|
try {
|
|
String line;
|
|
ArrayList<HDBlockModels> modlist = new ArrayList<HDBlockModels>();
|
|
int layerbits = 0;
|
|
int rownum = 0;
|
|
int scale = 0;
|
|
rdr = new LineNumberReader(new InputStreamReader(in));
|
|
while((line = rdr.readLine()) != null) {
|
|
if(line.startsWith("block:")) {
|
|
ArrayList<Integer> blkids = new ArrayList<Integer>();
|
|
int databits = 0;
|
|
scale = 0;
|
|
line = line.substring(6);
|
|
String[] args = line.split(",");
|
|
for(String a : args) {
|
|
String[] av = a.split("=");
|
|
if(av.length < 2) continue;
|
|
if(av[0].equals("id")) {
|
|
blkids.add(Integer.parseInt(av[1]));
|
|
}
|
|
else if(av[0].equals("data")) {
|
|
if(av[1].equals("*"))
|
|
databits = 0xFFFF;
|
|
else
|
|
databits |= (1 << Integer.parseInt(av[1]));
|
|
}
|
|
else if(av[0].equals("scale")) {
|
|
scale = Integer.parseInt(av[1]);
|
|
}
|
|
}
|
|
/* If we have everything, build block */
|
|
if((blkids.size() > 0) && (databits != 0) && (scale > 0)) {
|
|
modlist.clear();
|
|
for(Integer id : blkids) {
|
|
modlist.add(new HDBlockModels(id.intValue(), databits, scale, new long[0]));
|
|
cnt++;
|
|
}
|
|
}
|
|
else {
|
|
Log.severe("Block model missing required parameters = line " + rdr.getLineNumber() + " of " + fname);
|
|
}
|
|
layerbits = 0;
|
|
}
|
|
else if(line.startsWith("layer:")) {
|
|
line = line.substring(6);
|
|
String args[] = line.split(",");
|
|
layerbits = 0;
|
|
rownum = 0;
|
|
for(String a: args) {
|
|
layerbits |= (1 << Integer.parseInt(a));
|
|
}
|
|
}
|
|
else if(line.startsWith("rotate:")) {
|
|
line = line.substring(7);
|
|
String args[] = line.split(",");
|
|
int id = -1;
|
|
int data = -1;
|
|
int rot = -1;
|
|
for(String a : args) {
|
|
String[] av = a.split("=");
|
|
if(av.length < 2) continue;
|
|
if(av[0].equals("id")) { id = Integer.parseInt(av[1]); }
|
|
if(av[0].equals("data")) { data = Integer.parseInt(av[1]); }
|
|
if(av[0].equals("rot")) { rot = Integer.parseInt(av[1]); }
|
|
}
|
|
/* get old model to be rotated */
|
|
HDBlockModels mod = models_by_id_data.get((id<<4)+data);
|
|
if((mod != null) && ((rot%90) == 0)) {
|
|
for(int x = 0; x < scale; x++) {
|
|
for(int y = 0; y < scale; y++) {
|
|
for(int z = 0; z < scale; z++) {
|
|
if(mod.isSubblockSet(x, y, z) == false) continue;
|
|
switch(rot) {
|
|
case 0:
|
|
for(HDBlockModels bm : modlist)
|
|
bm.setSubblock(x, y, z, true);
|
|
break;
|
|
case 90:
|
|
for(HDBlockModels bm : modlist)
|
|
bm.setSubblock(scale-z-1, y, x, true);
|
|
break;
|
|
case 180:
|
|
for(HDBlockModels bm : modlist)
|
|
bm.setSubblock(scale-x-1, y, scale-z-1, true);
|
|
break;
|
|
case 270:
|
|
for(HDBlockModels bm : modlist)
|
|
bm.setSubblock(z, y, scale-x-1, true);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if(line.startsWith("linkmap:")) {
|
|
ArrayList<Integer> blkids = new ArrayList<Integer>();
|
|
line = line.substring(8);
|
|
String[] args = line.split(",");
|
|
List<Integer> map = new ArrayList<Integer>();
|
|
int linktype = 0;
|
|
for(String a : args) {
|
|
String[] av = a.split("=");
|
|
if(av.length < 2) continue;
|
|
if(av[0].equals("id")) {
|
|
blkids.add(Integer.parseInt(av[1]));
|
|
}
|
|
else if(av[0].equals("linkalg")) {
|
|
linktype = Integer.parseInt(av[1]);
|
|
}
|
|
else if(av[0].equals("linkid")) {
|
|
map.add(Integer.parseInt(av[1]));
|
|
}
|
|
}
|
|
if(linktype > 0) {
|
|
int[] mapids = new int[map.size()];
|
|
for(int i = 0; i < mapids.length; i++)
|
|
mapids[i] = map.get(i);
|
|
for(Integer bid : blkids) {
|
|
linkalg[bid] = linktype;
|
|
linkmap[bid] = mapids;
|
|
}
|
|
}
|
|
}
|
|
else if(line.startsWith("#") || line.startsWith(";")) {
|
|
}
|
|
else if(line.startsWith("enabled:")) { /* Test if texture file is enabled */
|
|
line = line.substring(8).trim();
|
|
if(line.startsWith("true")) { /* We're enabled? */
|
|
/* Nothing to do - keep processing */
|
|
}
|
|
else if(line.startsWith("false")) { /* Disabled */
|
|
return; /* Quit */
|
|
}
|
|
/* If setting is not defined or false, quit */
|
|
else if(config.getBoolean(line, false) == false) {
|
|
return;
|
|
}
|
|
else {
|
|
Log.info(line + " models enabled");
|
|
}
|
|
}
|
|
else if(layerbits != 0) { /* If we're working pattern lines */
|
|
/* Layerbits determine Y, rows count from North to South (X=0 to X=N-1), columns Z are West to East (N-1 to 0) */
|
|
for(int i = 0; (i < scale) && (i < line.length()); i++) {
|
|
if(line.charAt(i) == '*') { /* If an asterix, set flag */
|
|
for(int y = 0; y < scale; y++) {
|
|
if((layerbits & (1<<y)) != 0) {
|
|
for(HDBlockModels mod : modlist) {
|
|
mod.setSubblock(rownum, y, scale-i-1, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/* See if we're done with layer */
|
|
rownum++;
|
|
if(rownum >= scale) {
|
|
rownum = 0;
|
|
layerbits = 0;
|
|
}
|
|
}
|
|
}
|
|
Log.verboseinfo("Loaded " + cnt + " block models from " + fname);
|
|
} catch (IOException iox) {
|
|
Log.severe("Error reading models.txt - " + iox.toString());
|
|
} catch (NumberFormatException nfx) {
|
|
Log.severe("Format error - line " + rdr.getLineNumber() + " of " + fname);
|
|
} finally {
|
|
if(rdr != null) {
|
|
try {
|
|
rdr.close();
|
|
rdr = null;
|
|
} catch (IOException e) {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|