Hello everyone,

I just set the prefix to OpenGL because thats in the end what my engine is based on. Tho the question is not related to OpenGL per se but of a general kind.

Currently i am rendering terrain using cubes. 'Calculating' the normals for the cube faces is fairly obvious but im running into some problems with the fact that a vertex basically has 3 normals. I am using a vertex buffer with the points of the cube and an index buffer which holds the indices for the faces. So a cube in the end consists of 8 vertices and up to 36 indices (depending on the neighbors). Now a vertex has 3 distinct normals and there should be no interpolation amongst the faces of the cube. Is there an elegant way to my normals working and avoiding to create 3 vertices for each point with lots of redundant data?

Thanks in advance for you help and a merry xmas

Plerion

Hey, thank you for the hints. I have considered several options. First i was still trying to somehow get it done with 8 vertices and like a cube map for normals but in the end decided thats not even worth trying, as it hits performance way too bad and im not really in trouble with the current bandwidth. So rather ive tried to compress my data (3 floats position, 3 floats normals) and ended up with 2 bytes position and 1 byte normal. 1 byte of the position contains x and y as chunks have 16x16 rows so its upper 4 and lower 4 bits of the value. The second byte contains the z position as a row can be up to 256 blocks high. Finally the normal is compressed like this: 1 -> 1/0/0, -1 -> -1/0/0, 10 -> 0/1/0, -10 -> 0/-1/0, 100 -> 0/0/1, -100 -> 0/0/-1 and then reconstructed using the step function and division. So now i use less badnwidth and have correct normals and still have a byte left for occlusion values (as im using an Int4 vector).

PS: Merci, das wünsch ich diar doch au :D

If you only need flat shading, then you may actually get away with only eight vertices even if a cube with normals technically has 24 unique vertices. In flat shading, an attribute is automatically replicated over all vertices for a given primitive, and it is in fact possible to specify a cube with a vertex/normal array size of only eight entries. Look up the command glProvokingVertex which specifies which of the three vertices in a triangle, for example, that contains the flat-shaded attribute.

If you have for example a flat-shaded normal attribute in your vertex shader, and specify the last vertex as the provoking vertex, then the last vertex is the one containing the normal for all three vertices. The first two vertices effectively contains unused normal data and you should be able to take advantage of that to reduce the size of the vertex arrays.

//     7-----6
//    /|    /|
//   3-----2 |
//   | 4---|-5 
//   |/    |/
//   0-----1
 
    vector3 p[] = {
       { -1, -1, -1},
       {  1, -1, -1},
       {  1,  1, -1},
       { -1,  1, -1},
       { -1, -1,  1},
       {  1, -1,  1},
       {  1,  1,  1},
       { -1,  1,  1},
    };
 
    vector3 n[] = {
       {  0, -1,  0},
       {  1,  0,  0},
       {  0,  0, -1},
       { -1,  0,  0},
       {  0,  0,  0},
       {  0,  0,  0},
       {  0,  1,  0},
       {  0,  0,  1},
    };
 
    int index[] = {
        0,1,2,3,0,2,
        5,6,1,6,2,1,
        5,4,7,6,5,7,
        4,0,3,7,4,3,
        3,2,6,7,3,6,
        5,4,0,1,5,0,
    };

Try and see if this works, I don't have the possibility to try it myself at the moment. The index list is a list for 12 CCW-winded triangles building the cube in the comment at the top of the code.

If you only need to draw parts of the cube, you can truncate the index list accordingly.

void ProceduralCubeVS(uint iid: SV_VertexID,
  out float3 position   : POSITION,
  out float2 tex        : TEXCOORD,
  out float3 normal     : NORMAL,    
  out float4 positionCS : SV_Position)
{
    uint face = iid / 6;
    uint index = iid % 6;
    float sign = face >= 3 ? 1 : -1;
    uint dir = face % 3;
    normal = float3(dir.xxx == uint3(0,1,2));
    float3 t = normal.yzx;
    float3 b = normal.zxy;

    const uint FSQIDS[] = {0,1,2,1,3,2};    
    uint id = FSQIDS[index];
    tex = float2(id & 1, (id >> 1) & 1);
    float2 fsq = float2(tex * float2(1,-1) + float2(-0.5,0.5));    
    normal *= sign;
    position = float3(fsq.x * t + sign * fsq.y * b + 0.5 * normal);

    positionCS = mul(float4(position,1), WorldViewProjection);
    position = mul(float4(position, 1), World).xyz;    
    normal = mul(normal, (float3x3)World).xyz;    
}

@BrotherBob: Your suggestion is very interesting! I will surely try that as soon as i find time!

@Samith: I will try this as well and see what impact on performance it has and then see what balances out better, thanks for the tipp!

@unbird: Hehe, that looks interesting, but need to have a closer look at it first :D