Cube normals on voxel engine producing odd results

Question

I am trying to add normals to my voxel engines 16x16 cube chunks. When I render everything I get odd results. I am not sure if I have placed my normals incorrectly or if implementing simple shadows with lighting wont work how I am using it.

The following is the vertexes for each of my cubes and there respective normals.

public void putVertices(float tx, float ty, float tz, FloatBuffer vertexPositionData) {
    float l_length = Constants.BLOCK_SIZE;
    float l_height = Constants.BLOCK_SIZE;
    float l_width = Constants.BLOCK_SIZE;
    vertexPositionData.put(new float[]{
            xOffset + l_length + tx, -l_height + ty, zOffset + -l_width + tz,
            xOffset + -l_length + tx, -l_height + ty, zOffset + -l_width + tz,
            xOffset + -l_length + tx, l_height + ty, zOffset + -l_width + tz,
            xOffset + l_length + tx, l_height + ty, zOffset + -l_width + tz,

            xOffset + -l_length + tx, -l_height + ty, zOffset + l_width + tz,
            xOffset + l_length + tx, -l_height + ty, zOffset + l_width + tz,
            xOffset + l_length + tx, l_height + ty, zOffset + l_width + tz,
            xOffset + -l_length + tx, l_height + ty, zOffset + l_width + tz,

            xOffset + l_length + tx, -l_height + ty, zOffset + l_width + tz,
            xOffset + l_length + tx, -l_height + ty,zOffset +  -l_width + tz,
            xOffset + l_length + tx, l_height + ty,zOffset +  -l_width + tz,
            xOffset + l_length + tx, l_height + ty, zOffset + l_width + tz,

            xOffset + -l_length + tx, -l_height + ty, zOffset + -l_width + tz,
            xOffset + -l_length + tx, -l_height + ty,zOffset +  l_width + tz,
            xOffset + -l_length + tx, l_height + ty, zOffset + l_width + tz,
            xOffset + -l_length + tx, l_height + ty, zOffset + -l_width + tz,

            xOffset + -l_length + tx, -l_height + ty, zOffset + -l_width + tz,
            xOffset + l_length + tx, -l_height + ty, zOffset + -l_width + tz,
            xOffset + l_length + tx, -l_height + ty, zOffset + l_width + tz,
            xOffset + -l_length + tx, -l_height + ty,zOffset +  l_width + tz,

            xOffset + l_length + tx, l_height + ty,zOffset +  -l_width + tz,
            xOffset + -l_length + tx, l_height + ty, zOffset + -l_width + tz,
            xOffset + -l_length + tx, l_height + ty, zOffset + l_width + tz,
            xOffset + l_length + tx, l_height + ty, zOffset + l_width + tz

    });
}

public void putNormals(FloatBuffer vertexNormalData) {
    float[] normals = new float[] {
            0.0f, 0.0f, -1.0f,
            0.0f, 0.0f, 1.0f,
            1.0f, 0.0f, 0.0f,
            -1.0f, 0.0f, 0.0f,
            0.0f, -1.0f, 0.0f,
            0.0f, 1.0f, 0.0f,
    };

This is what it looks like when I run the program, Weird shadows with normals

It appears that the light is calculated as if each block surrounding it isnt there. How can I correct this? The result should look seamless when blocks are flat like in the picture.

How are you setting up your lights? Are you using the fixed function lights or shaders? — Colonel Thirty Two, Jun 15 '14 at 22:21
I am currently using fixed function lights. I set them up in my init function for opengl — sunsunsunsunsun, Jun 15 '14 at 22:24

Reto Koradi · Accepted Answer · 2014-06-15T23:57:00.280

You have 24 positions, but only 6 normal vectors, in your vertex data. You need a normal vector for each vertex. So with 24 positions, you also need 24 normal vectors.

Since the 4 vertices per side have the same normal vector, you need to repeat each of the normal vectors in your normals array 4 times, which will give you the necessary 24 normal vectors.

vertexNormalData.put(new float[] {
        0.0f, 0.0f, -1.0f,
        0.0f, 0.0f, -1.0f,
        0.0f, 0.0f, -1.0f,
        0.0f, 0.0f, -1.0f,
        0.0f, 0.0f, 1.0f,
        0.0f, 0.0f, 1.0f,
        0.0f, 0.0f, 1.0f,
        0.0f, 0.0f, 1.0f,
        1.0f, 0.0f, 0.0f,
        1.0f, 0.0f, 0.0f,
        1.0f, 0.0f, 0.0f,
        1.0f, 0.0f, 0.0f,
        -1.0f, 0.0f, 0.0f,
        -1.0f, 0.0f, 0.0f,
        -1.0f, 0.0f, 0.0f,
        -1.0f, 0.0f, 0.0f,
        0.0f, -1.0f, 0.0f,
        0.0f, -1.0f, 0.0f,
        0.0f, -1.0f, 0.0f,
        0.0f, -1.0f, 0.0f,
        0.0f, 1.0f, 0.0f,
        0.0f, 1.0f, 0.0f,
        0.0f, 1.0f, 0.0f,
        0.0f, 1.0f, 0.0f
});

I have tried what you said but I still get similar results. It does look marginally better. I don't get the seamless effect I'm looking for though. — sunsunsunsunsun, Jun 15 '14 at 23:11
I added the normal definitions to the answer, just to make sure that what I explained was clear. — Reto Koradi, Jun 15 '14 at 23:58
Brilliant! Works like a charm. I was just putting the vertexNormalData.put into a loop, whoops. — sunsunsunsunsun, Jun 16 '14 at 00:04

Cube normals on voxel engine producing odd results

1 Answers1