← Back to branch summary

~mmach/netext73/webkit2gtk

« back to all changes in this revision

Viewing changes to Source/ThirdParty/ANGLE/src/libANGLE/validationGL45.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/validationGL45.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
// validationGL45.cpp: Validation functions for OpenGL 4.5 entry point parameters
 
8
 
 
9
#include "libANGLE/validationGL45_autogen.h"
 
10
 
 
11
namespace gl
 
12
{
 
13
 
 
14
bool ValidateBindTextureUnit(Context *context, GLuint unit, TextureID texture)
 
15
{
 
16
    return true;
 
17
}
 
18
 
 
19
bool ValidateBlitNamedFramebuffer(Context *context,
 
20
                                  GLuint readFramebuffer,
 
21
                                  GLuint drawFramebuffer,
 
22
                                  GLint srcX0,
 
23
                                  GLint srcY0,
 
24
                                  GLint srcX1,
 
25
                                  GLint srcY1,
 
26
                                  GLint dstX0,
 
27
                                  GLint dstY0,
 
28
                                  GLint dstX1,
 
29
                                  GLint dstY1,
 
30
                                  GLbitfield mask,
 
31
                                  GLenum filter)
 
32
{
 
33
    return true;
 
34
}
 
35
 
 
36
bool ValidateCheckNamedFramebufferStatus(Context *context, FramebufferID framebuffer, GLenum target)
 
37
{
 
38
    return true;
 
39
}
 
40
 
 
41
bool ValidateClearNamedBufferData(Context *context,
 
42
                                  BufferID buffer,
 
43
                                  GLenum internalformat,
 
44
                                  GLenum format,
 
45
                                  GLenum type,
 
46
                                  const void *data)
 
47
{
 
48
    return true;
 
49
}
 
50
 
 
51
bool ValidateClearNamedBufferSubData(Context *context,
 
52
                                     BufferID buffer,
 
53
                                     GLenum internalformat,
 
54
                                     GLintptr offset,
 
55
                                     GLsizeiptr size,
 
56
                                     GLenum format,
 
57
                                     GLenum type,
 
58
                                     const void *data)
 
59
{
 
60
    return true;
 
61
}
 
62
 
 
63
bool ValidateClearNamedFramebufferfi(Context *context,
 
64
                                     FramebufferID framebuffer,
 
65
                                     GLenum buffer,
 
66
                                     GLint drawbuffer,
 
67
                                     GLfloat depth,
 
68
                                     GLint stencil)
 
69
{
 
70
    return true;
 
71
}
 
72
 
 
73
bool ValidateClearNamedFramebufferfv(Context *context,
 
74
                                     FramebufferID framebuffer,
 
75
                                     GLenum buffer,
 
76
                                     GLint drawbuffer,
 
77
                                     const GLfloat *value)
 
78
{
 
79
    return true;
 
80
}
 
81
 
 
82
bool ValidateClearNamedFramebufferiv(Context *context,
 
83
                                     FramebufferID framebuffer,
 
84
                                     GLenum buffer,
 
85
                                     GLint drawbuffer,
 
86
                                     const GLint *value)
 
87
{
 
88
    return true;
 
89
}
 
90
 
 
91
bool ValidateClearNamedFramebufferuiv(Context *context,
 
92
                                      FramebufferID framebuffer,
 
93
                                      GLenum buffer,
 
94
                                      GLint drawbuffer,
 
95
                                      const GLuint *value)
 
96
{
 
97
    return true;
 
98
}
 
99
 
 
100
bool ValidateClipControl(Context *context, GLenum origin, GLenum depth)
 
101
{
 
102
    return true;
 
103
}
 
104
 
 
105
bool ValidateCompressedTextureSubImage1D(Context *context,
 
106
                                         TextureID texture,
 
107
                                         GLint level,
 
108
                                         GLint xoffset,
 
109
                                         GLsizei width,
 
110
                                         GLenum format,
 
111
                                         GLsizei imageSize,
 
112
                                         const void *data)
 
113
{
 
114
    return true;
 
115
}
 
116
 
 
117
bool ValidateCompressedTextureSubImage2D(Context *context,
 
118
                                         TextureID texture,
 
119
                                         GLint level,
 
120
                                         GLint xoffset,
 
121
                                         GLint yoffset,
 
122
                                         GLsizei width,
 
123
                                         GLsizei height,
 
124
                                         GLenum format,
 
125
                                         GLsizei imageSize,
 
126
                                         const void *data)
 
127
{
 
128
    return true;
 
129
}
 
130
 
 
131
bool ValidateCompressedTextureSubImage3D(Context *context,
 
132
                                         TextureID texture,
 
133
                                         GLint level,
 
134
                                         GLint xoffset,
 
135
                                         GLint yoffset,
 
136
                                         GLint zoffset,
 
137
                                         GLsizei width,
 
138
                                         GLsizei height,
 
139
                                         GLsizei depth,
 
140
                                         GLenum format,
 
141
                                         GLsizei imageSize,
 
142
                                         const void *data)
 
143
{
 
144
    return true;
 
145
}
 
146
 
 
147
bool ValidateCopyNamedBufferSubData(Context *context,
 
148
                                    GLuint readBuffer,
 
149
                                    GLuint writeBuffer,
 
150
                                    GLintptr readOffset,
 
151
                                    GLintptr writeOffset,
 
152
                                    GLsizeiptr size)
 
153
{
 
154
    return true;
 
155
}
 
156
 
 
157
bool ValidateCopyTextureSubImage1D(Context *context,
 
158
                                   TextureID texture,
 
159
                                   GLint level,
 
160
                                   GLint xoffset,
 
161
                                   GLint x,
 
162
                                   GLint y,
 
163
                                   GLsizei width)
 
164
{
 
165
    return true;
 
166
}
 
167
 
 
168
bool ValidateCopyTextureSubImage2D(Context *context,
 
169
                                   TextureID texture,
 
170
                                   GLint level,
 
171
                                   GLint xoffset,
 
172
                                   GLint yoffset,
 
173
                                   GLint x,
 
174
                                   GLint y,
 
175
                                   GLsizei width,
 
176
                                   GLsizei height)
 
177
{
 
178
    return true;
 
179
}
 
180
 
 
181
bool ValidateCopyTextureSubImage3D(Context *context,
 
182
                                   TextureID texture,
 
183
                                   GLint level,
 
184
                                   GLint xoffset,
 
185
                                   GLint yoffset,
 
186
                                   GLint zoffset,
 
187
                                   GLint x,
 
188
                                   GLint y,
 
189
                                   GLsizei width,
 
190
                                   GLsizei height)
 
191
{
 
192
    return true;
 
193
}
 
194
 
 
195
bool ValidateCreateBuffers(Context *context, GLsizei n, BufferID *buffers)
 
196
{
 
197
    return true;
 
198
}
 
199
 
 
200
bool ValidateCreateFramebuffers(Context *context, GLsizei n, GLuint *framebuffers)
 
201
{
 
202
    return true;
 
203
}
 
204
 
 
205
bool ValidateCreateProgramPipelines(Context *context, GLsizei n, GLuint *pipelines)
 
206
{
 
207
    return true;
 
208
}
 
209
 
 
210
bool ValidateCreateQueries(Context *context, GLenum target, GLsizei n, GLuint *ids)
 
211
{
 
212
    return true;
 
213
}
 
214
 
 
215
bool ValidateCreateRenderbuffers(Context *context, GLsizei n, RenderbufferID *renderbuffers)
 
216
{
 
217
    return true;
 
218
}
 
219
 
 
220
bool ValidateCreateSamplers(Context *context, GLsizei n, GLuint *samplers)
 
221
{
 
222
    return true;
 
223
}
 
224
 
 
225
bool ValidateCreateTextures(Context *context, GLenum target, GLsizei n, GLuint *textures)
 
226
{
 
227
    return true;
 
228
}
 
229
 
 
230
bool ValidateCreateTransformFeedbacks(Context *context, GLsizei n, GLuint *ids)
 
231
{
 
232
    return true;
 
233
}
 
234
 
 
235
bool ValidateCreateVertexArrays(Context *context, GLsizei n, VertexArrayID *arrays)
 
236
{
 
237
    return true;
 
238
}
 
239
 
 
240
bool ValidateDisableVertexArrayAttrib(Context *context, VertexArrayID vaobj, GLuint index)
 
241
{
 
242
    return true;
 
243
}
 
244
 
 
245
bool ValidateEnableVertexArrayAttrib(Context *context, VertexArrayID vaobj, GLuint index)
 
246
{
 
247
    return true;
 
248
}
 
249
 
 
250
bool ValidateFlushMappedNamedBufferRange(Context *context,
 
251
                                         BufferID buffer,
 
252
                                         GLintptr offset,
 
253
                                         GLsizeiptr length)
 
254
{
 
255
    return true;
 
256
}
 
257
 
 
258
bool ValidateGenerateTextureMipmap(Context *context, TextureID texture)
 
259
{
 
260
    return true;
 
261
}
 
262
 
 
263
bool ValidateGetCompressedTextureImage(Context *context,
 
264
                                       TextureID texture,
 
265
                                       GLint level,
 
266
                                       GLsizei bufSize,
 
267
                                       void *pixels)
 
268
{
 
269
    return true;
 
270
}
 
271
 
 
272
bool ValidateGetCompressedTextureSubImage(Context *context,
 
273
                                          TextureID texture,
 
274
                                          GLint level,
 
275
                                          GLint xoffset,
 
276
                                          GLint yoffset,
 
277
                                          GLint zoffset,
 
278
                                          GLsizei width,
 
279
                                          GLsizei height,
 
280
                                          GLsizei depth,
 
281
                                          GLsizei bufSize,
 
282
                                          void *pixels)
 
283
{
 
284
    return true;
 
285
}
 
286
 
 
287
bool ValidateGetNamedBufferParameteri64v(Context *context,
 
288
                                         BufferID buffer,
 
289
                                         GLenum pname,
 
290
                                         GLint64 *params)
 
291
{
 
292
    return true;
 
293
}
 
294
 
 
295
bool ValidateGetNamedBufferParameteriv(Context *context,
 
296
                                       BufferID buffer,
 
297
                                       GLenum pname,
 
298
                                       GLint *params)
 
299
{
 
300
    return true;
 
301
}
 
302
 
 
303
bool ValidateGetNamedBufferPointerv(Context *context, BufferID buffer, GLenum pname, void **params)
 
304
{
 
305
    return true;
 
306
}
 
307
 
 
308
bool ValidateGetNamedBufferSubData(Context *context,
 
309
                                   BufferID buffer,
 
310
                                   GLintptr offset,
 
311
                                   GLsizeiptr size,
 
312
                                   void *data)
 
313
{
 
314
    return true;
 
315
}
 
316
 
 
317
bool ValidateGetNamedFramebufferAttachmentParameteriv(Context *context,
 
318
                                                      FramebufferID framebuffer,
 
319
                                                      GLenum attachment,
 
320
                                                      GLenum pname,
 
321
                                                      GLint *params)
 
322
{
 
323
    return true;
 
324
}
 
325
 
 
326
bool ValidateGetNamedFramebufferParameteriv(Context *context,
 
327
                                            FramebufferID framebuffer,
 
328
                                            GLenum pname,
 
329
                                            GLint *param)
 
330
{
 
331
    return true;
 
332
}
 
333
 
 
334
bool ValidateGetNamedRenderbufferParameteriv(Context *context,
 
335
                                             RenderbufferID renderbuffer,
 
336
                                             GLenum pname,
 
337
                                             GLint *params)
 
338
{
 
339
    return true;
 
340
}
 
341
 
 
342
bool ValidateGetQueryBufferObjecti64v(Context *context,
 
343
                                      GLuint id,
 
344
                                      BufferID buffer,
 
345
                                      GLenum pname,
 
346
                                      GLintptr offset)
 
347
{
 
348
    return true;
 
349
}
 
350
 
 
351
bool ValidateGetQueryBufferObjectiv(Context *context,
 
352
                                    GLuint id,
 
353
                                    BufferID buffer,
 
354
                                    GLenum pname,
 
355
                                    GLintptr offset)
 
356
{
 
357
    return true;
 
358
}
 
359
 
 
360
bool ValidateGetQueryBufferObjectui64v(Context *context,
 
361
                                       GLuint id,
 
362
                                       BufferID buffer,
 
363
                                       GLenum pname,
 
364
                                       GLintptr offset)
 
365
{
 
366
    return true;
 
367
}
 
368
 
 
369
bool ValidateGetQueryBufferObjectuiv(Context *context,
 
370
                                     GLuint id,
 
371
                                     BufferID buffer,
 
372
                                     GLenum pname,
 
373
                                     GLintptr offset)
 
374
{
 
375
    return true;
 
376
}
 
377
 
 
378
bool ValidateGetTextureImage(Context *context,
 
379
                             TextureID texture,
 
380
                             GLint level,
 
381
                             GLenum format,
 
382
                             GLenum type,
 
383
                             GLsizei bufSize,
 
384
                             void *pixels)
 
385
{
 
386
    return true;
 
387
}
 
388
 
 
389
bool ValidateGetTextureLevelParameterfv(Context *context,
 
390
                                        TextureID texture,
 
391
                                        GLint level,
 
392
                                        GLenum pname,
 
393
                                        GLfloat *params)
 
394
{
 
395
    return true;
 
396
}
 
397
 
 
398
bool ValidateGetTextureLevelParameteriv(Context *context,
 
399
                                        TextureID texture,
 
400
                                        GLint level,
 
401
                                        GLenum pname,
 
402
                                        GLint *params)
 
403
{
 
404
    return true;
 
405
}
 
406
 
 
407
bool ValidateGetTextureParameterIiv(Context *context,
 
408
                                    TextureID texture,
 
409
                                    GLenum pname,
 
410
                                    GLint *params)
 
411
{
 
412
    return true;
 
413
}
 
414
 
 
415
bool ValidateGetTextureParameterIuiv(Context *context,
 
416
                                     TextureID texture,
 
417
                                     GLenum pname,
 
418
                                     GLuint *params)
 
419
{
 
420
    return true;
 
421
}
 
422
 
 
423
bool ValidateGetTextureParameterfv(Context *context,
 
424
                                   TextureID texture,
 
425
                                   GLenum pname,
 
426
                                   GLfloat *params)
 
427
{
 
428
    return true;
 
429
}
 
430
 
 
431
bool ValidateGetTextureParameteriv(Context *context, TextureID texture, GLenum pname, GLint *params)
 
432
{
 
433
    return true;
 
434
}
 
435
 
 
436
bool ValidateGetTextureSubImage(Context *context,
 
437
                                TextureID texture,
 
438
                                GLint level,
 
439
                                GLint xoffset,
 
440
                                GLint yoffset,
 
441
                                GLint zoffset,
 
442
                                GLsizei width,
 
443
                                GLsizei height,
 
444
                                GLsizei depth,
 
445
                                GLenum format,
 
446
                                GLenum type,
 
447
                                GLsizei bufSize,
 
448
                                void *pixels)
 
449
{
 
450
    return true;
 
451
}
 
452
 
 
453
bool ValidateGetTransformFeedbacki64_v(Context *context,
 
454
                                       GLuint xfb,
 
455
                                       GLenum pname,
 
456
                                       GLuint index,
 
457
                                       GLint64 *param)
 
458
{
 
459
    return true;
 
460
}
 
461
 
 
462
bool ValidateGetTransformFeedbacki_v(Context *context,
 
463
                                     GLuint xfb,
 
464
                                     GLenum pname,
 
465
                                     GLuint index,
 
466
                                     GLint *param)
 
467
{
 
468
    return true;
 
469
}
 
470
 
 
471
bool ValidateGetTransformFeedbackiv(Context *context, GLuint xfb, GLenum pname, GLint *param)
 
472
{
 
473
    return true;
 
474
}
 
475
 
 
476
bool ValidateGetVertexArrayIndexed64iv(Context *context,
 
477
                                       VertexArrayID vaobj,
 
478
                                       GLuint index,
 
479
                                       GLenum pname,
 
480
                                       GLint64 *param)
 
481
{
 
482
    return true;
 
483
}
 
484
 
 
485
bool ValidateGetVertexArrayIndexediv(Context *context,
 
486
                                     VertexArrayID vaobj,
 
487
                                     GLuint index,
 
488
                                     GLenum pname,
 
489
                                     GLint *param)
 
490
{
 
491
    return true;
 
492
}
 
493
 
 
494
bool ValidateGetVertexArrayiv(Context *context, VertexArrayID vaobj, GLenum pname, GLint *param)
 
495
{
 
496
    return true;
 
497
}
 
498
 
 
499
bool ValidateGetnColorTable(Context *context,
 
500
                            GLenum target,
 
501
                            GLenum format,
 
502
                            GLenum type,
 
503
                            GLsizei bufSize,
 
504
                            void *table)
 
505
{
 
506
    return true;
 
507
}
 
508
 
 
509
bool ValidateGetnCompressedTexImage(Context *context,
 
510
                                    GLenum target,
 
511
                                    GLint lod,
 
512
                                    GLsizei bufSize,
 
513
                                    void *pixels)
 
514
{
 
515
    return true;
 
516
}
 
517
 
 
518
bool ValidateGetnConvolutionFilter(Context *context,
 
519
                                   GLenum target,
 
520
                                   GLenum format,
 
521
                                   GLenum type,
 
522
                                   GLsizei bufSize,
 
523
                                   void *image)
 
524
{
 
525
    return true;
 
526
}
 
527
 
 
528
bool ValidateGetnHistogram(Context *context,
 
529
                           GLenum target,
 
530
                           GLboolean reset,
 
531
                           GLenum format,
 
532
                           GLenum type,
 
533
                           GLsizei bufSize,
 
534
                           void *values)
 
535
{
 
536
    return true;
 
537
}
 
538
 
 
539
bool ValidateGetnMapdv(Context *context, GLenum target, GLenum query, GLsizei bufSize, GLdouble *v)
 
540
{
 
541
    return true;
 
542
}
 
543
 
 
544
bool ValidateGetnMapfv(Context *context, GLenum target, GLenum query, GLsizei bufSize, GLfloat *v)
 
545
{
 
546
    return true;
 
547
}
 
548
 
 
549
bool ValidateGetnMapiv(Context *context, GLenum target, GLenum query, GLsizei bufSize, GLint *v)
 
550
{
 
551
    return true;
 
552
}
 
553
 
 
554
bool ValidateGetnMinmax(Context *context,
 
555
                        GLenum target,
 
556
                        GLboolean reset,
 
557
                        GLenum format,
 
558
                        GLenum type,
 
559
                        GLsizei bufSize,
 
560
                        void *values)
 
561
{
 
562
    return true;
 
563
}
 
564
 
 
565
bool ValidateGetnPixelMapfv(Context *context, GLenum map, GLsizei bufSize, GLfloat *values)
 
566
{
 
567
    return true;
 
568
}
 
569
 
 
570
bool ValidateGetnPixelMapuiv(Context *context, GLenum map, GLsizei bufSize, GLuint *values)
 
571
{
 
572
    return true;
 
573
}
 
574
 
 
575
bool ValidateGetnPixelMapusv(Context *context, GLenum map, GLsizei bufSize, GLushort *values)
 
576
{
 
577
    return true;
 
578
}
 
579
 
 
580
bool ValidateGetnPolygonStipple(Context *context, GLsizei bufSize, GLubyte *pattern)
 
581
{
 
582
    return true;
 
583
}
 
584
 
 
585
bool ValidateGetnSeparableFilter(Context *context,
 
586
                                 GLenum target,
 
587
                                 GLenum format,
 
588
                                 GLenum type,
 
589
                                 GLsizei rowBufSize,
 
590
                                 void *row,
 
591
                                 GLsizei columnBufSize,
 
592
                                 void *column,
 
593
                                 void *span)
 
594
{
 
595
    return true;
 
596
}
 
597
 
 
598
bool ValidateGetnTexImage(Context *context,
 
599
                          GLenum target,
 
600
                          GLint level,
 
601
                          GLenum format,
 
602
                          GLenum type,
 
603
                          GLsizei bufSize,
 
604
                          void *pixels)
 
605
{
 
606
    return true;
 
607
}
 
608
 
 
609
bool ValidateGetnUniformdv(Context *context,
 
610
                           ShaderProgramID program,
 
611
                           GLint location,
 
612
                           GLsizei bufSize,
 
613
                           GLdouble *params)
 
614
{
 
615
    return true;
 
616
}
 
617
 
 
618
bool ValidateInvalidateNamedFramebufferData(Context *context,
 
619
                                            FramebufferID framebuffer,
 
620
                                            GLsizei numAttachments,
 
621
                                            const GLenum *attachments)
 
622
{
 
623
    return true;
 
624
}
 
625
 
 
626
bool ValidateInvalidateNamedFramebufferSubData(Context *context,
 
627
                                               FramebufferID framebuffer,
 
628
                                               GLsizei numAttachments,
 
629
                                               const GLenum *attachments,
 
630
                                               GLint x,
 
631
                                               GLint y,
 
632
                                               GLsizei width,
 
633
                                               GLsizei height)
 
634
{
 
635
    return true;
 
636
}
 
637
 
 
638
bool ValidateMapNamedBuffer(Context *context, BufferID buffer, GLenum access)
 
639
{
 
640
    return true;
 
641
}
 
642
 
 
643
bool ValidateMapNamedBufferRange(Context *context,
 
644
                                 BufferID buffer,
 
645
                                 GLintptr offset,
 
646
                                 GLsizeiptr length,
 
647
                                 GLbitfield access)
 
648
{
 
649
    return true;
 
650
}
 
651
 
 
652
bool ValidateNamedBufferData(Context *context,
 
653
                             BufferID buffer,
 
654
                             GLsizeiptr size,
 
655
                             const void *data,
 
656
                             GLenum usage)
 
657
{
 
658
    return true;
 
659
}
 
660
 
 
661
bool ValidateNamedBufferStorage(Context *context,
 
662
                                BufferID buffer,
 
663
                                GLsizeiptr size,
 
664
                                const void *data,
 
665
                                GLbitfield flags)
 
666
{
 
667
    return true;
 
668
}
 
669
 
 
670
bool ValidateNamedBufferSubData(Context *context,
 
671
                                BufferID buffer,
 
672
                                GLintptr offset,
 
673
                                GLsizeiptr size,
 
674
                                const void *data)
 
675
{
 
676
    return true;
 
677
}
 
678
 
 
679
bool ValidateNamedFramebufferDrawBuffer(Context *context, FramebufferID framebuffer, GLenum buf)
 
680
{
 
681
    return true;
 
682
}
 
683
 
 
684
bool ValidateNamedFramebufferDrawBuffers(Context *context,
 
685
                                         FramebufferID framebuffer,
 
686
                                         GLsizei n,
 
687
                                         const GLenum *bufs)
 
688
{
 
689
    return true;
 
690
}
 
691
 
 
692
bool ValidateNamedFramebufferParameteri(Context *context,
 
693
                                        FramebufferID framebuffer,
 
694
                                        GLenum pname,
 
695
                                        GLint param)
 
696
{
 
697
    return true;
 
698
}
 
699
 
 
700
bool ValidateNamedFramebufferReadBuffer(Context *context, FramebufferID framebuffer, GLenum src)
 
701
{
 
702
    return true;
 
703
}
 
704
 
 
705
bool ValidateNamedFramebufferRenderbuffer(Context *context,
 
706
                                          FramebufferID framebuffer,
 
707
                                          GLenum attachment,
 
708
                                          GLenum renderbuffertarget,
 
709
                                          RenderbufferID renderbuffer)
 
710
{
 
711
    return true;
 
712
}
 
713
 
 
714
bool ValidateNamedFramebufferTexture(Context *context,
 
715
                                     FramebufferID framebuffer,
 
716
                                     GLenum attachment,
 
717
                                     TextureID texture,
 
718
                                     GLint level)
 
719
{
 
720
    return true;
 
721
}
 
722
 
 
723
bool ValidateNamedFramebufferTextureLayer(Context *context,
 
724
                                          FramebufferID framebuffer,
 
725
                                          GLenum attachment,
 
726
                                          TextureID texture,
 
727
                                          GLint level,
 
728
                                          GLint layer)
 
729
{
 
730
    return true;
 
731
}
 
732
 
 
733
bool ValidateNamedRenderbufferStorage(Context *context,
 
734
                                      RenderbufferID renderbuffer,
 
735
                                      GLenum internalformat,
 
736
                                      GLsizei width,
 
737
                                      GLsizei height)
 
738
{
 
739
    return true;
 
740
}
 
741
 
 
742
bool ValidateNamedRenderbufferStorageMultisample(Context *context,
 
743
                                                 RenderbufferID renderbuffer,
 
744
                                                 GLsizei samples,
 
745
                                                 GLenum internalformat,
 
746
                                                 GLsizei width,
 
747
                                                 GLsizei height)
 
748
{
 
749
    return true;
 
750
}
 
751
 
 
752
bool ValidateTextureBarrier(Context *context)
 
753
{
 
754
    return true;
 
755
}
 
756
 
 
757
bool ValidateTextureBuffer(Context *context,
 
758
                           TextureID texture,
 
759
                           GLenum internalformat,
 
760
                           BufferID buffer)
 
761
{
 
762
    return true;
 
763
}
 
764
 
 
765
bool ValidateTextureBufferRange(Context *context,
 
766
                                TextureID texture,
 
767
                                GLenum internalformat,
 
768
                                BufferID buffer,
 
769
                                GLintptr offset,
 
770
                                GLsizeiptr size)
 
771
{
 
772
    return true;
 
773
}
 
774
 
 
775
bool ValidateTextureParameterIiv(Context *context,
 
776
                                 TextureID texture,
 
777
                                 GLenum pname,
 
778
                                 const GLint *params)
 
779
{
 
780
    return true;
 
781
}
 
782
 
 
783
bool ValidateTextureParameterIuiv(Context *context,
 
784
                                  TextureID texture,
 
785
                                  GLenum pname,
 
786
                                  const GLuint *params)
 
787
{
 
788
    return true;
 
789
}
 
790
 
 
791
bool ValidateTextureParameterf(Context *context, TextureID texture, GLenum pname, GLfloat param)
 
792
{
 
793
    return true;
 
794
}
 
795
 
 
796
bool ValidateTextureParameterfv(Context *context,
 
797
                                TextureID texture,
 
798
                                GLenum pname,
 
799
                                const GLfloat *param)
 
800
{
 
801
    return true;
 
802
}
 
803
 
 
804
bool ValidateTextureParameteri(Context *context, TextureID texture, GLenum pname, GLint param)
 
805
{
 
806
    return true;
 
807
}
 
808
 
 
809
bool ValidateTextureParameteriv(Context *context,
 
810
                                TextureID texture,
 
811
                                GLenum pname,
 
812
                                const GLint *param)
 
813
{
 
814
    return true;
 
815
}
 
816
 
 
817
bool ValidateTextureStorage1D(Context *context,
 
818
                              TextureID texture,
 
819
                              GLsizei levels,
 
820
                              GLenum internalformat,
 
821
                              GLsizei width)
 
822
{
 
823
    return true;
 
824
}
 
825
 
 
826
bool ValidateTextureStorage2D(Context *context,
 
827
                              TextureID texture,
 
828
                              GLsizei levels,
 
829
                              GLenum internalformat,
 
830
                              GLsizei width,
 
831
                              GLsizei height)
 
832
{
 
833
    return true;
 
834
}
 
835
 
 
836
bool ValidateTextureStorage2DMultisample(Context *context,
 
837
                                         TextureID texture,
 
838
                                         GLsizei samples,
 
839
                                         GLenum internalformat,
 
840
                                         GLsizei width,
 
841
                                         GLsizei height,
 
842
                                         GLboolean fixedsamplelocations)
 
843
{
 
844
    return true;
 
845
}
 
846
 
 
847
bool ValidateTextureStorage3D(Context *context,
 
848
                              TextureID texture,
 
849
                              GLsizei levels,
 
850
                              GLenum internalformat,
 
851
                              GLsizei width,
 
852
                              GLsizei height,
 
853
                              GLsizei depth)
 
854
{
 
855
    return true;
 
856
}
 
857
 
 
858
bool ValidateTextureStorage3DMultisample(Context *context,
 
859
                                         TextureID texture,
 
860
                                         GLsizei samples,
 
861
                                         GLenum internalformat,
 
862
                                         GLsizei width,
 
863
                                         GLsizei height,
 
864
                                         GLsizei depth,
 
865
                                         GLboolean fixedsamplelocations)
 
866
{
 
867
    return true;
 
868
}
 
869
 
 
870
bool ValidateTextureSubImage1D(Context *context,
 
871
                               TextureID texture,
 
872
                               GLint level,
 
873
                               GLint xoffset,
 
874
                               GLsizei width,
 
875
                               GLenum format,
 
876
                               GLenum type,
 
877
                               const void *pixels)
 
878
{
 
879
    return true;
 
880
}
 
881
 
 
882
bool ValidateTextureSubImage2D(Context *context,
 
883
                               TextureID texture,
 
884
                               GLint level,
 
885
                               GLint xoffset,
 
886
                               GLint yoffset,
 
887
                               GLsizei width,
 
888
                               GLsizei height,
 
889
                               GLenum format,
 
890
                               GLenum type,
 
891
                               const void *pixels)
 
892
{
 
893
    return true;
 
894
}
 
895
 
 
896
bool ValidateTextureSubImage3D(Context *context,
 
897
                               TextureID texture,
 
898
                               GLint level,
 
899
                               GLint xoffset,
 
900
                               GLint yoffset,
 
901
                               GLint zoffset,
 
902
                               GLsizei width,
 
903
                               GLsizei height,
 
904
                               GLsizei depth,
 
905
                               GLenum format,
 
906
                               GLenum type,
 
907
                               const void *pixels)
 
908
{
 
909
    return true;
 
910
}
 
911
 
 
912
bool ValidateTransformFeedbackBufferBase(Context *context,
 
913
                                         GLuint xfb,
 
914
                                         GLuint index,
 
915
                                         BufferID buffer)
 
916
{
 
917
    return true;
 
918
}
 
919
 
 
920
bool ValidateTransformFeedbackBufferRange(Context *context,
 
921
                                          GLuint xfb,
 
922
                                          GLuint index,
 
923
                                          BufferID buffer,
 
924
                                          GLintptr offset,
 
925
                                          GLsizeiptr size)
 
926
{
 
927
    return true;
 
928
}
 
929
 
 
930
bool ValidateUnmapNamedBuffer(Context *context, BufferID buffer)
 
931
{
 
932
    return true;
 
933
}
 
934
 
 
935
bool ValidateVertexArrayAttribBinding(Context *context,
 
936
                                      VertexArrayID vaobj,
 
937
                                      GLuint attribindex,
 
938
                                      GLuint bindingindex)
 
939
{
 
940
    return true;
 
941
}
 
942
 
 
943
bool ValidateVertexArrayAttribFormat(Context *context,
 
944
                                     VertexArrayID vaobj,
 
945
                                     GLuint attribindex,
 
946
                                     GLint size,
 
947
                                     GLenum type,
 
948
                                     GLboolean normalized,
 
949
                                     GLuint relativeoffset)
 
950
{
 
951
    return true;
 
952
}
 
953
 
 
954
bool ValidateVertexArrayAttribIFormat(Context *context,
 
955
                                      VertexArrayID vaobj,
 
956
                                      GLuint attribindex,
 
957
                                      GLint size,
 
958
                                      GLenum type,
 
959
                                      GLuint relativeoffset)
 
960
{
 
961
    return true;
 
962
}
 
963
 
 
964
bool ValidateVertexArrayAttribLFormat(Context *context,
 
965
                                      VertexArrayID vaobj,
 
966
                                      GLuint attribindex,
 
967
                                      GLint size,
 
968
                                      GLenum type,
 
969
                                      GLuint relativeoffset)
 
970
{
 
971
    return true;
 
972
}
 
973
 
 
974
bool ValidateVertexArrayBindingDivisor(Context *context,
 
975
                                       VertexArrayID vaobj,
 
976
                                       GLuint bindingindex,
 
977
                                       GLuint divisor)
 
978
{
 
979
    return true;
 
980
}
 
981
 
 
982
bool ValidateVertexArrayElementBuffer(Context *context, VertexArrayID vaobj, BufferID buffer)
 
983
{
 
984
    return true;
 
985
}
 
986
 
 
987
bool ValidateVertexArrayVertexBuffer(Context *context,
 
988
                                     VertexArrayID vaobj,
 
989
                                     GLuint bindingindex,
 
990
                                     BufferID buffer,
 
991
                                     GLintptr offset,
 
992
                                     GLsizei stride)
 
993
{
 
994
    return true;
 
995
}
 
996
 
 
997
bool ValidateVertexArrayVertexBuffers(Context *context,
 
998
                                      VertexArrayID vaobj,
 
999
                                      GLuint first,
 
1000
                                      GLsizei count,
 
1001
                                      const BufferID *buffers,
 
1002
                                      const GLintptr *offsets,
 
1003
                                      const GLsizei *strides)
 
1004
{
 
1005
    return true;
 
1006
}
 
1007
 
 
1008
}  // namespace gl