I've been learning about 3D for a couple days now. I managed to create a chunk (8x8x8). Add optimization so it only renders the active and visible blocks. Then I added so it only draws the faces which don't have a neighbor.
Next what I found from online research was that it is better to use glDrawArrays to increase performance. So I restarted my little project. Render an entire chunck, add optimization so it only renders active and visible blocks.
But now I want to add so it only draws the visible faces while using glDrawArrays. This is giving me some trouble with calling glDrawArrays because I'm passing a wrong count parameter.
> # A fatal error has been detected by the Java Runtime Environment:
> #
> # EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x0000000006e31a03, pid=1032, tid=3184
> #
Stack: [0x00000000023a0000,0x00000000024a0000], sp=0x000000000249ef70, free space=1019k
Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)
C [ig4icd64.dll+0xa1a03]
Java frames: (J=compiled Java code, j=interpreted, Vv=VM code)
j org.lwjgl.opengl.GL11.nglDrawArrays(IIIJ)V+0
j org.lwjgl.opengl.GL11.glDrawArrays(III)V+20
j com.vox.block.Chunk.render()V+410
j com.vox.ChunkManager.render()V+30
j com.vox.Game.render()V+11
j com.vox.GameHandler.render()V+12
j com.vox.GameHandler.gameLoop()V+15
j com.vox.Main.main([Ljava/lang/StringV+13
v ~StubRoutines::call_stub
public class Chunk {
public final static int[] DIM = { 8, 8, 8};
public final static int CHUNK_SIZE = (DIM[0] * DIM[1] * DIM[2]);
Block[][][] blocks;
private int index;
private int vBOVertexHandle;
private int vBOColorHandle;
public Chunk(int index) {
this.index = index;
vBOColorHandle = GL15.glGenBuffers();
vBOVertexHandle = GL15.glGenBuffers();
blocks = new Block[DIM[0]][DIM[1]][DIM[2]];
for(int x = 0; x < DIM[0]; x++){
for(int y = 0; y < DIM[1]; y++){
for(int z = 0; z < DIM[2]; z++){
blocks[x][y][z] = new Block();
}
}
}
}
public void render(){
Block curr;
FloatBuffer vertexPositionData2 = BufferUtils.createFloatBuffer(CHUNK_SIZE * 6 * 12);
FloatBuffer vertexColorData2 = BufferUtils.createFloatBuffer(CHUNK_SIZE * 6 * 12);
int counter = 0;
for(int x = 0; x < DIM[0]; x++){
for(int y = 0; y < DIM[1]; y++){
for(int z = 0; z < DIM[2]; z++){
curr = blocks[x][y][z];
boolean[] neightbours = validateNeightbours(x, y, z);
if(curr.isActive() && !neightbours[6]) {
float[] arr = curr.createCube((index*DIM[0]*Block.BLOCK_SIZE*2) + x*2, y*2, z*2, neightbours);
counter += arr.length;
vertexPositionData2.put(arr);
vertexColorData2.put(createCubeVertexCol(curr.getCubeColor()));
}
}
}
}
vertexPositionData2.flip();
vertexPositionData2.flip();
FloatBuffer vertexPositionData = BufferUtils.createFloatBuffer(vertexColorData2.position());
FloatBuffer vertexColorData = BufferUtils.createFloatBuffer(vertexColorData2.position());
for(int i = 0; i < vertexPositionData2.position(); i++)
vertexPositionData.put(vertexPositionData2.get(i));
for(int i = 0; i < vertexColorData2.position(); i++)
vertexColorData.put(vertexColorData2.get(i));
vertexColorData.flip();
vertexPositionData.flip();
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vBOVertexHandle);
GL15.glBufferData(GL15.GL_ARRAY_BUFFER, vertexPositionData, GL15.GL_STATIC_DRAW);
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vBOColorHandle);
GL15.glBufferData(GL15.GL_ARRAY_BUFFER, vertexColorData, GL15.GL_STATIC_DRAW);
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
GL11.glPushMatrix();
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vBOVertexHandle);
GL11.glVertexPointer(3, GL11.GL_FLOAT, 0, 0L);
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vBOColorHandle);
GL11.glColorPointer(3, GL11.GL_FLOAT, 0, 0L);
System.out.println("Counter " + counter);
GL11.glDrawArrays(GL11.GL_LINE_LOOP, 0, counter);
GL11.glPopMatrix();
//blocks[r.nextInt(DIM[0])][2][r.nextInt(DIM[2])].setActive(false);
}
//Random r = new Random();
private float[] createCubeVertexCol(float[] CubeColorArray) {
float[] cubeColors = new float[CubeColorArray.length * 4 * 6];
for (int i = 0; i < cubeColors.length; i++) {
cubeColors[i] = CubeColorArray[i % CubeColorArray.length];
}
return cubeColors;
}
private boolean[] validateNeightbours(int x, int y, int z) {
boolean[] bools = new boolean[7];
bools[6] = true;
bools[6] = bools[6] && (bools[0] = y > 0 && y < DIM[1]-1 && blocks[x][y+1][z].isActive());//top
bools[6] = bools[6] && (bools[1] = y > 0 && y < DIM[1]-1 && blocks[x][y-1][z].isActive());//bottom
bools[6] = bools[6] && (bools[2] = z > 0 && z < DIM[2]-1 && blocks[x][y][z+1].isActive());//front
bools[6] = bools[6] && (bools[3] = z > 0 && z < DIM[2]-1 && blocks[x][y][z-1].isActive());//back
bools[6] = bools[6] && (bools[4] = x > 0 && x < DIM[0]-1 && blocks[x+1][y][z].isActive());//left
bools[6] = bools[6] && (bools[5] = x > 0 && x < DIM[0]-1 && blocks[x-1][y][z].isActive());//right
return bools;
}
}
public class Block {
public static final float BLOCK_SIZE = 1f;
public enum BlockType {
Default(0),
Grass(1),
Dirt(2),
Water(3),
Stone(4),
Wood(5),
Sand(6),
LAVA(7);
int BlockID;
BlockType(int i) {
BlockID=i;
}
}
private boolean active;
private BlockType type;
public Block() {
this(BlockType.Default);
}
public Block(BlockType type){
active = true;
this.type = type;
}
public float[] getCubeColor() {
switch (type.BlockID) {
case 1:
return new float[] { 1, 1, 0 };
case 2:
return new float[] { 1, 0.5f, 0 };
case 3:
return new float[] { 0, 0f, 1f };
default:
return new float[] {0.5f, 0.5f, 1f};
}
}
public float[] createCube(float x, float y, float z, boolean[] neightbours){
int counter = 0;
for(boolean b : neightbours)
if(!b)
counter++;
float[] array = new float[counter*12];
int offset = 0;
if(!neightbours[0]){//top
array[offset++] = x*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE - BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE - BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE + BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE + BLOCK_SIZE;
}
if(!neightbours[1]){//bottom
array[offset++] = x*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE + BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE + BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE - BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE - BLOCK_SIZE;
}
if(!neightbours[2]){//front
array[offset++] = x*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE + BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE + BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE + BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE + BLOCK_SIZE;
}
if(!neightbours[3]){//back
array[offset++] = x*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE - BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE - BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE - BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE - BLOCK_SIZE;
}
if(!neightbours[4]){//left
array[offset++] = x*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE + BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE - BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE - BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE + BLOCK_SIZE;
}
if(!neightbours[5]){//right
array[offset++] = x*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE - BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE + BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE + BLOCK_SIZE; array[offset++] =
x*BLOCK_SIZE + BLOCK_SIZE; array[offset++] = y*BLOCK_SIZE - BLOCK_SIZE; array[offset++] = z*BLOCK_SIZE - BLOCK_SIZE;
}
return Arrays.copyOf(array, offset);
}
public boolean isActive() {
return active;
}
public void setActive(boolean active) {
this.active = active;
}
public BlockType getType() {
return type;
}
public void setType(BlockType type) {
this.type = type;
}
}
I highlighted the code I'm concerned about in this following screenshot:
- http://imageshack.us/a/img820/7606/18626782.png - (Not allowed to upload images yet)
I know the code is a mess but I'm just testing stuff so I wasn't really thinking about it.
