← Back to branch summary

~mmach/netext73/webkit2gtk

« back to all changes in this revision

Viewing changes to Source/ThirdParty/ANGLE/src/libANGLE/validationGL1.cpp

  • Committer: mmach
  • Date: 2023-06-16 17:21:37 UTC
  • Revision ID: netbit73@gmail.com-20230616172137-2rqx6yr96ga9g3kp
1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/ThirdParty/ANGLE/src/libANGLE/validationGL1.cpp
 
1
//
 
2
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
 
3
// Use of this source code is governed by a BSD-style license that can be
 
4
// found in the LICENSE file.
 
5
//
 
6
 
 
7
// validationGL1.cpp: Validation functions for OpenGL 1.0 entry point parameters
 
8
 
 
9
#include "libANGLE/validationGL1_autogen.h"
 
10
 
 
11
namespace gl
 
12
{
 
13
 
 
14
bool ValidateAccum(Context *context, GLenum op, GLfloat value)
 
15
{
 
16
    return true;
 
17
}
 
18
 
 
19
bool ValidateBegin(Context *context, GLenum mode)
 
20
{
 
21
    return true;
 
22
}
 
23
 
 
24
bool ValidateBitmap(Context *context,
 
25
                    GLsizei width,
 
26
                    GLsizei height,
 
27
                    GLfloat xorig,
 
28
                    GLfloat yorig,
 
29
                    GLfloat xmove,
 
30
                    GLfloat ymove,
 
31
                    const GLubyte *bitmap)
 
32
{
 
33
    return true;
 
34
}
 
35
 
 
36
bool ValidateCallList(Context *context, GLuint list)
 
37
{
 
38
    return true;
 
39
}
 
40
 
 
41
bool ValidateCallLists(Context *context, GLsizei n, GLenum type, const void *lists)
 
42
{
 
43
    return true;
 
44
}
 
45
 
 
46
bool ValidateClearAccum(Context *context, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 
47
{
 
48
    return true;
 
49
}
 
50
 
 
51
bool ValidateClearDepth(Context *context, GLdouble depth)
 
52
{
 
53
    return true;
 
54
}
 
55
 
 
56
bool ValidateClearIndex(Context *context, GLfloat c)
 
57
{
 
58
    return true;
 
59
}
 
60
 
 
61
bool ValidateClipPlane(Context *context, GLenum plane, const GLdouble *equation)
 
62
{
 
63
    return true;
 
64
}
 
65
 
 
66
bool ValidateColor3b(Context *context, GLbyte red, GLbyte green, GLbyte blue)
 
67
{
 
68
    return true;
 
69
}
 
70
 
 
71
bool ValidateColor3bv(Context *context, const GLbyte *v)
 
72
{
 
73
    return true;
 
74
}
 
75
 
 
76
bool ValidateColor3d(Context *context, GLdouble red, GLdouble green, GLdouble blue)
 
77
{
 
78
    return true;
 
79
}
 
80
 
 
81
bool ValidateColor3dv(Context *context, const GLdouble *v)
 
82
{
 
83
    return true;
 
84
}
 
85
 
 
86
bool ValidateColor3f(Context *context, GLfloat red, GLfloat green, GLfloat blue)
 
87
{
 
88
    return true;
 
89
}
 
90
 
 
91
bool ValidateColor3fv(Context *context, const GLfloat *v)
 
92
{
 
93
    return true;
 
94
}
 
95
 
 
96
bool ValidateColor3i(Context *context, GLint red, GLint green, GLint blue)
 
97
{
 
98
    return true;
 
99
}
 
100
 
 
101
bool ValidateColor3iv(Context *context, const GLint *v)
 
102
{
 
103
    return true;
 
104
}
 
105
 
 
106
bool ValidateColor3s(Context *context, GLshort red, GLshort green, GLshort blue)
 
107
{
 
108
    return true;
 
109
}
 
110
 
 
111
bool ValidateColor3sv(Context *context, const GLshort *v)
 
112
{
 
113
    return true;
 
114
}
 
115
 
 
116
bool ValidateColor3ub(Context *context, GLubyte red, GLubyte green, GLubyte blue)
 
117
{
 
118
    return true;
 
119
}
 
120
 
 
121
bool ValidateColor3ubv(Context *context, const GLubyte *v)
 
122
{
 
123
    return true;
 
124
}
 
125
 
 
126
bool ValidateColor3ui(Context *context, GLuint red, GLuint green, GLuint blue)
 
127
{
 
128
    return true;
 
129
}
 
130
 
 
131
bool ValidateColor3uiv(Context *context, const GLuint *v)
 
132
{
 
133
    return true;
 
134
}
 
135
 
 
136
bool ValidateColor3us(Context *context, GLushort red, GLushort green, GLushort blue)
 
137
{
 
138
    return true;
 
139
}
 
140
 
 
141
bool ValidateColor3usv(Context *context, const GLushort *v)
 
142
{
 
143
    return true;
 
144
}
 
145
 
 
146
bool ValidateColor4b(Context *context, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 
147
{
 
148
    return true;
 
149
}
 
150
 
 
151
bool ValidateColor4bv(Context *context, const GLbyte *v)
 
152
{
 
153
    return true;
 
154
}
 
155
 
 
156
bool ValidateColor4d(Context *context, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 
157
{
 
158
    return true;
 
159
}
 
160
 
 
161
bool ValidateColor4dv(Context *context, const GLdouble *v)
 
162
{
 
163
    return true;
 
164
}
 
165
 
 
166
bool ValidateColor4fv(Context *context, const GLfloat *v)
 
167
{
 
168
    return true;
 
169
}
 
170
 
 
171
bool ValidateColor4i(Context *context, GLint red, GLint green, GLint blue, GLint alpha)
 
172
{
 
173
    return true;
 
174
}
 
175
 
 
176
bool ValidateColor4iv(Context *context, const GLint *v)
 
177
{
 
178
    return true;
 
179
}
 
180
 
 
181
bool ValidateColor4s(Context *context, GLshort red, GLshort green, GLshort blue, GLshort alpha)
 
182
{
 
183
    return true;
 
184
}
 
185
 
 
186
bool ValidateColor4sv(Context *context, const GLshort *v)
 
187
{
 
188
    return true;
 
189
}
 
190
 
 
191
bool ValidateColor4ubv(Context *context, const GLubyte *v)
 
192
{
 
193
    return true;
 
194
}
 
195
 
 
196
bool ValidateColor4ui(Context *context, GLuint red, GLuint green, GLuint blue, GLuint alpha)
 
197
{
 
198
    return true;
 
199
}
 
200
 
 
201
bool ValidateColor4uiv(Context *context, const GLuint *v)
 
202
{
 
203
    return true;
 
204
}
 
205
 
 
206
bool ValidateColor4us(Context *context, GLushort red, GLushort green, GLushort blue, GLushort alpha)
 
207
{
 
208
    return true;
 
209
}
 
210
 
 
211
bool ValidateColor4usv(Context *context, const GLushort *v)
 
212
{
 
213
    return true;
 
214
}
 
215
 
 
216
bool ValidateColorMaterial(Context *context, GLenum face, GLenum mode)
 
217
{
 
218
    return true;
 
219
}
 
220
 
 
221
bool ValidateCopyPixels(Context *context,
 
222
                        GLint x,
 
223
                        GLint y,
 
224
                        GLsizei width,
 
225
                        GLsizei height,
 
226
                        GLenum type)
 
227
{
 
228
    return true;
 
229
}
 
230
 
 
231
bool ValidateDeleteLists(Context *context, GLuint list, GLsizei range)
 
232
{
 
233
    return true;
 
234
}
 
235
 
 
236
bool ValidateDepthRange(Context *context, GLdouble n, GLdouble f)
 
237
{
 
238
    return true;
 
239
}
 
240
 
 
241
bool ValidateDrawBuffer(Context *context, GLenum buf)
 
242
{
 
243
    return true;
 
244
}
 
245
 
 
246
bool ValidateDrawPixels(Context *context,
 
247
                        GLsizei width,
 
248
                        GLsizei height,
 
249
                        GLenum format,
 
250
                        GLenum type,
 
251
                        const void *pixels)
 
252
{
 
253
    return true;
 
254
}
 
255
 
 
256
bool ValidateEdgeFlag(Context *context, GLboolean flag)
 
257
{
 
258
    return true;
 
259
}
 
260
 
 
261
bool ValidateEdgeFlagv(Context *context, const GLboolean *flag)
 
262
{
 
263
    return true;
 
264
}
 
265
 
 
266
bool ValidateEnd(Context *context)
 
267
{
 
268
    return true;
 
269
}
 
270
 
 
271
bool ValidateEndList(Context *context)
 
272
{
 
273
    return true;
 
274
}
 
275
 
 
276
bool ValidateEvalCoord1d(Context *context, GLdouble u)
 
277
{
 
278
    return true;
 
279
}
 
280
 
 
281
bool ValidateEvalCoord1dv(Context *context, const GLdouble *u)
 
282
{
 
283
    return true;
 
284
}
 
285
 
 
286
bool ValidateEvalCoord1f(Context *context, GLfloat u)
 
287
{
 
288
    return true;
 
289
}
 
290
 
 
291
bool ValidateEvalCoord1fv(Context *context, const GLfloat *u)
 
292
{
 
293
    return true;
 
294
}
 
295
 
 
296
bool ValidateEvalCoord2d(Context *context, GLdouble u, GLdouble v)
 
297
{
 
298
    return true;
 
299
}
 
300
 
 
301
bool ValidateEvalCoord2dv(Context *context, const GLdouble *u)
 
302
{
 
303
    return true;
 
304
}
 
305
 
 
306
bool ValidateEvalCoord2f(Context *context, GLfloat u, GLfloat v)
 
307
{
 
308
    return true;
 
309
}
 
310
 
 
311
bool ValidateEvalCoord2fv(Context *context, const GLfloat *u)
 
312
{
 
313
    return true;
 
314
}
 
315
 
 
316
bool ValidateEvalMesh1(Context *context, GLenum mode, GLint i1, GLint i2)
 
317
{
 
318
    return true;
 
319
}
 
320
 
 
321
bool ValidateEvalMesh2(Context *context, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 
322
{
 
323
    return true;
 
324
}
 
325
 
 
326
bool ValidateEvalPoint1(Context *context, GLint i)
 
327
{
 
328
    return true;
 
329
}
 
330
 
 
331
bool ValidateEvalPoint2(Context *context, GLint i, GLint j)
 
332
{
 
333
    return true;
 
334
}
 
335
 
 
336
bool ValidateFeedbackBuffer(Context *context, GLsizei size, GLenum type, GLfloat *buffer)
 
337
{
 
338
    return true;
 
339
}
 
340
 
 
341
bool ValidateFogi(Context *context, GLenum pname, GLint param)
 
342
{
 
343
    return true;
 
344
}
 
345
 
 
346
bool ValidateFogiv(Context *context, GLenum pname, const GLint *params)
 
347
{
 
348
    return true;
 
349
}
 
350
 
 
351
bool ValidateFrustum(Context *context,
 
352
                     GLdouble left,
 
353
                     GLdouble right,
 
354
                     GLdouble bottom,
 
355
                     GLdouble top,
 
356
                     GLdouble zNear,
 
357
                     GLdouble zFar)
 
358
{
 
359
    return true;
 
360
}
 
361
 
 
362
bool ValidateGenLists(Context *context, GLsizei range)
 
363
{
 
364
    return true;
 
365
}
 
366
 
 
367
bool ValidateGetClipPlane(Context *context, GLenum plane, GLdouble *equation)
 
368
{
 
369
    return true;
 
370
}
 
371
 
 
372
bool ValidateGetDoublev(Context *context, GLenum pname, GLdouble *data)
 
373
{
 
374
    return true;
 
375
}
 
376
 
 
377
bool ValidateGetLightiv(Context *context, GLenum light, GLenum pname, GLint *params)
 
378
{
 
379
    return true;
 
380
}
 
381
 
 
382
bool ValidateGetMapdv(Context *context, GLenum target, GLenum query, GLdouble *v)
 
383
{
 
384
    return true;
 
385
}
 
386
 
 
387
bool ValidateGetMapfv(Context *context, GLenum target, GLenum query, GLfloat *v)
 
388
{
 
389
    return true;
 
390
}
 
391
 
 
392
bool ValidateGetMapiv(Context *context, GLenum target, GLenum query, GLint *v)
 
393
{
 
394
    return true;
 
395
}
 
396
 
 
397
bool ValidateGetMaterialiv(Context *context, GLenum face, GLenum pname, GLint *params)
 
398
{
 
399
    return true;
 
400
}
 
401
 
 
402
bool ValidateGetPixelMapfv(Context *context, GLenum map, GLfloat *values)
 
403
{
 
404
    return true;
 
405
}
 
406
 
 
407
bool ValidateGetPixelMapuiv(Context *context, GLenum map, GLuint *values)
 
408
{
 
409
    return true;
 
410
}
 
411
 
 
412
bool ValidateGetPixelMapusv(Context *context, GLenum map, GLushort *values)
 
413
{
 
414
    return true;
 
415
}
 
416
 
 
417
bool ValidateGetPolygonStipple(Context *context, GLubyte *mask)
 
418
{
 
419
    return true;
 
420
}
 
421
 
 
422
bool ValidateGetTexGendv(Context *context, GLenum coord, GLenum pname, GLdouble *params)
 
423
{
 
424
    return true;
 
425
}
 
426
 
 
427
bool ValidateGetTexGenfv(Context *context, GLenum coord, GLenum pname, GLfloat *params)
 
428
{
 
429
    return true;
 
430
}
 
431
 
 
432
bool ValidateGetTexGeniv(Context *context, GLenum coord, GLenum pname, GLint *params)
 
433
{
 
434
    return true;
 
435
}
 
436
 
 
437
bool ValidateGetTexImage(Context *context,
 
438
                         TextureTarget target,
 
439
                         GLint level,
 
440
                         GLenum format,
 
441
                         GLenum type,
 
442
                         void *pixels)
 
443
{
 
444
    return true;
 
445
}
 
446
 
 
447
bool ValidateIndexMask(Context *context, GLuint mask)
 
448
{
 
449
    return true;
 
450
}
 
451
 
 
452
bool ValidateIndexd(Context *context, GLdouble c)
 
453
{
 
454
    return true;
 
455
}
 
456
 
 
457
bool ValidateIndexdv(Context *context, const GLdouble *c)
 
458
{
 
459
    return true;
 
460
}
 
461
 
 
462
bool ValidateIndexf(Context *context, GLfloat c)
 
463
{
 
464
    return true;
 
465
}
 
466
 
 
467
bool ValidateIndexfv(Context *context, const GLfloat *c)
 
468
{
 
469
    return true;
 
470
}
 
471
 
 
472
bool ValidateIndexi(Context *context, GLint c)
 
473
{
 
474
    return true;
 
475
}
 
476
 
 
477
bool ValidateIndexiv(Context *context, const GLint *c)
 
478
{
 
479
    return true;
 
480
}
 
481
 
 
482
bool ValidateIndexs(Context *context, GLshort c)
 
483
{
 
484
    return true;
 
485
}
 
486
 
 
487
bool ValidateIndexsv(Context *context, const GLshort *c)
 
488
{
 
489
    return true;
 
490
}
 
491
 
 
492
bool ValidateInitNames(Context *context)
 
493
{
 
494
    return true;
 
495
}
 
496
 
 
497
bool ValidateIsList(Context *context, GLuint list)
 
498
{
 
499
    return true;
 
500
}
 
501
 
 
502
bool ValidateLightModeli(Context *context, GLenum pname, GLint param)
 
503
{
 
504
    return true;
 
505
}
 
506
 
 
507
bool ValidateLightModeliv(Context *context, GLenum pname, const GLint *params)
 
508
{
 
509
    return true;
 
510
}
 
511
 
 
512
bool ValidateLighti(Context *context, GLenum light, GLenum pname, GLint param)
 
513
{
 
514
    return true;
 
515
}
 
516
 
 
517
bool ValidateLightiv(Context *context, GLenum light, GLenum pname, const GLint *params)
 
518
{
 
519
    return true;
 
520
}
 
521
 
 
522
bool ValidateLineStipple(Context *context, GLint factor, GLushort pattern)
 
523
{
 
524
    return true;
 
525
}
 
526
 
 
527
bool ValidateListBase(Context *context, GLuint base)
 
528
{
 
529
    return true;
 
530
}
 
531
 
 
532
bool ValidateLoadMatrixd(Context *context, const GLdouble *m)
 
533
{
 
534
    return true;
 
535
}
 
536
 
 
537
bool ValidateLoadName(Context *context, GLuint name)
 
538
{
 
539
    return true;
 
540
}
 
541
 
 
542
bool ValidateMap1d(Context *context,
 
543
                   GLenum target,
 
544
                   GLdouble u1,
 
545
                   GLdouble u2,
 
546
                   GLint stride,
 
547
                   GLint order,
 
548
                   const GLdouble *points)
 
549
{
 
550
    return true;
 
551
}
 
552
 
 
553
bool ValidateMap1f(Context *context,
 
554
                   GLenum target,
 
555
                   GLfloat u1,
 
556
                   GLfloat u2,
 
557
                   GLint stride,
 
558
                   GLint order,
 
559
                   const GLfloat *points)
 
560
{
 
561
    return true;
 
562
}
 
563
 
 
564
bool ValidateMap2d(Context *context,
 
565
                   GLenum target,
 
566
                   GLdouble u1,
 
567
                   GLdouble u2,
 
568
                   GLint ustride,
 
569
                   GLint uorder,
 
570
                   GLdouble v1,
 
571
                   GLdouble v2,
 
572
                   GLint vstride,
 
573
                   GLint vorder,
 
574
                   const GLdouble *points)
 
575
{
 
576
    return true;
 
577
}
 
578
 
 
579
bool ValidateMap2f(Context *context,
 
580
                   GLenum target,
 
581
                   GLfloat u1,
 
582
                   GLfloat u2,
 
583
                   GLint ustride,
 
584
                   GLint uorder,
 
585
                   GLfloat v1,
 
586
                   GLfloat v2,
 
587
                   GLint vstride,
 
588
                   GLint vorder,
 
589
                   const GLfloat *points)
 
590
{
 
591
    return true;
 
592
}
 
593
 
 
594
bool ValidateMapGrid1d(Context *context, GLint un, GLdouble u1, GLdouble u2)
 
595
{
 
596
    return true;
 
597
}
 
598
 
 
599
bool ValidateMapGrid1f(Context *context, GLint un, GLfloat u1, GLfloat u2)
 
600
{
 
601
    return true;
 
602
}
 
603
 
 
604
bool ValidateMapGrid2d(Context *context,
 
605
                       GLint un,
 
606
                       GLdouble u1,
 
607
                       GLdouble u2,
 
608
                       GLint vn,
 
609
                       GLdouble v1,
 
610
                       GLdouble v2)
 
611
{
 
612
    return true;
 
613
}
 
614
 
 
615
bool ValidateMapGrid2f(Context *context,
 
616
                       GLint un,
 
617
                       GLfloat u1,
 
618
                       GLfloat u2,
 
619
                       GLint vn,
 
620
                       GLfloat v1,
 
621
                       GLfloat v2)
 
622
{
 
623
    return true;
 
624
}
 
625
 
 
626
bool ValidateMateriali(Context *context, GLenum face, GLenum pname, GLint param)
 
627
{
 
628
    return true;
 
629
}
 
630
 
 
631
bool ValidateMaterialiv(Context *context, GLenum face, GLenum pname, const GLint *params)
 
632
{
 
633
    return true;
 
634
}
 
635
 
 
636
bool ValidateMultMatrixd(Context *context, const GLdouble *m)
 
637
{
 
638
    return true;
 
639
}
 
640
 
 
641
bool ValidateNewList(Context *context, GLuint list, GLenum mode)
 
642
{
 
643
    return true;
 
644
}
 
645
 
 
646
bool ValidateNormal3b(Context *context, GLbyte nx, GLbyte ny, GLbyte nz)
 
647
{
 
648
    return true;
 
649
}
 
650
 
 
651
bool ValidateNormal3bv(Context *context, const GLbyte *v)
 
652
{
 
653
    return true;
 
654
}
 
655
 
 
656
bool ValidateNormal3d(Context *context, GLdouble nx, GLdouble ny, GLdouble nz)
 
657
{
 
658
    return true;
 
659
}
 
660
 
 
661
bool ValidateNormal3dv(Context *context, const GLdouble *v)
 
662
{
 
663
    return true;
 
664
}
 
665
 
 
666
bool ValidateNormal3fv(Context *context, const GLfloat *v)
 
667
{
 
668
    return true;
 
669
}
 
670
 
 
671
bool ValidateNormal3i(Context *context, GLint nx, GLint ny, GLint nz)
 
672
{
 
673
    return true;
 
674
}
 
675
 
 
676
bool ValidateNormal3iv(Context *context, const GLint *v)
 
677
{
 
678
    return true;
 
679
}
 
680
 
 
681
bool ValidateNormal3s(Context *context, GLshort nx, GLshort ny, GLshort nz)
 
682
{
 
683
    return true;
 
684
}
 
685
 
 
686
bool ValidateNormal3sv(Context *context, const GLshort *v)
 
687
{
 
688
    return true;
 
689
}
 
690
 
 
691
bool ValidateOrtho(Context *context,
 
692
                   GLdouble left,
 
693
                   GLdouble right,
 
694
                   GLdouble bottom,
 
695
                   GLdouble top,
 
696
                   GLdouble zNear,
 
697
                   GLdouble zFar)
 
698
{
 
699
    return true;
 
700
}
 
701
 
 
702
bool ValidatePassThrough(Context *context, GLfloat token)
 
703
{
 
704
    return true;
 
705
}
 
706
 
 
707
bool ValidatePixelMapfv(Context *context, GLenum map, GLsizei mapsize, const GLfloat *values)
 
708
{
 
709
    return true;
 
710
}
 
711
 
 
712
bool ValidatePixelMapuiv(Context *context, GLenum map, GLsizei mapsize, const GLuint *values)
 
713
{
 
714
    return true;
 
715
}
 
716
 
 
717
bool ValidatePixelMapusv(Context *context, GLenum map, GLsizei mapsize, const GLushort *values)
 
718
{
 
719
    return true;
 
720
}
 
721
 
 
722
bool ValidatePixelStoref(Context *context, GLenum pname, GLfloat param)
 
723
{
 
724
    return true;
 
725
}
 
726
 
 
727
bool ValidatePixelTransferf(Context *context, GLenum pname, GLfloat param)
 
728
{
 
729
    return true;
 
730
}
 
731
 
 
732
bool ValidatePixelTransferi(Context *context, GLenum pname, GLint param)
 
733
{
 
734
    return true;
 
735
}
 
736
 
 
737
bool ValidatePixelZoom(Context *context, GLfloat xfactor, GLfloat yfactor)
 
738
{
 
739
    return true;
 
740
}
 
741
 
 
742
bool ValidatePolygonMode(Context *context, GLenum face, GLenum mode)
 
743
{
 
744
    return true;
 
745
}
 
746
 
 
747
bool ValidatePolygonStipple(Context *context, const GLubyte *mask)
 
748
{
 
749
    return true;
 
750
}
 
751
 
 
752
bool ValidatePopAttrib(Context *context)
 
753
{
 
754
    return true;
 
755
}
 
756
 
 
757
bool ValidatePopName(Context *context)
 
758
{
 
759
    return true;
 
760
}
 
761
 
 
762
bool ValidatePushAttrib(Context *context, GLbitfield mask)
 
763
{
 
764
    return true;
 
765
}
 
766
 
 
767
bool ValidatePushName(Context *context, GLuint name)
 
768
{
 
769
    return true;
 
770
}
 
771
 
 
772
bool ValidateRasterPos2d(Context *context, GLdouble x, GLdouble y)
 
773
{
 
774
    return true;
 
775
}
 
776
 
 
777
bool ValidateRasterPos2dv(Context *context, const GLdouble *v)
 
778
{
 
779
    return true;
 
780
}
 
781
 
 
782
bool ValidateRasterPos2f(Context *context, GLfloat x, GLfloat y)
 
783
{
 
784
    return true;
 
785
}
 
786
 
 
787
bool ValidateRasterPos2fv(Context *context, const GLfloat *v)
 
788
{
 
789
    return true;
 
790
}
 
791
 
 
792
bool ValidateRasterPos2i(Context *context, GLint x, GLint y)
 
793
{
 
794
    return true;
 
795
}
 
796
 
 
797
bool ValidateRasterPos2iv(Context *context, const GLint *v)
 
798
{
 
799
    return true;
 
800
}
 
801
 
 
802
bool ValidateRasterPos2s(Context *context, GLshort x, GLshort y)
 
803
{
 
804
    return true;
 
805
}
 
806
 
 
807
bool ValidateRasterPos2sv(Context *context, const GLshort *v)
 
808
{
 
809
    return true;
 
810
}
 
811
 
 
812
bool ValidateRasterPos3d(Context *context, GLdouble x, GLdouble y, GLdouble z)
 
813
{
 
814
    return true;
 
815
}
 
816
 
 
817
bool ValidateRasterPos3dv(Context *context, const GLdouble *v)
 
818
{
 
819
    return true;
 
820
}
 
821
 
 
822
bool ValidateRasterPos3f(Context *context, GLfloat x, GLfloat y, GLfloat z)
 
823
{
 
824
    return true;
 
825
}
 
826
 
 
827
bool ValidateRasterPos3fv(Context *context, const GLfloat *v)
 
828
{
 
829
    return true;
 
830
}
 
831
 
 
832
bool ValidateRasterPos3i(Context *context, GLint x, GLint y, GLint z)
 
833
{
 
834
    return true;
 
835
}
 
836
 
 
837
bool ValidateRasterPos3iv(Context *context, const GLint *v)
 
838
{
 
839
    return true;
 
840
}
 
841
 
 
842
bool ValidateRasterPos3s(Context *context, GLshort x, GLshort y, GLshort z)
 
843
{
 
844
    return true;
 
845
}
 
846
 
 
847
bool ValidateRasterPos3sv(Context *context, const GLshort *v)
 
848
{
 
849
    return true;
 
850
}
 
851
 
 
852
bool ValidateRasterPos4d(Context *context, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 
853
{
 
854
    return true;
 
855
}
 
856
 
 
857
bool ValidateRasterPos4dv(Context *context, const GLdouble *v)
 
858
{
 
859
    return true;
 
860
}
 
861
 
 
862
bool ValidateRasterPos4f(Context *context, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 
863
{
 
864
    return true;
 
865
}
 
866
 
 
867
bool ValidateRasterPos4fv(Context *context, const GLfloat *v)
 
868
{
 
869
    return true;
 
870
}
 
871
 
 
872
bool ValidateRasterPos4i(Context *context, GLint x, GLint y, GLint z, GLint w)
 
873
{
 
874
    return true;
 
875
}
 
876
 
 
877
bool ValidateRasterPos4iv(Context *context, const GLint *v)
 
878
{
 
879
    return true;
 
880
}
 
881
 
 
882
bool ValidateRasterPos4s(Context *context, GLshort x, GLshort y, GLshort z, GLshort w)
 
883
{
 
884
    return true;
 
885
}
 
886
 
 
887
bool ValidateRasterPos4sv(Context *context, const GLshort *v)
 
888
{
 
889
    return true;
 
890
}
 
891
 
 
892
bool ValidateRectd(Context *context, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 
893
{
 
894
    return true;
 
895
}
 
896
 
 
897
bool ValidateRectdv(Context *context, const GLdouble *v1, const GLdouble *v2)
 
898
{
 
899
    return true;
 
900
}
 
901
 
 
902
bool ValidateRectf(Context *context, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 
903
{
 
904
    return true;
 
905
}
 
906
 
 
907
bool ValidateRectfv(Context *context, const GLfloat *v1, const GLfloat *v2)
 
908
{
 
909
    return true;
 
910
}
 
911
 
 
912
bool ValidateRecti(Context *context, GLint x1, GLint y1, GLint x2, GLint y2)
 
913
{
 
914
    return true;
 
915
}
 
916
 
 
917
bool ValidateRectiv(Context *context, const GLint *v1, const GLint *v2)
 
918
{
 
919
    return true;
 
920
}
 
921
 
 
922
bool ValidateRects(Context *context, GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 
923
{
 
924
    return true;
 
925
}
 
926
 
 
927
bool ValidateRectsv(Context *context, const GLshort *v1, const GLshort *v2)
 
928
{
 
929
    return true;
 
930
}
 
931
 
 
932
bool ValidateRenderMode(Context *context, GLenum mode)
 
933
{
 
934
    return true;
 
935
}
 
936
 
 
937
bool ValidateRotated(Context *context, GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 
938
{
 
939
    return true;
 
940
}
 
941
 
 
942
bool ValidateScaled(Context *context, GLdouble x, GLdouble y, GLdouble z)
 
943
{
 
944
    return true;
 
945
}
 
946
 
 
947
bool ValidateSelectBuffer(Context *context, GLsizei size, GLuint *buffer)
 
948
{
 
949
    return true;
 
950
}
 
951
 
 
952
bool ValidateTexCoord1d(Context *context, GLdouble s)
 
953
{
 
954
    return true;
 
955
}
 
956
 
 
957
bool ValidateTexCoord1dv(Context *context, const GLdouble *v)
 
958
{
 
959
    return true;
 
960
}
 
961
 
 
962
bool ValidateTexCoord1f(Context *context, GLfloat s)
 
963
{
 
964
    return true;
 
965
}
 
966
 
 
967
bool ValidateTexCoord1fv(Context *context, const GLfloat *v)
 
968
{
 
969
    return true;
 
970
}
 
971
 
 
972
bool ValidateTexCoord1i(Context *context, GLint s)
 
973
{
 
974
    return true;
 
975
}
 
976
 
 
977
bool ValidateTexCoord1iv(Context *context, const GLint *v)
 
978
{
 
979
    return true;
 
980
}
 
981
 
 
982
bool ValidateTexCoord1s(Context *context, GLshort s)
 
983
{
 
984
    return true;
 
985
}
 
986
 
 
987
bool ValidateTexCoord1sv(Context *context, const GLshort *v)
 
988
{
 
989
    return true;
 
990
}
 
991
 
 
992
bool ValidateTexCoord2d(Context *context, GLdouble s, GLdouble t)
 
993
{
 
994
    return true;
 
995
}
 
996
 
 
997
bool ValidateTexCoord2dv(Context *context, const GLdouble *v)
 
998
{
 
999
    return true;
 
1000
}
 
1001
 
 
1002
bool ValidateTexCoord2f(Context *context, GLfloat s, GLfloat t)
 
1003
{
 
1004
    return true;
 
1005
}
 
1006
 
 
1007
bool ValidateTexCoord2fv(Context *context, const GLfloat *v)
 
1008
{
 
1009
    return true;
 
1010
}
 
1011
 
 
1012
bool ValidateTexCoord2i(Context *context, GLint s, GLint t)
 
1013
{
 
1014
    return true;
 
1015
}
 
1016
 
 
1017
bool ValidateTexCoord2iv(Context *context, const GLint *v)
 
1018
{
 
1019
    return true;
 
1020
}
 
1021
 
 
1022
bool ValidateTexCoord2s(Context *context, GLshort s, GLshort t)
 
1023
{
 
1024
    return true;
 
1025
}
 
1026
 
 
1027
bool ValidateTexCoord2sv(Context *context, const GLshort *v)
 
1028
{
 
1029
    return true;
 
1030
}
 
1031
 
 
1032
bool ValidateTexCoord3d(Context *context, GLdouble s, GLdouble t, GLdouble r)
 
1033
{
 
1034
    return true;
 
1035
}
 
1036
 
 
1037
bool ValidateTexCoord3dv(Context *context, const GLdouble *v)
 
1038
{
 
1039
    return true;
 
1040
}
 
1041
 
 
1042
bool ValidateTexCoord3f(Context *context, GLfloat s, GLfloat t, GLfloat r)
 
1043
{
 
1044
    return true;
 
1045
}
 
1046
 
 
1047
bool ValidateTexCoord3fv(Context *context, const GLfloat *v)
 
1048
{
 
1049
    return true;
 
1050
}
 
1051
 
 
1052
bool ValidateTexCoord3i(Context *context, GLint s, GLint t, GLint r)
 
1053
{
 
1054
    return true;
 
1055
}
 
1056
 
 
1057
bool ValidateTexCoord3iv(Context *context, const GLint *v)
 
1058
{
 
1059
    return true;
 
1060
}
 
1061
 
 
1062
bool ValidateTexCoord3s(Context *context, GLshort s, GLshort t, GLshort r)
 
1063
{
 
1064
    return true;
 
1065
}
 
1066
 
 
1067
bool ValidateTexCoord3sv(Context *context, const GLshort *v)
 
1068
{
 
1069
    return true;
 
1070
}
 
1071
 
 
1072
bool ValidateTexCoord4d(Context *context, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 
1073
{
 
1074
    return true;
 
1075
}
 
1076
 
 
1077
bool ValidateTexCoord4dv(Context *context, const GLdouble *v)
 
1078
{
 
1079
    return true;
 
1080
}
 
1081
 
 
1082
bool ValidateTexCoord4f(Context *context, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 
1083
{
 
1084
    return true;
 
1085
}
 
1086
 
 
1087
bool ValidateTexCoord4fv(Context *context, const GLfloat *v)
 
1088
{
 
1089
    return true;
 
1090
}
 
1091
 
 
1092
bool ValidateTexCoord4i(Context *context, GLint s, GLint t, GLint r, GLint q)
 
1093
{
 
1094
    return true;
 
1095
}
 
1096
 
 
1097
bool ValidateTexCoord4iv(Context *context, const GLint *v)
 
1098
{
 
1099
    return true;
 
1100
}
 
1101
 
 
1102
bool ValidateTexCoord4s(Context *context, GLshort s, GLshort t, GLshort r, GLshort q)
 
1103
{
 
1104
    return true;
 
1105
}
 
1106
 
 
1107
bool ValidateTexCoord4sv(Context *context, const GLshort *v)
 
1108
{
 
1109
    return true;
 
1110
}
 
1111
 
 
1112
bool ValidateTexGend(Context *context, GLenum coord, GLenum pname, GLdouble param)
 
1113
{
 
1114
    return true;
 
1115
}
 
1116
 
 
1117
bool ValidateTexGendv(Context *context, GLenum coord, GLenum pname, const GLdouble *params)
 
1118
{
 
1119
    return true;
 
1120
}
 
1121
 
 
1122
bool ValidateTexGenf(Context *context, GLenum coord, GLenum pname, GLfloat param)
 
1123
{
 
1124
    return true;
 
1125
}
 
1126
bool ValidateTexGenfv(Context *context, GLenum coord, GLenum pname, const GLfloat *params)
 
1127
{
 
1128
    return true;
 
1129
}
 
1130
 
 
1131
bool ValidateTexGeni(Context *context, GLenum coord, GLenum pname, GLint param)
 
1132
{
 
1133
    return true;
 
1134
}
 
1135
 
 
1136
bool ValidateTexGeniv(Context *context, GLenum coord, GLenum pname, const GLint *params)
 
1137
{
 
1138
    return true;
 
1139
}
 
1140
 
 
1141
bool ValidateTexImage1D(Context *context,
 
1142
                        GLenum target,
 
1143
                        GLint level,
 
1144
                        GLint internalformat,
 
1145
                        GLsizei width,
 
1146
                        GLint border,
 
1147
                        GLenum format,
 
1148
                        GLenum type,
 
1149
                        const void *pixels)
 
1150
{
 
1151
    return true;
 
1152
}
 
1153
 
 
1154
bool ValidateTranslated(Context *context, GLdouble x, GLdouble y, GLdouble z)
 
1155
{
 
1156
    return true;
 
1157
}
 
1158
 
 
1159
bool ValidateVertex2d(Context *context, GLdouble x, GLdouble y)
 
1160
{
 
1161
    return true;
 
1162
}
 
1163
 
 
1164
bool ValidateVertex2dv(Context *context, const GLdouble *v)
 
1165
{
 
1166
    return true;
 
1167
}
 
1168
 
 
1169
bool ValidateVertex2f(Context *context, GLfloat x, GLfloat y)
 
1170
{
 
1171
    return true;
 
1172
}
 
1173
 
 
1174
bool ValidateVertex2fv(Context *context, const GLfloat *v)
 
1175
{
 
1176
    return true;
 
1177
}
 
1178
 
 
1179
bool ValidateVertex2i(Context *context, GLint x, GLint y)
 
1180
{
 
1181
    return true;
 
1182
}
 
1183
 
 
1184
bool ValidateVertex2iv(Context *context, const GLint *v)
 
1185
{
 
1186
    return true;
 
1187
}
 
1188
 
 
1189
bool ValidateVertex2s(Context *context, GLshort x, GLshort y)
 
1190
{
 
1191
    return true;
 
1192
}
 
1193
 
 
1194
bool ValidateVertex2sv(Context *context, const GLshort *v)
 
1195
{
 
1196
    return true;
 
1197
}
 
1198
 
 
1199
bool ValidateVertex3d(Context *context, GLdouble x, GLdouble y, GLdouble z)
 
1200
{
 
1201
    return true;
 
1202
}
 
1203
 
 
1204
bool ValidateVertex3dv(Context *context, const GLdouble *v)
 
1205
{
 
1206
    return true;
 
1207
}
 
1208
 
 
1209
bool ValidateVertex3f(Context *context, GLfloat x, GLfloat y, GLfloat z)
 
1210
{
 
1211
    return true;
 
1212
}
 
1213
 
 
1214
bool ValidateVertex3fv(Context *context, const GLfloat *v)
 
1215
{
 
1216
    return true;
 
1217
}
 
1218
 
 
1219
bool ValidateVertex3i(Context *context, GLint x, GLint y, GLint z)
 
1220
{
 
1221
    return true;
 
1222
}
 
1223
 
 
1224
bool ValidateVertex3iv(Context *context, const GLint *v)
 
1225
{
 
1226
    return true;
 
1227
}
 
1228
 
 
1229
bool ValidateVertex3s(Context *context, GLshort x, GLshort y, GLshort z)
 
1230
{
 
1231
    return true;
 
1232
}
 
1233
 
 
1234
bool ValidateVertex3sv(Context *context, const GLshort *v)
 
1235
{
 
1236
    return true;
 
1237
}
 
1238
 
 
1239
bool ValidateVertex4d(Context *context, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 
1240
{
 
1241
    return true;
 
1242
}
 
1243
 
 
1244
bool ValidateVertex4dv(Context *context, const GLdouble *v)
 
1245
{
 
1246
    return true;
 
1247
}
 
1248
 
 
1249
bool ValidateVertex4f(Context *context, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 
1250
{
 
1251
    return true;
 
1252
}
 
1253
 
 
1254
bool ValidateVertex4fv(Context *context, const GLfloat *v)
 
1255
{
 
1256
    return true;
 
1257
}
 
1258
 
 
1259
bool ValidateVertex4i(Context *context, GLint x, GLint y, GLint z, GLint w)
 
1260
{
 
1261
    return true;
 
1262
}
 
1263
 
 
1264
bool ValidateVertex4iv(Context *context, const GLint *v)
 
1265
{
 
1266
    return true;
 
1267
}
 
1268
 
 
1269
bool ValidateVertex4s(Context *context, GLshort x, GLshort y, GLshort z, GLshort w)
 
1270
{
 
1271
    return true;
 
1272
}
 
1273
 
 
1274
bool ValidateVertex4sv(Context *context, const GLshort *v)
 
1275
{
 
1276
    return true;
 
1277
}
 
1278
 
 
1279
}  // namespace gl