← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mesa/quantal

« back to all changes in this revision

Viewing changes to src/glsl/builtins/profiles/130.glsl

  • Committer: Package Import Robot
  • Author(s): Timo Aaltonen
  • Date: 2012-08-23 15:37:30 UTC
  • mfrom: (1.7.6)
  • Revision ID: package-import@ubuntu.com-20120823153730-c499sefj7btu4386
Tags: 9.0~git20120821.c1114c61-0ubuntu1
https://launchpad.net/bugs/1009089
* Merge from unreleased debian git.
  - Includes support for ATI Trinity PCI IDs (LP: #1009089)
* rules, control, libgl1-mesa-swx11*: Remove swx11 support.
* Refresh patches:
  - drop 115_llvm_dynamic_linking.diff,
    117_nullptr_check_in_query_version.patch, and
    118_glsl_initialize_samplers.patch, all upstream
  - disable 116_use_shared_galliumcore.diff until it's reviewed and
    reworked to apply
* not-installed, libegl1-mesa-drivers-install.linux.in: Updated to
  match the single-pass build.
* libgl1-mesa-dri.*install.in: Drop libglsl.so, it's included in
  libdricore.so now.
* rules: Don't disable GLU on the common flags, we need to build it
  on the dri target.
* libglu*install.in: Fix the source file paths to match the build target.
  Drop the static lib from -dev since only shared libs get built.
* libgl1-mesa-dev.install.in: Fix the source file paths to match the
  build target.
* libgl1-mesa-dri.install.linux.in: Don't try to install libgallium.so,
  which isn't built yet.
* rules: Enable llvmpipe on armhf to see if it works or not.
* rules: Remove bin/install-sh on clean, and don't create a symlink for
  it.
* control: Add Pre-Depends on dpkg-dev due to the binaries using xz
  compression.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/glsl/builtins/profiles/130.glsl
 
1
#version 130
 
2
/*
 
3
 * 8.1 - Angle and Trigonometry Functions
 
4
 */
 
5
float radians(float degrees);
 
6
vec2  radians(vec2  degrees);
 
7
vec3  radians(vec3  degrees);
 
8
vec4  radians(vec4  degrees);
 
9
 
 
10
float degrees(float radians);
 
11
vec2  degrees(vec2  radians);
 
12
vec3  degrees(vec3  radians);
 
13
vec4  degrees(vec4  radians);
 
14
 
 
15
float sin(float angle);
 
16
vec2  sin(vec2  angle);
 
17
vec3  sin(vec3  angle);
 
18
vec4  sin(vec4  angle);
 
19
 
 
20
float cos(float angle);
 
21
vec2  cos(vec2  angle);
 
22
vec3  cos(vec3  angle);
 
23
vec4  cos(vec4  angle);
 
24
 
 
25
float tan(float angle);
 
26
vec2  tan(vec2  angle);
 
27
vec3  tan(vec3  angle);
 
28
vec4  tan(vec4  angle);
 
29
 
 
30
float asin(float angle);
 
31
vec2  asin(vec2  angle);
 
32
vec3  asin(vec3  angle);
 
33
vec4  asin(vec4  angle);
 
34
 
 
35
float acos(float angle);
 
36
vec2  acos(vec2  angle);
 
37
vec3  acos(vec3  angle);
 
38
vec4  acos(vec4  angle);
 
39
 
 
40
float atan(float y, float x);
 
41
vec2  atan(vec2  y, vec2  x);
 
42
vec3  atan(vec3  y, vec3  x);
 
43
vec4  atan(vec4  y, vec4  x);
 
44
 
 
45
float atan(float y_over_x);
 
46
vec2  atan(vec2  y_over_x);
 
47
vec3  atan(vec3  y_over_x);
 
48
vec4  atan(vec4  y_over_x);
 
49
 
 
50
float sinh(float x);
 
51
vec2  sinh(vec2  x);
 
52
vec3  sinh(vec3  x);
 
53
vec4  sinh(vec4  x);
 
54
 
 
55
float cosh(float x);
 
56
vec2  cosh(vec2  x);
 
57
vec3  cosh(vec3  x);
 
58
vec4  cosh(vec4  x);
 
59
 
 
60
float tanh(float x);
 
61
vec2  tanh(vec2  x);
 
62
vec3  tanh(vec3  x);
 
63
vec4  tanh(vec4  x);
 
64
 
 
65
float asinh(float x);
 
66
vec2  asinh(vec2  x);
 
67
vec3  asinh(vec3  x);
 
68
vec4  asinh(vec4  x);
 
69
 
 
70
float acosh(float x);
 
71
vec2  acosh(vec2  x);
 
72
vec3  acosh(vec3  x);
 
73
vec4  acosh(vec4  x);
 
74
 
 
75
float atanh(float x);
 
76
vec2  atanh(vec2  x);
 
77
vec3  atanh(vec3  x);
 
78
vec4  atanh(vec4  x);
 
79
 
 
80
/*
 
81
 * 8.2 - Exponential Functions
 
82
 */
 
83
float pow(float x, float y);
 
84
vec2  pow(vec2  x, vec2  y);
 
85
vec3  pow(vec3  x, vec3  y);
 
86
vec4  pow(vec4  x, vec4  y);
 
87
 
 
88
float exp(float x);
 
89
vec2  exp(vec2  x);
 
90
vec3  exp(vec3  x);
 
91
vec4  exp(vec4  x);
 
92
 
 
93
float log(float x);
 
94
vec2  log(vec2  x);
 
95
vec3  log(vec3  x);
 
96
vec4  log(vec4  x);
 
97
 
 
98
float exp2(float x);
 
99
vec2  exp2(vec2  x);
 
100
vec3  exp2(vec3  x);
 
101
vec4  exp2(vec4  x);
 
102
 
 
103
float log2(float x);
 
104
vec2  log2(vec2  x);
 
105
vec3  log2(vec3  x);
 
106
vec4  log2(vec4  x);
 
107
 
 
108
float sqrt(float x);
 
109
vec2  sqrt(vec2  x);
 
110
vec3  sqrt(vec3  x);
 
111
vec4  sqrt(vec4  x);
 
112
 
 
113
float inversesqrt(float x);
 
114
vec2  inversesqrt(vec2  x);
 
115
vec3  inversesqrt(vec3  x);
 
116
vec4  inversesqrt(vec4  x);
 
117
 
 
118
/*
 
119
 * 8.3 - Common Functions
 
120
 */
 
121
float abs(float x);
 
122
vec2  abs(vec2  x);
 
123
vec3  abs(vec3  x);
 
124
vec4  abs(vec4  x);
 
125
int   abs(int   x);
 
126
ivec2 abs(ivec2 x);
 
127
ivec3 abs(ivec3 x);
 
128
ivec4 abs(ivec4 x);
 
129
 
 
130
float sign(float x);
 
131
vec2  sign(vec2  x);
 
132
vec3  sign(vec3  x);
 
133
vec4  sign(vec4  x);
 
134
int   sign(int   x);
 
135
ivec2 sign(ivec2 x);
 
136
ivec3 sign(ivec3 x);
 
137
ivec4 sign(ivec4 x);
 
138
 
 
139
float floor(float x);
 
140
vec2  floor(vec2  x);
 
141
vec3  floor(vec3  x);
 
142
vec4  floor(vec4  x);
 
143
 
 
144
float trunc(float x);
 
145
vec2  trunc(vec2  x);
 
146
vec3  trunc(vec3  x);
 
147
vec4  trunc(vec4  x);
 
148
 
 
149
float round(float x);
 
150
vec2  round(vec2  x);
 
151
vec3  round(vec3  x);
 
152
vec4  round(vec4  x);
 
153
 
 
154
float roundEven(float x);
 
155
vec2  roundEven(vec2  x);
 
156
vec3  roundEven(vec3  x);
 
157
vec4  roundEven(vec4  x);
 
158
 
 
159
float ceil(float x);
 
160
vec2  ceil(vec2  x);
 
161
vec3  ceil(vec3  x);
 
162
vec4  ceil(vec4  x);
 
163
 
 
164
float fract(float x);
 
165
vec2  fract(vec2  x);
 
166
vec3  fract(vec3  x);
 
167
vec4  fract(vec4  x);
 
168
 
 
169
float mod(float x, float y);
 
170
vec2  mod(vec2  x, float y);
 
171
vec3  mod(vec3  x, float y);
 
172
vec4  mod(vec4  x, float y);
 
173
 
 
174
vec2  mod(vec2  x, vec2  y);
 
175
vec3  mod(vec3  x, vec3  y);
 
176
vec4  mod(vec4  x, vec4  y);
 
177
 
 
178
float modf(float x, out float i);
 
179
vec2  modf(vec2  x, out vec2  i);
 
180
vec3  modf(vec3  x, out vec3  i);
 
181
vec4  modf(vec4  x, out vec4  i);
 
182
 
 
183
float min(float x, float y);
 
184
vec2  min(vec2  x, vec2  y);
 
185
vec3  min(vec3  x, vec3  y);
 
186
vec4  min(vec4  x, vec4  y);
 
187
 
 
188
vec2  min(vec2  x, float y);
 
189
vec3  min(vec3  x, float y);
 
190
vec4  min(vec4  x, float y);
 
191
 
 
192
int   min(int   x, int   y);
 
193
ivec2 min(ivec2 x, ivec2 y);
 
194
ivec3 min(ivec3 x, ivec3 y);
 
195
ivec4 min(ivec4 x, ivec4 y);
 
196
 
 
197
ivec2 min(ivec2 x, int   y);
 
198
ivec3 min(ivec3 x, int   y);
 
199
ivec4 min(ivec4 x, int   y);
 
200
 
 
201
uint  min(uint  x, uint  y);
 
202
uvec2 min(uvec2 x, uvec2 y);
 
203
uvec3 min(uvec3 x, uvec3 y);
 
204
uvec4 min(uvec4 x, uvec4 y);
 
205
 
 
206
uvec2 min(uvec2 x, uint  y);
 
207
uvec3 min(uvec3 x, uint  y);
 
208
uvec4 min(uvec4 x, uint  y);
 
209
 
 
210
float max(float x, float y);
 
211
vec2  max(vec2  x, vec2  y);
 
212
vec3  max(vec3  x, vec3  y);
 
213
vec4  max(vec4  x, vec4  y);
 
214
 
 
215
vec2  max(vec2  x, float y);
 
216
vec3  max(vec3  x, float y);
 
217
vec4  max(vec4  x, float y);
 
218
 
 
219
int   max(int   x, int   y);
 
220
ivec2 max(ivec2 x, ivec2 y);
 
221
ivec3 max(ivec3 x, ivec3 y);
 
222
ivec4 max(ivec4 x, ivec4 y);
 
223
 
 
224
ivec2 max(ivec2 x, int   y);
 
225
ivec3 max(ivec3 x, int   y);
 
226
ivec4 max(ivec4 x, int   y);
 
227
 
 
228
uint  max(uint  x, uint  y);
 
229
uvec2 max(uvec2 x, uvec2 y);
 
230
uvec3 max(uvec3 x, uvec3 y);
 
231
uvec4 max(uvec4 x, uvec4 y);
 
232
 
 
233
uvec2 max(uvec2 x, uint  y);
 
234
uvec3 max(uvec3 x, uint  y);
 
235
uvec4 max(uvec4 x, uint  y);
 
236
 
 
237
float clamp(float x, float minVal, float maxVal);
 
238
vec2  clamp(vec2  x, vec2  minVal, vec2  maxVal);
 
239
vec3  clamp(vec3  x, vec3  minVal, vec3  maxVal);
 
240
vec4  clamp(vec4  x, vec4  minVal, vec4  maxVal);
 
241
 
 
242
vec2  clamp(vec2  x, float minVal, float maxVal);
 
243
vec3  clamp(vec3  x, float minVal, float maxVal);
 
244
vec4  clamp(vec4  x, float minVal, float maxVal);
 
245
 
 
246
int   clamp(int   x, int   minVal, int   maxVal);
 
247
ivec2 clamp(ivec2 x, ivec2 minVal, ivec2 maxVal);
 
248
ivec3 clamp(ivec3 x, ivec3 minVal, ivec3 maxVal);
 
249
ivec4 clamp(ivec4 x, ivec4 minVal, ivec4 maxVal);
 
250
 
 
251
ivec2 clamp(ivec2 x, int   minVal, int   maxVal);
 
252
ivec3 clamp(ivec3 x, int   minVal, int   maxVal);
 
253
ivec4 clamp(ivec4 x, int   minVal, int   maxVal);
 
254
 
 
255
uint  clamp(uint  x, uint  minVal, uint  maxVal);
 
256
uvec2 clamp(uvec2 x, uvec2 minVal, uvec2 maxVal);
 
257
uvec3 clamp(uvec3 x, uvec3 minVal, uvec3 maxVal);
 
258
uvec4 clamp(uvec4 x, uvec4 minVal, uvec4 maxVal);
 
259
 
 
260
uvec2 clamp(uvec2 x, uint  minVal, uint  maxVal);
 
261
uvec3 clamp(uvec3 x, uint  minVal, uint  maxVal);
 
262
uvec4 clamp(uvec4 x, uint  minVal, uint  maxVal);
 
263
 
 
264
float mix(float x, float y, float a);
 
265
vec2  mix(vec2  x, vec2  y, vec2  a);
 
266
vec3  mix(vec3  x, vec3  y, vec3  a);
 
267
vec4  mix(vec4  x, vec4  y, vec4  a);
 
268
 
 
269
vec2  mix(vec2  x, vec2  y, float a);
 
270
vec3  mix(vec3  x, vec3  y, float a);
 
271
vec4  mix(vec4  x, vec4  y, float a);
 
272
 
 
273
float mix(float x, float y, bool  a);
 
274
vec2  mix(vec2  x, vec2  y, bvec2 a);
 
275
vec3  mix(vec3  x, vec3  y, bvec3 a);
 
276
vec4  mix(vec4  x, vec4  y, bvec4 a);
 
277
 
 
278
float step(float edge, float x);
 
279
vec2  step(vec2  edge, vec2  x);
 
280
vec3  step(vec3  edge, vec3  x);
 
281
vec4  step(vec4  edge, vec4  x);
 
282
 
 
283
vec2  step(float edge, vec2  x);
 
284
vec3  step(float edge, vec3  x);
 
285
vec4  step(float edge, vec4  x);
 
286
 
 
287
float smoothstep(float edge0, float edge1, float x);
 
288
vec2  smoothstep(vec2  edge0, vec2  edge1, vec2  x);
 
289
vec3  smoothstep(vec3  edge0, vec3  edge1, vec3  x);
 
290
vec4  smoothstep(vec4  edge0, vec4  edge1, vec4  x);
 
291
 
 
292
vec2  smoothstep(float edge0, float edge1, vec2  x);
 
293
vec3  smoothstep(float edge0, float edge1, vec3  x);
 
294
vec4  smoothstep(float edge0, float edge1, vec4  x);
 
295
 
 
296
bool  isnan(float x);
 
297
bvec2 isnan(vec2  x);
 
298
bvec3 isnan(vec3  x);
 
299
bvec4 isnan(vec4  x);
 
300
 
 
301
bool  isinf(float x);
 
302
bvec2 isinf(vec2  x);
 
303
bvec3 isinf(vec3  x);
 
304
bvec4 isinf(vec4  x);
 
305
 
 
306
/*
 
307
 * 8.4 - Geometric Functions
 
308
 */
 
309
float length(float x);
 
310
float length(vec2  x);
 
311
float length(vec3  x);
 
312
float length(vec4  x);
 
313
 
 
314
float distance(float p0, float p1);
 
315
float distance(vec2  p0, vec2  p1);
 
316
float distance(vec3  p0, vec3  p1);
 
317
float distance(vec4  p0, vec4  p1);
 
318
 
 
319
float dot(float x, float y);
 
320
float dot(vec2  x, vec2  y);
 
321
float dot(vec3  x, vec3  y);
 
322
float dot(vec4  x, vec4  y);
 
323
 
 
324
vec3 cross(vec3 x, vec3 y);
 
325
 
 
326
float normalize(float x);
 
327
vec2  normalize(vec2  x);
 
328
vec3  normalize(vec3  x);
 
329
vec4  normalize(vec4  x);
 
330
 
 
331
float faceforward(float N, float I, float Nref);
 
332
vec2  faceforward(vec2  N, vec2  I, vec2  Nref);
 
333
vec3  faceforward(vec3  N, vec3  I, vec3  Nref);
 
334
vec4  faceforward(vec4  N, vec4  I, vec4  Nref);
 
335
 
 
336
float reflect(float I, float N);
 
337
vec2  reflect(vec2  I, vec2  N);
 
338
vec3  reflect(vec3  I, vec3  N);
 
339
vec4  reflect(vec4  I, vec4  N);
 
340
 
 
341
float refract(float I, float N, float eta);
 
342
vec2  refract(vec2  I, vec2  N, float eta);
 
343
vec3  refract(vec3  I, vec3  N, float eta);
 
344
vec4  refract(vec4  I, vec4  N, float eta);
 
345
 
 
346
 
 
347
/*
 
348
 * 8.5 - Matrix Functions
 
349
 */
 
350
mat2   matrixCompMult(mat2   x, mat2   y);
 
351
mat3   matrixCompMult(mat3   x, mat3   y);
 
352
mat4   matrixCompMult(mat4   x, mat4   y);
 
353
mat2x3 matrixCompMult(mat2x3 x, mat2x3 y);
 
354
mat2x4 matrixCompMult(mat2x4 x, mat2x4 y);
 
355
mat3x2 matrixCompMult(mat3x2 x, mat3x2 y);
 
356
mat3x4 matrixCompMult(mat3x4 x, mat3x4 y);
 
357
mat4x2 matrixCompMult(mat4x2 x, mat4x2 y);
 
358
mat4x3 matrixCompMult(mat4x3 x, mat4x3 y);
 
359
 
 
360
mat2   outerProduct(vec2 c, vec2 r);
 
361
mat3   outerProduct(vec3 c, vec3 r);
 
362
mat4   outerProduct(vec4 c, vec4 r);
 
363
 
 
364
mat2x3 outerProduct(vec3 c, vec2 r);
 
365
mat3x2 outerProduct(vec2 c, vec3 r);
 
366
 
 
367
mat2x4 outerProduct(vec4 c, vec2 r);
 
368
mat4x2 outerProduct(vec2 c, vec4 r);
 
369
 
 
370
mat3x4 outerProduct(vec4 c, vec3 r);
 
371
mat4x3 outerProduct(vec3 c, vec4 r);
 
372
 
 
373
mat2   transpose(mat2 m);
 
374
mat3   transpose(mat3 m);
 
375
mat4   transpose(mat4 m);
 
376
 
 
377
mat2x3 transpose(mat3x2 m);
 
378
mat3x2 transpose(mat2x3 m);
 
379
 
 
380
mat2x4 transpose(mat4x2 m);
 
381
mat4x2 transpose(mat2x4 m);
 
382
 
 
383
mat3x4 transpose(mat4x3 m);
 
384
mat4x3 transpose(mat3x4 m);
 
385
 
 
386
/*
 
387
 * 8.6 - Vector Relational Functions
 
388
 */
 
389
bvec2 lessThan( vec2 x,  vec2 y);
 
390
bvec3 lessThan( vec3 x,  vec3 y);
 
391
bvec4 lessThan( vec4 x,  vec4 y);
 
392
bvec2 lessThan(ivec2 x, ivec2 y);
 
393
bvec3 lessThan(ivec3 x, ivec3 y);
 
394
bvec4 lessThan(ivec4 x, ivec4 y);
 
395
bvec2 lessThan(uvec2 x, uvec2 y);
 
396
bvec3 lessThan(uvec3 x, uvec3 y);
 
397
bvec4 lessThan(uvec4 x, uvec4 y);
 
398
 
 
399
bvec2 lessThanEqual( vec2 x,  vec2 y);
 
400
bvec3 lessThanEqual( vec3 x,  vec3 y);
 
401
bvec4 lessThanEqual( vec4 x,  vec4 y);
 
402
bvec2 lessThanEqual(ivec2 x, ivec2 y);
 
403
bvec3 lessThanEqual(ivec3 x, ivec3 y);
 
404
bvec4 lessThanEqual(ivec4 x, ivec4 y);
 
405
bvec2 lessThanEqual(uvec2 x, uvec2 y);
 
406
bvec3 lessThanEqual(uvec3 x, uvec3 y);
 
407
bvec4 lessThanEqual(uvec4 x, uvec4 y);
 
408
 
 
409
bvec2 greaterThan( vec2 x,  vec2 y);
 
410
bvec3 greaterThan( vec3 x,  vec3 y);
 
411
bvec4 greaterThan( vec4 x,  vec4 y);
 
412
bvec2 greaterThan(ivec2 x, ivec2 y);
 
413
bvec3 greaterThan(ivec3 x, ivec3 y);
 
414
bvec4 greaterThan(ivec4 x, ivec4 y);
 
415
bvec2 greaterThan(uvec2 x, uvec2 y);
 
416
bvec3 greaterThan(uvec3 x, uvec3 y);
 
417
bvec4 greaterThan(uvec4 x, uvec4 y);
 
418
 
 
419
bvec2 greaterThanEqual( vec2 x,  vec2 y);
 
420
bvec3 greaterThanEqual( vec3 x,  vec3 y);
 
421
bvec4 greaterThanEqual( vec4 x,  vec4 y);
 
422
bvec2 greaterThanEqual(ivec2 x, ivec2 y);
 
423
bvec3 greaterThanEqual(ivec3 x, ivec3 y);
 
424
bvec4 greaterThanEqual(ivec4 x, ivec4 y);
 
425
bvec2 greaterThanEqual(uvec2 x, uvec2 y);
 
426
bvec3 greaterThanEqual(uvec3 x, uvec3 y);
 
427
bvec4 greaterThanEqual(uvec4 x, uvec4 y);
 
428
 
 
429
bvec2 equal( vec2 x,  vec2 y);
 
430
bvec3 equal( vec3 x,  vec3 y);
 
431
bvec4 equal( vec4 x,  vec4 y);
 
432
bvec2 equal(ivec2 x, ivec2 y);
 
433
bvec3 equal(ivec3 x, ivec3 y);
 
434
bvec4 equal(ivec4 x, ivec4 y);
 
435
bvec2 equal(uvec2 x, uvec2 y);
 
436
bvec3 equal(uvec3 x, uvec3 y);
 
437
bvec4 equal(uvec4 x, uvec4 y);
 
438
bvec2 equal(bvec2 x, bvec2 y);
 
439
bvec3 equal(bvec3 x, bvec3 y);
 
440
bvec4 equal(bvec4 x, bvec4 y);
 
441
 
 
442
bvec2 notEqual( vec2 x,  vec2 y);
 
443
bvec3 notEqual( vec3 x,  vec3 y);
 
444
bvec4 notEqual( vec4 x,  vec4 y);
 
445
bvec2 notEqual(ivec2 x, ivec2 y);
 
446
bvec3 notEqual(ivec3 x, ivec3 y);
 
447
bvec4 notEqual(ivec4 x, ivec4 y);
 
448
bvec2 notEqual(uvec2 x, uvec2 y);
 
449
bvec3 notEqual(uvec3 x, uvec3 y);
 
450
bvec4 notEqual(uvec4 x, uvec4 y);
 
451
bvec2 notEqual(bvec2 x, bvec2 y);
 
452
bvec3 notEqual(bvec3 x, bvec3 y);
 
453
bvec4 notEqual(bvec4 x, bvec4 y);
 
454
 
 
455
bool any(bvec2 x);
 
456
bool any(bvec3 x);
 
457
bool any(bvec4 x);
 
458
 
 
459
bool all(bvec2 x);
 
460
bool all(bvec3 x);
 
461
bool all(bvec4 x);
 
462
 
 
463
bvec2 not(bvec2 x);
 
464
bvec3 not(bvec3 x);
 
465
bvec4 not(bvec4 x);
 
466
 
 
467
/*
 
468
 * 8.7 - Texture Lookup Functions
 
469
 */
 
470
 
 
471
/* textureSize */
 
472
int   textureSize( sampler1D sampler, int lod);
 
473
int   textureSize(isampler1D sampler, int lod);
 
474
int   textureSize(usampler1D sampler, int lod);
 
475
 
 
476
ivec2 textureSize( sampler2D sampler, int lod);
 
477
ivec2 textureSize(isampler2D sampler, int lod);
 
478
ivec2 textureSize(usampler2D sampler, int lod);
 
479
 
 
480
ivec3 textureSize( sampler3D sampler, int lod);
 
481
ivec3 textureSize(isampler3D sampler, int lod);
 
482
ivec3 textureSize(usampler3D sampler, int lod);
 
483
 
 
484
ivec2 textureSize( samplerCube sampler, int lod);
 
485
ivec2 textureSize(isamplerCube sampler, int lod);
 
486
ivec2 textureSize(usamplerCube sampler, int lod);
 
487
 
 
488
int   textureSize(sampler1DShadow   sampler, int lod);
 
489
ivec2 textureSize(sampler2DShadow   sampler, int lod);
 
490
ivec2 textureSize(samplerCubeShadow sampler, int lod);
 
491
 
 
492
ivec2 textureSize( sampler1DArray sampler, int lod);
 
493
ivec2 textureSize(isampler1DArray sampler, int lod);
 
494
ivec2 textureSize(usampler1DArray sampler, int lod);
 
495
ivec3 textureSize( sampler2DArray sampler, int lod);
 
496
ivec3 textureSize(isampler2DArray sampler, int lod);
 
497
ivec3 textureSize(usampler2DArray sampler, int lod);
 
498
 
 
499
ivec2 textureSize(sampler1DArrayShadow sampler, int lod);
 
500
ivec3 textureSize(sampler2DArrayShadow sampler, int lod);
 
501
 
 
502
/* texture - no bias */
 
503
 vec4 texture( sampler1D sampler, float P);
 
504
ivec4 texture(isampler1D sampler, float P);
 
505
uvec4 texture(usampler1D sampler, float P);
 
506
 
 
507
 vec4 texture( sampler2D sampler, vec2 P);
 
508
ivec4 texture(isampler2D sampler, vec2 P);
 
509
uvec4 texture(usampler2D sampler, vec2 P);
 
510
 
 
511
 vec4 texture( sampler3D sampler, vec3 P);
 
512
ivec4 texture(isampler3D sampler, vec3 P);
 
513
uvec4 texture(usampler3D sampler, vec3 P);
 
514
 
 
515
 vec4 texture( samplerCube sampler, vec3 P);
 
516
ivec4 texture(isamplerCube sampler, vec3 P);
 
517
uvec4 texture(usamplerCube sampler, vec3 P);
 
518
 
 
519
float texture(sampler1DShadow   sampler, vec3 P);
 
520
float texture(sampler2DShadow   sampler, vec3 P);
 
521
float texture(samplerCubeShadow sampler, vec4 P);
 
522
 
 
523
 vec4 texture( sampler1DArray sampler, vec2 P);
 
524
ivec4 texture(isampler1DArray sampler, vec2 P);
 
525
uvec4 texture(usampler1DArray sampler, vec2 P);
 
526
 
 
527
 vec4 texture( sampler2DArray sampler, vec3 P);
 
528
ivec4 texture(isampler2DArray sampler, vec3 P);
 
529
uvec4 texture(usampler2DArray sampler, vec3 P);
 
530
 
 
531
float texture(sampler1DArrayShadow sampler, vec3 P);
 
532
float texture(sampler2DArrayShadow sampler, vec4 P);
 
533
 
 
534
/* textureProj - no bias */
 
535
 vec4 textureProj( sampler1D sampler, vec2 P);
 
536
ivec4 textureProj(isampler1D sampler, vec2 P);
 
537
uvec4 textureProj(usampler1D sampler, vec2 P);
 
538
 vec4 textureProj( sampler1D sampler, vec4 P);
 
539
ivec4 textureProj(isampler1D sampler, vec4 P);
 
540
uvec4 textureProj(usampler1D sampler, vec4 P);
 
541
 
 
542
 vec4 textureProj( sampler2D sampler, vec3 P);
 
543
ivec4 textureProj(isampler2D sampler, vec3 P);
 
544
uvec4 textureProj(usampler2D sampler, vec3 P);
 
545
 vec4 textureProj( sampler2D sampler, vec4 P);
 
546
ivec4 textureProj(isampler2D sampler, vec4 P);
 
547
uvec4 textureProj(usampler2D sampler, vec4 P);
 
548
 
 
549
 vec4 textureProj( sampler3D sampler, vec4 P);
 
550
ivec4 textureProj(isampler3D sampler, vec4 P);
 
551
uvec4 textureProj(usampler3D sampler, vec4 P);
 
552
 
 
553
float textureProj(sampler1DShadow sampler, vec4 P);
 
554
float textureProj(sampler2DShadow sampler, vec4 P);
 
555
 
 
556
/* textureLod */
 
557
 vec4 textureLod( sampler1D sampler, float P, float lod);
 
558
ivec4 textureLod(isampler1D sampler, float P, float lod);
 
559
uvec4 textureLod(usampler1D sampler, float P, float lod);
 
560
 
 
561
 vec4 textureLod( sampler2D sampler, vec2 P, float lod);
 
562
ivec4 textureLod(isampler2D sampler, vec2 P, float lod);
 
563
uvec4 textureLod(usampler2D sampler, vec2 P, float lod);
 
564
 
 
565
 vec4 textureLod( sampler3D sampler, vec3 P, float lod);
 
566
ivec4 textureLod(isampler3D sampler, vec3 P, float lod);
 
567
uvec4 textureLod(usampler3D sampler, vec3 P, float lod);
 
568
 
 
569
 vec4 textureLod( samplerCube sampler, vec3 P, float lod);
 
570
ivec4 textureLod(isamplerCube sampler, vec3 P, float lod);
 
571
uvec4 textureLod(usamplerCube sampler, vec3 P, float lod);
 
572
 
 
573
float textureLod(sampler1DShadow sampler, vec3 P, float lod);
 
574
float textureLod(sampler2DShadow sampler, vec3 P, float lod);
 
575
 
 
576
 vec4 textureLod( sampler1DArray sampler, vec2 P, float lod);
 
577
ivec4 textureLod(isampler1DArray sampler, vec2 P, float lod);
 
578
uvec4 textureLod(usampler1DArray sampler, vec2 P, float lod);
 
579
 
 
580
 vec4 textureLod( sampler2DArray sampler, vec3 P, float lod);
 
581
ivec4 textureLod(isampler2DArray sampler, vec3 P, float lod);
 
582
uvec4 textureLod(usampler2DArray sampler, vec3 P, float lod);
 
583
 
 
584
float textureLod(sampler1DArrayShadow sampler, vec3 P, float lod);
 
585
 
 
586
/* textureOffset - no bias */
 
587
 vec4 textureOffset( sampler1D sampler, float P, int offset);
 
588
ivec4 textureOffset(isampler1D sampler, float P, int offset);
 
589
uvec4 textureOffset(usampler1D sampler, float P, int offset);
 
590
 
 
591
 vec4 textureOffset( sampler2D sampler, vec2 P, ivec2 offset);
 
592
ivec4 textureOffset(isampler2D sampler, vec2 P, ivec2 offset);
 
593
uvec4 textureOffset(usampler2D sampler, vec2 P, ivec2 offset);
 
594
 
 
595
 vec4 textureOffset( sampler3D sampler, vec3 P, ivec3 offset);
 
596
ivec4 textureOffset(isampler3D sampler, vec3 P, ivec3 offset);
 
597
uvec4 textureOffset(usampler3D sampler, vec3 P, ivec3 offset);
 
598
 
 
599
float textureOffset(sampler1DShadow sampler, vec3 P, int offset);
 
600
float textureOffset(sampler2DShadow sampler, vec3 P, ivec2 offset);
 
601
 
 
602
 vec4 textureOffset( sampler1DArray sampler, vec2 P, int offset);
 
603
ivec4 textureOffset(isampler1DArray sampler, vec2 P, int offset);
 
604
uvec4 textureOffset(usampler1DArray sampler, vec2 P, int offset);
 
605
 
 
606
 vec4 textureOffset( sampler2DArray sampler, vec3 P, ivec2 offset);
 
607
ivec4 textureOffset(isampler2DArray sampler, vec3 P, ivec2 offset);
 
608
uvec4 textureOffset(usampler2DArray sampler, vec3 P, ivec2 offset);
 
609
 
 
610
float textureOffset(sampler1DArrayShadow sampler, vec3 P, int offset);
 
611
 
 
612
/* texelFetch */
 
613
 vec4 texelFetch( sampler1D sampler, int P, int lod);
 
614
ivec4 texelFetch(isampler1D sampler, int P, int lod);
 
615
uvec4 texelFetch(usampler1D sampler, int P, int lod);
 
616
 
 
617
 vec4 texelFetch( sampler2D sampler, ivec2 P, int lod);
 
618
ivec4 texelFetch(isampler2D sampler, ivec2 P, int lod);
 
619
uvec4 texelFetch(usampler2D sampler, ivec2 P, int lod);
 
620
 
 
621
 vec4 texelFetch( sampler3D sampler, ivec3 P, int lod);
 
622
ivec4 texelFetch(isampler3D sampler, ivec3 P, int lod);
 
623
uvec4 texelFetch(usampler3D sampler, ivec3 P, int lod);
 
624
 
 
625
 vec4 texelFetch( sampler1DArray sampler, ivec2 P, int lod);
 
626
ivec4 texelFetch(isampler1DArray sampler, ivec2 P, int lod);
 
627
uvec4 texelFetch(usampler1DArray sampler, ivec2 P, int lod);
 
628
 
 
629
 vec4 texelFetch( sampler2DArray sampler, ivec3 P, int lod);
 
630
ivec4 texelFetch(isampler2DArray sampler, ivec3 P, int lod);
 
631
uvec4 texelFetch(usampler2DArray sampler, ivec3 P, int lod);
 
632
 
 
633
/* texelFetchOffset */
 
634
 vec4 texelFetchOffset( sampler1D sampler, int P, int lod, int offset);
 
635
ivec4 texelFetchOffset(isampler1D sampler, int P, int lod, int offset);
 
636
uvec4 texelFetchOffset(usampler1D sampler, int P, int lod, int offset);
 
637
 
 
638
 vec4 texelFetchOffset( sampler2D sampler, ivec2 P, int lod, ivec2 offset);
 
639
ivec4 texelFetchOffset(isampler2D sampler, ivec2 P, int lod, ivec2 offset);
 
640
uvec4 texelFetchOffset(usampler2D sampler, ivec2 P, int lod, ivec2 offset);
 
641
 
 
642
 vec4 texelFetchOffset( sampler3D sampler, ivec3 P, int lod, ivec3 offset);
 
643
ivec4 texelFetchOffset(isampler3D sampler, ivec3 P, int lod, ivec3 offset);
 
644
uvec4 texelFetchOffset(usampler3D sampler, ivec3 P, int lod, ivec3 offset);
 
645
 
 
646
 vec4 texelFetchOffset( sampler1DArray sampler, ivec2 P, int lod, int offset);
 
647
ivec4 texelFetchOffset(isampler1DArray sampler, ivec2 P, int lod, int offset);
 
648
uvec4 texelFetchOffset(usampler1DArray sampler, ivec2 P, int lod, int offset);
 
649
 
 
650
 vec4 texelFetchOffset( sampler2DArray sampler, ivec3 P, int lod, ivec2 offset);
 
651
ivec4 texelFetchOffset(isampler2DArray sampler, ivec3 P, int lod, ivec2 offset);
 
652
uvec4 texelFetchOffset(usampler2DArray sampler, ivec3 P, int lod, ivec2 offset);
 
653
 
 
654
/* textureProjOffset - no bias */
 
655
 vec4 textureProjOffset( sampler1D sampler, vec2 P, int offset);
 
656
ivec4 textureProjOffset(isampler1D sampler, vec2 P, int offset);
 
657
uvec4 textureProjOffset(usampler1D sampler, vec2 P, int offset);
 
658
 vec4 textureProjOffset( sampler1D sampler, vec4 P, int offset);
 
659
ivec4 textureProjOffset(isampler1D sampler, vec4 P, int offset);
 
660
uvec4 textureProjOffset(usampler1D sampler, vec4 P, int offset);
 
661
 
 
662
 vec4 textureProjOffset( sampler2D sampler, vec3 P, ivec2 offset);
 
663
ivec4 textureProjOffset(isampler2D sampler, vec3 P, ivec2 offset);
 
664
uvec4 textureProjOffset(usampler2D sampler, vec3 P, ivec2 offset);
 
665
 vec4 textureProjOffset( sampler2D sampler, vec4 P, ivec2 offset);
 
666
ivec4 textureProjOffset(isampler2D sampler, vec4 P, ivec2 offset);
 
667
uvec4 textureProjOffset(usampler2D sampler, vec4 P, ivec2 offset);
 
668
 
 
669
 vec4 textureProjOffset( sampler3D sampler, vec4 P, ivec3 offset);
 
670
ivec4 textureProjOffset(isampler3D sampler, vec4 P, ivec3 offset);
 
671
uvec4 textureProjOffset(usampler3D sampler, vec4 P, ivec3 offset);
 
672
 
 
673
float textureProjOffset(sampler1DShadow sampler, vec4 P, int offset);
 
674
float textureProjOffset(sampler2DShadow sampler, vec4 P, ivec2 offset);
 
675
 
 
676
/* textureLodOffset */
 
677
 vec4 textureLodOffset( sampler1D sampler, float P, float lod, int offset);
 
678
ivec4 textureLodOffset(isampler1D sampler, float P, float lod, int offset);
 
679
uvec4 textureLodOffset(usampler1D sampler, float P, float lod, int offset);
 
680
 
 
681
 vec4 textureLodOffset( sampler2D sampler, vec2 P, float lod, ivec2 offset);
 
682
ivec4 textureLodOffset(isampler2D sampler, vec2 P, float lod, ivec2 offset);
 
683
uvec4 textureLodOffset(usampler2D sampler, vec2 P, float lod, ivec2 offset);
 
684
 
 
685
 vec4 textureLodOffset( sampler3D sampler, vec3 P, float lod, ivec3 offset);
 
686
ivec4 textureLodOffset(isampler3D sampler, vec3 P, float lod, ivec3 offset);
 
687
uvec4 textureLodOffset(usampler3D sampler, vec3 P, float lod, ivec3 offset);
 
688
 
 
689
float textureLodOffset(sampler1DShadow samp, vec3 P, float lod, int offset);
 
690
float textureLodOffset(sampler2DShadow samp, vec3 P, float lod, ivec2 offset);
 
691
 
 
692
 vec4 textureLodOffset( sampler1DArray sampler, vec2 P, float lod, int offset);
 
693
ivec4 textureLodOffset(isampler1DArray sampler, vec2 P, float lod, int offset);
 
694
uvec4 textureLodOffset(usampler1DArray sampler, vec2 P, float lod, int offset);
 
695
 
 
696
 vec4 textureLodOffset( sampler2DArray samp, vec3 P, float lod, ivec2 offset);
 
697
ivec4 textureLodOffset(isampler2DArray samp, vec3 P, float lod, ivec2 offset);
 
698
uvec4 textureLodOffset(usampler2DArray samp, vec3 P, float lod, ivec2 offset);
 
699
 
 
700
float textureLodOffset(sampler1DArrayShadow s, vec3 P, float lod, int offset);
 
701
 
 
702
/* textureProjLod */
 
703
 vec4 textureProjLod( sampler1D sampler, vec2 P, float lod);
 
704
ivec4 textureProjLod(isampler1D sampler, vec2 P, float lod);
 
705
uvec4 textureProjLod(usampler1D sampler, vec2 P, float lod);
 
706
 vec4 textureProjLod( sampler1D sampler, vec4 P, float lod);
 
707
ivec4 textureProjLod(isampler1D sampler, vec4 P, float lod);
 
708
uvec4 textureProjLod(usampler1D sampler, vec4 P, float lod);
 
709
 
 
710
 vec4 textureProjLod( sampler2D sampler, vec3 P, float lod);
 
711
ivec4 textureProjLod(isampler2D sampler, vec3 P, float lod);
 
712
uvec4 textureProjLod(usampler2D sampler, vec3 P, float lod);
 
713
 vec4 textureProjLod( sampler2D sampler, vec4 P, float lod);
 
714
ivec4 textureProjLod(isampler2D sampler, vec4 P, float lod);
 
715
uvec4 textureProjLod(usampler2D sampler, vec4 P, float lod);
 
716
 
 
717
 vec4 textureProjLod( sampler3D sampler, vec4 P, float lod);
 
718
ivec4 textureProjLod(isampler3D sampler, vec4 P, float lod);
 
719
uvec4 textureProjLod(usampler3D sampler, vec4 P, float lod);
 
720
 
 
721
float textureProjLod(sampler1DShadow sampler, vec4 P, float lod);
 
722
float textureProjLod(sampler2DShadow sampler, vec4 P, float lod);
 
723
 
 
724
/* textureProjLodOffset */
 
725
 vec4 textureProjLodOffset( sampler1D sampler, vec2 P, float lod, int offset);
 
726
ivec4 textureProjLodOffset(isampler1D sampler, vec2 P, float lod, int offset);
 
727
uvec4 textureProjLodOffset(usampler1D sampler, vec2 P, float lod, int offset);
 
728
 vec4 textureProjLodOffset( sampler1D sampler, vec4 P, float lod, int offset);
 
729
ivec4 textureProjLodOffset(isampler1D sampler, vec4 P, float lod, int offset);
 
730
uvec4 textureProjLodOffset(usampler1D sampler, vec4 P, float lod, int offset);
 
731
 
 
732
 vec4 textureProjLodOffset( sampler2D sampler, vec3 P, float lod, ivec2 offset);
 
733
ivec4 textureProjLodOffset(isampler2D sampler, vec3 P, float lod, ivec2 offset);
 
734
uvec4 textureProjLodOffset(usampler2D sampler, vec3 P, float lod, ivec2 offset);
 
735
 vec4 textureProjLodOffset( sampler2D sampler, vec4 P, float lod, ivec2 offset);
 
736
ivec4 textureProjLodOffset(isampler2D sampler, vec4 P, float lod, ivec2 offset);
 
737
uvec4 textureProjLodOffset(usampler2D sampler, vec4 P, float lod, ivec2 offset);
 
738
 
 
739
 vec4 textureProjLodOffset( sampler3D sampler, vec4 P, float lod, ivec3 offset);
 
740
ivec4 textureProjLodOffset(isampler3D sampler, vec4 P, float lod, ivec3 offset);
 
741
uvec4 textureProjLodOffset(usampler3D sampler, vec4 P, float lod, ivec3 offset);
 
742
 
 
743
float textureProjLodOffset(sampler1DShadow s, vec4 P, float lod, int offset);
 
744
float textureProjLodOffset(sampler2DShadow s, vec4 P, float lod, ivec2 offset);
 
745
 
 
746
/* textureGrad */
 
747
 vec4 textureGrad( sampler1D sampler, float P, float dPdx, float dPdy);
 
748
ivec4 textureGrad(isampler1D sampler, float P, float dPdx, float dPdy);
 
749
uvec4 textureGrad(usampler1D sampler, float P, float dPdx, float dPdy);
 
750
 
 
751
 vec4 textureGrad( sampler2D sampler, vec2 P, vec2 dPdx, vec2 dPdy);
 
752
ivec4 textureGrad(isampler2D sampler, vec2 P, vec2 dPdx, vec2 dPdy);
 
753
uvec4 textureGrad(usampler2D sampler, vec2 P, vec2 dPdx, vec2 dPdy);
 
754
 
 
755
 vec4 textureGrad( sampler3D sampler, vec3 P, vec3 dPdx, vec3 dPdy);
 
756
ivec4 textureGrad(isampler3D sampler, vec3 P, vec3 dPdx, vec3 dPdy);
 
757
uvec4 textureGrad(usampler3D sampler, vec3 P, vec3 dPdx, vec3 dPdy);
 
758
 
 
759
 vec4 textureGrad( samplerCube sampler, vec3 P, vec3 dPdx, vec3 dPdy);
 
760
ivec4 textureGrad(isamplerCube sampler, vec3 P, vec3 dPdx, vec3 dPdy);
 
761
uvec4 textureGrad(usamplerCube sampler, vec3 P, vec3 dPdx, vec3 dPdy);
 
762
 
 
763
float textureGrad(sampler1DShadow   sampler, vec3 P, float dPdx, float dPdy);
 
764
float textureGrad(sampler2DShadow   sampler, vec3 P, vec2  dPdx, vec2  dPdy);
 
765
float textureGrad(samplerCubeShadow sampler, vec4 P, vec3  dPdx, vec3  dPdy);
 
766
 
 
767
 vec4 textureGrad( sampler1DArray sampler, vec2 P, float dPdx, float dPdy);
 
768
ivec4 textureGrad(isampler1DArray sampler, vec2 P, float dPdx, float dPdy);
 
769
uvec4 textureGrad(usampler1DArray sampler, vec2 P, float dPdx, float dPdy);
 
770
 
 
771
 vec4 textureGrad( sampler2DArray sampler, vec3 P, vec2 dPdx, vec2 dPdy);
 
772
ivec4 textureGrad(isampler2DArray sampler, vec3 P, vec2 dPdx, vec2 dPdy);
 
773
uvec4 textureGrad(usampler2DArray sampler, vec3 P, vec2 dPdx, vec2 dPdy);
 
774
 
 
775
float textureGrad(sampler1DArrayShadow sampler, vec3 P, float dPdx, float dPdy);
 
776
float textureGrad(sampler2DArrayShadow sampler, vec4 P, vec2  dPdx, vec2  dPdy);
 
777
 
 
778
/* textureGradOffset */
 
779
 vec4 textureGradOffset( sampler1D s, float P, float dx, float dy, int off);
 
780
ivec4 textureGradOffset(isampler1D s, float P, float dx, float dy, int offset);
 
781
uvec4 textureGradOffset(usampler1D s, float P, float dx, float dy, int offset);
 
782
 
 
783
 vec4 textureGradOffset( sampler2D s, vec2 P, vec2 dx, vec2 dy, ivec2 offset);
 
784
ivec4 textureGradOffset(isampler2D s, vec2 P, vec2 dx, vec2 dy, ivec2 offset);
 
785
uvec4 textureGradOffset(usampler2D s, vec2 P, vec2 dx, vec2 dy, ivec2 offset);
 
786
 
 
787
 vec4 textureGradOffset( sampler3D s, vec3 P, vec3 dx, vec3 dy, ivec3 offset);
 
788
ivec4 textureGradOffset(isampler3D s, vec3 P, vec3 dx, vec3 dy, ivec3 offset);
 
789
uvec4 textureGradOffset(usampler3D s, vec3 P, vec3 dx, vec3 dy, ivec3 offset);
 
790
 
 
791
float textureGradOffset(sampler1DShadow s, vec3 P, float dx, float dy, int off);
 
792
float textureGradOffset(sampler2DShadow s, vec3 P, vec2 dx, vec2 dy, ivec2 off);
 
793
 
 
794
 vec4 textureGradOffset( sampler1DArray s, vec2 P, float dx, float dy, int off);
 
795
ivec4 textureGradOffset(isampler1DArray s, vec2 P, float dx, float dy, int off);
 
796
uvec4 textureGradOffset(usampler1DArray s, vec2 P, float dx, float dy, int off);
 
797
 
 
798
 vec4 textureGradOffset( sampler2DArray s, vec3 P, vec2 dx, vec2 dy, ivec2 off);
 
799
ivec4 textureGradOffset(isampler2DArray s, vec3 P, vec2 dx, vec2 dy, ivec2 off);
 
800
uvec4 textureGradOffset(usampler2DArray s, vec3 P, vec2 dx, vec2 dy, ivec2 off);
 
801
 
 
802
float textureGradOffset(sampler1DArrayShadow s, vec3 P, float dx, float dy, int o);
 
803
float textureGradOffset(sampler2DArrayShadow s, vec4 P, vec2 dx, vec2 dy, ivec2 o);
 
804
 
 
805
/* textureProjGrad */
 
806
 vec4 textureProjGrad( sampler1D sampler, vec2 P, float dPdx, float dPdy);
 
807
ivec4 textureProjGrad(isampler1D sampler, vec2 P, float dPdx, float dPdy);
 
808
uvec4 textureProjGrad(usampler1D sampler, vec2 P, float dPdx, float dPdy);
 
809
 vec4 textureProjGrad( sampler1D sampler, vec4 P, float dPdx, float dPdy);
 
810
ivec4 textureProjGrad(isampler1D sampler, vec4 P, float dPdx, float dPdy);
 
811
uvec4 textureProjGrad(usampler1D sampler, vec4 P, float dPdx, float dPdy);
 
812
 
 
813
 vec4 textureProjGrad( sampler2D sampler, vec3 P, vec2 dPdx, vec2 dPdy);
 
814
ivec4 textureProjGrad(isampler2D sampler, vec3 P, vec2 dPdx, vec2 dPdy);
 
815
uvec4 textureProjGrad(usampler2D sampler, vec3 P, vec2 dPdx, vec2 dPdy);
 
816
 vec4 textureProjGrad( sampler2D sampler, vec4 P, vec2 dPdx, vec2 dPdy);
 
817
ivec4 textureProjGrad(isampler2D sampler, vec4 P, vec2 dPdx, vec2 dPdy);
 
818
uvec4 textureProjGrad(usampler2D sampler, vec4 P, vec2 dPdx, vec2 dPdy);
 
819
 
 
820
 vec4 textureProjGrad( sampler3D sampler, vec4 P, vec3 dPdx, vec3 dPdy);
 
821
ivec4 textureProjGrad(isampler3D sampler, vec4 P, vec3 dPdx, vec3 dPdy);
 
822
uvec4 textureProjGrad(usampler3D sampler, vec4 P, vec3 dPdx, vec3 dPdy);
 
823
 
 
824
float textureProjGrad(sampler1DShadow sampler, vec4 P, float dPdx, float dPdy);
 
825
float textureProjGrad(sampler2DShadow sampler, vec4 P, vec2  dPdx, vec2  dPdy);
 
826
 
 
827
/* textureProjGradOffset */
 
828
 vec4 textureProjGradOffset( sampler1D s, vec2 P, float dx, float dy, int off);
 
829
ivec4 textureProjGradOffset(isampler1D s, vec2 P, float dx, float dy, int off);
 
830
uvec4 textureProjGradOffset(usampler1D s, vec2 P, float dx, float dy, int off);
 
831
 vec4 textureProjGradOffset( sampler1D s, vec4 P, float dx, float dy, int off);
 
832
ivec4 textureProjGradOffset(isampler1D s, vec4 P, float dx, float dy, int off);
 
833
uvec4 textureProjGradOffset(usampler1D s, vec4 P, float dx, float dy, int off);
 
834
 
 
835
 vec4 textureProjGradOffset( sampler2D s, vec3 P, vec2 dx, vec2 dy, ivec2 off);
 
836
ivec4 textureProjGradOffset(isampler2D s, vec3 P, vec2 dx, vec2 dy, ivec2 off);
 
837
uvec4 textureProjGradOffset(usampler2D s, vec3 P, vec2 dx, vec2 dy, ivec2 off);
 
838
 vec4 textureProjGradOffset( sampler2D s, vec4 P, vec2 dx, vec2 dy, ivec2 off);
 
839
ivec4 textureProjGradOffset(isampler2D s, vec4 P, vec2 dx, vec2 dy, ivec2 off);
 
840
uvec4 textureProjGradOffset(usampler2D s, vec4 P, vec2 dx, vec2 dy, ivec2 off);
 
841
 
 
842
 vec4 textureProjGradOffset( sampler3D s, vec4 P, vec3 dx, vec3 dy, ivec3 off);
 
843
ivec4 textureProjGradOffset(isampler3D s, vec4 P, vec3 dx, vec3 dy, ivec3 off);
 
844
uvec4 textureProjGradOffset(usampler3D s, vec4 P, vec3 dx, vec3 dy, ivec3 off);
 
845
 
 
846
float textureProjGradOffset(sampler1DShadow s, vec4 P, float dx, float dy, int o);
 
847
float textureProjGradOffset(sampler2DShadow s, vec4 P, vec2 dx, vec2 dy, ivec2 o);
 
848
 
 
849
/*
 
850
 * The following texture functions are deprecated:
 
851
 */
 
852
vec4 texture1D       (sampler1D sampler, float coord);
 
853
vec4 texture1DProj   (sampler1D sampler, vec2  coord);
 
854
vec4 texture1DProj   (sampler1D sampler, vec4  coord);
 
855
vec4 texture1DLod    (sampler1D sampler, float coord, float lod);
 
856
vec4 texture1DProjLod(sampler1D sampler, vec2  coord, float lod);
 
857
vec4 texture1DProjLod(sampler1D sampler, vec4  coord, float lod);
 
858
 
 
859
vec4 texture2D       (sampler2D sampler, vec2 coord);
 
860
vec4 texture2DProj   (sampler2D sampler, vec3 coord);
 
861
vec4 texture2DProj   (sampler2D sampler, vec4 coord);
 
862
vec4 texture2DLod    (sampler2D sampler, vec2 coord, float lod);
 
863
vec4 texture2DProjLod(sampler2D sampler, vec3 coord, float lod);
 
864
vec4 texture2DProjLod(sampler2D sampler, vec4 coord, float lod);
 
865
 
 
866
vec4 texture3D       (sampler3D sampler, vec3 coord);
 
867
vec4 texture3DProj   (sampler3D sampler, vec4 coord);
 
868
vec4 texture3DLod    (sampler3D sampler, vec3 coord, float lod);
 
869
vec4 texture3DProjLod(sampler3D sampler, vec4 coord, float lod);
 
870
 
 
871
vec4 textureCube     (samplerCube sampler, vec3 coord);
 
872
vec4 textureCubeLod  (samplerCube sampler, vec3 coord, float lod);
 
873
 
 
874
vec4 shadow1D       (sampler1DShadow sampler, vec3 coord);
 
875
vec4 shadow2D       (sampler2DShadow sampler, vec3 coord);
 
876
vec4 shadow1DProj   (sampler1DShadow sampler, vec4 coord);
 
877
vec4 shadow2DProj   (sampler2DShadow sampler, vec4 coord);
 
878
vec4 shadow1DLod    (sampler1DShadow sampler, vec3 coord, float lod);
 
879
vec4 shadow2DLod    (sampler2DShadow sampler, vec3 coord, float lod);
 
880
vec4 shadow1DProjLod(sampler1DShadow sampler, vec4 coord, float lod);
 
881
vec4 shadow2DProjLod(sampler2DShadow sampler, vec4 coord, float lod);
 
882
 
 
883
/*
 
884
 * 8.9 - Noise Functions
 
885
 */
 
886
float noise1(float x);
 
887
float noise1(vec2  x);
 
888
float noise1(vec3  x);
 
889
float noise1(vec4  x);
 
890
 
 
891
vec2  noise2(float x);
 
892
vec2  noise2(vec2  x);
 
893
vec2  noise2(vec3  x);
 
894
vec2  noise2(vec4  x);
 
895
 
 
896
vec3  noise3(float x);
 
897
vec3  noise3(vec2  x);
 
898
vec3  noise3(vec3  x);
 
899
vec3  noise3(vec4  x);
 
900
 
 
901
vec4  noise4(float x);
 
902
vec4  noise4(vec2  x);
 
903
vec4  noise4(vec3  x);
 
904
vec4  noise4(vec4  x);