save

1 files changed, 214 insertions, 0 deletions

diff --git a/src/main/java/net/tylermurphy/Minecraft/Chunk/ChunkMesh.java b/src/main/java/net/tylermurphy/Minecraft/Chunk/ChunkMesh.java
new file mode 100755
index 0000000..093243a
--- /dev/null
+++ b/src/main/java/net/tylermurphy/Minecraft/Chunk/ChunkMesh.java
@@ -0,0 +1,214 @@
+package net.tylermurphy.Minecraft.Chunk;

+

+import static net.tylermurphy.Minecraft.Chunk.Cube.*;

+

+import java.util.ArrayList;

+import java.util.List;

+

+import net.tylermurphy.Minecraft.Scene.Objects.Transform;

+import org.json.JSONArray;

+import org.json.JSONObject;

+import org.joml.Vector2f;

+import org.joml.Vector3f;

+

+import net.tylermurphy.Minecraft.Render.Data.Mesh;

+import net.tylermurphy.Minecraft.Scene.World;

+import net.tylermurphy.Minecraft.Scene.Objects.Renderable;

+

+public class ChunkMesh {

+	

+	private List<Vertex> verticies;

+	private List<Vertex> tranaparentVerticies;

+	private List<Float> positionsList;

+	private List<Float> normalsList;

+	private List<Float> tcsList;

+	private List<Float> lightingList;

+	private List<Float> layerList;

+	

+	public float[] positions, tcs, normals, lighting, layers;

+	

+	private Chunk chunk;

+	

+	private boolean transparent;

+	

+	public boolean completed = false;

+

+	public void update(Chunk chunk, boolean transparent) {

+		

+		this.chunk = chunk;

+		this.transparent = transparent;

+		this.completed = false;

+		

+		verticies = new ArrayList<>();

+		tranaparentVerticies = new ArrayList<>();

+		positionsList = new ArrayList<>();

+		normalsList = new ArrayList<>();

+		tcsList = new ArrayList<>();

+		lightingList = new ArrayList<>();

+		layerList = new ArrayList<>();

+		

+		buildMesh();

+		populateLists();

+		

+		this.completed = true;

+	}

+	

+	private void buildMesh() {

+		for(int x=0;x<16;x++) {

+			for(int y=0; y<256; y++) {

+				for(int z=0; z<16; z++) {

+					

+					if(chunk.cubes[x][y][z] == AIR) continue;

+					

+					if(getBlock(chunk.cubes[x][y][z]).transparent != transparent) continue;

+					

+					boolean px = true, nx = true, py = true, ny = true, pz = true, nz = true;

+					

+					if(x<15) px = chunk.cubes[x + 1][y][z] != AIR && transparentCheck(x + 1, y, z, x, y, z);

+					else px = getCube(chunk.gridX + 1, chunk.gridZ, 0, y, z) != AIR && transparentCheck(getCube(chunk.gridX + 1, chunk.gridZ, 0, y, z), x, y, z);

+					if(x>0) nx = chunk.cubes[x - 1][y][z] != AIR && transparentCheck(x - 1, y, z, x, y, z);

+					else nx = getCube(chunk.gridX - 1, chunk.gridZ, 15, y, z) != AIR && transparentCheck(getCube(chunk.gridX - 1, chunk.gridZ, 15, y, z), x, y, z);

+					if(y<255) py = chunk.cubes[x][y + 1][z] != AIR && transparentCheck(x, y + 1, z, x, y, z);

+					if(y>0) ny = chunk.cubes[x][y - 1][z] != AIR && transparentCheck(x, y - 1, z, x, y, z);

+					if(z<15) pz = chunk.cubes[x][y][z + 1] != AIR && transparentCheck(x, y, z + 1, x, y, z);

+					else pz = getCube(chunk.gridX, chunk.gridZ + 1, x, y, 0) != AIR && transparentCheck(getCube(chunk.gridX, chunk.gridZ + 1, x, y, 0), x, y, z);

+					if(z>0) nz = chunk.cubes[x][y][z - 1] != AIR && transparentCheck(x, y, z - 1, x, y, z);

+					else nz = getCube(chunk.gridX, chunk.gridZ - 1, x, y, 15) != AIR && transparentCheck(getCube(chunk.gridX, chunk.gridZ - 1, x, y, 15), x, y, z);

+					

+					JSONObject positions = getBlock(chunk.cubes[x][y][z]).positions;

+					if(chunk.cubes[x][y][z]==17 && ( y==255 || chunk.cubes[x][y+1][z] != 17 )) {

+						

+						if(y<255) {

+							byte xp,xn,zp,zn;

+							

+							if(x<15) xp = chunk.cubes[x+1][y+1][z];

+							else xp = getCube(chunk.gridX+1,chunk.gridZ,0,y+1,z);

+							if(x<0) xn = chunk.cubes[x-1][y+1][z];

+							else xn = getCube(chunk.gridX-1,chunk.gridZ,15,y+1,z);

+							if(z<15) zp = chunk.cubes[x][y+1][z+1];

+							else zp = getCube(chunk.gridX,chunk.gridZ+1,x,y+1,0);

+							if(z<0) zn = chunk.cubes[x][y+1][z-1];

+							else zn = getCube(chunk.gridX,chunk.gridZ-1,x,y+1,15);

+							

+							if(xp != 17 && xn != 17 && zp != 17 && zn != 17) {

+								positions = models.get("water");

+								py = false;

+							}

+						} else {

+							positions = models.get("water");

+							py = false;

+						}

+						

+					}

+					

+					if(getBlock(chunk.cubes[x][y][z]).transparent && chunk.cubes[x][y][z] != 17 && (y == 0 || chunk.cubes[x][y-1][z] == 17)) {

+						ny = false;

+					}

+					

+					JSONArray PX_POS = positions.getJSONArray("PX_POS");

+					JSONArray NX_POS = positions.getJSONArray("NX_POS");

+					JSONArray PY_POS = positions.getJSONArray("PY_POS");

+					JSONArray NY_POS = positions.getJSONArray("NY_POS");

+					JSONArray PZ_POS = positions.getJSONArray("PZ_POS");

+					JSONArray NZ_POS = positions.getJSONArray("NZ_POS");

+					

+					if(!px) { for(int i=0;i<6;i++) { verticies.add(new Vertex(new Vector3f((float) PX_POS.getJSONArray(i).getDouble(0) + x, (float) PX_POS.getJSONArray(i).getDouble(1) + y, (float) PX_POS.getJSONArray(i).getDouble(2) + z), TEXTURE_CORDS[i], NORMALS[i], getBlock(chunk.cubes[x][y][z]).tex_px, .9f)); } }

+					if(!nx) { for(int i=0;i<6;i++) { verticies.add(new Vertex(new Vector3f((float) NX_POS.getJSONArray(i).getDouble(0) + x, (float) NX_POS.getJSONArray(i).getDouble(1) + y, (float) NX_POS.getJSONArray(i).getDouble(2) + z), TEXTURE_CORDS[i], NORMALS[i], getBlock(chunk.cubes[x][y][z]).tex_nx, .9f)); } }

+					if(!py) { for(int i=0;i<6;i++) { verticies.add(new Vertex(new Vector3f((float) PY_POS.getJSONArray(i).getDouble(0) + x, (float) PY_POS.getJSONArray(i).getDouble(1) + y, (float) PY_POS.getJSONArray(i).getDouble(2) + z), TEXTURE_CORDS[i], NORMALS[i], getBlock(chunk.cubes[x][y][z]).tex_py, 1f)); } }

+					if(!ny) { for(int i=0;i<6;i++) { verticies.add(new Vertex(new Vector3f((float) NY_POS.getJSONArray(i).getDouble(0) + x, (float) NY_POS.getJSONArray(i).getDouble(1) + y, (float) NY_POS.getJSONArray(i).getDouble(2) + z), TEXTURE_CORDS[i], NORMALS[i], getBlock(chunk.cubes[x][y][z]).tex_ny, 1f)); } }

+					if(!pz) { for(int i=0;i<6;i++) { verticies.add(new Vertex(new Vector3f((float) PZ_POS.getJSONArray(i).getDouble(0) + x, (float) PZ_POS.getJSONArray(i).getDouble(1) + y, (float) PZ_POS.getJSONArray(i).getDouble(2) + z), TEXTURE_CORDS[i], NORMALS[i], getBlock(chunk.cubes[x][y][z]).tex_pz, .8f)); } }

+					if(!nz) { for(int i=0;i<6;i++) { verticies.add(new Vertex(new Vector3f((float) NZ_POS.getJSONArray(i).getDouble(0) + x, (float) NZ_POS.getJSONArray(i).getDouble(1) + y, (float) NZ_POS.getJSONArray(i).getDouble(2) + z), TEXTURE_CORDS[i], NORMALS[i], getBlock(chunk.cubes[x][y][z]).tex_nz, .8f)); } }

+				}

+			}

+		}

+	}

+	

+	private byte getCube(int gx, int gz, int x, int y, int z) {

+		Chunk c = World.getChunk(gx,gz);

+		if(c == null) return 0;

+		return c.cubes[x][y][z];

+	}

+	

+	private boolean transparentCheck(int x1,int y1,int z1,int x2,int y2,int z2) {

+		return transparentCheck(chunk.cubes[x1][y1][z1], x2, y2, z2);

+	}

+	

+	private boolean transparentCheck(byte block,int x2,int y2,int z2) {

+		if(getBlock(block).alwaysRenderNeighbors || getBlock(chunk.cubes[x2][y2][z2]).alwaysRenderNeighbors)

+			return false;

+		else if(!getBlock(block).transparent && !getBlock(chunk.cubes[x2][y2][z2]).transparent && block == chunk.cubes[x2][y2][z2])

+			return true;

+		else return getBlock(block).transparent == getBlock(chunk.cubes[x2][y2][z2]).transparent || !getBlock(block).transparent;

+	}

+	

+	static class Vertex{

+		Vector3f positions;

+		Vector2f uvs;

+		Vector3f normals;

+		float light;

+		float layer;

+		Vertex(Vector3f positions, Vector2f uvs, Vector3f normals, float layer, float light){

+			this.positions = positions;

+			this.uvs = uvs;

+			this.normals = normals;

+			this.layer = layer;

+			this.light = light;

+		}

+	}

+	

+	private void populateLists() {

+		for(Vertex vertex : verticies) {

+			positionsList.add(vertex.positions.x);

+			positionsList.add(vertex.positions.y);

+			positionsList.add(vertex.positions.z);

+			tcsList.add(vertex.uvs.x);

+			tcsList.add(vertex.uvs.y);

+			normalsList.add(vertex.normals.x);

+			normalsList.add(vertex.normals.y);

+			normalsList.add(vertex.normals.z);

+			lightingList.add(vertex.light);

+			layerList.add(vertex.layer);

+		}

+		

+		positions = new float[positionsList.size()];

+		tcs = new float[tcsList.size()];

+		normals = new float[normalsList.size()];

+		lighting = new float[lightingList.size()];

+		layers = new float[layerList.size()];

+

+		for(int i=0;i<positions.length;i++) positions[i] = positionsList.get(i);

+		for(int i=0;i<normals.length;i++) normals[i] = normalsList.get(i);

+		for(int i=0;i<tcs.length;i++) tcs[i] = tcsList.get(i);

+		for(int i=0;i<lighting.length;i++) lighting[i] = lightingList.get(i);

+		for(int i=0;i<layers.length;i++) layers[i] = layerList.get(i);

+

+		verticies.clear();

+		tranaparentVerticies.clear();

+		positionsList.clear();

+		normalsList.clear();

+		tcsList.clear();

+		lightingList.clear();

+		layerList.clear();

+	}

+	

+	public Renderable createChunkMesh() {

+		Mesh mesh = new Mesh(positions.length)

+				.store(positions, 3)

+				.store(tcs, 2)

+				.store(lighting, 1)

+				.store(layers, 1)

+				.finish();

+		Transform transform = new Transform().setPosition(new Vector3f(chunk.gridX*16,9,chunk.gridZ*16));

+		Renderable renderable = new Renderable(mesh, transform, TEXTURE);

+		this.positions = null;

+		this.tcs = null;

+		this.normals = null;

+		this.lighting = null;

+		this.layers = null;

+		this.chunk = null;

+		this.completed = false;

+		return renderable;

+

+	}

+	

+}
\ No newline at end of file