1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
#version 430
#extension GL_3DL_array_objects : enable
out Vertex {
vec4 Position; // API transform/feedback will use “Vertex.Position”
vec2 Texture;
} Coords; // shader will use “Coords.Position”
out Vertex2 {
vec4 Color; // API will use “Color”
};
uniform Transform { // API uses “Transform[2]” to refer to instance 2
mat4 ModelViewMatrix;
mat4 ModelViewProjectionMatrix;
vec4 a[]; // array will get implicitly sized
float Deformation;
} transforms[4];
layout(location = 3) in vec4 normal;
layout(location = 6) in vec4 colors[3];
layout(location = 9) in mat4 transforms2[2];
layout(location = 3) struct S {
vec3 a1;
mat2 b;
vec4 c[2];
} s;
layout(triangles, invocations = 6) in;
layout(lines) in; // legal for Color2, input size is 2, matching Color2
layout(triangle_strip, max_vertices = 60) out; // order does not matter
layout(max_vertices = 60) out; // redeclaration okay
layout(triangle_strip) out; // redeclaration okay
//layout(points) out; // error, contradicts triangle_strip
//layout(max_vertices = 30) out; // error, contradicts 60
layout(stream = 1) out;
layout(stream=1) out; // default is now stream 1
out vec4 var1; // var1 gets default stream (1)
layout(stream=2) out Block1 { // "Block1" belongs to stream 2
layout(stream=2) vec4 var2; // redundant block member stream decl
layout(stream=3) vec2 var3; // ILLEGAL (must match block stream)
vec3 var4; // belongs to stream 2
};
layout(stream=0) out; // default is now stream 0
out vec4 var5; // var5 gets default stream (0)
out Block2 { // "Block2" gets default stream (0)
vec4 var6;
};
layout(stream=3) out vec4 var7; // var7 belongs to stream 3
layout(shared, column_major) uniform;
layout(shared, column_major) buffer;
layout(row_major, column_major)
layout(shared, row_major) uniform; // default is now shared and row_major
layout(std140) uniform Transform2 { // layout of this block is std140
mat4 M1; // row_major
layout(column_major) mat4 M2; // column major
mat3 N1; // row_major
};
layout(column_major) uniform T3 { // shared and column_major
mat4 M13; // column_major
layout(row_major) mat4 m14; // row major
mat3 N12; // column_major
};
// in one compilation unit...
layout(binding=3) uniform sampler2D s17; // s bound to unit 3
// in another compilation unit...
uniform sampler2D s17; // okay, s still bound at 3
// in another compilation unit...
//layout(binding=4) uniform sampler2D s; // ERROR: contradictory bindings
layout (binding = 2, offset = 4) uniform atomic_uint a2;
layout (binding = 2) uniform atomic_uint bar;
layout (binding = 2, offset = 4) uniform atomic_uint;
layout (binding = 2) uniform atomic_uint bar; // offset is 4
layout (offset = 8) uniform atomic_uint bar23; // error, no default binding
layout (binding=3, offset=4) uniform atomic_uint a2; // offset = 4
layout (binding=2) uniform atomic_uint b2; // offset = 0
layout (binding=3) uniform atomic_uint c2; // offset = 8
layout (binding=2) uniform atomic_uint d2; // offset = 4
//layout (offset=4) // error, must include binding
//layout (binding=1, offset=0) a; // okay
//layout (binding=2, offset=0) b; // okay
//layout (binding=1, offset=0) c; // error, offsets must not be shared
// // between a and c
//layout (binding=1, offset=2) d; // error, overlaps offset 0 of a
flat in vec4 gl_FrontColor; // input to geometry shader, no “gl_in[]”
flat out vec4 gl_FrontColor; // output from geometry shader
invariant gl_Position; // make existing gl_Position be invariant
out vec3 ColorInv;
invariant ColorIvn; // make existing Color be invariant
invariant centroid out vec3 Color4;
precise out vec4 position;
out vec3 Color5;
precise Color5; // make existing Color be precise
in vec4 a, b, c, d;
precise out vec4 v;
coherent buffer Block {
readonly vec4 member1;
vec4 member2;
};
buffer Block2a {
coherent readonly vec4 member1A;
coherent vec4 member2A;
};
shared vec4 shv;
vec4 funcA(restrict image2D a) { }
vec4 funcB(image2D a) { }
layout(rgba32f) uniform image2D img1;
layout(rgba32f) coherent uniform image2D img2;
float func(float e, float f, float g, float h)
{
return (e*f) + (g*h); // no constraint on order or
// operator consistency
}
float func2(float e, float f, float g, float h)
{
precise float result = (e*f) + (g*h); // ensures same precision for
// the two multiplies
return result;
}
float func3(float i, float j, precise out float k)
{
k = i * i + j; // precise, due to <k> declaration
}
void main()
{
vec3 r = vec3(a * b); // precise, used to compute v.xyz
vec3 s = vec3(c * d); // precise, used to compute v.xyz
v.xyz = r + s; // precise
v.w = (a.w * b.w) + (c.w * d.w); // precise
v.x = func(a.x, b.x, c.x, d.x); // values computed in func()
// are NOT precise
v.x = func2(a.x, b.x, c.x, d.x); // precise!
func3(a.x * b.x, c.x * d.x, v.x); // precise!
funcA(img1); // OK, adding "restrict" is allowed
funcB(img2); // illegal, stripping "coherent" is not
{
struct light {
float intensity;
vec3 position;
};
light lightVar = light(3.0, vec3(1.0, 2.0, 3.0));
}
{
const float c[3] = float[3](5.0, 7.2, 1.1);
const float d[3] = float[](5.0, 7.2, 1.1);
float g;
float a[5] = float[5](g, 1, g, 2.3, g);
float b[3];
b = float[3](g, g + 1.0, g + 2.0);
}
{
vec4 b[2] = { vec4(1.0), vec4(1.0) };
vec4[3][2](b, b, b); // constructor
vec4[][2](b, b, b); // constructor, valid, size deduced
vec4[3][](b, b, b); // compile-time error, invalid type constructed
}
}
|