← Back to branch summary

~mmach/netext73/webkit2gtk

« back to all changes in this revision

Viewing changes to Source/ThirdParty/ANGLE/src/libANGLE/Context_gl.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/Context_gl.cpp
 
1
// GENERATED FILE - DO NOT EDIT.
 
2
// Generated by generate_entry_points.py using data from gl.xml.
 
3
//
 
4
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
 
5
// Use of this source code is governed by a BSD-style license that can be
 
6
// found in the LICENSE file.
 
7
//
 
8
// Context_gl.cpp: Implements the GL specific parts of Context.
 
9
 
 
10
#include "Context.h"
 
11
#include "common/debug.h"
 
12
 
 
13
namespace gl
 
14
{
 
15
 
 
16
void Context::compressedTexImage1D(GLenum target,
 
17
                                   GLint level,
 
18
                                   GLenum internalformat,
 
19
                                   GLsizei width,
 
20
                                   GLint border,
 
21
                                   GLsizei imageSize,
 
22
                                   const void *data)
 
23
{
 
24
    UNIMPLEMENTED();
 
25
}
 
26
 
 
27
void Context::compressedTexSubImage1D(GLenum target,
 
28
                                      GLint level,
 
29
                                      GLint xoffset,
 
30
                                      GLsizei width,
 
31
                                      GLenum format,
 
32
                                      GLsizei imageSize,
 
33
                                      const void *data)
 
34
{
 
35
    UNIMPLEMENTED();
 
36
}
 
37
 
 
38
void Context::getCompressedTexImage(GLenum target, GLint level, void *img)
 
39
{
 
40
    UNIMPLEMENTED();
 
41
}
 
42
 
 
43
void Context::loadTransposeMatrixd(const GLdouble *m)
 
44
{
 
45
    UNIMPLEMENTED();
 
46
}
 
47
 
 
48
void Context::loadTransposeMatrixf(const GLfloat *m)
 
49
{
 
50
    UNIMPLEMENTED();
 
51
}
 
52
 
 
53
void Context::multTransposeMatrixd(const GLdouble *m)
 
54
{
 
55
    UNIMPLEMENTED();
 
56
}
 
57
 
 
58
void Context::multTransposeMatrixf(const GLfloat *m)
 
59
{
 
60
    UNIMPLEMENTED();
 
61
}
 
62
 
 
63
void Context::multiTexCoord1d(GLenum target, GLdouble s)
 
64
{
 
65
    UNIMPLEMENTED();
 
66
}
 
67
 
 
68
void Context::multiTexCoord1dv(GLenum target, const GLdouble *v)
 
69
{
 
70
    UNIMPLEMENTED();
 
71
}
 
72
 
 
73
void Context::multiTexCoord1f(GLenum target, GLfloat s)
 
74
{
 
75
    UNIMPLEMENTED();
 
76
}
 
77
 
 
78
void Context::multiTexCoord1fv(GLenum target, const GLfloat *v)
 
79
{
 
80
    UNIMPLEMENTED();
 
81
}
 
82
 
 
83
void Context::multiTexCoord1i(GLenum target, GLint s)
 
84
{
 
85
    UNIMPLEMENTED();
 
86
}
 
87
 
 
88
void Context::multiTexCoord1iv(GLenum target, const GLint *v)
 
89
{
 
90
    UNIMPLEMENTED();
 
91
}
 
92
 
 
93
void Context::multiTexCoord1s(GLenum target, GLshort s)
 
94
{
 
95
    UNIMPLEMENTED();
 
96
}
 
97
 
 
98
void Context::multiTexCoord1sv(GLenum target, const GLshort *v)
 
99
{
 
100
    UNIMPLEMENTED();
 
101
}
 
102
 
 
103
void Context::multiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
 
104
{
 
105
    UNIMPLEMENTED();
 
106
}
 
107
 
 
108
void Context::multiTexCoord2dv(GLenum target, const GLdouble *v)
 
109
{
 
110
    UNIMPLEMENTED();
 
111
}
 
112
 
 
113
void Context::multiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
 
114
{
 
115
    UNIMPLEMENTED();
 
116
}
 
117
 
 
118
void Context::multiTexCoord2fv(GLenum target, const GLfloat *v)
 
119
{
 
120
    UNIMPLEMENTED();
 
121
}
 
122
 
 
123
void Context::multiTexCoord2i(GLenum target, GLint s, GLint t)
 
124
{
 
125
    UNIMPLEMENTED();
 
126
}
 
127
 
 
128
void Context::multiTexCoord2iv(GLenum target, const GLint *v)
 
129
{
 
130
    UNIMPLEMENTED();
 
131
}
 
132
 
 
133
void Context::multiTexCoord2s(GLenum target, GLshort s, GLshort t)
 
134
{
 
135
    UNIMPLEMENTED();
 
136
}
 
137
 
 
138
void Context::multiTexCoord2sv(GLenum target, const GLshort *v)
 
139
{
 
140
    UNIMPLEMENTED();
 
141
}
 
142
 
 
143
void Context::multiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 
144
{
 
145
    UNIMPLEMENTED();
 
146
}
 
147
 
 
148
void Context::multiTexCoord3dv(GLenum target, const GLdouble *v)
 
149
{
 
150
    UNIMPLEMENTED();
 
151
}
 
152
 
 
153
void Context::multiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 
154
{
 
155
    UNIMPLEMENTED();
 
156
}
 
157
 
 
158
void Context::multiTexCoord3fv(GLenum target, const GLfloat *v)
 
159
{
 
160
    UNIMPLEMENTED();
 
161
}
 
162
 
 
163
void Context::multiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
 
164
{
 
165
    UNIMPLEMENTED();
 
166
}
 
167
 
 
168
void Context::multiTexCoord3iv(GLenum target, const GLint *v)
 
169
{
 
170
    UNIMPLEMENTED();
 
171
}
 
172
 
 
173
void Context::multiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
 
174
{
 
175
    UNIMPLEMENTED();
 
176
}
 
177
 
 
178
void Context::multiTexCoord3sv(GLenum target, const GLshort *v)
 
179
{
 
180
    UNIMPLEMENTED();
 
181
}
 
182
 
 
183
void Context::multiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 
184
{
 
185
    UNIMPLEMENTED();
 
186
}
 
187
 
 
188
void Context::multiTexCoord4dv(GLenum target, const GLdouble *v)
 
189
{
 
190
    UNIMPLEMENTED();
 
191
}
 
192
 
 
193
void Context::multiTexCoord4fv(GLenum target, const GLfloat *v)
 
194
{
 
195
    UNIMPLEMENTED();
 
196
}
 
197
 
 
198
void Context::multiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
 
199
{
 
200
    UNIMPLEMENTED();
 
201
}
 
202
 
 
203
void Context::multiTexCoord4iv(GLenum target, const GLint *v)
 
204
{
 
205
    UNIMPLEMENTED();
 
206
}
 
207
 
 
208
void Context::multiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 
209
{
 
210
    UNIMPLEMENTED();
 
211
}
 
212
 
 
213
void Context::multiTexCoord4sv(GLenum target, const GLshort *v)
 
214
{
 
215
    UNIMPLEMENTED();
 
216
}
 
217
 
 
218
void Context::getVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 
219
{
 
220
    UNIMPLEMENTED();
 
221
}
 
222
 
 
223
void Context::vertexAttrib1d(GLuint index, GLdouble x)
 
224
{
 
225
    UNIMPLEMENTED();
 
226
}
 
227
 
 
228
void Context::vertexAttrib1dv(GLuint index, const GLdouble *v)
 
229
{
 
230
    UNIMPLEMENTED();
 
231
}
 
232
 
 
233
void Context::vertexAttrib1s(GLuint index, GLshort x)
 
234
{
 
235
    UNIMPLEMENTED();
 
236
}
 
237
 
 
238
void Context::vertexAttrib1sv(GLuint index, const GLshort *v)
 
239
{
 
240
    UNIMPLEMENTED();
 
241
}
 
242
 
 
243
void Context::vertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
 
244
{
 
245
    UNIMPLEMENTED();
 
246
}
 
247
 
 
248
void Context::vertexAttrib2dv(GLuint index, const GLdouble *v)
 
249
{
 
250
    UNIMPLEMENTED();
 
251
}
 
252
 
 
253
void Context::vertexAttrib2s(GLuint index, GLshort x, GLshort y)
 
254
{
 
255
    UNIMPLEMENTED();
 
256
}
 
257
 
 
258
void Context::vertexAttrib2sv(GLuint index, const GLshort *v)
 
259
{
 
260
    UNIMPLEMENTED();
 
261
}
 
262
 
 
263
void Context::vertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 
264
{
 
265
    UNIMPLEMENTED();
 
266
}
 
267
 
 
268
void Context::vertexAttrib3dv(GLuint index, const GLdouble *v)
 
269
{
 
270
    UNIMPLEMENTED();
 
271
}
 
272
 
 
273
void Context::vertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
 
274
{
 
275
    UNIMPLEMENTED();
 
276
}
 
277
 
 
278
void Context::vertexAttrib3sv(GLuint index, const GLshort *v)
 
279
{
 
280
    UNIMPLEMENTED();
 
281
}
 
282
 
 
283
void Context::vertexAttrib4Nbv(GLuint index, const GLbyte *v)
 
284
{
 
285
    UNIMPLEMENTED();
 
286
}
 
287
 
 
288
void Context::vertexAttrib4Niv(GLuint index, const GLint *v)
 
289
{
 
290
    UNIMPLEMENTED();
 
291
}
 
292
 
 
293
void Context::vertexAttrib4Nsv(GLuint index, const GLshort *v)
 
294
{
 
295
    UNIMPLEMENTED();
 
296
}
 
297
 
 
298
void Context::vertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
 
299
{
 
300
    UNIMPLEMENTED();
 
301
}
 
302
 
 
303
void Context::vertexAttrib4Nubv(GLuint index, const GLubyte *v)
 
304
{
 
305
    UNIMPLEMENTED();
 
306
}
 
307
 
 
308
void Context::vertexAttrib4Nuiv(GLuint index, const GLuint *v)
 
309
{
 
310
    UNIMPLEMENTED();
 
311
}
 
312
 
 
313
void Context::vertexAttrib4Nusv(GLuint index, const GLushort *v)
 
314
{
 
315
    UNIMPLEMENTED();
 
316
}
 
317
 
 
318
void Context::vertexAttrib4bv(GLuint index, const GLbyte *v)
 
319
{
 
320
    UNIMPLEMENTED();
 
321
}
 
322
 
 
323
void Context::vertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 
324
{
 
325
    UNIMPLEMENTED();
 
326
}
 
327
 
 
328
void Context::vertexAttrib4dv(GLuint index, const GLdouble *v)
 
329
{
 
330
    UNIMPLEMENTED();
 
331
}
 
332
 
 
333
void Context::vertexAttrib4iv(GLuint index, const GLint *v)
 
334
{
 
335
    UNIMPLEMENTED();
 
336
}
 
337
 
 
338
void Context::vertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
 
339
{
 
340
    UNIMPLEMENTED();
 
341
}
 
342
 
 
343
void Context::vertexAttrib4sv(GLuint index, const GLshort *v)
 
344
{
 
345
    UNIMPLEMENTED();
 
346
}
 
347
 
 
348
void Context::vertexAttrib4ubv(GLuint index, const GLubyte *v)
 
349
{
 
350
    UNIMPLEMENTED();
 
351
}
 
352
 
 
353
void Context::vertexAttrib4uiv(GLuint index, const GLuint *v)
 
354
{
 
355
    UNIMPLEMENTED();
 
356
}
 
357
 
 
358
void Context::vertexAttrib4usv(GLuint index, const GLushort *v)
 
359
{
 
360
    UNIMPLEMENTED();
 
361
}
 
362
 
 
363
void Context::beginConditionalRender(GLuint id, GLenum mode)
 
364
{
 
365
    UNIMPLEMENTED();
 
366
}
 
367
 
 
368
void Context::clampColor(GLenum target, GLenum clamp)
 
369
{
 
370
    UNIMPLEMENTED();
 
371
}
 
372
 
 
373
void Context::endConditionalRender()
 
374
{
 
375
    UNIMPLEMENTED();
 
376
}
 
377
 
 
378
void Context::framebufferTexture1D(GLenum target,
 
379
                                   GLenum attachment,
 
380
                                   TextureTarget textarget,
 
381
                                   TextureID texture,
 
382
                                   GLint level)
 
383
{
 
384
    UNIMPLEMENTED();
 
385
}
 
386
 
 
387
void Context::vertexAttribI1i(GLuint index, GLint x)
 
388
{
 
389
    UNIMPLEMENTED();
 
390
}
 
391
 
 
392
void Context::vertexAttribI1iv(GLuint index, const GLint *v)
 
393
{
 
394
    UNIMPLEMENTED();
 
395
}
 
396
 
 
397
void Context::vertexAttribI1ui(GLuint index, GLuint x)
 
398
{
 
399
    UNIMPLEMENTED();
 
400
}
 
401
 
 
402
void Context::vertexAttribI1uiv(GLuint index, const GLuint *v)
 
403
{
 
404
    UNIMPLEMENTED();
 
405
}
 
406
 
 
407
void Context::vertexAttribI2i(GLuint index, GLint x, GLint y)
 
408
{
 
409
    UNIMPLEMENTED();
 
410
}
 
411
 
 
412
void Context::vertexAttribI2iv(GLuint index, const GLint *v)
 
413
{
 
414
    UNIMPLEMENTED();
 
415
}
 
416
 
 
417
void Context::vertexAttribI2ui(GLuint index, GLuint x, GLuint y)
 
418
{
 
419
    UNIMPLEMENTED();
 
420
}
 
421
 
 
422
void Context::vertexAttribI2uiv(GLuint index, const GLuint *v)
 
423
{
 
424
    UNIMPLEMENTED();
 
425
}
 
426
 
 
427
void Context::vertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
 
428
{
 
429
    UNIMPLEMENTED();
 
430
}
 
431
 
 
432
void Context::vertexAttribI3iv(GLuint index, const GLint *v)
 
433
{
 
434
    UNIMPLEMENTED();
 
435
}
 
436
 
 
437
void Context::vertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
 
438
{
 
439
    UNIMPLEMENTED();
 
440
}
 
441
 
 
442
void Context::vertexAttribI3uiv(GLuint index, const GLuint *v)
 
443
{
 
444
    UNIMPLEMENTED();
 
445
}
 
446
 
 
447
void Context::vertexAttribI4bv(GLuint index, const GLbyte *v)
 
448
{
 
449
    UNIMPLEMENTED();
 
450
}
 
451
 
 
452
void Context::vertexAttribI4sv(GLuint index, const GLshort *v)
 
453
{
 
454
    UNIMPLEMENTED();
 
455
}
 
456
 
 
457
void Context::vertexAttribI4ubv(GLuint index, const GLubyte *v)
 
458
{
 
459
    UNIMPLEMENTED();
 
460
}
 
461
 
 
462
void Context::vertexAttribI4usv(GLuint index, const GLushort *v)
 
463
{
 
464
    UNIMPLEMENTED();
 
465
}
 
466
 
 
467
void Context::getActiveUniformName(ShaderProgramID program,
 
468
                                   GLuint uniformIndex,
 
469
                                   GLsizei bufSize,
 
470
                                   GLsizei *length,
 
471
                                   GLchar *uniformName)
 
472
{
 
473
    UNIMPLEMENTED();
 
474
}
 
475
 
 
476
void Context::primitiveRestartIndex(GLuint index)
 
477
{
 
478
    UNIMPLEMENTED();
 
479
}
 
480
 
 
481
void Context::fogCoordPointer(GLenum type, GLsizei stride, const void *pointer)
 
482
{
 
483
    UNIMPLEMENTED();
 
484
}
 
485
 
 
486
void Context::fogCoordd(GLdouble coord)
 
487
{
 
488
    UNIMPLEMENTED();
 
489
}
 
490
 
 
491
void Context::fogCoorddv(const GLdouble *coord)
 
492
{
 
493
    UNIMPLEMENTED();
 
494
}
 
495
 
 
496
void Context::fogCoordf(GLfloat coord)
 
497
{
 
498
    UNIMPLEMENTED();
 
499
}
 
500
 
 
501
void Context::fogCoordfv(const GLfloat *coord)
 
502
{
 
503
    UNIMPLEMENTED();
 
504
}
 
505
 
 
506
void Context::pointParameteri(GLenum pname, GLint param)
 
507
{
 
508
    UNIMPLEMENTED();
 
509
}
 
510
 
 
511
void Context::pointParameteriv(GLenum pname, const GLint *params)
 
512
{
 
513
    UNIMPLEMENTED();
 
514
}
 
515
 
 
516
void Context::secondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
 
517
{
 
518
    UNIMPLEMENTED();
 
519
}
 
520
 
 
521
void Context::secondaryColor3bv(const GLbyte *v)
 
522
{
 
523
    UNIMPLEMENTED();
 
524
}
 
525
 
 
526
void Context::secondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
 
527
{
 
528
    UNIMPLEMENTED();
 
529
}
 
530
 
 
531
void Context::secondaryColor3dv(const GLdouble *v)
 
532
{
 
533
    UNIMPLEMENTED();
 
534
}
 
535
 
 
536
void Context::secondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
 
537
{
 
538
    UNIMPLEMENTED();
 
539
}
 
540
 
 
541
void Context::secondaryColor3fv(const GLfloat *v)
 
542
{
 
543
    UNIMPLEMENTED();
 
544
}
 
545
 
 
546
void Context::secondaryColor3i(GLint red, GLint green, GLint blue)
 
547
{
 
548
    UNIMPLEMENTED();
 
549
}
 
550
 
 
551
void Context::secondaryColor3iv(const GLint *v)
 
552
{
 
553
    UNIMPLEMENTED();
 
554
}
 
555
 
 
556
void Context::secondaryColor3s(GLshort red, GLshort green, GLshort blue)
 
557
{
 
558
    UNIMPLEMENTED();
 
559
}
 
560
 
 
561
void Context::secondaryColor3sv(const GLshort *v)
 
562
{
 
563
    UNIMPLEMENTED();
 
564
}
 
565
 
 
566
void Context::secondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 
567
{
 
568
    UNIMPLEMENTED();
 
569
}
 
570
 
 
571
void Context::secondaryColor3ubv(const GLubyte *v)
 
572
{
 
573
    UNIMPLEMENTED();
 
574
}
 
575
 
 
576
void Context::secondaryColor3ui(GLuint red, GLuint green, GLuint blue)
 
577
{
 
578
    UNIMPLEMENTED();
 
579
}
 
580
 
 
581
void Context::secondaryColor3uiv(const GLuint *v)
 
582
{
 
583
    UNIMPLEMENTED();
 
584
}
 
585
 
 
586
void Context::secondaryColor3us(GLushort red, GLushort green, GLushort blue)
 
587
{
 
588
    UNIMPLEMENTED();
 
589
}
 
590
 
 
591
void Context::secondaryColor3usv(const GLushort *v)
 
592
{
 
593
    UNIMPLEMENTED();
 
594
}
 
595
 
 
596
void Context::secondaryColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
 
597
{
 
598
    UNIMPLEMENTED();
 
599
}
 
600
 
 
601
void Context::windowPos2d(GLdouble x, GLdouble y)
 
602
{
 
603
    UNIMPLEMENTED();
 
604
}
 
605
 
 
606
void Context::windowPos2dv(const GLdouble *v)
 
607
{
 
608
    UNIMPLEMENTED();
 
609
}
 
610
 
 
611
void Context::windowPos2f(GLfloat x, GLfloat y)
 
612
{
 
613
    UNIMPLEMENTED();
 
614
}
 
615
 
 
616
void Context::windowPos2fv(const GLfloat *v)
 
617
{
 
618
    UNIMPLEMENTED();
 
619
}
 
620
 
 
621
void Context::windowPos2i(GLint x, GLint y)
 
622
{
 
623
    UNIMPLEMENTED();
 
624
}
 
625
 
 
626
void Context::windowPos2iv(const GLint *v)
 
627
{
 
628
    UNIMPLEMENTED();
 
629
}
 
630
 
 
631
void Context::windowPos2s(GLshort x, GLshort y)
 
632
{
 
633
    UNIMPLEMENTED();
 
634
}
 
635
 
 
636
void Context::windowPos2sv(const GLshort *v)
 
637
{
 
638
    UNIMPLEMENTED();
 
639
}
 
640
 
 
641
void Context::windowPos3d(GLdouble x, GLdouble y, GLdouble z)
 
642
{
 
643
    UNIMPLEMENTED();
 
644
}
 
645
 
 
646
void Context::windowPos3dv(const GLdouble *v)
 
647
{
 
648
    UNIMPLEMENTED();
 
649
}
 
650
 
 
651
void Context::windowPos3f(GLfloat x, GLfloat y, GLfloat z)
 
652
{
 
653
    UNIMPLEMENTED();
 
654
}
 
655
 
 
656
void Context::windowPos3fv(const GLfloat *v)
 
657
{
 
658
    UNIMPLEMENTED();
 
659
}
 
660
 
 
661
void Context::windowPos3i(GLint x, GLint y, GLint z)
 
662
{
 
663
    UNIMPLEMENTED();
 
664
}
 
665
 
 
666
void Context::windowPos3iv(const GLint *v)
 
667
{
 
668
    UNIMPLEMENTED();
 
669
}
 
670
 
 
671
void Context::windowPos3s(GLshort x, GLshort y, GLshort z)
 
672
{
 
673
    UNIMPLEMENTED();
 
674
}
 
675
 
 
676
void Context::windowPos3sv(const GLshort *v)
 
677
{
 
678
    UNIMPLEMENTED();
 
679
}
 
680
 
 
681
void Context::getBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data)
 
682
{
 
683
    UNIMPLEMENTED();
 
684
}
 
685
 
 
686
void Context::accum(GLenum op, GLfloat value)
 
687
{
 
688
    UNIMPLEMENTED();
 
689
}
 
690
 
 
691
void Context::begin(GLenum mode)
 
692
{
 
693
    UNIMPLEMENTED();
 
694
}
 
695
 
 
696
void Context::bitmap(GLsizei width,
 
697
                     GLsizei height,
 
698
                     GLfloat xorig,
 
699
                     GLfloat yorig,
 
700
                     GLfloat xmove,
 
701
                     GLfloat ymove,
 
702
                     const GLubyte *bitmap)
 
703
{
 
704
    UNIMPLEMENTED();
 
705
}
 
706
 
 
707
void Context::callList(GLuint list)
 
708
{
 
709
    UNIMPLEMENTED();
 
710
}
 
711
 
 
712
void Context::callLists(GLsizei n, GLenum type, const void *lists)
 
713
{
 
714
    UNIMPLEMENTED();
 
715
}
 
716
 
 
717
void Context::clearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 
718
{
 
719
    UNIMPLEMENTED();
 
720
}
 
721
 
 
722
void Context::clearDepth(GLdouble depth)
 
723
{
 
724
    UNIMPLEMENTED();
 
725
}
 
726
 
 
727
void Context::clearIndex(GLfloat c)
 
728
{
 
729
    UNIMPLEMENTED();
 
730
}
 
731
 
 
732
void Context::clipPlane(GLenum plane, const GLdouble *equation)
 
733
{
 
734
    UNIMPLEMENTED();
 
735
}
 
736
 
 
737
void Context::color3b(GLbyte red, GLbyte green, GLbyte blue)
 
738
{
 
739
    UNIMPLEMENTED();
 
740
}
 
741
 
 
742
void Context::color3bv(const GLbyte *v)
 
743
{
 
744
    UNIMPLEMENTED();
 
745
}
 
746
 
 
747
void Context::color3d(GLdouble red, GLdouble green, GLdouble blue)
 
748
{
 
749
    UNIMPLEMENTED();
 
750
}
 
751
 
 
752
void Context::color3dv(const GLdouble *v)
 
753
{
 
754
    UNIMPLEMENTED();
 
755
}
 
756
 
 
757
void Context::color3f(GLfloat red, GLfloat green, GLfloat blue)
 
758
{
 
759
    UNIMPLEMENTED();
 
760
}
 
761
 
 
762
void Context::color3fv(const GLfloat *v)
 
763
{
 
764
    UNIMPLEMENTED();
 
765
}
 
766
 
 
767
void Context::color3i(GLint red, GLint green, GLint blue)
 
768
{
 
769
    UNIMPLEMENTED();
 
770
}
 
771
 
 
772
void Context::color3iv(const GLint *v)
 
773
{
 
774
    UNIMPLEMENTED();
 
775
}
 
776
 
 
777
void Context::color3s(GLshort red, GLshort green, GLshort blue)
 
778
{
 
779
    UNIMPLEMENTED();
 
780
}
 
781
 
 
782
void Context::color3sv(const GLshort *v)
 
783
{
 
784
    UNIMPLEMENTED();
 
785
}
 
786
 
 
787
void Context::color3ub(GLubyte red, GLubyte green, GLubyte blue)
 
788
{
 
789
    UNIMPLEMENTED();
 
790
}
 
791
 
 
792
void Context::color3ubv(const GLubyte *v)
 
793
{
 
794
    UNIMPLEMENTED();
 
795
}
 
796
 
 
797
void Context::color3ui(GLuint red, GLuint green, GLuint blue)
 
798
{
 
799
    UNIMPLEMENTED();
 
800
}
 
801
 
 
802
void Context::color3uiv(const GLuint *v)
 
803
{
 
804
    UNIMPLEMENTED();
 
805
}
 
806
 
 
807
void Context::color3us(GLushort red, GLushort green, GLushort blue)
 
808
{
 
809
    UNIMPLEMENTED();
 
810
}
 
811
 
 
812
void Context::color3usv(const GLushort *v)
 
813
{
 
814
    UNIMPLEMENTED();
 
815
}
 
816
 
 
817
void Context::color4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 
818
{
 
819
    UNIMPLEMENTED();
 
820
}
 
821
 
 
822
void Context::color4bv(const GLbyte *v)
 
823
{
 
824
    UNIMPLEMENTED();
 
825
}
 
826
 
 
827
void Context::color4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 
828
{
 
829
    UNIMPLEMENTED();
 
830
}
 
831
 
 
832
void Context::color4dv(const GLdouble *v)
 
833
{
 
834
    UNIMPLEMENTED();
 
835
}
 
836
 
 
837
void Context::color4fv(const GLfloat *v)
 
838
{
 
839
    UNIMPLEMENTED();
 
840
}
 
841
 
 
842
void Context::color4i(GLint red, GLint green, GLint blue, GLint alpha)
 
843
{
 
844
    UNIMPLEMENTED();
 
845
}
 
846
 
 
847
void Context::color4iv(const GLint *v)
 
848
{
 
849
    UNIMPLEMENTED();
 
850
}
 
851
 
 
852
void Context::color4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 
853
{
 
854
    UNIMPLEMENTED();
 
855
}
 
856
 
 
857
void Context::color4sv(const GLshort *v)
 
858
{
 
859
    UNIMPLEMENTED();
 
860
}
 
861
 
 
862
void Context::color4ubv(const GLubyte *v)
 
863
{
 
864
    UNIMPLEMENTED();
 
865
}
 
866
 
 
867
void Context::color4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 
868
{
 
869
    UNIMPLEMENTED();
 
870
}
 
871
 
 
872
void Context::color4uiv(const GLuint *v)
 
873
{
 
874
    UNIMPLEMENTED();
 
875
}
 
876
 
 
877
void Context::color4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 
878
{
 
879
    UNIMPLEMENTED();
 
880
}
 
881
 
 
882
void Context::color4usv(const GLushort *v)
 
883
{
 
884
    UNIMPLEMENTED();
 
885
}
 
886
 
 
887
void Context::colorMaterial(GLenum face, GLenum mode)
 
888
{
 
889
    UNIMPLEMENTED();
 
890
}
 
891
 
 
892
void Context::copyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 
893
{
 
894
    UNIMPLEMENTED();
 
895
}
 
896
 
 
897
void Context::deleteLists(GLuint list, GLsizei range)
 
898
{
 
899
    UNIMPLEMENTED();
 
900
}
 
901
 
 
902
void Context::depthRange(GLdouble n, GLdouble f)
 
903
{
 
904
    UNIMPLEMENTED();
 
905
}
 
906
 
 
907
void Context::drawBuffer(GLenum buf)
 
908
{
 
909
    UNIMPLEMENTED();
 
910
}
 
911
 
 
912
void Context::drawPixels(GLsizei width,
 
913
                         GLsizei height,
 
914
                         GLenum format,
 
915
                         GLenum type,
 
916
                         const void *pixels)
 
917
{
 
918
    UNIMPLEMENTED();
 
919
}
 
920
 
 
921
void Context::edgeFlag(GLboolean flag)
 
922
{
 
923
    UNIMPLEMENTED();
 
924
}
 
925
 
 
926
void Context::edgeFlagv(const GLboolean *flag)
 
927
{
 
928
    UNIMPLEMENTED();
 
929
}
 
930
 
 
931
void Context::end()
 
932
{
 
933
    UNIMPLEMENTED();
 
934
}
 
935
 
 
936
void Context::endList()
 
937
{
 
938
    UNIMPLEMENTED();
 
939
}
 
940
 
 
941
void Context::evalCoord1d(GLdouble u)
 
942
{
 
943
    UNIMPLEMENTED();
 
944
}
 
945
 
 
946
void Context::evalCoord1dv(const GLdouble *u)
 
947
{
 
948
    UNIMPLEMENTED();
 
949
}
 
950
 
 
951
void Context::evalCoord1f(GLfloat u)
 
952
{
 
953
    UNIMPLEMENTED();
 
954
}
 
955
 
 
956
void Context::evalCoord1fv(const GLfloat *u)
 
957
{
 
958
    UNIMPLEMENTED();
 
959
}
 
960
 
 
961
void Context::evalCoord2d(GLdouble u, GLdouble v)
 
962
{
 
963
    UNIMPLEMENTED();
 
964
}
 
965
 
 
966
void Context::evalCoord2dv(const GLdouble *u)
 
967
{
 
968
    UNIMPLEMENTED();
 
969
}
 
970
 
 
971
void Context::evalCoord2f(GLfloat u, GLfloat v)
 
972
{
 
973
    UNIMPLEMENTED();
 
974
}
 
975
 
 
976
void Context::evalCoord2fv(const GLfloat *u)
 
977
{
 
978
    UNIMPLEMENTED();
 
979
}
 
980
 
 
981
void Context::evalMesh1(GLenum mode, GLint i1, GLint i2)
 
982
{
 
983
    UNIMPLEMENTED();
 
984
}
 
985
 
 
986
void Context::evalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 
987
{
 
988
    UNIMPLEMENTED();
 
989
}
 
990
 
 
991
void Context::evalPoint1(GLint i)
 
992
{
 
993
    UNIMPLEMENTED();
 
994
}
 
995
 
 
996
void Context::evalPoint2(GLint i, GLint j)
 
997
{
 
998
    UNIMPLEMENTED();
 
999
}
 
1000
 
 
1001
void Context::feedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 
1002
{
 
1003
    UNIMPLEMENTED();
 
1004
}
 
1005
 
 
1006
void Context::fogi(GLenum pname, GLint param)
 
1007
{
 
1008
    UNIMPLEMENTED();
 
1009
}
 
1010
 
 
1011
void Context::fogiv(GLenum pname, const GLint *params)
 
1012
{
 
1013
    UNIMPLEMENTED();
 
1014
}
 
1015
 
 
1016
void Context::frustum(GLdouble left,
 
1017
                      GLdouble right,
 
1018
                      GLdouble bottom,
 
1019
                      GLdouble top,
 
1020
                      GLdouble zNear,
 
1021
                      GLdouble zFar)
 
1022
{
 
1023
    UNIMPLEMENTED();
 
1024
}
 
1025
 
 
1026
GLuint Context::genLists(GLsizei range)
 
1027
{
 
1028
    UNIMPLEMENTED();
 
1029
    return 0;
 
1030
}
 
1031
 
 
1032
void Context::getClipPlane(GLenum plane, GLdouble *equation)
 
1033
{
 
1034
    UNIMPLEMENTED();
 
1035
}
 
1036
 
 
1037
void Context::getDoublev(GLenum pname, GLdouble *data)
 
1038
{
 
1039
    UNIMPLEMENTED();
 
1040
}
 
1041
 
 
1042
void Context::getLightiv(GLenum light, GLenum pname, GLint *params)
 
1043
{
 
1044
    UNIMPLEMENTED();
 
1045
}
 
1046
 
 
1047
void Context::getMapdv(GLenum target, GLenum query, GLdouble *v)
 
1048
{
 
1049
    UNIMPLEMENTED();
 
1050
}
 
1051
 
 
1052
void Context::getMapfv(GLenum target, GLenum query, GLfloat *v)
 
1053
{
 
1054
    UNIMPLEMENTED();
 
1055
}
 
1056
 
 
1057
void Context::getMapiv(GLenum target, GLenum query, GLint *v)
 
1058
{
 
1059
    UNIMPLEMENTED();
 
1060
}
 
1061
 
 
1062
void Context::getMaterialiv(GLenum face, GLenum pname, GLint *params)
 
1063
{
 
1064
    UNIMPLEMENTED();
 
1065
}
 
1066
 
 
1067
void Context::getPixelMapfv(GLenum map, GLfloat *values)
 
1068
{
 
1069
    UNIMPLEMENTED();
 
1070
}
 
1071
 
 
1072
void Context::getPixelMapuiv(GLenum map, GLuint *values)
 
1073
{
 
1074
    UNIMPLEMENTED();
 
1075
}
 
1076
 
 
1077
void Context::getPixelMapusv(GLenum map, GLushort *values)
 
1078
{
 
1079
    UNIMPLEMENTED();
 
1080
}
 
1081
 
 
1082
void Context::getPolygonStipple(GLubyte *mask)
 
1083
{
 
1084
    UNIMPLEMENTED();
 
1085
}
 
1086
 
 
1087
void Context::getTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 
1088
{
 
1089
    UNIMPLEMENTED();
 
1090
}
 
1091
 
 
1092
void Context::indexMask(GLuint mask)
 
1093
{
 
1094
    UNIMPLEMENTED();
 
1095
}
 
1096
 
 
1097
void Context::indexd(GLdouble c)
 
1098
{
 
1099
    UNIMPLEMENTED();
 
1100
}
 
1101
 
 
1102
void Context::indexdv(const GLdouble *c)
 
1103
{
 
1104
    UNIMPLEMENTED();
 
1105
}
 
1106
 
 
1107
void Context::indexf(GLfloat c)
 
1108
{
 
1109
    UNIMPLEMENTED();
 
1110
}
 
1111
 
 
1112
void Context::indexfv(const GLfloat *c)
 
1113
{
 
1114
    UNIMPLEMENTED();
 
1115
}
 
1116
 
 
1117
void Context::indexi(GLint c)
 
1118
{
 
1119
    UNIMPLEMENTED();
 
1120
}
 
1121
 
 
1122
void Context::indexiv(const GLint *c)
 
1123
{
 
1124
    UNIMPLEMENTED();
 
1125
}
 
1126
 
 
1127
void Context::indexs(GLshort c)
 
1128
{
 
1129
    UNIMPLEMENTED();
 
1130
}
 
1131
 
 
1132
void Context::indexsv(const GLshort *c)
 
1133
{
 
1134
    UNIMPLEMENTED();
 
1135
}
 
1136
 
 
1137
void Context::initNames()
 
1138
{
 
1139
    UNIMPLEMENTED();
 
1140
}
 
1141
 
 
1142
GLboolean Context::isList(GLuint list)
 
1143
{
 
1144
    UNIMPLEMENTED();
 
1145
    return false;
 
1146
}
 
1147
 
 
1148
void Context::lightModeli(GLenum pname, GLint param)
 
1149
{
 
1150
    UNIMPLEMENTED();
 
1151
}
 
1152
 
 
1153
void Context::lightModeliv(GLenum pname, const GLint *params)
 
1154
{
 
1155
    UNIMPLEMENTED();
 
1156
}
 
1157
 
 
1158
void Context::lighti(GLenum light, GLenum pname, GLint param)
 
1159
{
 
1160
    UNIMPLEMENTED();
 
1161
}
 
1162
 
 
1163
void Context::lightiv(GLenum light, GLenum pname, const GLint *params)
 
1164
{
 
1165
    UNIMPLEMENTED();
 
1166
}
 
1167
 
 
1168
void Context::lineStipple(GLint factor, GLushort pattern)
 
1169
{
 
1170
    UNIMPLEMENTED();
 
1171
}
 
1172
 
 
1173
void Context::listBase(GLuint base)
 
1174
{
 
1175
    UNIMPLEMENTED();
 
1176
}
 
1177
 
 
1178
void Context::loadMatrixd(const GLdouble *m)
 
1179
{
 
1180
    UNIMPLEMENTED();
 
1181
}
 
1182
 
 
1183
void Context::loadName(GLuint name)
 
1184
{
 
1185
    UNIMPLEMENTED();
 
1186
}
 
1187
 
 
1188
void Context::map1d(GLenum target,
 
1189
                    GLdouble u1,
 
1190
                    GLdouble u2,
 
1191
                    GLint stride,
 
1192
                    GLint order,
 
1193
                    const GLdouble *points)
 
1194
{
 
1195
    UNIMPLEMENTED();
 
1196
}
 
1197
 
 
1198
void Context::map1f(GLenum target,
 
1199
                    GLfloat u1,
 
1200
                    GLfloat u2,
 
1201
                    GLint stride,
 
1202
                    GLint order,
 
1203
                    const GLfloat *points)
 
1204
{
 
1205
    UNIMPLEMENTED();
 
1206
}
 
1207
 
 
1208
void Context::map2d(GLenum target,
 
1209
                    GLdouble u1,
 
1210
                    GLdouble u2,
 
1211
                    GLint ustride,
 
1212
                    GLint uorder,
 
1213
                    GLdouble v1,
 
1214
                    GLdouble v2,
 
1215
                    GLint vstride,
 
1216
                    GLint vorder,
 
1217
                    const GLdouble *points)
 
1218
{
 
1219
    UNIMPLEMENTED();
 
1220
}
 
1221
 
 
1222
void Context::map2f(GLenum target,
 
1223
                    GLfloat u1,
 
1224
                    GLfloat u2,
 
1225
                    GLint ustride,
 
1226
                    GLint uorder,
 
1227
                    GLfloat v1,
 
1228
                    GLfloat v2,
 
1229
                    GLint vstride,
 
1230
                    GLint vorder,
 
1231
                    const GLfloat *points)
 
1232
{
 
1233
    UNIMPLEMENTED();
 
1234
}
 
1235
 
 
1236
void Context::mapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 
1237
{
 
1238
    UNIMPLEMENTED();
 
1239
}
 
1240
 
 
1241
void Context::mapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 
1242
{
 
1243
    UNIMPLEMENTED();
 
1244
}
 
1245
 
 
1246
void Context::mapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 
1247
{
 
1248
    UNIMPLEMENTED();
 
1249
}
 
1250
 
 
1251
void Context::mapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 
1252
{
 
1253
    UNIMPLEMENTED();
 
1254
}
 
1255
 
 
1256
void Context::materiali(GLenum face, GLenum pname, GLint param)
 
1257
{
 
1258
    UNIMPLEMENTED();
 
1259
}
 
1260
 
 
1261
void Context::materialiv(GLenum face, GLenum pname, const GLint *params)
 
1262
{
 
1263
    UNIMPLEMENTED();
 
1264
}
 
1265
 
 
1266
void Context::multMatrixd(const GLdouble *m)
 
1267
{
 
1268
    UNIMPLEMENTED();
 
1269
}
 
1270
 
 
1271
void Context::newList(GLuint list, GLenum mode)
 
1272
{
 
1273
    UNIMPLEMENTED();
 
1274
}
 
1275
 
 
1276
void Context::normal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 
1277
{
 
1278
    UNIMPLEMENTED();
 
1279
}
 
1280
 
 
1281
void Context::normal3bv(const GLbyte *v)
 
1282
{
 
1283
    UNIMPLEMENTED();
 
1284
}
 
1285
 
 
1286
void Context::normal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 
1287
{
 
1288
    UNIMPLEMENTED();
 
1289
}
 
1290
 
 
1291
void Context::normal3dv(const GLdouble *v)
 
1292
{
 
1293
    UNIMPLEMENTED();
 
1294
}
 
1295
 
 
1296
void Context::normal3fv(const GLfloat *v)
 
1297
{
 
1298
    UNIMPLEMENTED();
 
1299
}
 
1300
 
 
1301
void Context::normal3i(GLint nx, GLint ny, GLint nz)
 
1302
{
 
1303
    UNIMPLEMENTED();
 
1304
}
 
1305
 
 
1306
void Context::normal3iv(const GLint *v)
 
1307
{
 
1308
    UNIMPLEMENTED();
 
1309
}
 
1310
 
 
1311
void Context::normal3s(GLshort nx, GLshort ny, GLshort nz)
 
1312
{
 
1313
    UNIMPLEMENTED();
 
1314
}
 
1315
 
 
1316
void Context::normal3sv(const GLshort *v)
 
1317
{
 
1318
    UNIMPLEMENTED();
 
1319
}
 
1320
 
 
1321
void Context::ortho(GLdouble left,
 
1322
                    GLdouble right,
 
1323
                    GLdouble bottom,
 
1324
                    GLdouble top,
 
1325
                    GLdouble zNear,
 
1326
                    GLdouble zFar)
 
1327
{
 
1328
    UNIMPLEMENTED();
 
1329
}
 
1330
 
 
1331
void Context::passThrough(GLfloat token)
 
1332
{
 
1333
    UNIMPLEMENTED();
 
1334
}
 
1335
 
 
1336
void Context::pixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
 
1337
{
 
1338
    UNIMPLEMENTED();
 
1339
}
 
1340
 
 
1341
void Context::pixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
 
1342
{
 
1343
    UNIMPLEMENTED();
 
1344
}
 
1345
 
 
1346
void Context::pixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
 
1347
{
 
1348
    UNIMPLEMENTED();
 
1349
}
 
1350
 
 
1351
void Context::pixelStoref(GLenum pname, GLfloat param)
 
1352
{
 
1353
    UNIMPLEMENTED();
 
1354
}
 
1355
 
 
1356
void Context::pixelTransferf(GLenum pname, GLfloat param)
 
1357
{
 
1358
    UNIMPLEMENTED();
 
1359
}
 
1360
 
 
1361
void Context::pixelTransferi(GLenum pname, GLint param)
 
1362
{
 
1363
    UNIMPLEMENTED();
 
1364
}
 
1365
 
 
1366
void Context::pixelZoom(GLfloat xfactor, GLfloat yfactor)
 
1367
{
 
1368
    UNIMPLEMENTED();
 
1369
}
 
1370
 
 
1371
void Context::polygonMode(GLenum face, GLenum mode)
 
1372
{
 
1373
    UNIMPLEMENTED();
 
1374
}
 
1375
 
 
1376
void Context::polygonStipple(const GLubyte *mask)
 
1377
{
 
1378
    UNIMPLEMENTED();
 
1379
}
 
1380
 
 
1381
void Context::popAttrib()
 
1382
{
 
1383
    UNIMPLEMENTED();
 
1384
}
 
1385
 
 
1386
void Context::popName()
 
1387
{
 
1388
    UNIMPLEMENTED();
 
1389
}
 
1390
 
 
1391
void Context::pushAttrib(GLbitfield mask)
 
1392
{
 
1393
    UNIMPLEMENTED();
 
1394
}
 
1395
 
 
1396
void Context::pushName(GLuint name)
 
1397
{
 
1398
    UNIMPLEMENTED();
 
1399
}
 
1400
 
 
1401
void Context::rasterPos2d(GLdouble x, GLdouble y)
 
1402
{
 
1403
    UNIMPLEMENTED();
 
1404
}
 
1405
 
 
1406
void Context::rasterPos2dv(const GLdouble *v)
 
1407
{
 
1408
    UNIMPLEMENTED();
 
1409
}
 
1410
 
 
1411
void Context::rasterPos2f(GLfloat x, GLfloat y)
 
1412
{
 
1413
    UNIMPLEMENTED();
 
1414
}
 
1415
 
 
1416
void Context::rasterPos2fv(const GLfloat *v)
 
1417
{
 
1418
    UNIMPLEMENTED();
 
1419
}
 
1420
 
 
1421
void Context::rasterPos2i(GLint x, GLint y)
 
1422
{
 
1423
    UNIMPLEMENTED();
 
1424
}
 
1425
 
 
1426
void Context::rasterPos2iv(const GLint *v)
 
1427
{
 
1428
    UNIMPLEMENTED();
 
1429
}
 
1430
 
 
1431
void Context::rasterPos2s(GLshort x, GLshort y)
 
1432
{
 
1433
    UNIMPLEMENTED();
 
1434
}
 
1435
 
 
1436
void Context::rasterPos2sv(const GLshort *v)
 
1437
{
 
1438
    UNIMPLEMENTED();
 
1439
}
 
1440
 
 
1441
void Context::rasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 
1442
{
 
1443
    UNIMPLEMENTED();
 
1444
}
 
1445
 
 
1446
void Context::rasterPos3dv(const GLdouble *v)
 
1447
{
 
1448
    UNIMPLEMENTED();
 
1449
}
 
1450
 
 
1451
void Context::rasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 
1452
{
 
1453
    UNIMPLEMENTED();
 
1454
}
 
1455
 
 
1456
void Context::rasterPos3fv(const GLfloat *v)
 
1457
{
 
1458
    UNIMPLEMENTED();
 
1459
}
 
1460
 
 
1461
void Context::rasterPos3i(GLint x, GLint y, GLint z)
 
1462
{
 
1463
    UNIMPLEMENTED();
 
1464
}
 
1465
 
 
1466
void Context::rasterPos3iv(const GLint *v)
 
1467
{
 
1468
    UNIMPLEMENTED();
 
1469
}
 
1470
 
 
1471
void Context::rasterPos3s(GLshort x, GLshort y, GLshort z)
 
1472
{
 
1473
    UNIMPLEMENTED();
 
1474
}
 
1475
 
 
1476
void Context::rasterPos3sv(const GLshort *v)
 
1477
{
 
1478
    UNIMPLEMENTED();
 
1479
}
 
1480
 
 
1481
void Context::rasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 
1482
{
 
1483
    UNIMPLEMENTED();
 
1484
}
 
1485
 
 
1486
void Context::rasterPos4dv(const GLdouble *v)
 
1487
{
 
1488
    UNIMPLEMENTED();
 
1489
}
 
1490
 
 
1491
void Context::rasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 
1492
{
 
1493
    UNIMPLEMENTED();
 
1494
}
 
1495
 
 
1496
void Context::rasterPos4fv(const GLfloat *v)
 
1497
{
 
1498
    UNIMPLEMENTED();
 
1499
}
 
1500
 
 
1501
void Context::rasterPos4i(GLint x, GLint y, GLint z, GLint w)
 
1502
{
 
1503
    UNIMPLEMENTED();
 
1504
}
 
1505
 
 
1506
void Context::rasterPos4iv(const GLint *v)
 
1507
{
 
1508
    UNIMPLEMENTED();
 
1509
}
 
1510
 
 
1511
void Context::rasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 
1512
{
 
1513
    UNIMPLEMENTED();
 
1514
}
 
1515
 
 
1516
void Context::rasterPos4sv(const GLshort *v)
 
1517
{
 
1518
    UNIMPLEMENTED();
 
1519
}
 
1520
 
 
1521
void Context::rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 
1522
{
 
1523
    UNIMPLEMENTED();
 
1524
}
 
1525
 
 
1526
void Context::rectdv(const GLdouble *v1, const GLdouble *v2)
 
1527
{
 
1528
    UNIMPLEMENTED();
 
1529
}
 
1530
 
 
1531
void Context::rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 
1532
{
 
1533
    UNIMPLEMENTED();
 
1534
}
 
1535
 
 
1536
void Context::rectfv(const GLfloat *v1, const GLfloat *v2)
 
1537
{
 
1538
    UNIMPLEMENTED();
 
1539
}
 
1540
 
 
1541
void Context::recti(GLint x1, GLint y1, GLint x2, GLint y2)
 
1542
{
 
1543
    UNIMPLEMENTED();
 
1544
}
 
1545
 
 
1546
void Context::rectiv(const GLint *v1, const GLint *v2)
 
1547
{
 
1548
    UNIMPLEMENTED();
 
1549
}
 
1550
 
 
1551
void Context::rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 
1552
{
 
1553
    UNIMPLEMENTED();
 
1554
}
 
1555
 
 
1556
void Context::rectsv(const GLshort *v1, const GLshort *v2)
 
1557
{
 
1558
    UNIMPLEMENTED();
 
1559
}
 
1560
 
 
1561
GLint Context::renderMode(GLenum mode)
 
1562
{
 
1563
    UNIMPLEMENTED();
 
1564
    return 0;
 
1565
}
 
1566
 
 
1567
void Context::rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 
1568
{
 
1569
    UNIMPLEMENTED();
 
1570
}
 
1571
 
 
1572
void Context::scaled(GLdouble x, GLdouble y, GLdouble z)
 
1573
{
 
1574
    UNIMPLEMENTED();
 
1575
}
 
1576
 
 
1577
void Context::selectBuffer(GLsizei size, GLuint *buffer)
 
1578
{
 
1579
    UNIMPLEMENTED();
 
1580
}
 
1581
 
 
1582
void Context::texCoord1d(GLdouble s)
 
1583
{
 
1584
    UNIMPLEMENTED();
 
1585
}
 
1586
 
 
1587
void Context::texCoord1dv(const GLdouble *v)
 
1588
{
 
1589
    UNIMPLEMENTED();
 
1590
}
 
1591
 
 
1592
void Context::texCoord1f(GLfloat s)
 
1593
{
 
1594
    UNIMPLEMENTED();
 
1595
}
 
1596
 
 
1597
void Context::texCoord1fv(const GLfloat *v)
 
1598
{
 
1599
    UNIMPLEMENTED();
 
1600
}
 
1601
 
 
1602
void Context::texCoord1i(GLint s)
 
1603
{
 
1604
    UNIMPLEMENTED();
 
1605
}
 
1606
 
 
1607
void Context::texCoord1iv(const GLint *v)
 
1608
{
 
1609
    UNIMPLEMENTED();
 
1610
}
 
1611
 
 
1612
void Context::texCoord1s(GLshort s)
 
1613
{
 
1614
    UNIMPLEMENTED();
 
1615
}
 
1616
 
 
1617
void Context::texCoord1sv(const GLshort *v)
 
1618
{
 
1619
    UNIMPLEMENTED();
 
1620
}
 
1621
 
 
1622
void Context::texCoord2d(GLdouble s, GLdouble t)
 
1623
{
 
1624
    UNIMPLEMENTED();
 
1625
}
 
1626
 
 
1627
void Context::texCoord2dv(const GLdouble *v)
 
1628
{
 
1629
    UNIMPLEMENTED();
 
1630
}
 
1631
 
 
1632
void Context::texCoord2f(GLfloat s, GLfloat t)
 
1633
{
 
1634
    UNIMPLEMENTED();
 
1635
}
 
1636
 
 
1637
void Context::texCoord2fv(const GLfloat *v)
 
1638
{
 
1639
    UNIMPLEMENTED();
 
1640
}
 
1641
 
 
1642
void Context::texCoord2i(GLint s, GLint t)
 
1643
{
 
1644
    UNIMPLEMENTED();
 
1645
}
 
1646
 
 
1647
void Context::texCoord2iv(const GLint *v)
 
1648
{
 
1649
    UNIMPLEMENTED();
 
1650
}
 
1651
 
 
1652
void Context::texCoord2s(GLshort s, GLshort t)
 
1653
{
 
1654
    UNIMPLEMENTED();
 
1655
}
 
1656
 
 
1657
void Context::texCoord2sv(const GLshort *v)
 
1658
{
 
1659
    UNIMPLEMENTED();
 
1660
}
 
1661
 
 
1662
void Context::texCoord3d(GLdouble s, GLdouble t, GLdouble r)
 
1663
{
 
1664
    UNIMPLEMENTED();
 
1665
}
 
1666
 
 
1667
void Context::texCoord3dv(const GLdouble *v)
 
1668
{
 
1669
    UNIMPLEMENTED();
 
1670
}
 
1671
 
 
1672
void Context::texCoord3f(GLfloat s, GLfloat t, GLfloat r)
 
1673
{
 
1674
    UNIMPLEMENTED();
 
1675
}
 
1676
 
 
1677
void Context::texCoord3fv(const GLfloat *v)
 
1678
{
 
1679
    UNIMPLEMENTED();
 
1680
}
 
1681
 
 
1682
void Context::texCoord3i(GLint s, GLint t, GLint r)
 
1683
{
 
1684
    UNIMPLEMENTED();
 
1685
}
 
1686
 
 
1687
void Context::texCoord3iv(const GLint *v)
 
1688
{
 
1689
    UNIMPLEMENTED();
 
1690
}
 
1691
 
 
1692
void Context::texCoord3s(GLshort s, GLshort t, GLshort r)
 
1693
{
 
1694
    UNIMPLEMENTED();
 
1695
}
 
1696
 
 
1697
void Context::texCoord3sv(const GLshort *v)
 
1698
{
 
1699
    UNIMPLEMENTED();
 
1700
}
 
1701
 
 
1702
void Context::texCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 
1703
{
 
1704
    UNIMPLEMENTED();
 
1705
}
 
1706
 
 
1707
void Context::texCoord4dv(const GLdouble *v)
 
1708
{
 
1709
    UNIMPLEMENTED();
 
1710
}
 
1711
 
 
1712
void Context::texCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 
1713
{
 
1714
    UNIMPLEMENTED();
 
1715
}
 
1716
 
 
1717
void Context::texCoord4fv(const GLfloat *v)
 
1718
{
 
1719
    UNIMPLEMENTED();
 
1720
}
 
1721
 
 
1722
void Context::texCoord4i(GLint s, GLint t, GLint r, GLint q)
 
1723
{
 
1724
    UNIMPLEMENTED();
 
1725
}
 
1726
 
 
1727
void Context::texCoord4iv(const GLint *v)
 
1728
{
 
1729
    UNIMPLEMENTED();
 
1730
}
 
1731
 
 
1732
void Context::texCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 
1733
{
 
1734
    UNIMPLEMENTED();
 
1735
}
 
1736
 
 
1737
void Context::texCoord4sv(const GLshort *v)
 
1738
{
 
1739
    UNIMPLEMENTED();
 
1740
}
 
1741
 
 
1742
void Context::texGend(GLenum coord, GLenum pname, GLdouble param)
 
1743
{
 
1744
    UNIMPLEMENTED();
 
1745
}
 
1746
 
 
1747
void Context::texGendv(GLenum coord, GLenum pname, const GLdouble *params)
 
1748
{
 
1749
    UNIMPLEMENTED();
 
1750
}
 
1751
 
 
1752
void Context::texImage1D(GLenum target,
 
1753
                         GLint level,
 
1754
                         GLint internalformat,
 
1755
                         GLsizei width,
 
1756
                         GLint border,
 
1757
                         GLenum format,
 
1758
                         GLenum type,
 
1759
                         const void *pixels)
 
1760
{
 
1761
    UNIMPLEMENTED();
 
1762
}
 
1763
 
 
1764
void Context::translated(GLdouble x, GLdouble y, GLdouble z)
 
1765
{
 
1766
    UNIMPLEMENTED();
 
1767
}
 
1768
 
 
1769
void Context::vertex2d(GLdouble x, GLdouble y)
 
1770
{
 
1771
    UNIMPLEMENTED();
 
1772
}
 
1773
 
 
1774
void Context::vertex2dv(const GLdouble *v)
 
1775
{
 
1776
    UNIMPLEMENTED();
 
1777
}
 
1778
 
 
1779
void Context::vertex2f(GLfloat x, GLfloat y)
 
1780
{
 
1781
    UNIMPLEMENTED();
 
1782
}
 
1783
 
 
1784
void Context::vertex2fv(const GLfloat *v)
 
1785
{
 
1786
    UNIMPLEMENTED();
 
1787
}
 
1788
 
 
1789
void Context::vertex2i(GLint x, GLint y)
 
1790
{
 
1791
    UNIMPLEMENTED();
 
1792
}
 
1793
 
 
1794
void Context::vertex2iv(const GLint *v)
 
1795
{
 
1796
    UNIMPLEMENTED();
 
1797
}
 
1798
 
 
1799
void Context::vertex2s(GLshort x, GLshort y)
 
1800
{
 
1801
    UNIMPLEMENTED();
 
1802
}
 
1803
 
 
1804
void Context::vertex2sv(const GLshort *v)
 
1805
{
 
1806
    UNIMPLEMENTED();
 
1807
}
 
1808
 
 
1809
void Context::vertex3d(GLdouble x, GLdouble y, GLdouble z)
 
1810
{
 
1811
    UNIMPLEMENTED();
 
1812
}
 
1813
 
 
1814
void Context::vertex3dv(const GLdouble *v)
 
1815
{
 
1816
    UNIMPLEMENTED();
 
1817
}
 
1818
 
 
1819
void Context::vertex3f(GLfloat x, GLfloat y, GLfloat z)
 
1820
{
 
1821
    UNIMPLEMENTED();
 
1822
}
 
1823
 
 
1824
void Context::vertex3fv(const GLfloat *v)
 
1825
{
 
1826
    UNIMPLEMENTED();
 
1827
}
 
1828
 
 
1829
void Context::vertex3i(GLint x, GLint y, GLint z)
 
1830
{
 
1831
    UNIMPLEMENTED();
 
1832
}
 
1833
 
 
1834
void Context::vertex3iv(const GLint *v)
 
1835
{
 
1836
    UNIMPLEMENTED();
 
1837
}
 
1838
 
 
1839
void Context::vertex3s(GLshort x, GLshort y, GLshort z)
 
1840
{
 
1841
    UNIMPLEMENTED();
 
1842
}
 
1843
 
 
1844
void Context::vertex3sv(const GLshort *v)
 
1845
{
 
1846
    UNIMPLEMENTED();
 
1847
}
 
1848
 
 
1849
void Context::vertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 
1850
{
 
1851
    UNIMPLEMENTED();
 
1852
}
 
1853
 
 
1854
void Context::vertex4dv(const GLdouble *v)
 
1855
{
 
1856
    UNIMPLEMENTED();
 
1857
}
 
1858
 
 
1859
void Context::vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 
1860
{
 
1861
    UNIMPLEMENTED();
 
1862
}
 
1863
 
 
1864
void Context::vertex4fv(const GLfloat *v)
 
1865
{
 
1866
    UNIMPLEMENTED();
 
1867
}
 
1868
 
 
1869
void Context::vertex4i(GLint x, GLint y, GLint z, GLint w)
 
1870
{
 
1871
    UNIMPLEMENTED();
 
1872
}
 
1873
 
 
1874
void Context::vertex4iv(const GLint *v)
 
1875
{
 
1876
    UNIMPLEMENTED();
 
1877
}
 
1878
 
 
1879
void Context::vertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 
1880
{
 
1881
    UNIMPLEMENTED();
 
1882
}
 
1883
 
 
1884
void Context::vertex4sv(const GLshort *v)
 
1885
{
 
1886
    UNIMPLEMENTED();
 
1887
}
 
1888
 
 
1889
GLboolean Context::areTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 
1890
{
 
1891
    UNIMPLEMENTED();
 
1892
    return false;
 
1893
}
 
1894
 
 
1895
void Context::arrayElement(GLint i)
 
1896
{
 
1897
    UNIMPLEMENTED();
 
1898
}
 
1899
 
 
1900
void Context::copyTexImage1D(GLenum target,
 
1901
                             GLint level,
 
1902
                             GLenum internalformat,
 
1903
                             GLint x,
 
1904
                             GLint y,
 
1905
                             GLsizei width,
 
1906
                             GLint border)
 
1907
{
 
1908
    UNIMPLEMENTED();
 
1909
}
 
1910
 
 
1911
void Context::copyTexSubImage1D(GLenum target,
 
1912
                                GLint level,
 
1913
                                GLint xoffset,
 
1914
                                GLint x,
 
1915
                                GLint y,
 
1916
                                GLsizei width)
 
1917
{
 
1918
    UNIMPLEMENTED();
 
1919
}
 
1920
 
 
1921
void Context::edgeFlagPointer(GLsizei stride, const void *pointer)
 
1922
{
 
1923
    UNIMPLEMENTED();
 
1924
}
 
1925
 
 
1926
void Context::indexPointer(GLenum type, GLsizei stride, const void *pointer)
 
1927
{
 
1928
    UNIMPLEMENTED();
 
1929
}
 
1930
 
 
1931
void Context::indexub(GLubyte c)
 
1932
{
 
1933
    UNIMPLEMENTED();
 
1934
}
 
1935
 
 
1936
void Context::indexubv(const GLubyte *c)
 
1937
{
 
1938
    UNIMPLEMENTED();
 
1939
}
 
1940
 
 
1941
void Context::interleavedArrays(GLenum format, GLsizei stride, const void *pointer)
 
1942
{
 
1943
    UNIMPLEMENTED();
 
1944
}
 
1945
 
 
1946
void Context::popClientAttrib()
 
1947
{
 
1948
    UNIMPLEMENTED();
 
1949
}
 
1950
 
 
1951
void Context::prioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
 
1952
{
 
1953
    UNIMPLEMENTED();
 
1954
}
 
1955
 
 
1956
void Context::pushClientAttrib(GLbitfield mask)
 
1957
{
 
1958
    UNIMPLEMENTED();
 
1959
}
 
1960
 
 
1961
void Context::texSubImage1D(GLenum target,
 
1962
                            GLint level,
 
1963
                            GLint xoffset,
 
1964
                            GLsizei width,
 
1965
                            GLenum format,
 
1966
                            GLenum type,
 
1967
                            const void *pixels)
 
1968
{
 
1969
    UNIMPLEMENTED();
 
1970
}
 
1971
 
 
1972
void Context::multiDrawElementsBaseVertex(PrimitiveMode mode,
 
1973
                                          const GLsizei *count,
 
1974
                                          DrawElementsType type,
 
1975
                                          const void *const *indices,
 
1976
                                          GLsizei drawcount,
 
1977
                                          const GLint *basevertex)
 
1978
{
 
1979
    UNIMPLEMENTED();
 
1980
}
 
1981
 
 
1982
void Context::texImage2DMultisample(GLenum target,
 
1983
                                    GLsizei samples,
 
1984
                                    GLenum internalformat,
 
1985
                                    GLsizei width,
 
1986
                                    GLsizei height,
 
1987
                                    GLboolean fixedsamplelocations)
 
1988
{
 
1989
    UNIMPLEMENTED();
 
1990
}
 
1991
 
 
1992
void Context::texImage3DMultisample(GLenum target,
 
1993
                                    GLsizei samples,
 
1994
                                    GLenum internalformat,
 
1995
                                    GLsizei width,
 
1996
                                    GLsizei height,
 
1997
                                    GLsizei depth,
 
1998
                                    GLboolean fixedsamplelocations)
 
1999
{
 
2000
    UNIMPLEMENTED();
 
2001
}
 
2002
 
 
2003
void Context::colorP3ui(GLenum type, GLuint color)
 
2004
{
 
2005
    UNIMPLEMENTED();
 
2006
}
 
2007
 
 
2008
void Context::colorP3uiv(GLenum type, const GLuint *color)
 
2009
{
 
2010
    UNIMPLEMENTED();
 
2011
}
 
2012
 
 
2013
void Context::colorP4ui(GLenum type, GLuint color)
 
2014
{
 
2015
    UNIMPLEMENTED();
 
2016
}
 
2017
 
 
2018
void Context::colorP4uiv(GLenum type, const GLuint *color)
 
2019
{
 
2020
    UNIMPLEMENTED();
 
2021
}
 
2022
 
 
2023
void Context::multiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
 
2024
{
 
2025
    UNIMPLEMENTED();
 
2026
}
 
2027
 
 
2028
void Context::multiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
 
2029
{
 
2030
    UNIMPLEMENTED();
 
2031
}
 
2032
 
 
2033
void Context::multiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
 
2034
{
 
2035
    UNIMPLEMENTED();
 
2036
}
 
2037
 
 
2038
void Context::multiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
 
2039
{
 
2040
    UNIMPLEMENTED();
 
2041
}
 
2042
 
 
2043
void Context::multiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
 
2044
{
 
2045
    UNIMPLEMENTED();
 
2046
}
 
2047
 
 
2048
void Context::multiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
 
2049
{
 
2050
    UNIMPLEMENTED();
 
2051
}
 
2052
 
 
2053
void Context::multiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
 
2054
{
 
2055
    UNIMPLEMENTED();
 
2056
}
 
2057
 
 
2058
void Context::multiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
 
2059
{
 
2060
    UNIMPLEMENTED();
 
2061
}
 
2062
 
 
2063
void Context::normalP3ui(GLenum type, GLuint coords)
 
2064
{
 
2065
    UNIMPLEMENTED();
 
2066
}
 
2067
 
 
2068
void Context::normalP3uiv(GLenum type, const GLuint *coords)
 
2069
{
 
2070
    UNIMPLEMENTED();
 
2071
}
 
2072
 
 
2073
void Context::secondaryColorP3ui(GLenum type, GLuint color)
 
2074
{
 
2075
    UNIMPLEMENTED();
 
2076
}
 
2077
 
 
2078
void Context::secondaryColorP3uiv(GLenum type, const GLuint *color)
 
2079
{
 
2080
    UNIMPLEMENTED();
 
2081
}
 
2082
 
 
2083
void Context::texCoordP1ui(GLenum type, GLuint coords)
 
2084
{
 
2085
    UNIMPLEMENTED();
 
2086
}
 
2087
 
 
2088
void Context::texCoordP1uiv(GLenum type, const GLuint *coords)
 
2089
{
 
2090
    UNIMPLEMENTED();
 
2091
}
 
2092
 
 
2093
void Context::texCoordP2ui(GLenum type, GLuint coords)
 
2094
{
 
2095
    UNIMPLEMENTED();
 
2096
}
 
2097
 
 
2098
void Context::texCoordP2uiv(GLenum type, const GLuint *coords)
 
2099
{
 
2100
    UNIMPLEMENTED();
 
2101
}
 
2102
 
 
2103
void Context::texCoordP3ui(GLenum type, GLuint coords)
 
2104
{
 
2105
    UNIMPLEMENTED();
 
2106
}
 
2107
 
 
2108
void Context::texCoordP3uiv(GLenum type, const GLuint *coords)
 
2109
{
 
2110
    UNIMPLEMENTED();
 
2111
}
 
2112
 
 
2113
void Context::texCoordP4ui(GLenum type, GLuint coords)
 
2114
{
 
2115
    UNIMPLEMENTED();
 
2116
}
 
2117
 
 
2118
void Context::texCoordP4uiv(GLenum type, const GLuint *coords)
 
2119
{
 
2120
    UNIMPLEMENTED();
 
2121
}
 
2122
 
 
2123
void Context::vertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 
2124
{
 
2125
    UNIMPLEMENTED();
 
2126
}
 
2127
 
 
2128
void Context::vertexAttribP1uiv(GLuint index,
 
2129
                                GLenum type,
 
2130
                                GLboolean normalized,
 
2131
                                const GLuint *value)
 
2132
{
 
2133
    UNIMPLEMENTED();
 
2134
}
 
2135
 
 
2136
void Context::vertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 
2137
{
 
2138
    UNIMPLEMENTED();
 
2139
}
 
2140
 
 
2141
void Context::vertexAttribP2uiv(GLuint index,
 
2142
                                GLenum type,
 
2143
                                GLboolean normalized,
 
2144
                                const GLuint *value)
 
2145
{
 
2146
    UNIMPLEMENTED();
 
2147
}
 
2148
 
 
2149
void Context::vertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 
2150
{
 
2151
    UNIMPLEMENTED();
 
2152
}
 
2153
 
 
2154
void Context::vertexAttribP3uiv(GLuint index,
 
2155
                                GLenum type,
 
2156
                                GLboolean normalized,
 
2157
                                const GLuint *value)
 
2158
{
 
2159
    UNIMPLEMENTED();
 
2160
}
 
2161
 
 
2162
void Context::vertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 
2163
{
 
2164
    UNIMPLEMENTED();
 
2165
}
 
2166
 
 
2167
void Context::vertexAttribP4uiv(GLuint index,
 
2168
                                GLenum type,
 
2169
                                GLboolean normalized,
 
2170
                                const GLuint *value)
 
2171
{
 
2172
    UNIMPLEMENTED();
 
2173
}
 
2174
 
 
2175
void Context::vertexP2ui(GLenum type, GLuint value)
 
2176
{
 
2177
    UNIMPLEMENTED();
 
2178
}
 
2179
 
 
2180
void Context::vertexP2uiv(GLenum type, const GLuint *value)
 
2181
{
 
2182
    UNIMPLEMENTED();
 
2183
}
 
2184
 
 
2185
void Context::vertexP3ui(GLenum type, GLuint value)
 
2186
{
 
2187
    UNIMPLEMENTED();
 
2188
}
 
2189
 
 
2190
void Context::vertexP3uiv(GLenum type, const GLuint *value)
 
2191
{
 
2192
    UNIMPLEMENTED();
 
2193
}
 
2194
 
 
2195
void Context::vertexP4ui(GLenum type, GLuint value)
 
2196
{
 
2197
    UNIMPLEMENTED();
 
2198
}
 
2199
 
 
2200
void Context::vertexP4uiv(GLenum type, const GLuint *value)
 
2201
{
 
2202
    UNIMPLEMENTED();
 
2203
}
 
2204
 
 
2205
void Context::beginQueryIndexed(GLenum target, GLuint index, QueryID id)
 
2206
{
 
2207
    UNIMPLEMENTED();
 
2208
}
 
2209
 
 
2210
void Context::drawTransformFeedback(GLenum mode, TransformFeedbackID id)
 
2211
{
 
2212
    UNIMPLEMENTED();
 
2213
}
 
2214
 
 
2215
void Context::drawTransformFeedbackStream(GLenum mode, TransformFeedbackID id, GLuint stream)
 
2216
{
 
2217
    UNIMPLEMENTED();
 
2218
}
 
2219
 
 
2220
void Context::endQueryIndexed(GLenum target, GLuint index)
 
2221
{
 
2222
    UNIMPLEMENTED();
 
2223
}
 
2224
 
 
2225
void Context::getActiveSubroutineName(ShaderProgramID program,
 
2226
                                      GLenum shadertype,
 
2227
                                      GLuint index,
 
2228
                                      GLsizei bufsize,
 
2229
                                      GLsizei *length,
 
2230
                                      GLchar *name)
 
2231
{
 
2232
    UNIMPLEMENTED();
 
2233
}
 
2234
 
 
2235
void Context::getActiveSubroutineUniformName(ShaderProgramID program,
 
2236
                                             GLenum shadertype,
 
2237
                                             GLuint index,
 
2238
                                             GLsizei bufsize,
 
2239
                                             GLsizei *length,
 
2240
                                             GLchar *name)
 
2241
{
 
2242
    UNIMPLEMENTED();
 
2243
}
 
2244
 
 
2245
void Context::getActiveSubroutineUniformiv(ShaderProgramID program,
 
2246
                                           GLenum shadertype,
 
2247
                                           GLuint index,
 
2248
                                           GLenum pname,
 
2249
                                           GLint *values)
 
2250
{
 
2251
    UNIMPLEMENTED();
 
2252
}
 
2253
 
 
2254
void Context::getProgramStageiv(ShaderProgramID program,
 
2255
                                GLenum shadertype,
 
2256
                                GLenum pname,
 
2257
                                GLint *values)
 
2258
{
 
2259
    UNIMPLEMENTED();
 
2260
}
 
2261
 
 
2262
void Context::getQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
 
2263
{
 
2264
    UNIMPLEMENTED();
 
2265
}
 
2266
 
 
2267
GLuint Context::getSubroutineIndex(ShaderProgramID program, GLenum shadertype, const GLchar *name)
 
2268
{
 
2269
    UNIMPLEMENTED();
 
2270
    return 0;
 
2271
}
 
2272
 
 
2273
GLint Context::getSubroutineUniformLocation(ShaderProgramID program,
 
2274
                                            GLenum shadertype,
 
2275
                                            const GLchar *name)
 
2276
{
 
2277
    UNIMPLEMENTED();
 
2278
    return 0;
 
2279
}
 
2280
 
 
2281
void Context::getUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
 
2282
{
 
2283
    UNIMPLEMENTED();
 
2284
}
 
2285
 
 
2286
void Context::getUniformdv(ShaderProgramID program, GLint location, GLdouble *params)
 
2287
{
 
2288
    UNIMPLEMENTED();
 
2289
}
 
2290
 
 
2291
void Context::patchParameterfv(GLenum pname, const GLfloat *values)
 
2292
{
 
2293
    UNIMPLEMENTED();
 
2294
}
 
2295
 
 
2296
void Context::uniform1d(GLint location, GLdouble x)
 
2297
{
 
2298
    UNIMPLEMENTED();
 
2299
}
 
2300
 
 
2301
void Context::uniform1dv(GLint location, GLsizei count, const GLdouble *value)
 
2302
{
 
2303
    UNIMPLEMENTED();
 
2304
}
 
2305
 
 
2306
void Context::uniform2d(GLint location, GLdouble x, GLdouble y)
 
2307
{
 
2308
    UNIMPLEMENTED();
 
2309
}
 
2310
 
 
2311
void Context::uniform2dv(GLint location, GLsizei count, const GLdouble *value)
 
2312
{
 
2313
    UNIMPLEMENTED();
 
2314
}
 
2315
 
 
2316
void Context::uniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
 
2317
{
 
2318
    UNIMPLEMENTED();
 
2319
}
 
2320
 
 
2321
void Context::uniform3dv(GLint location, GLsizei count, const GLdouble *value)
 
2322
{
 
2323
    UNIMPLEMENTED();
 
2324
}
 
2325
 
 
2326
void Context::uniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 
2327
{
 
2328
    UNIMPLEMENTED();
 
2329
}
 
2330
 
 
2331
void Context::uniform4dv(GLint location, GLsizei count, const GLdouble *value)
 
2332
{
 
2333
    UNIMPLEMENTED();
 
2334
}
 
2335
 
 
2336
void Context::uniformMatrix2dv(GLint location,
 
2337
                               GLsizei count,
 
2338
                               GLboolean transpose,
 
2339
                               const GLdouble *value)
 
2340
{
 
2341
    UNIMPLEMENTED();
 
2342
}
 
2343
 
 
2344
void Context::uniformMatrix2x3dv(GLint location,
 
2345
                                 GLsizei count,
 
2346
                                 GLboolean transpose,
 
2347
                                 const GLdouble *value)
 
2348
{
 
2349
    UNIMPLEMENTED();
 
2350
}
 
2351
 
 
2352
void Context::uniformMatrix2x4dv(GLint location,
 
2353
                                 GLsizei count,
 
2354
                                 GLboolean transpose,
 
2355
                                 const GLdouble *value)
 
2356
{
 
2357
    UNIMPLEMENTED();
 
2358
}
 
2359
 
 
2360
void Context::uniformMatrix3dv(GLint location,
 
2361
                               GLsizei count,
 
2362
                               GLboolean transpose,
 
2363
                               const GLdouble *value)
 
2364
{
 
2365
    UNIMPLEMENTED();
 
2366
}
 
2367
 
 
2368
void Context::uniformMatrix3x2dv(GLint location,
 
2369
                                 GLsizei count,
 
2370
                                 GLboolean transpose,
 
2371
                                 const GLdouble *value)
 
2372
{
 
2373
    UNIMPLEMENTED();
 
2374
}
 
2375
 
 
2376
void Context::uniformMatrix3x4dv(GLint location,
 
2377
                                 GLsizei count,
 
2378
                                 GLboolean transpose,
 
2379
                                 const GLdouble *value)
 
2380
{
 
2381
    UNIMPLEMENTED();
 
2382
}
 
2383
 
 
2384
void Context::uniformMatrix4dv(GLint location,
 
2385
                               GLsizei count,
 
2386
                               GLboolean transpose,
 
2387
                               const GLdouble *value)
 
2388
{
 
2389
    UNIMPLEMENTED();
 
2390
}
 
2391
 
 
2392
void Context::uniformMatrix4x2dv(GLint location,
 
2393
                                 GLsizei count,
 
2394
                                 GLboolean transpose,
 
2395
                                 const GLdouble *value)
 
2396
{
 
2397
    UNIMPLEMENTED();
 
2398
}
 
2399
 
 
2400
void Context::uniformMatrix4x3dv(GLint location,
 
2401
                                 GLsizei count,
 
2402
                                 GLboolean transpose,
 
2403
                                 const GLdouble *value)
 
2404
{
 
2405
    UNIMPLEMENTED();
 
2406
}
 
2407
 
 
2408
void Context::uniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
 
2409
{
 
2410
    UNIMPLEMENTED();
 
2411
}
 
2412
 
 
2413
void Context::depthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
 
2414
{
 
2415
    UNIMPLEMENTED();
 
2416
}
 
2417
 
 
2418
void Context::depthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
 
2419
{
 
2420
    UNIMPLEMENTED();
 
2421
}
 
2422
 
 
2423
void Context::getDoublei_v(GLenum target, GLuint index, GLdouble *data)
 
2424
{
 
2425
    UNIMPLEMENTED();
 
2426
}
 
2427
 
 
2428
void Context::getFloati_v(GLenum target, GLuint index, GLfloat *data)
 
2429
{
 
2430
    UNIMPLEMENTED();
 
2431
}
 
2432
 
 
2433
void Context::getVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
 
2434
{
 
2435
    UNIMPLEMENTED();
 
2436
}
 
2437
 
 
2438
void Context::programUniform1d(ShaderProgramID program, GLint location, GLdouble v0)
 
2439
{
 
2440
    UNIMPLEMENTED();
 
2441
}
 
2442
 
 
2443
void Context::programUniform1dv(ShaderProgramID program,
 
2444
                                GLint location,
 
2445
                                GLsizei count,
 
2446
                                const GLdouble *value)
 
2447
{
 
2448
    UNIMPLEMENTED();
 
2449
}
 
2450
 
 
2451
void Context::programUniform2d(ShaderProgramID program, GLint location, GLdouble v0, GLdouble v1)
 
2452
{
 
2453
    UNIMPLEMENTED();
 
2454
}
 
2455
 
 
2456
void Context::programUniform2dv(ShaderProgramID program,
 
2457
                                GLint location,
 
2458
                                GLsizei count,
 
2459
                                const GLdouble *value)
 
2460
{
 
2461
    UNIMPLEMENTED();
 
2462
}
 
2463
 
 
2464
void Context::programUniform3d(ShaderProgramID program,
 
2465
                               GLint location,
 
2466
                               GLdouble v0,
 
2467
                               GLdouble v1,
 
2468
                               GLdouble v2)
 
2469
{
 
2470
    UNIMPLEMENTED();
 
2471
}
 
2472
 
 
2473
void Context::programUniform3dv(ShaderProgramID program,
 
2474
                                GLint location,
 
2475
                                GLsizei count,
 
2476
                                const GLdouble *value)
 
2477
{
 
2478
    UNIMPLEMENTED();
 
2479
}
 
2480
 
 
2481
void Context::programUniform4d(ShaderProgramID program,
 
2482
                               GLint location,
 
2483
                               GLdouble v0,
 
2484
                               GLdouble v1,
 
2485
                               GLdouble v2,
 
2486
                               GLdouble v3)
 
2487
{
 
2488
    UNIMPLEMENTED();
 
2489
}
 
2490
 
 
2491
void Context::programUniform4dv(ShaderProgramID program,
 
2492
                                GLint location,
 
2493
                                GLsizei count,
 
2494
                                const GLdouble *value)
 
2495
{
 
2496
    UNIMPLEMENTED();
 
2497
}
 
2498
 
 
2499
void Context::programUniformMatrix2dv(ShaderProgramID program,
 
2500
                                      GLint location,
 
2501
                                      GLsizei count,
 
2502
                                      GLboolean transpose,
 
2503
                                      const GLdouble *value)
 
2504
{
 
2505
    UNIMPLEMENTED();
 
2506
}
 
2507
 
 
2508
void Context::programUniformMatrix2x3dv(ShaderProgramID program,
 
2509
                                        GLint location,
 
2510
                                        GLsizei count,
 
2511
                                        GLboolean transpose,
 
2512
                                        const GLdouble *value)
 
2513
{
 
2514
    UNIMPLEMENTED();
 
2515
}
 
2516
 
 
2517
void Context::programUniformMatrix2x4dv(ShaderProgramID program,
 
2518
                                        GLint location,
 
2519
                                        GLsizei count,
 
2520
                                        GLboolean transpose,
 
2521
                                        const GLdouble *value)
 
2522
{
 
2523
    UNIMPLEMENTED();
 
2524
}
 
2525
 
 
2526
void Context::programUniformMatrix3dv(ShaderProgramID program,
 
2527
                                      GLint location,
 
2528
                                      GLsizei count,
 
2529
                                      GLboolean transpose,
 
2530
                                      const GLdouble *value)
 
2531
{
 
2532
    UNIMPLEMENTED();
 
2533
}
 
2534
 
 
2535
void Context::programUniformMatrix3x2dv(ShaderProgramID program,
 
2536
                                        GLint location,
 
2537
                                        GLsizei count,
 
2538
                                        GLboolean transpose,
 
2539
                                        const GLdouble *value)
 
2540
{
 
2541
    UNIMPLEMENTED();
 
2542
}
 
2543
 
 
2544
void Context::programUniformMatrix3x4dv(ShaderProgramID program,
 
2545
                                        GLint location,
 
2546
                                        GLsizei count,
 
2547
                                        GLboolean transpose,
 
2548
                                        const GLdouble *value)
 
2549
{
 
2550
    UNIMPLEMENTED();
 
2551
}
 
2552
 
 
2553
void Context::programUniformMatrix4dv(ShaderProgramID program,
 
2554
                                      GLint location,
 
2555
                                      GLsizei count,
 
2556
                                      GLboolean transpose,
 
2557
                                      const GLdouble *value)
 
2558
{
 
2559
    UNIMPLEMENTED();
 
2560
}
 
2561
 
 
2562
void Context::programUniformMatrix4x2dv(ShaderProgramID program,
 
2563
                                        GLint location,
 
2564
                                        GLsizei count,
 
2565
                                        GLboolean transpose,
 
2566
                                        const GLdouble *value)
 
2567
{
 
2568
    UNIMPLEMENTED();
 
2569
}
 
2570
 
 
2571
void Context::programUniformMatrix4x3dv(ShaderProgramID program,
 
2572
                                        GLint location,
 
2573
                                        GLsizei count,
 
2574
                                        GLboolean transpose,
 
2575
                                        const GLdouble *value)
 
2576
{
 
2577
    UNIMPLEMENTED();
 
2578
}
 
2579
 
 
2580
void Context::scissorArrayv(GLuint first, GLsizei count, const GLint *v)
 
2581
{
 
2582
    UNIMPLEMENTED();
 
2583
}
 
2584
 
 
2585
void Context::scissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
 
2586
{
 
2587
    UNIMPLEMENTED();
 
2588
}
 
2589
 
 
2590
void Context::scissorIndexedv(GLuint index, const GLint *v)
 
2591
{
 
2592
    UNIMPLEMENTED();
 
2593
}
 
2594
 
 
2595
void Context::vertexAttribL1d(GLuint index, GLdouble x)
 
2596
{
 
2597
    UNIMPLEMENTED();
 
2598
}
 
2599
 
 
2600
void Context::vertexAttribL1dv(GLuint index, const GLdouble *v)
 
2601
{
 
2602
    UNIMPLEMENTED();
 
2603
}
 
2604
 
 
2605
void Context::vertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
 
2606
{
 
2607
    UNIMPLEMENTED();
 
2608
}
 
2609
 
 
2610
void Context::vertexAttribL2dv(GLuint index, const GLdouble *v)
 
2611
{
 
2612
    UNIMPLEMENTED();
 
2613
}
 
2614
 
 
2615
void Context::vertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 
2616
{
 
2617
    UNIMPLEMENTED();
 
2618
}
 
2619
 
 
2620
void Context::vertexAttribL3dv(GLuint index, const GLdouble *v)
 
2621
{
 
2622
    UNIMPLEMENTED();
 
2623
}
 
2624
 
 
2625
void Context::vertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 
2626
{
 
2627
    UNIMPLEMENTED();
 
2628
}
 
2629
 
 
2630
void Context::vertexAttribL4dv(GLuint index, const GLdouble *v)
 
2631
{
 
2632
    UNIMPLEMENTED();
 
2633
}
 
2634
 
 
2635
void Context::vertexAttribLPointer(GLuint index,
 
2636
                                   GLint size,
 
2637
                                   GLenum type,
 
2638
                                   GLsizei stride,
 
2639
                                   const void *pointer)
 
2640
{
 
2641
    UNIMPLEMENTED();
 
2642
}
 
2643
 
 
2644
void Context::viewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
 
2645
{
 
2646
    UNIMPLEMENTED();
 
2647
}
 
2648
 
 
2649
void Context::viewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
 
2650
{
 
2651
    UNIMPLEMENTED();
 
2652
}
 
2653
 
 
2654
void Context::viewportIndexedfv(GLuint index, const GLfloat *v)
 
2655
{
 
2656
    UNIMPLEMENTED();
 
2657
}
 
2658
 
 
2659
void Context::drawElementsInstancedBaseInstance(GLenum mode,
 
2660
                                                GLsizei count,
 
2661
                                                GLenum type,
 
2662
                                                const void *indices,
 
2663
                                                GLsizei instancecount,
 
2664
                                                GLuint baseinstance)
 
2665
{
 
2666
    UNIMPLEMENTED();
 
2667
}
 
2668
 
 
2669
void Context::drawTransformFeedbackInstanced(GLenum mode,
 
2670
                                             TransformFeedbackID id,
 
2671
                                             GLsizei instancecount)
 
2672
{
 
2673
    UNIMPLEMENTED();
 
2674
}
 
2675
 
 
2676
void Context::drawTransformFeedbackStreamInstanced(GLenum mode,
 
2677
                                                   TransformFeedbackID id,
 
2678
                                                   GLuint stream,
 
2679
                                                   GLsizei instancecount)
 
2680
{
 
2681
    UNIMPLEMENTED();
 
2682
}
 
2683
 
 
2684
void Context::getActiveAtomicCounterBufferiv(ShaderProgramID program,
 
2685
                                             GLuint bufferIndex,
 
2686
                                             GLenum pname,
 
2687
                                             GLint *params)
 
2688
{
 
2689
    UNIMPLEMENTED();
 
2690
}
 
2691
 
 
2692
void Context::clearBufferData(GLenum target,
 
2693
                              GLenum internalformat,
 
2694
                              GLenum format,
 
2695
                              GLenum type,
 
2696
                              const void *data)
 
2697
{
 
2698
    UNIMPLEMENTED();
 
2699
}
 
2700
 
 
2701
void Context::clearBufferSubData(GLenum target,
 
2702
                                 GLenum internalformat,
 
2703
                                 GLintptr offset,
 
2704
                                 GLsizeiptr size,
 
2705
                                 GLenum format,
 
2706
                                 GLenum type,
 
2707
                                 const void *data)
 
2708
{
 
2709
    UNIMPLEMENTED();
 
2710
}
 
2711
 
 
2712
void Context::getInternalformati64v(GLenum target,
 
2713
                                    GLenum internalformat,
 
2714
                                    GLenum pname,
 
2715
                                    GLsizei bufSize,
 
2716
                                    GLint64 *params)
 
2717
{
 
2718
    UNIMPLEMENTED();
 
2719
}
 
2720
 
 
2721
void Context::invalidateBufferData(BufferID buffer)
 
2722
{
 
2723
    UNIMPLEMENTED();
 
2724
}
 
2725
 
 
2726
void Context::invalidateBufferSubData(BufferID buffer, GLintptr offset, GLsizeiptr length)
 
2727
{
 
2728
    UNIMPLEMENTED();
 
2729
}
 
2730
 
 
2731
void Context::invalidateTexImage(TextureID texture, GLint level)
 
2732
{
 
2733
    UNIMPLEMENTED();
 
2734
}
 
2735
 
 
2736
void Context::invalidateTexSubImage(TextureID texture,
 
2737
                                    GLint level,
 
2738
                                    GLint xoffset,
 
2739
                                    GLint yoffset,
 
2740
                                    GLint zoffset,
 
2741
                                    GLsizei width,
 
2742
                                    GLsizei height,
 
2743
                                    GLsizei depth)
 
2744
{
 
2745
    UNIMPLEMENTED();
 
2746
}
 
2747
 
 
2748
void Context::multiDrawArraysIndirect(GLenum mode,
 
2749
                                      const void *indirect,
 
2750
                                      GLsizei drawcount,
 
2751
                                      GLsizei stride)
 
2752
{
 
2753
    UNIMPLEMENTED();
 
2754
}
 
2755
 
 
2756
void Context::multiDrawElementsIndirect(GLenum mode,
 
2757
                                        GLenum type,
 
2758
                                        const void *indirect,
 
2759
                                        GLsizei drawcount,
 
2760
                                        GLsizei stride)
 
2761
{
 
2762
    UNIMPLEMENTED();
 
2763
}
 
2764
 
 
2765
void Context::shaderStorageBlockBinding(ShaderProgramID program,
 
2766
                                        GLuint storageBlockIndex,
 
2767
                                        GLuint storageBlockBinding)
 
2768
{
 
2769
    UNIMPLEMENTED();
 
2770
}
 
2771
 
 
2772
void Context::textureView(TextureID texture,
 
2773
                          GLenum target,
 
2774
                          GLuint origtexture,
 
2775
                          GLenum internalformat,
 
2776
                          GLuint minlevel,
 
2777
                          GLuint numlevels,
 
2778
                          GLuint minlayer,
 
2779
                          GLuint numlayers)
 
2780
{
 
2781
    UNIMPLEMENTED();
 
2782
}
 
2783
 
 
2784
void Context::vertexAttribLFormat(GLuint attribindex,
 
2785
                                  GLint size,
 
2786
                                  GLenum type,
 
2787
                                  GLuint relativeoffset)
 
2788
{
 
2789
    UNIMPLEMENTED();
 
2790
}
 
2791
 
 
2792
void Context::bindBuffersBase(GLenum target, GLuint first, GLsizei count, const BufferID *buffers)
 
2793
{
 
2794
    UNIMPLEMENTED();
 
2795
}
 
2796
 
 
2797
void Context::bindBuffersRange(GLenum target,
 
2798
                               GLuint first,
 
2799
                               GLsizei count,
 
2800
                               const BufferID *buffers,
 
2801
                               const GLintptr *offsets,
 
2802
                               const GLsizeiptr *sizes)
 
2803
{
 
2804
    UNIMPLEMENTED();
 
2805
}
 
2806
 
 
2807
void Context::bindImageTextures(GLuint first, GLsizei count, const GLuint *textures)
 
2808
{
 
2809
    UNIMPLEMENTED();
 
2810
}
 
2811
 
 
2812
void Context::bindSamplers(GLuint first, GLsizei count, const GLuint *samplers)
 
2813
{
 
2814
    UNIMPLEMENTED();
 
2815
}
 
2816
 
 
2817
void Context::bindTextures(GLuint first, GLsizei count, const GLuint *textures)
 
2818
{
 
2819
    UNIMPLEMENTED();
 
2820
}
 
2821
 
 
2822
void Context::bindVertexBuffers(GLuint first,
 
2823
                                GLsizei count,
 
2824
                                const BufferID *buffers,
 
2825
                                const GLintptr *offsets,
 
2826
                                const GLsizei *strides)
 
2827
{
 
2828
    UNIMPLEMENTED();
 
2829
}
 
2830
 
 
2831
void Context::bufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)
 
2832
{
 
2833
    UNIMPLEMENTED();
 
2834
}
 
2835
 
 
2836
void Context::clearTexImage(TextureID texture,
 
2837
                            GLint level,
 
2838
                            GLenum format,
 
2839
                            GLenum type,
 
2840
                            const void *data)
 
2841
{
 
2842
    UNIMPLEMENTED();
 
2843
}
 
2844
 
 
2845
void Context::clearTexSubImage(TextureID texture,
 
2846
                               GLint level,
 
2847
                               GLint xoffset,
 
2848
                               GLint yoffset,
 
2849
                               GLint zoffset,
 
2850
                               GLsizei width,
 
2851
                               GLsizei height,
 
2852
                               GLsizei depth,
 
2853
                               GLenum format,
 
2854
                               GLenum type,
 
2855
                               const void *data)
 
2856
{
 
2857
    UNIMPLEMENTED();
 
2858
}
 
2859
 
 
2860
void Context::bindTextureUnit(GLuint unit, TextureID texture)
 
2861
{
 
2862
    UNIMPLEMENTED();
 
2863
}
 
2864
 
 
2865
void Context::blitNamedFramebuffer(GLuint readFramebuffer,
 
2866
                                   GLuint drawFramebuffer,
 
2867
                                   GLint srcX0,
 
2868
                                   GLint srcY0,
 
2869
                                   GLint srcX1,
 
2870
                                   GLint srcY1,
 
2871
                                   GLint dstX0,
 
2872
                                   GLint dstY0,
 
2873
                                   GLint dstX1,
 
2874
                                   GLint dstY1,
 
2875
                                   GLbitfield mask,
 
2876
                                   GLenum filter)
 
2877
{
 
2878
    UNIMPLEMENTED();
 
2879
}
 
2880
 
 
2881
GLenum Context::checkNamedFramebufferStatus(FramebufferID framebuffer, GLenum target)
 
2882
{
 
2883
    UNIMPLEMENTED();
 
2884
    return 0;
 
2885
}
 
2886
 
 
2887
void Context::clearNamedBufferData(BufferID buffer,
 
2888
                                   GLenum internalformat,
 
2889
                                   GLenum format,
 
2890
                                   GLenum type,
 
2891
                                   const void *data)
 
2892
{
 
2893
    UNIMPLEMENTED();
 
2894
}
 
2895
 
 
2896
void Context::clearNamedBufferSubData(BufferID buffer,
 
2897
                                      GLenum internalformat,
 
2898
                                      GLintptr offset,
 
2899
                                      GLsizeiptr size,
 
2900
                                      GLenum format,
 
2901
                                      GLenum type,
 
2902
                                      const void *data)
 
2903
{
 
2904
    UNIMPLEMENTED();
 
2905
}
 
2906
 
 
2907
void Context::clearNamedFramebufferfi(FramebufferID framebuffer,
 
2908
                                      GLenum buffer,
 
2909
                                      GLint drawbuffer,
 
2910
                                      GLfloat depth,
 
2911
                                      GLint stencil)
 
2912
{
 
2913
    UNIMPLEMENTED();
 
2914
}
 
2915
 
 
2916
void Context::clearNamedFramebufferfv(FramebufferID framebuffer,
 
2917
                                      GLenum buffer,
 
2918
                                      GLint drawbuffer,
 
2919
                                      const GLfloat *value)
 
2920
{
 
2921
    UNIMPLEMENTED();
 
2922
}
 
2923
 
 
2924
void Context::clearNamedFramebufferiv(FramebufferID framebuffer,
 
2925
                                      GLenum buffer,
 
2926
                                      GLint drawbuffer,
 
2927
                                      const GLint *value)
 
2928
{
 
2929
    UNIMPLEMENTED();
 
2930
}
 
2931
 
 
2932
void Context::clearNamedFramebufferuiv(FramebufferID framebuffer,
 
2933
                                       GLenum buffer,
 
2934
                                       GLint drawbuffer,
 
2935
                                       const GLuint *value)
 
2936
{
 
2937
    UNIMPLEMENTED();
 
2938
}
 
2939
 
 
2940
void Context::clipControl(GLenum origin, GLenum depth)
 
2941
{
 
2942
    UNIMPLEMENTED();
 
2943
}
 
2944
 
 
2945
void Context::compressedTextureSubImage1D(TextureID texture,
 
2946
                                          GLint level,
 
2947
                                          GLint xoffset,
 
2948
                                          GLsizei width,
 
2949
                                          GLenum format,
 
2950
                                          GLsizei imageSize,
 
2951
                                          const void *data)
 
2952
{
 
2953
    UNIMPLEMENTED();
 
2954
}
 
2955
 
 
2956
void Context::compressedTextureSubImage2D(TextureID texture,
 
2957
                                          GLint level,
 
2958
                                          GLint xoffset,
 
2959
                                          GLint yoffset,
 
2960
                                          GLsizei width,
 
2961
                                          GLsizei height,
 
2962
                                          GLenum format,
 
2963
                                          GLsizei imageSize,
 
2964
                                          const void *data)
 
2965
{
 
2966
    UNIMPLEMENTED();
 
2967
}
 
2968
 
 
2969
void Context::compressedTextureSubImage3D(TextureID texture,
 
2970
                                          GLint level,
 
2971
                                          GLint xoffset,
 
2972
                                          GLint yoffset,
 
2973
                                          GLint zoffset,
 
2974
                                          GLsizei width,
 
2975
                                          GLsizei height,
 
2976
                                          GLsizei depth,
 
2977
                                          GLenum format,
 
2978
                                          GLsizei imageSize,
 
2979
                                          const void *data)
 
2980
{
 
2981
    UNIMPLEMENTED();
 
2982
}
 
2983
 
 
2984
void Context::copyNamedBufferSubData(GLuint readBuffer,
 
2985
                                     GLuint writeBuffer,
 
2986
                                     GLintptr readOffset,
 
2987
                                     GLintptr writeOffset,
 
2988
                                     GLsizeiptr size)
 
2989
{
 
2990
    UNIMPLEMENTED();
 
2991
}
 
2992
 
 
2993
void Context::copyTextureSubImage1D(TextureID texture,
 
2994
                                    GLint level,
 
2995
                                    GLint xoffset,
 
2996
                                    GLint x,
 
2997
                                    GLint y,
 
2998
                                    GLsizei width)
 
2999
{
 
3000
    UNIMPLEMENTED();
 
3001
}
 
3002
 
 
3003
void Context::copyTextureSubImage2D(TextureID texture,
 
3004
                                    GLint level,
 
3005
                                    GLint xoffset,
 
3006
                                    GLint yoffset,
 
3007
                                    GLint x,
 
3008
                                    GLint y,
 
3009
                                    GLsizei width,
 
3010
                                    GLsizei height)
 
3011
{
 
3012
    UNIMPLEMENTED();
 
3013
}
 
3014
 
 
3015
void Context::copyTextureSubImage3D(TextureID texture,
 
3016
                                    GLint level,
 
3017
                                    GLint xoffset,
 
3018
                                    GLint yoffset,
 
3019
                                    GLint zoffset,
 
3020
                                    GLint x,
 
3021
                                    GLint y,
 
3022
                                    GLsizei width,
 
3023
                                    GLsizei height)
 
3024
{
 
3025
    UNIMPLEMENTED();
 
3026
}
 
3027
 
 
3028
void Context::createBuffers(GLsizei n, BufferID *buffers)
 
3029
{
 
3030
    UNIMPLEMENTED();
 
3031
}
 
3032
 
 
3033
void Context::createFramebuffers(GLsizei n, GLuint *framebuffers)
 
3034
{
 
3035
    UNIMPLEMENTED();
 
3036
}
 
3037
 
 
3038
void Context::createProgramPipelines(GLsizei n, GLuint *pipelines)
 
3039
{
 
3040
    UNIMPLEMENTED();
 
3041
}
 
3042
 
 
3043
void Context::createQueries(GLenum target, GLsizei n, GLuint *ids)
 
3044
{
 
3045
    UNIMPLEMENTED();
 
3046
}
 
3047
 
 
3048
void Context::createRenderbuffers(GLsizei n, RenderbufferID *renderbuffers)
 
3049
{
 
3050
    UNIMPLEMENTED();
 
3051
}
 
3052
 
 
3053
void Context::createSamplers(GLsizei n, GLuint *samplers)
 
3054
{
 
3055
    UNIMPLEMENTED();
 
3056
}
 
3057
 
 
3058
void Context::createTextures(GLenum target, GLsizei n, GLuint *textures)
 
3059
{
 
3060
    UNIMPLEMENTED();
 
3061
}
 
3062
 
 
3063
void Context::createTransformFeedbacks(GLsizei n, GLuint *ids)
 
3064
{
 
3065
    UNIMPLEMENTED();
 
3066
}
 
3067
 
 
3068
void Context::createVertexArrays(GLsizei n, VertexArrayID *arrays)
 
3069
{
 
3070
    UNIMPLEMENTED();
 
3071
}
 
3072
 
 
3073
void Context::disableVertexArrayAttrib(VertexArrayID vaobj, GLuint index)
 
3074
{
 
3075
    UNIMPLEMENTED();
 
3076
}
 
3077
 
 
3078
void Context::enableVertexArrayAttrib(VertexArrayID vaobj, GLuint index)
 
3079
{
 
3080
    UNIMPLEMENTED();
 
3081
}
 
3082
 
 
3083
void Context::flushMappedNamedBufferRange(BufferID buffer, GLintptr offset, GLsizeiptr length)
 
3084
{
 
3085
    UNIMPLEMENTED();
 
3086
}
 
3087
 
 
3088
void Context::generateTextureMipmap(TextureID texture)
 
3089
{
 
3090
    UNIMPLEMENTED();
 
3091
}
 
3092
 
 
3093
void Context::getCompressedTextureImage(TextureID texture,
 
3094
                                        GLint level,
 
3095
                                        GLsizei bufSize,
 
3096
                                        void *pixels)
 
3097
{
 
3098
    UNIMPLEMENTED();
 
3099
}
 
3100
 
 
3101
void Context::getCompressedTextureSubImage(TextureID texture,
 
3102
                                           GLint level,
 
3103
                                           GLint xoffset,
 
3104
                                           GLint yoffset,
 
3105
                                           GLint zoffset,
 
3106
                                           GLsizei width,
 
3107
                                           GLsizei height,
 
3108
                                           GLsizei depth,
 
3109
                                           GLsizei bufSize,
 
3110
                                           void *pixels)
 
3111
{
 
3112
    UNIMPLEMENTED();
 
3113
}
 
3114
 
 
3115
void Context::getNamedBufferParameteri64v(BufferID buffer, GLenum pname, GLint64 *params)
 
3116
{
 
3117
    UNIMPLEMENTED();
 
3118
}
 
3119
 
 
3120
void Context::getNamedBufferParameteriv(BufferID buffer, GLenum pname, GLint *params)
 
3121
{
 
3122
    UNIMPLEMENTED();
 
3123
}
 
3124
 
 
3125
void Context::getNamedBufferPointerv(BufferID buffer, GLenum pname, void **params)
 
3126
{
 
3127
    UNIMPLEMENTED();
 
3128
}
 
3129
 
 
3130
void Context::getNamedBufferSubData(BufferID buffer, GLintptr offset, GLsizeiptr size, void *data)
 
3131
{
 
3132
    UNIMPLEMENTED();
 
3133
}
 
3134
 
 
3135
void Context::getNamedFramebufferAttachmentParameteriv(FramebufferID framebuffer,
 
3136
                                                       GLenum attachment,
 
3137
                                                       GLenum pname,
 
3138
                                                       GLint *params)
 
3139
{
 
3140
    UNIMPLEMENTED();
 
3141
}
 
3142
 
 
3143
void Context::getNamedFramebufferParameteriv(FramebufferID framebuffer, GLenum pname, GLint *param)
 
3144
{
 
3145
    UNIMPLEMENTED();
 
3146
}
 
3147
 
 
3148
void Context::getNamedRenderbufferParameteriv(RenderbufferID renderbuffer,
 
3149
                                              GLenum pname,
 
3150
                                              GLint *params)
 
3151
{
 
3152
    UNIMPLEMENTED();
 
3153
}
 
3154
 
 
3155
void Context::getQueryBufferObjecti64v(GLuint id, BufferID buffer, GLenum pname, GLintptr offset)
 
3156
{
 
3157
    UNIMPLEMENTED();
 
3158
}
 
3159
 
 
3160
void Context::getQueryBufferObjectiv(GLuint id, BufferID buffer, GLenum pname, GLintptr offset)
 
3161
{
 
3162
    UNIMPLEMENTED();
 
3163
}
 
3164
 
 
3165
void Context::getQueryBufferObjectui64v(GLuint id, BufferID buffer, GLenum pname, GLintptr offset)
 
3166
{
 
3167
    UNIMPLEMENTED();
 
3168
}
 
3169
 
 
3170
void Context::getQueryBufferObjectuiv(GLuint id, BufferID buffer, GLenum pname, GLintptr offset)
 
3171
{
 
3172
    UNIMPLEMENTED();
 
3173
}
 
3174
 
 
3175
void Context::getTextureImage(TextureID texture,
 
3176
                              GLint level,
 
3177
                              GLenum format,
 
3178
                              GLenum type,
 
3179
                              GLsizei bufSize,
 
3180
                              void *pixels)
 
3181
{
 
3182
    UNIMPLEMENTED();
 
3183
}
 
3184
 
 
3185
void Context::getTextureLevelParameterfv(TextureID texture,
 
3186
                                         GLint level,
 
3187
                                         GLenum pname,
 
3188
                                         GLfloat *params)
 
3189
{
 
3190
    UNIMPLEMENTED();
 
3191
}
 
3192
 
 
3193
void Context::getTextureLevelParameteriv(TextureID texture,
 
3194
                                         GLint level,
 
3195
                                         GLenum pname,
 
3196
                                         GLint *params)
 
3197
{
 
3198
    UNIMPLEMENTED();
 
3199
}
 
3200
 
 
3201
void Context::getTextureParameterIiv(TextureID texture, GLenum pname, GLint *params)
 
3202
{
 
3203
    UNIMPLEMENTED();
 
3204
}
 
3205
 
 
3206
void Context::getTextureParameterIuiv(TextureID texture, GLenum pname, GLuint *params)
 
3207
{
 
3208
    UNIMPLEMENTED();
 
3209
}
 
3210
 
 
3211
void Context::getTextureParameterfv(TextureID texture, GLenum pname, GLfloat *params)
 
3212
{
 
3213
    UNIMPLEMENTED();
 
3214
}
 
3215
 
 
3216
void Context::getTextureParameteriv(TextureID texture, GLenum pname, GLint *params)
 
3217
{
 
3218
    UNIMPLEMENTED();
 
3219
}
 
3220
 
 
3221
void Context::getTextureSubImage(TextureID texture,
 
3222
                                 GLint level,
 
3223
                                 GLint xoffset,
 
3224
                                 GLint yoffset,
 
3225
                                 GLint zoffset,
 
3226
                                 GLsizei width,
 
3227
                                 GLsizei height,
 
3228
                                 GLsizei depth,
 
3229
                                 GLenum format,
 
3230
                                 GLenum type,
 
3231
                                 GLsizei bufSize,
 
3232
                                 void *pixels)
 
3233
{
 
3234
    UNIMPLEMENTED();
 
3235
}
 
3236
 
 
3237
void Context::getTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index, GLint64 *param)
 
3238
{
 
3239
    UNIMPLEMENTED();
 
3240
}
 
3241
 
 
3242
void Context::getTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index, GLint *param)
 
3243
{
 
3244
    UNIMPLEMENTED();
 
3245
}
 
3246
 
 
3247
void Context::getTransformFeedbackiv(GLuint xfb, GLenum pname, GLint *param)
 
3248
{
 
3249
    UNIMPLEMENTED();
 
3250
}
 
3251
 
 
3252
void Context::getVertexArrayIndexed64iv(VertexArrayID vaobj,
 
3253
                                        GLuint index,
 
3254
                                        GLenum pname,
 
3255
                                        GLint64 *param)
 
3256
{
 
3257
    UNIMPLEMENTED();
 
3258
}
 
3259
 
 
3260
void Context::getVertexArrayIndexediv(VertexArrayID vaobj, GLuint index, GLenum pname, GLint *param)
 
3261
{
 
3262
    UNIMPLEMENTED();
 
3263
}
 
3264
 
 
3265
void Context::getVertexArrayiv(VertexArrayID vaobj, GLenum pname, GLint *param)
 
3266
{
 
3267
    UNIMPLEMENTED();
 
3268
}
 
3269
 
 
3270
void Context::getnColorTable(GLenum target,
 
3271
                             GLenum format,
 
3272
                             GLenum type,
 
3273
                             GLsizei bufSize,
 
3274
                             void *table)
 
3275
{
 
3276
    UNIMPLEMENTED();
 
3277
}
 
3278
 
 
3279
void Context::getnCompressedTexImage(GLenum target, GLint lod, GLsizei bufSize, void *pixels)
 
3280
{
 
3281
    UNIMPLEMENTED();
 
3282
}
 
3283
 
 
3284
void Context::getnConvolutionFilter(GLenum target,
 
3285
                                    GLenum format,
 
3286
                                    GLenum type,
 
3287
                                    GLsizei bufSize,
 
3288
                                    void *image)
 
3289
{
 
3290
    UNIMPLEMENTED();
 
3291
}
 
3292
 
 
3293
void Context::getnHistogram(GLenum target,
 
3294
                            GLboolean reset,
 
3295
                            GLenum format,
 
3296
                            GLenum type,
 
3297
                            GLsizei bufSize,
 
3298
                            void *values)
 
3299
{
 
3300
    UNIMPLEMENTED();
 
3301
}
 
3302
 
 
3303
void Context::getnMapdv(GLenum target, GLenum query, GLsizei bufSize, GLdouble *v)
 
3304
{
 
3305
    UNIMPLEMENTED();
 
3306
}
 
3307
 
 
3308
void Context::getnMapfv(GLenum target, GLenum query, GLsizei bufSize, GLfloat *v)
 
3309
{
 
3310
    UNIMPLEMENTED();
 
3311
}
 
3312
 
 
3313
void Context::getnMapiv(GLenum target, GLenum query, GLsizei bufSize, GLint *v)
 
3314
{
 
3315
    UNIMPLEMENTED();
 
3316
}
 
3317
 
 
3318
void Context::getnMinmax(GLenum target,
 
3319
                         GLboolean reset,
 
3320
                         GLenum format,
 
3321
                         GLenum type,
 
3322
                         GLsizei bufSize,
 
3323
                         void *values)
 
3324
{
 
3325
    UNIMPLEMENTED();
 
3326
}
 
3327
 
 
3328
void Context::getnPixelMapfv(GLenum map, GLsizei bufSize, GLfloat *values)
 
3329
{
 
3330
    UNIMPLEMENTED();
 
3331
}
 
3332
 
 
3333
void Context::getnPixelMapuiv(GLenum map, GLsizei bufSize, GLuint *values)
 
3334
{
 
3335
    UNIMPLEMENTED();
 
3336
}
 
3337
 
 
3338
void Context::getnPixelMapusv(GLenum map, GLsizei bufSize, GLushort *values)
 
3339
{
 
3340
    UNIMPLEMENTED();
 
3341
}
 
3342
 
 
3343
void Context::getnPolygonStipple(GLsizei bufSize, GLubyte *pattern)
 
3344
{
 
3345
    UNIMPLEMENTED();
 
3346
}
 
3347
 
 
3348
void Context::getnSeparableFilter(GLenum target,
 
3349
                                  GLenum format,
 
3350
                                  GLenum type,
 
3351
                                  GLsizei rowBufSize,
 
3352
                                  void *row,
 
3353
                                  GLsizei columnBufSize,
 
3354
                                  void *column,
 
3355
                                  void *span)
 
3356
{
 
3357
    UNIMPLEMENTED();
 
3358
}
 
3359
 
 
3360
void Context::getnTexImage(GLenum target,
 
3361
                           GLint level,
 
3362
                           GLenum format,
 
3363
                           GLenum type,
 
3364
                           GLsizei bufSize,
 
3365
                           void *pixels)
 
3366
{
 
3367
    UNIMPLEMENTED();
 
3368
}
 
3369
 
 
3370
void Context::getnUniformdv(ShaderProgramID program,
 
3371
                            GLint location,
 
3372
                            GLsizei bufSize,
 
3373
                            GLdouble *params)
 
3374
{
 
3375
    UNIMPLEMENTED();
 
3376
}
 
3377
 
 
3378
void Context::getnUniformuiv(ShaderProgramID program,
 
3379
                             GLint location,
 
3380
                             GLsizei bufSize,
 
3381
                             GLuint *params)
 
3382
{
 
3383
    UNIMPLEMENTED();
 
3384
}
 
3385
 
 
3386
void Context::invalidateNamedFramebufferData(FramebufferID framebuffer,
 
3387
                                             GLsizei numAttachments,
 
3388
                                             const GLenum *attachments)
 
3389
{
 
3390
    UNIMPLEMENTED();
 
3391
}
 
3392
 
 
3393
void Context::invalidateNamedFramebufferSubData(FramebufferID framebuffer,
 
3394
                                                GLsizei numAttachments,
 
3395
                                                const GLenum *attachments,
 
3396
                                                GLint x,
 
3397
                                                GLint y,
 
3398
                                                GLsizei width,
 
3399
                                                GLsizei height)
 
3400
{
 
3401
    UNIMPLEMENTED();
 
3402
}
 
3403
 
 
3404
void *Context::mapNamedBuffer(BufferID buffer, GLenum access)
 
3405
{
 
3406
    UNIMPLEMENTED();
 
3407
    return nullptr;
 
3408
}
 
3409
 
 
3410
void *Context::mapNamedBufferRange(BufferID buffer,
 
3411
                                   GLintptr offset,
 
3412
                                   GLsizeiptr length,
 
3413
                                   GLbitfield access)
 
3414
{
 
3415
    UNIMPLEMENTED();
 
3416
    return nullptr;
 
3417
}
 
3418
 
 
3419
void Context::namedBufferData(BufferID buffer, GLsizeiptr size, const void *data, GLenum usage)
 
3420
{
 
3421
    UNIMPLEMENTED();
 
3422
}
 
3423
 
 
3424
void Context::namedBufferStorage(BufferID buffer,
 
3425
                                 GLsizeiptr size,
 
3426
                                 const void *data,
 
3427
                                 GLbitfield flags)
 
3428
{
 
3429
    UNIMPLEMENTED();
 
3430
}
 
3431
 
 
3432
void Context::namedBufferSubData(BufferID buffer,
 
3433
                                 GLintptr offset,
 
3434
                                 GLsizeiptr size,
 
3435
                                 const void *data)
 
3436
{
 
3437
    UNIMPLEMENTED();
 
3438
}
 
3439
 
 
3440
void Context::namedFramebufferDrawBuffer(FramebufferID framebuffer, GLenum buf)
 
3441
{
 
3442
    UNIMPLEMENTED();
 
3443
}
 
3444
 
 
3445
void Context::namedFramebufferDrawBuffers(FramebufferID framebuffer, GLsizei n, const GLenum *bufs)
 
3446
{
 
3447
    UNIMPLEMENTED();
 
3448
}
 
3449
 
 
3450
void Context::namedFramebufferParameteri(FramebufferID framebuffer, GLenum pname, GLint param)
 
3451
{
 
3452
    UNIMPLEMENTED();
 
3453
}
 
3454
 
 
3455
void Context::namedFramebufferReadBuffer(FramebufferID framebuffer, GLenum src)
 
3456
{
 
3457
    UNIMPLEMENTED();
 
3458
}
 
3459
 
 
3460
void Context::namedFramebufferRenderbuffer(FramebufferID framebuffer,
 
3461
                                           GLenum attachment,
 
3462
                                           GLenum renderbuffertarget,
 
3463
                                           RenderbufferID renderbuffer)
 
3464
{
 
3465
    UNIMPLEMENTED();
 
3466
}
 
3467
 
 
3468
void Context::namedFramebufferTexture(FramebufferID framebuffer,
 
3469
                                      GLenum attachment,
 
3470
                                      TextureID texture,
 
3471
                                      GLint level)
 
3472
{
 
3473
    UNIMPLEMENTED();
 
3474
}
 
3475
 
 
3476
void Context::namedFramebufferTextureLayer(FramebufferID framebuffer,
 
3477
                                           GLenum attachment,
 
3478
                                           TextureID texture,
 
3479
                                           GLint level,
 
3480
                                           GLint layer)
 
3481
{
 
3482
    UNIMPLEMENTED();
 
3483
}
 
3484
 
 
3485
void Context::namedRenderbufferStorage(RenderbufferID renderbuffer,
 
3486
                                       GLenum internalformat,
 
3487
                                       GLsizei width,
 
3488
                                       GLsizei height)
 
3489
{
 
3490
    UNIMPLEMENTED();
 
3491
}
 
3492
 
 
3493
void Context::namedRenderbufferStorageMultisample(RenderbufferID renderbuffer,
 
3494
                                                  GLsizei samples,
 
3495
                                                  GLenum internalformat,
 
3496
                                                  GLsizei width,
 
3497
                                                  GLsizei height)
 
3498
{
 
3499
    UNIMPLEMENTED();
 
3500
}
 
3501
 
 
3502
void Context::textureBarrier()
 
3503
{
 
3504
    UNIMPLEMENTED();
 
3505
}
 
3506
 
 
3507
void Context::textureBuffer(TextureID texture, GLenum internalformat, BufferID buffer)
 
3508
{
 
3509
    UNIMPLEMENTED();
 
3510
}
 
3511
 
 
3512
void Context::textureBufferRange(TextureID texture,
 
3513
                                 GLenum internalformat,
 
3514
                                 BufferID buffer,
 
3515
                                 GLintptr offset,
 
3516
                                 GLsizeiptr size)
 
3517
{
 
3518
    UNIMPLEMENTED();
 
3519
}
 
3520
 
 
3521
void Context::textureParameterIiv(TextureID texture, GLenum pname, const GLint *params)
 
3522
{
 
3523
    UNIMPLEMENTED();
 
3524
}
 
3525
 
 
3526
void Context::textureParameterIuiv(TextureID texture, GLenum pname, const GLuint *params)
 
3527
{
 
3528
    UNIMPLEMENTED();
 
3529
}
 
3530
 
 
3531
void Context::textureParameterf(TextureID texture, GLenum pname, GLfloat param)
 
3532
{
 
3533
    UNIMPLEMENTED();
 
3534
}
 
3535
 
 
3536
void Context::textureParameterfv(TextureID texture, GLenum pname, const GLfloat *param)
 
3537
{
 
3538
    UNIMPLEMENTED();
 
3539
}
 
3540
 
 
3541
void Context::textureParameteri(TextureID texture, GLenum pname, GLint param)
 
3542
{
 
3543
    UNIMPLEMENTED();
 
3544
}
 
3545
 
 
3546
void Context::textureParameteriv(TextureID texture, GLenum pname, const GLint *param)
 
3547
{
 
3548
    UNIMPLEMENTED();
 
3549
}
 
3550
 
 
3551
void Context::textureStorage1D(TextureID texture,
 
3552
                               GLsizei levels,
 
3553
                               GLenum internalformat,
 
3554
                               GLsizei width)
 
3555
{
 
3556
    UNIMPLEMENTED();
 
3557
}
 
3558
 
 
3559
void Context::textureStorage2D(TextureID texture,
 
3560
                               GLsizei levels,
 
3561
                               GLenum internalformat,
 
3562
                               GLsizei width,
 
3563
                               GLsizei height)
 
3564
{
 
3565
    UNIMPLEMENTED();
 
3566
}
 
3567
 
 
3568
void Context::textureStorage2DMultisample(TextureID texture,
 
3569
                                          GLsizei samples,
 
3570
                                          GLenum internalformat,
 
3571
                                          GLsizei width,
 
3572
                                          GLsizei height,
 
3573
                                          GLboolean fixedsamplelocations)
 
3574
{
 
3575
    UNIMPLEMENTED();
 
3576
}
 
3577
 
 
3578
void Context::textureStorage3D(TextureID texture,
 
3579
                               GLsizei levels,
 
3580
                               GLenum internalformat,
 
3581
                               GLsizei width,
 
3582
                               GLsizei height,
 
3583
                               GLsizei depth)
 
3584
{
 
3585
    UNIMPLEMENTED();
 
3586
}
 
3587
 
 
3588
void Context::textureStorage3DMultisample(TextureID texture,
 
3589
                                          GLsizei samples,
 
3590
                                          GLenum internalformat,
 
3591
                                          GLsizei width,
 
3592
                                          GLsizei height,
 
3593
                                          GLsizei depth,
 
3594
                                          GLboolean fixedsamplelocations)
 
3595
{
 
3596
    UNIMPLEMENTED();
 
3597
}
 
3598
 
 
3599
void Context::textureSubImage1D(TextureID texture,
 
3600
                                GLint level,
 
3601
                                GLint xoffset,
 
3602
                                GLsizei width,
 
3603
                                GLenum format,
 
3604
                                GLenum type,
 
3605
                                const void *pixels)
 
3606
{
 
3607
    UNIMPLEMENTED();
 
3608
}
 
3609
 
 
3610
void Context::textureSubImage2D(TextureID texture,
 
3611
                                GLint level,
 
3612
                                GLint xoffset,
 
3613
                                GLint yoffset,
 
3614
                                GLsizei width,
 
3615
                                GLsizei height,
 
3616
                                GLenum format,
 
3617
                                GLenum type,
 
3618
                                const void *pixels)
 
3619
{
 
3620
    UNIMPLEMENTED();
 
3621
}
 
3622
 
 
3623
void Context::textureSubImage3D(TextureID texture,
 
3624
                                GLint level,
 
3625
                                GLint xoffset,
 
3626
                                GLint yoffset,
 
3627
                                GLint zoffset,
 
3628
                                GLsizei width,
 
3629
                                GLsizei height,
 
3630
                                GLsizei depth,
 
3631
                                GLenum format,
 
3632
                                GLenum type,
 
3633
                                const void *pixels)
 
3634
{
 
3635
    UNIMPLEMENTED();
 
3636
}
 
3637
 
 
3638
void Context::transformFeedbackBufferBase(GLuint xfb, GLuint index, BufferID buffer)
 
3639
{
 
3640
    UNIMPLEMENTED();
 
3641
}
 
3642
 
 
3643
void Context::transformFeedbackBufferRange(GLuint xfb,
 
3644
                                           GLuint index,
 
3645
                                           BufferID buffer,
 
3646
                                           GLintptr offset,
 
3647
                                           GLsizeiptr size)
 
3648
{
 
3649
    UNIMPLEMENTED();
 
3650
}
 
3651
 
 
3652
GLboolean Context::unmapNamedBuffer(BufferID buffer)
 
3653
{
 
3654
    UNIMPLEMENTED();
 
3655
    return false;
 
3656
}
 
3657
 
 
3658
void Context::vertexArrayAttribBinding(VertexArrayID vaobj, GLuint attribindex, GLuint bindingindex)
 
3659
{
 
3660
    UNIMPLEMENTED();
 
3661
}
 
3662
 
 
3663
void Context::vertexArrayAttribFormat(VertexArrayID vaobj,
 
3664
                                      GLuint attribindex,
 
3665
                                      GLint size,
 
3666
                                      GLenum type,
 
3667
                                      GLboolean normalized,
 
3668
                                      GLuint relativeoffset)
 
3669
{
 
3670
    UNIMPLEMENTED();
 
3671
}
 
3672
 
 
3673
void Context::vertexArrayAttribIFormat(VertexArrayID vaobj,
 
3674
                                       GLuint attribindex,
 
3675
                                       GLint size,
 
3676
                                       GLenum type,
 
3677
                                       GLuint relativeoffset)
 
3678
{
 
3679
    UNIMPLEMENTED();
 
3680
}
 
3681
 
 
3682
void Context::vertexArrayAttribLFormat(VertexArrayID vaobj,
 
3683
                                       GLuint attribindex,
 
3684
                                       GLint size,
 
3685
                                       GLenum type,
 
3686
                                       GLuint relativeoffset)
 
3687
{
 
3688
    UNIMPLEMENTED();
 
3689
}
 
3690
 
 
3691
void Context::vertexArrayBindingDivisor(VertexArrayID vaobj, GLuint bindingindex, GLuint divisor)
 
3692
{
 
3693
    UNIMPLEMENTED();
 
3694
}
 
3695
 
 
3696
void Context::vertexArrayElementBuffer(VertexArrayID vaobj, BufferID buffer)
 
3697
{
 
3698
    UNIMPLEMENTED();
 
3699
}
 
3700
 
 
3701
void Context::vertexArrayVertexBuffer(VertexArrayID vaobj,
 
3702
                                      GLuint bindingindex,
 
3703
                                      BufferID buffer,
 
3704
                                      GLintptr offset,
 
3705
                                      GLsizei stride)
 
3706
{
 
3707
    UNIMPLEMENTED();
 
3708
}
 
3709
 
 
3710
void Context::vertexArrayVertexBuffers(VertexArrayID vaobj,
 
3711
                                       GLuint first,
 
3712
                                       GLsizei count,
 
3713
                                       const BufferID *buffers,
 
3714
                                       const GLintptr *offsets,
 
3715
                                       const GLsizei *strides)
 
3716
{
 
3717
    UNIMPLEMENTED();
 
3718
}
 
3719
 
 
3720
void Context::multiDrawArraysIndirectCount(GLenum mode,
 
3721
                                           const void *indirect,
 
3722
                                           GLintptr drawcount,
 
3723
                                           GLsizei maxdrawcount,
 
3724
                                           GLsizei stride)
 
3725
{
 
3726
    UNIMPLEMENTED();
 
3727
}
 
3728
 
 
3729
void Context::multiDrawElementsIndirectCount(GLenum mode,
 
3730
                                             GLenum type,
 
3731
                                             const void *indirect,
 
3732
                                             GLintptr drawcount,
 
3733
                                             GLsizei maxdrawcount,
 
3734
                                             GLsizei stride)
 
3735
{
 
3736
    UNIMPLEMENTED();
 
3737
}
 
3738
 
 
3739
void Context::polygonOffsetClamp(GLfloat factor, GLfloat units, GLfloat clamp)
 
3740
{
 
3741
    UNIMPLEMENTED();
 
3742
}
 
3743
 
 
3744
void Context::specializeShader(GLuint shader,
 
3745
                               const GLchar *pEntryPoint,
 
3746
                               GLuint numSpecializationConstants,
 
3747
                               const GLuint *pConstantIndex,
 
3748
                               const GLuint *pConstantValue)
 
3749
{
 
3750
    UNIMPLEMENTED();
 
3751
}
 
3752
 
 
3753
}  // namespace gl