OpenGL.GL.ARB.enhanced_layouts

OpenGL extension ARB.enhanced_layouts

This module customises the behaviour of the OpenGL.raw.GL.ARB.enhanced_layouts to provide a more Python-friendly API

Overview (from the spec)

This extension adds the following functionality to layout qualifiers, including broadening the API where this functionality is reflected.

The following are added:

1) Use compile-time constant expressions. E.g.,

const int start = 6; layout(location = start + 2) int vec4 v;

2) Specify explicit byte offsets within a uniform or shader storage block. For example, if you want two vec4 variables "batman" and "robin" to appear at byte offsets 0 and 64 in your block, you can say:

uniform Block { layout(offset = 0) vec4 batman; layout(offset = 64) vec4 robin; };

3) Force alignment within a uniform or shader storage block. The previous example could also be expressed:

uniform Block { vec4 batman; layout(align = 64) vec4 robin; };

This says the member 'robin' must start at the next address that is a multiple of 64. It allows constructing the same layout in C and in GLSL without inventing explicit offsets.

Explicit offsets and aligned offsets can be combined:

uniform Block { vec4 batman; layout(offset = 44, align = 8) vec4 robin; };

would make 'robin' be at the first 8-byte aligned address, starting at 44, which is 48. This is more useful when using the *align* at the block level, which will apply to all members.

4) Specify component numbers to more fully utilize the vec4-slot interfaces between shader outputs and shader inputs.

For example, you could fit the following

into the space of 32 vec4 slots using the following code:

// consume X/Y/Z components of 32 vectors layout(location = 0) in vec3 batman[32];

// consumes W component of first vector layout(location = 0, component = 3) in float robin;

Further, an array of vec3 and an array of float can be stored interleaved, using the following.

// consumes W component of 32 vectors layout(location = 0, component = 3) in float robin[32];

// consume X/Y/Z components of 32 vectors layout(location = 0) in vec3 batman[32];

5) Specify transform/feedback buffers, locations, and widths. For example:

layout(xfb_buffer = 0, xfb_offset = 0) out vec3 var1; layout(xfb_buffer = 0, xfb_offset = 24) out vec3 var2; layout(xfb_buffer = 1, xfb_offset = 0) out vec4 var3;

The second line above says to write var2 out to byte offset 24 of transform/feedback buffer 0. (When doing this, output are only captured when xfb_offset is used.)

To specify the total number of bytes per entry in a buffer:

layout(xfb_buffer = 1, xfb_stride = 32) out;

This is necessary if, say, var3 above, which uses bytes 0-11, does not fully fill the buffer, which in this case takes 32 bytes.

Use of this feature effectively eliminates the need to use previously existing API commands to describe the transform feedback layout.

6) Allow locations on input and output blocks for SSO interface matching.

For example:

layout(location = 4) in block { vec4 batman; // gets location 4 vec4 robin; // gets location 5 layout(location = 7) vec4 joker; // gets location 7 vec4 riddler; // location 8 };

The official definition of this extension is available here: http://www.opengl.org/registry/specs/ARB/enhanced_layouts.txt