8

I'm using the compute shader bound with a SSAO. And I use the following structure in the compute shader:

struct Particle                 
{                       
    vec4 pAnds;                     
    vec3 velocity;                  
    float lifespan;             
    float age;                  
};

layout (std430, binding = 0) buffer members_in
{
    Particle particle[];
} input_data;

yet it seems that the memory block allocated for each of these data structure is not equal to (4 + 3 + 1 + 1) * 4. And I also tried another one:

struct Particle                 
{                       
    vec4 pAnds;                     
    vec3 velocity;                  
    float lifespan;             
};

This time it worked fine. I was wondering how the memory is allocated with std430 qualifier. How to make my first data structure work just as the second one?

updated: I changed it to the following form:

struct Particle
{                           
    float px, py, pz, s;
    float vx, vy, vz;
    float lifespan;
    float age;
};

This time it worked fine, but I still have no idea why there's problem using vec4 / vec3.

vallentin
  • 23,478
  • 6
  • 59
  • 81
Oscar
  • 1,993
  • 2
  • 18
  • 27
  • I'm not sure but I think each particle needs to be aligned to a 16 byte boundary (assuming you're running on x86) if you've got an array of particles there. Your second example does this (4 * 4 + 3 * 4 + 1 * 4) = 32. Your first example doesn't (4 * 4 + 3 * 4 + 1 * 4 + 1 * 4) = 36. So I think you may need to add 1 float of padding. – Robinson Apr 09 '15 at 08:58
  • ... or even 3 floats of padding actually. – Robinson Apr 09 '15 at 10:32
  • @Robinson I used four float instead of vec4, and three float instead of vec3, and it turned out to be correct. – Oscar Apr 09 '15 at 10:46
  • Yes, the alignment will be 1 rather than 4 (vec4) if you use floats. Though I'm not sure if that affects performance. – Robinson Apr 09 '15 at 10:50

1 Answers1

14

From the std430 Layout Rules:

Structure alignment is the same as the alignment for the biggest structure member, where three-component vectors are not rounded up to the size of four-component vectors. Each structure will start on this alignment, and its size will be the space needed by its members, according to the previous rules, rounded up to a multiple of the structure alignment.

The alignments for vec4 is four times the size of float.

Source: OpenGL Programming Guide, 8th Edition

First example:

struct Particle {
    vec4 pAnds;      // 4 * 4 bytes
    vec3 velocity;   // 3 * 4 bytes
    float lifespan;  // 1 * 4 bytes
    float age;       // 1 * 4 bytes
};

The biggest member of the structure is vec4 pAnds and it has 16 byte alignment. Therefore the structure's alignment is also 16 bytes, meaning, that inside an array each structure has to start at a position multiple of 16. In order to satisfy that, a 12 byte padding will be appended to the end of each structure.

Second example:

struct Particle {
    vec4 pAnds;      // 4 * 4 bytes
    vec3 velocity;   // 3 * 4 bytes
    float lifespan;  // 1 * 4 bytes
};

The structure has an alignment of 16 bytes and the size of the structure nicely fits into 2 times the alignment of the structure.

Third example:

struct Particle {
    float px, py, pz, s;
    float vx, vy, vz;
    float lifespan;
    float age;
};

The structure doesn't have any elements bigger than one size of float, therefore the alignment of the structure is only 4 bytes.

The workaround could be inserting an array of floats as an explicit padding or trying to pack your data tightly into a size multiple of the structure's alignment.

aethe
  • 308
  • 2
  • 10