Aligning structures to std140, CPU side

Question

I suppose this is a kind-of cross between a pure C++ question and an OpenGL question. I have a uniform buffer and am allocating space in it of sizeof(ShaderData) bytes. I'm using std140 layout on the GPU side in the shader.

According to std140 rules, I need to add padding in various places in my structure to make sure things like vectors are aligned correctly. The structure below is an example (for my light):

struct ShaderData {

    float Light_Intensity;  
    float _pad1[3];    // align following vec3 on 4N boundary
    Math::Vec3f Light_Position;
    float _pad2;       // align following vec4 on 4N boundary
    Math::Colour4f Light_Ambient;
    Math::Colour4f Light_Diffuse;
    Math::Colour4f Light_Specular;    
    float Light_AttenuationMin;
    float Light_AttenuationMax;

} MyShaderData;

Is this the way people generally do things in C++, or are there special keywords or pragmas for aligning individual elements of a structure CPU side that are a little tidier?

Answer 1

No, in this way you just waste space. You have to find the optimized layout according to std140 rules.

• a float needs 4 bytes and it's 4 bytes aligned
• a vec3 needs 12 bytes and it's 16 bytes aligned
• a vec4 needs 16 bytes and it's 16 bytes aligned

This means that you can find a better layout for your struct:

float Light_Intensity;          X
float _pad1[3];                  XXX
Math::Vec3f Light_Position;         XXX
float _pad2;                           X

As you can see you are wasting 4 bytes and what's worse is the fact that you can just do something like:

Math::Vec3f Light_Position      XXX
float Light_Intensity;             X

To have it aligned and without the need to waste a byte. This works because vec3 will be aligned to 16 bytes boundaries while the float will be still aligned to 4 bytes boundaries.