1 // Copyright 2016 The SwiftShader Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 // libGL.cpp: Implements the exported OpenGL functions.
15
16 #include "main.h"
17 #include "mathutil.h"
18 #include "utilities.h"
19 #include "Buffer.h"
20 #include "Context.h"
21 #include "Fence.h"
22 #include "Framebuffer.h"
23 #include "Program.h"
24 #include "Renderbuffer.h"
25 #include "Shader.h"
26 #include "Texture.h"
27 #include "Query.h"
28 #include "common/debug.h"
29 #include "Common/Version.h"
30
31 #define _GDI32_
32 #include <windows.h>
33 #include <GL/GL.h>
34 #include <GL/glext.h>
35
36 #include <limits>
37
38 using std::abs;
39
validImageSize(GLint level,GLsizei width,GLsizei height)40 static bool validImageSize(GLint level, GLsizei width, GLsizei height)
41 {
42 if(level < 0 || level >= gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS || width < 0 || height < 0)
43 {
44 return false;
45 }
46
47 return true;
48 }
49
validateSubImageParams(bool compressed,GLsizei width,GLsizei height,GLint xoffset,GLint yoffset,GLenum target,GLint level,GLenum format,gl::Texture * texture)50 static bool validateSubImageParams(bool compressed, GLsizei width, GLsizei height, GLint xoffset, GLint yoffset, GLenum target, GLint level, GLenum format, gl::Texture *texture)
51 {
52 if(!texture)
53 {
54 return error(GL_INVALID_OPERATION, false);
55 }
56
57 if(compressed != texture->isCompressed(target, level))
58 {
59 return error(GL_INVALID_OPERATION, false);
60 }
61
62 if(format != GL_NONE && format != texture->getFormat(target, level))
63 {
64 return error(GL_INVALID_OPERATION, false);
65 }
66
67 if(compressed)
68 {
69 if((width % 4 != 0 && width != texture->getWidth(target, 0)) ||
70 (height % 4 != 0 && height != texture->getHeight(target, 0)))
71 {
72 return error(GL_INVALID_OPERATION, false);
73 }
74 }
75
76 if(xoffset + width > texture->getWidth(target, level) ||
77 yoffset + height > texture->getHeight(target, level))
78 {
79 return error(GL_INVALID_VALUE, false);
80 }
81
82 return true;
83 }
84
85 // Check for combinations of format and type that are valid for ReadPixels
validReadFormatType(GLenum format,GLenum type)86 static bool validReadFormatType(GLenum format, GLenum type)
87 {
88 switch(format)
89 {
90 case GL_RGBA:
91 switch(type)
92 {
93 case GL_UNSIGNED_BYTE:
94 break;
95 default:
96 return false;
97 }
98 break;
99 case GL_BGRA_EXT:
100 switch(type)
101 {
102 case GL_UNSIGNED_BYTE:
103 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
104 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
105 break;
106 default:
107 return false;
108 }
109 break;
110 case gl::IMPLEMENTATION_COLOR_READ_FORMAT:
111 switch(type)
112 {
113 case gl::IMPLEMENTATION_COLOR_READ_TYPE:
114 break;
115 default:
116 return false;
117 }
118 break;
119 default:
120 return false;
121 }
122
123 return true;
124 }
125
126 extern "C"
127 {
128
glActiveTexture(GLenum texture)129 void APIENTRY glActiveTexture(GLenum texture)
130 {
131 TRACE("(GLenum texture = 0x%X)", texture);
132
133 gl::Context *context = gl::getContext();
134
135 if(context)
136 {
137 if(context->getListIndex() != 0)
138 {
139 UNIMPLEMENTED();
140 }
141
142 if(texture < GL_TEXTURE0 || texture > GL_TEXTURE0 + gl::MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1)
143 {
144 return error(GL_INVALID_ENUM);
145 }
146
147 context->setActiveSampler(texture - GL_TEXTURE0);
148 }
149 }
150
glAttachShader(GLuint program,GLuint shader)151 void APIENTRY glAttachShader(GLuint program, GLuint shader)
152 {
153 TRACE("(GLuint program = %d, GLuint shader = %d)", program, shader);
154
155 gl::Context *context = gl::getContext();
156
157 if(context)
158 {
159 gl::Program *programObject = context->getProgram(program);
160 gl::Shader *shaderObject = context->getShader(shader);
161
162 if(!programObject)
163 {
164 if(context->getShader(program))
165 {
166 return error(GL_INVALID_OPERATION);
167 }
168 else
169 {
170 return error(GL_INVALID_VALUE);
171 }
172 }
173
174 if(!shaderObject)
175 {
176 if(context->getProgram(shader))
177 {
178 return error(GL_INVALID_OPERATION);
179 }
180 else
181 {
182 return error(GL_INVALID_VALUE);
183 }
184 }
185
186 if(!programObject->attachShader(shaderObject))
187 {
188 return error(GL_INVALID_OPERATION);
189 }
190 }
191 }
192
glBeginQueryEXT(GLenum target,GLuint name)193 void APIENTRY glBeginQueryEXT(GLenum target, GLuint name)
194 {
195 TRACE("(GLenum target = 0x%X, GLuint name = %d)", target, name);
196
197 switch(target)
198 {
199 case GL_ANY_SAMPLES_PASSED:
200 case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
201 break;
202 default:
203 return error(GL_INVALID_ENUM);
204 }
205
206 if(name == 0)
207 {
208 return error(GL_INVALID_OPERATION);
209 }
210
211 gl::Context *context = gl::getContext();
212
213 if(context)
214 {
215 if(context->getListIndex() != 0)
216 {
217 UNIMPLEMENTED();
218 }
219
220 context->beginQuery(target, name);
221 }
222 }
223
glBindAttribLocation(GLuint program,GLuint index,const GLchar * name)224 void APIENTRY glBindAttribLocation(GLuint program, GLuint index, const GLchar* name)
225 {
226 TRACE("(GLuint program = %d, GLuint index = %d, const GLchar* name = %s)", program, index, name);
227
228 if(index >= gl::MAX_VERTEX_ATTRIBS)
229 {
230 return error(GL_INVALID_VALUE);
231 }
232
233 gl::Context *context = gl::getContext();
234
235 if(context)
236 {
237 gl::Program *programObject = context->getProgram(program);
238
239 if(!programObject)
240 {
241 if(context->getShader(program))
242 {
243 return error(GL_INVALID_OPERATION);
244 }
245 else
246 {
247 return error(GL_INVALID_VALUE);
248 }
249 }
250
251 if(strncmp(name, "gl_", 3) == 0)
252 {
253 return error(GL_INVALID_OPERATION);
254 }
255
256 programObject->bindAttributeLocation(index, name);
257 }
258 }
259
glBindBuffer(GLenum target,GLuint buffer)260 void APIENTRY glBindBuffer(GLenum target, GLuint buffer)
261 {
262 TRACE("(GLenum target = 0x%X, GLuint buffer = %d)", target, buffer);
263
264 gl::Context *context = gl::getContext();
265
266 if(context)
267 {
268 switch(target)
269 {
270 case GL_ARRAY_BUFFER:
271 context->bindArrayBuffer(buffer);
272 return;
273 case GL_ELEMENT_ARRAY_BUFFER:
274 context->bindElementArrayBuffer(buffer);
275 return;
276 default:
277 return error(GL_INVALID_ENUM);
278 }
279 }
280 }
281
glBindFramebuffer(GLenum target,GLuint framebuffer)282 void APIENTRY glBindFramebuffer(GLenum target, GLuint framebuffer)
283 {
284 TRACE("(GLenum target = 0x%X, GLuint framebuffer = %d)", target, framebuffer);
285
286 if(target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_EXT && target != GL_READ_FRAMEBUFFER_EXT)
287 {
288 return error(GL_INVALID_ENUM);
289 }
290
291 gl::Context *context = gl::getContext();
292
293 if(context)
294 {
295 if(context->getListIndex() != 0)
296 {
297 UNIMPLEMENTED();
298 }
299
300 if(target == GL_READ_FRAMEBUFFER_EXT || target == GL_FRAMEBUFFER)
301 {
302 context->bindReadFramebuffer(framebuffer);
303 }
304
305 if(target == GL_DRAW_FRAMEBUFFER_EXT || target == GL_FRAMEBUFFER)
306 {
307 context->bindDrawFramebuffer(framebuffer);
308 }
309 }
310 }
311
glBindRenderbuffer(GLenum target,GLuint renderbuffer)312 void APIENTRY glBindRenderbuffer(GLenum target, GLuint renderbuffer)
313 {
314 TRACE("(GLenum target = 0x%X, GLuint renderbuffer = %d)", target, renderbuffer);
315
316 if(target != GL_RENDERBUFFER)
317 {
318 return error(GL_INVALID_ENUM);
319 }
320
321 gl::Context *context = gl::getContext();
322
323 if(context)
324 {
325 if(context->getListIndex() != 0)
326 {
327 UNIMPLEMENTED();
328 }
329
330 context->bindRenderbuffer(renderbuffer);
331 }
332 }
333
glBindTexture(GLenum target,GLuint texture)334 void APIENTRY glBindTexture(GLenum target, GLuint texture)
335 {
336 TRACE("(GLenum target = 0x%X, GLuint texture = %d)", target, texture);
337
338 gl::Context *context = gl::getContext();
339
340 if(context)
341 {
342 if(context->getListIndex() != 0)
343 {
344 UNIMPLEMENTED();
345 }
346
347 gl::Texture *textureObject = context->getTexture(texture);
348
349 if(textureObject && textureObject->getTarget() != target && texture != 0)
350 {
351 return error(GL_INVALID_OPERATION);
352 }
353
354 switch(target)
355 {
356 case GL_TEXTURE_2D:
357 context->bindTexture2D(texture);
358 return;
359 case GL_TEXTURE_CUBE_MAP:
360 context->bindTextureCubeMap(texture);
361 return;
362 default:
363 return error(GL_INVALID_ENUM);
364 }
365 }
366 }
367
glBlendColor(GLclampf red,GLclampf green,GLclampf blue,GLclampf alpha)368 void APIENTRY glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
369 {
370 TRACE("(GLclampf red = %f, GLclampf green = %f, GLclampf blue = %f, GLclampf alpha = %f)",
371 red, green, blue, alpha);
372
373 gl::Context* context = gl::getContext();
374
375 if(context)
376 {
377 if(context->getListIndex() != 0)
378 {
379 UNIMPLEMENTED();
380 }
381
382 context->setBlendColor(gl::clamp01(red), gl::clamp01(green), gl::clamp01(blue), gl::clamp01(alpha));
383 }
384 }
385
glBlendEquation(GLenum mode)386 void APIENTRY glBlendEquation(GLenum mode)
387 {
388 glBlendEquationSeparate(mode, mode);
389 }
390
glBlendEquationSeparate(GLenum modeRGB,GLenum modeAlpha)391 void APIENTRY glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
392 {
393 TRACE("(GLenum modeRGB = 0x%X, GLenum modeAlpha = 0x%X)", modeRGB, modeAlpha);
394
395 switch(modeRGB)
396 {
397 case GL_FUNC_ADD:
398 case GL_FUNC_SUBTRACT:
399 case GL_FUNC_REVERSE_SUBTRACT:
400 case GL_MIN_EXT:
401 case GL_MAX_EXT:
402 break;
403 default:
404 return error(GL_INVALID_ENUM);
405 }
406
407 switch(modeAlpha)
408 {
409 case GL_FUNC_ADD:
410 case GL_FUNC_SUBTRACT:
411 case GL_FUNC_REVERSE_SUBTRACT:
412 case GL_MIN_EXT:
413 case GL_MAX_EXT:
414 break;
415 default:
416 return error(GL_INVALID_ENUM);
417 }
418
419 gl::Context *context = gl::getContext();
420
421 if(context)
422 {
423 if(context->getListIndex() != 0)
424 {
425 UNIMPLEMENTED();
426 }
427
428 context->setBlendEquation(modeRGB, modeAlpha);
429 }
430 }
431
glBlendFunc(GLenum sfactor,GLenum dfactor)432 void APIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor)
433 {
434 glBlendFuncSeparate(sfactor, dfactor, sfactor, dfactor);
435 }
436
glBlendFuncSeparate(GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)437 void APIENTRY glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
438 {
439 TRACE("(GLenum srcRGB = 0x%X, GLenum dstRGB = 0x%X, GLenum srcAlpha = 0x%X, GLenum dstAlpha = 0x%X)",
440 srcRGB, dstRGB, srcAlpha, dstAlpha);
441
442 switch(srcRGB)
443 {
444 case GL_ZERO:
445 case GL_ONE:
446 case GL_SRC_COLOR:
447 case GL_ONE_MINUS_SRC_COLOR:
448 case GL_DST_COLOR:
449 case GL_ONE_MINUS_DST_COLOR:
450 case GL_SRC_ALPHA:
451 case GL_ONE_MINUS_SRC_ALPHA:
452 case GL_DST_ALPHA:
453 case GL_ONE_MINUS_DST_ALPHA:
454 case GL_CONSTANT_COLOR:
455 case GL_ONE_MINUS_CONSTANT_COLOR:
456 case GL_CONSTANT_ALPHA:
457 case GL_ONE_MINUS_CONSTANT_ALPHA:
458 case GL_SRC_ALPHA_SATURATE:
459 break;
460 default:
461 return error(GL_INVALID_ENUM);
462 }
463
464 switch(dstRGB)
465 {
466 case GL_ZERO:
467 case GL_ONE:
468 case GL_SRC_COLOR:
469 case GL_ONE_MINUS_SRC_COLOR:
470 case GL_DST_COLOR:
471 case GL_ONE_MINUS_DST_COLOR:
472 case GL_SRC_ALPHA:
473 case GL_ONE_MINUS_SRC_ALPHA:
474 case GL_DST_ALPHA:
475 case GL_ONE_MINUS_DST_ALPHA:
476 case GL_CONSTANT_COLOR:
477 case GL_ONE_MINUS_CONSTANT_COLOR:
478 case GL_CONSTANT_ALPHA:
479 case GL_ONE_MINUS_CONSTANT_ALPHA:
480 break;
481 default:
482 return error(GL_INVALID_ENUM);
483 }
484
485 switch(srcAlpha)
486 {
487 case GL_ZERO:
488 case GL_ONE:
489 case GL_SRC_COLOR:
490 case GL_ONE_MINUS_SRC_COLOR:
491 case GL_DST_COLOR:
492 case GL_ONE_MINUS_DST_COLOR:
493 case GL_SRC_ALPHA:
494 case GL_ONE_MINUS_SRC_ALPHA:
495 case GL_DST_ALPHA:
496 case GL_ONE_MINUS_DST_ALPHA:
497 case GL_CONSTANT_COLOR:
498 case GL_ONE_MINUS_CONSTANT_COLOR:
499 case GL_CONSTANT_ALPHA:
500 case GL_ONE_MINUS_CONSTANT_ALPHA:
501 case GL_SRC_ALPHA_SATURATE:
502 break;
503 default:
504 return error(GL_INVALID_ENUM);
505 }
506
507 switch(dstAlpha)
508 {
509 case GL_ZERO:
510 case GL_ONE:
511 case GL_SRC_COLOR:
512 case GL_ONE_MINUS_SRC_COLOR:
513 case GL_DST_COLOR:
514 case GL_ONE_MINUS_DST_COLOR:
515 case GL_SRC_ALPHA:
516 case GL_ONE_MINUS_SRC_ALPHA:
517 case GL_DST_ALPHA:
518 case GL_ONE_MINUS_DST_ALPHA:
519 case GL_CONSTANT_COLOR:
520 case GL_ONE_MINUS_CONSTANT_COLOR:
521 case GL_CONSTANT_ALPHA:
522 case GL_ONE_MINUS_CONSTANT_ALPHA:
523 break;
524 default:
525 return error(GL_INVALID_ENUM);
526 }
527
528 gl::Context *context = gl::getContext();
529
530 if(context)
531 {
532 if(context->getListIndex() != 0)
533 {
534 UNIMPLEMENTED();
535 }
536
537 context->setBlendFactors(srcRGB, dstRGB, srcAlpha, dstAlpha);
538 }
539 }
540
glBufferData(GLenum target,GLsizeiptr size,const GLvoid * data,GLenum usage)541 void APIENTRY glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
542 {
543 TRACE("(GLenum target = 0x%X, GLsizeiptr size = %d, const GLvoid* data = %p, GLenum usage = %d)",
544 target, size, data, usage);
545
546 if(size < 0)
547 {
548 return error(GL_INVALID_VALUE);
549 }
550
551 switch(usage)
552 {
553 case GL_STREAM_DRAW:
554 case GL_STATIC_DRAW:
555 case GL_DYNAMIC_DRAW:
556 break;
557 default:
558 return error(GL_INVALID_ENUM);
559 }
560
561 gl::Context *context = gl::getContext();
562
563 if(context)
564 {
565 gl::Buffer *buffer;
566
567 switch(target)
568 {
569 case GL_ARRAY_BUFFER:
570 buffer = context->getArrayBuffer();
571 break;
572 case GL_ELEMENT_ARRAY_BUFFER:
573 buffer = context->getElementArrayBuffer();
574 break;
575 default:
576 return error(GL_INVALID_ENUM);
577 }
578
579 if(!buffer)
580 {
581 return error(GL_INVALID_OPERATION);
582 }
583
584 buffer->bufferData(data, size, usage);
585 }
586 }
587
glBufferSubData(GLenum target,GLintptr offset,GLsizeiptr size,const GLvoid * data)588 void APIENTRY glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
589 {
590 TRACE("(GLenum target = 0x%X, GLintptr offset = %d, GLsizeiptr size = %d, const GLvoid* data = %p)",
591 target, offset, size, data);
592
593 if(size < 0 || offset < 0)
594 {
595 return error(GL_INVALID_VALUE);
596 }
597
598 if(!data)
599 {
600 return;
601 }
602
603 gl::Context *context = gl::getContext();
604
605 if(context)
606 {
607 gl::Buffer *buffer;
608
609 switch(target)
610 {
611 case GL_ARRAY_BUFFER:
612 buffer = context->getArrayBuffer();
613 break;
614 case GL_ELEMENT_ARRAY_BUFFER:
615 buffer = context->getElementArrayBuffer();
616 break;
617 default:
618 return error(GL_INVALID_ENUM);
619 }
620
621 if(!buffer)
622 {
623 return error(GL_INVALID_OPERATION);
624 }
625
626 if((size_t)size + offset > buffer->size())
627 {
628 return error(GL_INVALID_VALUE);
629 }
630
631 buffer->bufferSubData(data, size, offset);
632 }
633 }
634
glCheckFramebufferStatus(GLenum target)635 GLenum APIENTRY glCheckFramebufferStatus(GLenum target)
636 {
637 TRACE("(GLenum target = 0x%X)", target);
638
639 if(target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_EXT && target != GL_READ_FRAMEBUFFER_EXT)
640 {
641 return error(GL_INVALID_ENUM, 0);
642 }
643
644 gl::Context *context = gl::getContext();
645
646 if(context)
647 {
648 if(context->getListIndex() != 0)
649 {
650 UNIMPLEMENTED();
651 }
652
653 gl::Framebuffer *framebuffer = nullptr;
654 if(target == GL_READ_FRAMEBUFFER_EXT)
655 {
656 framebuffer = context->getReadFramebuffer();
657 }
658 else
659 {
660 framebuffer = context->getDrawFramebuffer();
661 }
662
663 return framebuffer->completeness();
664 }
665
666 return 0;
667 }
668
glClear(GLbitfield mask)669 void APIENTRY glClear(GLbitfield mask)
670 {
671 TRACE("(GLbitfield mask = %X)", mask);
672
673 if((mask & ~(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) != 0)
674 {
675 return error(GL_INVALID_VALUE);
676 }
677
678 gl::Context *context = gl::getContext();
679
680 if(context)
681 {
682 if(context->getListIndex() != 0)
683 {
684 return context->listCommand(gl::newCommand(glClear, mask));
685 }
686
687 context->clear(mask);
688 }
689 }
690
glClearColor(GLclampf red,GLclampf green,GLclampf blue,GLclampf alpha)691 void APIENTRY glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
692 {
693 TRACE("(GLclampf red = %f, GLclampf green = %f, GLclampf blue = %f, GLclampf alpha = %f)",
694 red, green, blue, alpha);
695
696 gl::Context *context = gl::getContext();
697
698 if(context)
699 {
700 if(context->getListIndex() != 0)
701 {
702 UNIMPLEMENTED();
703 }
704
705 context->setClearColor(red, green, blue, alpha);
706 }
707 }
708
glClearDepthf(GLclampf depth)709 void APIENTRY glClearDepthf(GLclampf depth)
710 {
711 TRACE("(GLclampf depth = %f)", depth);
712
713 gl::Context *context = gl::getContext();
714
715 if(context)
716 {
717 if(context->getListIndex() != 0)
718 {
719 UNIMPLEMENTED();
720 }
721
722 context->setClearDepth(depth);
723 }
724 }
725
glClearStencil(GLint s)726 void APIENTRY glClearStencil(GLint s)
727 {
728 TRACE("(GLint s = %d)", s);
729
730 gl::Context *context = gl::getContext();
731
732 if(context)
733 {
734 if(context->getListIndex() != 0)
735 {
736 UNIMPLEMENTED();
737 }
738
739 context->setClearStencil(s);
740 }
741 }
742
glColorMask(GLboolean red,GLboolean green,GLboolean blue,GLboolean alpha)743 void APIENTRY glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
744 {
745 TRACE("(GLboolean red = %d, GLboolean green = %d, GLboolean blue = %d, GLboolean alpha = %d)",
746 red, green, blue, alpha);
747
748 gl::Context *context = gl::getContext();
749
750 if(context)
751 {
752 if(context->getListIndex() != 0)
753 {
754 UNIMPLEMENTED();
755 }
756
757 context->setColorMask(red == GL_TRUE, green == GL_TRUE, blue == GL_TRUE, alpha == GL_TRUE);
758 }
759 }
760
glCompileShader(GLuint shader)761 void APIENTRY glCompileShader(GLuint shader)
762 {
763 TRACE("(GLuint shader = %d)", shader);
764
765 gl::Context *context = gl::getContext();
766
767 if(context)
768 {
769 gl::Shader *shaderObject = context->getShader(shader);
770
771 if(!shaderObject)
772 {
773 if(context->getProgram(shader))
774 {
775 return error(GL_INVALID_OPERATION);
776 }
777 else
778 {
779 return error(GL_INVALID_VALUE);
780 }
781 }
782
783 shaderObject->compile();
784 }
785 }
786
glCompressedTexImage2D(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const GLvoid * data)787 void APIENTRY glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height,
788 GLint border, GLsizei imageSize, const GLvoid* data)
789 {
790 TRACE("(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = %d, "
791 "GLsizei height = %d, GLint border = %d, GLsizei imageSize = %d, const GLvoid* data = %p)",
792 target, level, internalformat, width, height, border, imageSize, data);
793
794 if(!validImageSize(level, width, height) || border != 0 || imageSize < 0)
795 {
796 return error(GL_INVALID_VALUE);
797 }
798
799 switch(internalformat)
800 {
801 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
802 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
803 case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
804 case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
805 break;
806 case GL_DEPTH_COMPONENT:
807 case GL_DEPTH_COMPONENT16:
808 case GL_DEPTH_COMPONENT32:
809 case GL_DEPTH_STENCIL_EXT:
810 case GL_DEPTH24_STENCIL8_EXT:
811 return error(GL_INVALID_OPERATION);
812 default:
813 return error(GL_INVALID_ENUM);
814 }
815
816 if(border != 0)
817 {
818 return error(GL_INVALID_VALUE);
819 }
820
821 gl::Context *context = gl::getContext();
822
823 if(context)
824 {
825 if(context->getListIndex() != 0)
826 {
827 UNIMPLEMENTED();
828 }
829
830 if(level > gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS)
831 {
832 return error(GL_INVALID_VALUE);
833 }
834
835 switch(target)
836 {
837 case GL_TEXTURE_2D:
838 if(width > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level) ||
839 height > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level))
840 {
841 return error(GL_INVALID_VALUE);
842 }
843 break;
844 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
845 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
846 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
847 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
848 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
849 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
850 if(width != height)
851 {
852 return error(GL_INVALID_VALUE);
853 }
854
855 if(width > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level) ||
856 height > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level))
857 {
858 return error(GL_INVALID_VALUE);
859 }
860 break;
861 default:
862 return error(GL_INVALID_ENUM);
863 }
864
865 if(imageSize != gl::ComputeCompressedSize(width, height, internalformat))
866 {
867 return error(GL_INVALID_VALUE);
868 }
869
870 if(target == GL_TEXTURE_2D)
871 {
872 gl::Texture2D *texture = context->getTexture2D(target);
873
874 if(!texture)
875 {
876 return error(GL_INVALID_OPERATION);
877 }
878
879 texture->setCompressedImage(level, internalformat, width, height, imageSize, data);
880 }
881 else
882 {
883 gl::TextureCubeMap *texture = context->getTextureCubeMap();
884
885 if(!texture)
886 {
887 return error(GL_INVALID_OPERATION);
888 }
889
890 switch(target)
891 {
892 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
893 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
894 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
895 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
896 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
897 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
898 texture->setCompressedImage(target, level, internalformat, width, height, imageSize, data);
899 break;
900 default: UNREACHABLE(target);
901 }
902 }
903 }
904 }
905
glCompressedTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const GLvoid * data)906 void APIENTRY glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
907 GLenum format, GLsizei imageSize, const GLvoid* data)
908 {
909 TRACE("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
910 "GLsizei width = %d, GLsizei height = %d, GLenum format = 0x%X, "
911 "GLsizei imageSize = %d, const GLvoid* data = %p)",
912 target, level, xoffset, yoffset, width, height, format, imageSize, data);
913
914 if(!gl::IsTextureTarget(target))
915 {
916 return error(GL_INVALID_ENUM);
917 }
918
919 if(xoffset < 0 || yoffset < 0 || !validImageSize(level, width, height) || imageSize < 0)
920 {
921 return error(GL_INVALID_VALUE);
922 }
923
924 switch(format)
925 {
926 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
927 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
928 case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
929 case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
930 break;
931 default:
932 return error(GL_INVALID_ENUM);
933 }
934
935 if(width == 0 || height == 0 || !data)
936 {
937 return;
938 }
939
940 gl::Context *context = gl::getContext();
941
942 if(context)
943 {
944 if(context->getListIndex() != 0)
945 {
946 UNIMPLEMENTED();
947 }
948
949 if(level > gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS)
950 {
951 return error(GL_INVALID_VALUE);
952 }
953
954 if(imageSize != gl::ComputeCompressedSize(width, height, format))
955 {
956 return error(GL_INVALID_VALUE);
957 }
958
959 if(xoffset % 4 != 0 || yoffset % 4 != 0)
960 {
961 // We wait to check the offsets until this point, because the multiple-of-four restriction does not exist unless DXT1 textures are supported
962 return error(GL_INVALID_OPERATION);
963 }
964
965 if(target == GL_TEXTURE_2D)
966 {
967 gl::Texture2D *texture = context->getTexture2D(target);
968
969 if(validateSubImageParams(true, width, height, xoffset, yoffset, target, level, format, texture))
970 {
971 texture->subImageCompressed(level, xoffset, yoffset, width, height, format, imageSize, data);
972 }
973 }
974 else if(gl::IsCubemapTextureTarget(target))
975 {
976 gl::TextureCubeMap *texture = context->getTextureCubeMap();
977
978 if(validateSubImageParams(true, width, height, xoffset, yoffset, target, level, format, texture))
979 {
980 texture->subImageCompressed(target, level, xoffset, yoffset, width, height, format, imageSize, data);
981 }
982 }
983 else UNREACHABLE(target);
984 }
985 }
986
glCopyTexImage2D(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border)987 void APIENTRY glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
988 {
989 TRACE("(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, "
990 "GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLint border = %d)",
991 target, level, internalformat, x, y, width, height, border);
992
993 if(!validImageSize(level, width, height))
994 {
995 return error(GL_INVALID_VALUE);
996 }
997
998 if(border != 0)
999 {
1000 return error(GL_INVALID_VALUE);
1001 }
1002
1003 gl::Context *context = gl::getContext();
1004
1005 if(context)
1006 {
1007 if(context->getListIndex() != 0)
1008 {
1009 UNIMPLEMENTED();
1010 }
1011
1012 switch(target)
1013 {
1014 case GL_TEXTURE_2D:
1015 if(width > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level) ||
1016 height > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level))
1017 {
1018 return error(GL_INVALID_VALUE);
1019 }
1020 break;
1021 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
1022 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
1023 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
1024 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
1025 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
1026 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
1027 if(width != height)
1028 {
1029 return error(GL_INVALID_VALUE);
1030 }
1031
1032 if(width > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level) ||
1033 height > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level))
1034 {
1035 return error(GL_INVALID_VALUE);
1036 }
1037 break;
1038 default:
1039 return error(GL_INVALID_ENUM);
1040 }
1041
1042 gl::Framebuffer *framebuffer = context->getReadFramebuffer();
1043
1044 if(framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
1045 {
1046 return error(GL_INVALID_FRAMEBUFFER_OPERATION);
1047 }
1048
1049 if(context->getReadFramebufferName() != 0 && framebuffer->getColorbuffer()->getSamples() > 1)
1050 {
1051 return error(GL_INVALID_OPERATION);
1052 }
1053
1054 gl::Renderbuffer *source = framebuffer->getColorbuffer();
1055 GLenum colorbufferFormat = source->getFormat();
1056
1057 switch(internalformat)
1058 {
1059 case GL_ALPHA:
1060 if(colorbufferFormat != GL_ALPHA &&
1061 colorbufferFormat != GL_RGBA &&
1062 colorbufferFormat != GL_RGBA4 &&
1063 colorbufferFormat != GL_RGB5_A1 &&
1064 colorbufferFormat != GL_RGBA8_EXT)
1065 {
1066 return error(GL_INVALID_OPERATION);
1067 }
1068 break;
1069 case GL_LUMINANCE:
1070 case GL_RGB:
1071 if(colorbufferFormat != GL_RGB &&
1072 colorbufferFormat != GL_RGB565 &&
1073 colorbufferFormat != GL_RGB8_EXT &&
1074 colorbufferFormat != GL_RGBA &&
1075 colorbufferFormat != GL_RGBA4 &&
1076 colorbufferFormat != GL_RGB5_A1 &&
1077 colorbufferFormat != GL_RGBA8_EXT)
1078 {
1079 return error(GL_INVALID_OPERATION);
1080 }
1081 break;
1082 case GL_LUMINANCE_ALPHA:
1083 case GL_RGBA:
1084 if(colorbufferFormat != GL_RGBA &&
1085 colorbufferFormat != GL_RGBA4 &&
1086 colorbufferFormat != GL_RGB5_A1 &&
1087 colorbufferFormat != GL_RGBA8_EXT)
1088 {
1089 return error(GL_INVALID_OPERATION);
1090 }
1091 break;
1092 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
1093 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
1094 case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
1095 case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
1096 return error(GL_INVALID_OPERATION);
1097 default:
1098 return error(GL_INVALID_ENUM);
1099 }
1100
1101 if(target == GL_TEXTURE_2D)
1102 {
1103 gl::Texture2D *texture = context->getTexture2D(target);
1104
1105 if(!texture)
1106 {
1107 return error(GL_INVALID_OPERATION);
1108 }
1109
1110 texture->copyImage(level, internalformat, x, y, width, height, framebuffer);
1111 }
1112 else if(gl::IsCubemapTextureTarget(target))
1113 {
1114 gl::TextureCubeMap *texture = context->getTextureCubeMap();
1115
1116 if(!texture)
1117 {
1118 return error(GL_INVALID_OPERATION);
1119 }
1120
1121 texture->copyImage(target, level, internalformat, x, y, width, height, framebuffer);
1122 }
1123 else UNREACHABLE(target);
1124 }
1125 }
1126
glCopyTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height)1127 void APIENTRY glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
1128 {
1129 TRACE("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
1130 "GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)",
1131 target, level, xoffset, yoffset, x, y, width, height);
1132
1133 if(!gl::IsTextureTarget(target))
1134 {
1135 return error(GL_INVALID_ENUM);
1136 }
1137
1138 if(level < 0 || xoffset < 0 || yoffset < 0 || width < 0 || height < 0)
1139 {
1140 return error(GL_INVALID_VALUE);
1141 }
1142
1143 if(std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height)
1144 {
1145 return error(GL_INVALID_VALUE);
1146 }
1147
1148 if(width == 0 || height == 0)
1149 {
1150 return;
1151 }
1152
1153 gl::Context *context = gl::getContext();
1154
1155 if(context)
1156 {
1157 if(context->getListIndex() != 0)
1158 {
1159 UNIMPLEMENTED();
1160 }
1161
1162 if(level > gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS)
1163 {
1164 return error(GL_INVALID_VALUE);
1165 }
1166
1167 gl::Framebuffer *framebuffer = context->getReadFramebuffer();
1168
1169 if(framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
1170 {
1171 return error(GL_INVALID_FRAMEBUFFER_OPERATION);
1172 }
1173
1174 if(context->getReadFramebufferName() != 0 && framebuffer->getColorbuffer()->getSamples() > 1)
1175 {
1176 return error(GL_INVALID_OPERATION);
1177 }
1178
1179 gl::Texture *texture = nullptr;
1180
1181 if(target == GL_TEXTURE_2D)
1182 {
1183 texture = context->getTexture2D(target);
1184 }
1185 else if(gl::IsCubemapTextureTarget(target))
1186 {
1187 texture = context->getTextureCubeMap();
1188 }
1189 else UNREACHABLE(target);
1190
1191 if(!validateSubImageParams(false, width, height, xoffset, yoffset, target, level, GL_NONE, texture))
1192 {
1193 return;
1194 }
1195
1196 texture->copySubImage(target, level, xoffset, yoffset, x, y, width, height, framebuffer);
1197 }
1198 }
1199
glCreateProgram(void)1200 GLuint APIENTRY glCreateProgram(void)
1201 {
1202 TRACE("()");
1203
1204 gl::Context *context = gl::getContext();
1205
1206 if(context)
1207 {
1208 return context->createProgram();
1209 }
1210
1211 return 0;
1212 }
1213
glCreateShader(GLenum type)1214 GLuint APIENTRY glCreateShader(GLenum type)
1215 {
1216 TRACE("(GLenum type = 0x%X)", type);
1217
1218 gl::Context *context = gl::getContext();
1219
1220 if(context)
1221 {
1222 switch(type)
1223 {
1224 case GL_FRAGMENT_SHADER:
1225 case GL_VERTEX_SHADER:
1226 return context->createShader(type);
1227 default:
1228 return error(GL_INVALID_ENUM, 0);
1229 }
1230 }
1231
1232 return 0;
1233 }
1234
glCullFace(GLenum mode)1235 void APIENTRY glCullFace(GLenum mode)
1236 {
1237 TRACE("(GLenum mode = 0x%X)", mode);
1238
1239 switch(mode)
1240 {
1241 case GL_FRONT:
1242 case GL_BACK:
1243 case GL_FRONT_AND_BACK:
1244 {
1245 gl::Context *context = gl::getContext();
1246
1247 if(context)
1248 {
1249 context->setCullMode(mode);
1250 }
1251 }
1252 break;
1253 default:
1254 return error(GL_INVALID_ENUM);
1255 }
1256 }
1257
glDeleteBuffers(GLsizei n,const GLuint * buffers)1258 void APIENTRY glDeleteBuffers(GLsizei n, const GLuint* buffers)
1259 {
1260 TRACE("(GLsizei n = %d, const GLuint* buffers = %p)", n, buffers);
1261
1262 if(n < 0)
1263 {
1264 return error(GL_INVALID_VALUE);
1265 }
1266
1267 gl::Context *context = gl::getContext();
1268
1269 if(context)
1270 {
1271 for(int i = 0; i < n; i++)
1272 {
1273 context->deleteBuffer(buffers[i]);
1274 }
1275 }
1276 }
1277
glDeleteFencesNV(GLsizei n,const GLuint * fences)1278 void APIENTRY glDeleteFencesNV(GLsizei n, const GLuint* fences)
1279 {
1280 TRACE("(GLsizei n = %d, const GLuint* fences = %p)", n, fences);
1281
1282 if(n < 0)
1283 {
1284 return error(GL_INVALID_VALUE);
1285 }
1286
1287 gl::Context *context = gl::getContext();
1288
1289 if(context)
1290 {
1291 if(context->getListIndex() != 0)
1292 {
1293 UNIMPLEMENTED();
1294 }
1295
1296 for(int i = 0; i < n; i++)
1297 {
1298 context->deleteFence(fences[i]);
1299 }
1300 }
1301 }
1302
glDeleteFramebuffers(GLsizei n,const GLuint * framebuffers)1303 void APIENTRY glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
1304 {
1305 TRACE("(GLsizei n = %d, const GLuint* framebuffers = %p)", n, framebuffers);
1306
1307 if(n < 0)
1308 {
1309 return error(GL_INVALID_VALUE);
1310 }
1311
1312 gl::Context *context = gl::getContext();
1313
1314 if(context)
1315 {
1316 if(context->getListIndex() != 0)
1317 {
1318 UNIMPLEMENTED();
1319 }
1320
1321 for(int i = 0; i < n; i++)
1322 {
1323 if(framebuffers[i] != 0)
1324 {
1325 context->deleteFramebuffer(framebuffers[i]);
1326 }
1327 }
1328 }
1329 }
1330
glDeleteProgram(GLuint program)1331 void APIENTRY glDeleteProgram(GLuint program)
1332 {
1333 TRACE("(GLuint program = %d)", program);
1334
1335 if(program == 0)
1336 {
1337 return;
1338 }
1339
1340 gl::Context *context = gl::getContext();
1341
1342 if(context)
1343 {
1344 if(!context->getProgram(program))
1345 {
1346 if(context->getShader(program))
1347 {
1348 return error(GL_INVALID_OPERATION);
1349 }
1350 else
1351 {
1352 return error(GL_INVALID_VALUE);
1353 }
1354 }
1355
1356 context->deleteProgram(program);
1357 }
1358 }
1359
glDeleteQueriesEXT(GLsizei n,const GLuint * ids)1360 void APIENTRY glDeleteQueriesEXT(GLsizei n, const GLuint *ids)
1361 {
1362 TRACE("(GLsizei n = %d, const GLuint *ids = %p)", n, ids);
1363
1364 if(n < 0)
1365 {
1366 return error(GL_INVALID_VALUE);
1367 }
1368
1369 gl::Context *context = gl::getContext();
1370
1371 if(context)
1372 {
1373 for(int i = 0; i < n; i++)
1374 {
1375 context->deleteQuery(ids[i]);
1376 }
1377 }
1378 }
1379
glDeleteRenderbuffers(GLsizei n,const GLuint * renderbuffers)1380 void APIENTRY glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
1381 {
1382 TRACE("(GLsizei n = %d, const GLuint* renderbuffers = %p)", n, renderbuffers);
1383
1384 if(n < 0)
1385 {
1386 return error(GL_INVALID_VALUE);
1387 }
1388
1389 gl::Context *context = gl::getContext();
1390
1391 if(context)
1392 {
1393 if(context->getListIndex() != 0)
1394 {
1395 UNIMPLEMENTED();
1396 }
1397
1398 for(int i = 0; i < n; i++)
1399 {
1400 context->deleteRenderbuffer(renderbuffers[i]);
1401 }
1402 }
1403 }
1404
glDeleteShader(GLuint shader)1405 void APIENTRY glDeleteShader(GLuint shader)
1406 {
1407 TRACE("(GLuint shader = %d)", shader);
1408
1409 if(shader == 0)
1410 {
1411 return;
1412 }
1413
1414 gl::Context *context = gl::getContext();
1415
1416 if(context)
1417 {
1418 if(!context->getShader(shader))
1419 {
1420 if(context->getProgram(shader))
1421 {
1422 return error(GL_INVALID_OPERATION);
1423 }
1424 else
1425 {
1426 return error(GL_INVALID_VALUE);
1427 }
1428 }
1429
1430 context->deleteShader(shader);
1431 }
1432 }
1433
glDeleteTextures(GLsizei n,const GLuint * textures)1434 void APIENTRY glDeleteTextures(GLsizei n, const GLuint* textures)
1435 {
1436 TRACE("(GLsizei n = %d, const GLuint* textures = %p)", n, textures);
1437
1438 if(n < 0)
1439 {
1440 return error(GL_INVALID_VALUE);
1441 }
1442
1443 gl::Context *context = gl::getContext();
1444
1445 if(context)
1446 {
1447 for(int i = 0; i < n; i++)
1448 {
1449 if(textures[i] != 0)
1450 {
1451 context->deleteTexture(textures[i]);
1452 }
1453 }
1454 }
1455 }
1456
glDepthFunc(GLenum func)1457 void APIENTRY glDepthFunc(GLenum func)
1458 {
1459 TRACE("(GLenum func = 0x%X)", func);
1460
1461 switch(func)
1462 {
1463 case GL_NEVER:
1464 case GL_ALWAYS:
1465 case GL_LESS:
1466 case GL_LEQUAL:
1467 case GL_EQUAL:
1468 case GL_GREATER:
1469 case GL_GEQUAL:
1470 case GL_NOTEQUAL:
1471 break;
1472 default:
1473 return error(GL_INVALID_ENUM);
1474 }
1475
1476 gl::Context *context = gl::getContext();
1477
1478 if(context)
1479 {
1480 if(context->getListIndex() != 0)
1481 {
1482 UNIMPLEMENTED();
1483 }
1484
1485 context->setDepthFunc(func);
1486 }
1487 }
1488
glDepthMask(GLboolean flag)1489 void APIENTRY glDepthMask(GLboolean flag)
1490 {
1491 TRACE("(GLboolean flag = %d)", flag);
1492
1493 gl::Context *context = gl::getContext();
1494
1495 if(context)
1496 {
1497 if(context->getListIndex() != 0)
1498 {
1499 UNIMPLEMENTED();
1500 }
1501
1502 context->setDepthMask(flag != GL_FALSE);
1503 }
1504 }
1505
glDepthRangef(GLclampf zNear,GLclampf zFar)1506 void APIENTRY glDepthRangef(GLclampf zNear, GLclampf zFar)
1507 {
1508 TRACE("(GLclampf zNear = %f, GLclampf zFar = %f)", zNear, zFar);
1509
1510 gl::Context *context = gl::getContext();
1511
1512 if(context)
1513 {
1514 if(context->getListIndex() != 0)
1515 {
1516 UNIMPLEMENTED();
1517 }
1518
1519 context->setDepthRange(zNear, zFar);
1520 }
1521 }
1522
glDetachShader(GLuint program,GLuint shader)1523 void APIENTRY glDetachShader(GLuint program, GLuint shader)
1524 {
1525 TRACE("(GLuint program = %d, GLuint shader = %d)", program, shader);
1526
1527 gl::Context *context = gl::getContext();
1528
1529 if(context)
1530 {
1531 gl::Program *programObject = context->getProgram(program);
1532 gl::Shader *shaderObject = context->getShader(shader);
1533
1534 if(!programObject)
1535 {
1536 gl::Shader *shaderByProgramHandle;
1537 shaderByProgramHandle = context->getShader(program);
1538 if(!shaderByProgramHandle)
1539 {
1540 return error(GL_INVALID_VALUE);
1541 }
1542 else
1543 {
1544 return error(GL_INVALID_OPERATION);
1545 }
1546 }
1547
1548 if(!shaderObject)
1549 {
1550 gl::Program *programByShaderHandle = context->getProgram(shader);
1551 if(!programByShaderHandle)
1552 {
1553 return error(GL_INVALID_VALUE);
1554 }
1555 else
1556 {
1557 return error(GL_INVALID_OPERATION);
1558 }
1559 }
1560
1561 if(!programObject->detachShader(shaderObject))
1562 {
1563 return error(GL_INVALID_OPERATION);
1564 }
1565 }
1566 }
1567
glDisable(GLenum cap)1568 void APIENTRY glDisable(GLenum cap)
1569 {
1570 TRACE("(GLenum cap = 0x%X)", cap);
1571
1572 gl::Context *context = gl::getContext();
1573
1574 if(context)
1575 {
1576 if(context->getListIndex() != 0)
1577 {
1578 UNIMPLEMENTED();
1579 }
1580
1581 switch(cap)
1582 {
1583 case GL_CULL_FACE: context->setCullFaceEnabled(false); break;
1584 case GL_POLYGON_OFFSET_FILL: context->setPolygonOffsetFillEnabled(false); break;
1585 case GL_SAMPLE_ALPHA_TO_COVERAGE: context->setSampleAlphaToCoverageEnabled(false); break;
1586 case GL_SAMPLE_COVERAGE: context->setSampleCoverageEnabled(false); break;
1587 case GL_SCISSOR_TEST: context->setScissorTestEnabled(false); break;
1588 case GL_STENCIL_TEST: context->setStencilTestEnabled(false); break;
1589 case GL_DEPTH_TEST: context->setDepthTestEnabled(false); break;
1590 case GL_BLEND: context->setBlendEnabled(false); break;
1591 case GL_DITHER: context->setDitherEnabled(false); break;
1592 case GL_LIGHTING: context->setLightingEnabled(false); break;
1593 case GL_FOG: context->setFogEnabled(false); break;
1594 case GL_ALPHA_TEST: context->setAlphaTestEnabled(false); break;
1595 case GL_TEXTURE_2D: context->setTexture2DEnabled(false); break;
1596 case GL_LIGHT0: context->setLightEnabled(0, false); break;
1597 case GL_LIGHT1: context->setLightEnabled(1, false); break;
1598 case GL_LIGHT2: context->setLightEnabled(2, false); break;
1599 case GL_LIGHT3: context->setLightEnabled(3, false); break;
1600 case GL_LIGHT4: context->setLightEnabled(4, false); break;
1601 case GL_LIGHT5: context->setLightEnabled(5, false); break;
1602 case GL_LIGHT6: context->setLightEnabled(6, false); break;
1603 case GL_LIGHT7: context->setLightEnabled(7, false); break;
1604 case GL_COLOR_MATERIAL: context->setColorMaterialEnabled(false); break;
1605 case GL_RESCALE_NORMAL: context->setNormalizeNormalsEnabled(false); break;
1606 case GL_COLOR_LOGIC_OP: context->setColorLogicOpEnabled(false); break;
1607 case GL_INDEX_LOGIC_OP: UNIMPLEMENTED();
1608 default:
1609 return error(GL_INVALID_ENUM);
1610 }
1611 }
1612 }
1613
glDisableVertexAttribArray(GLuint index)1614 void APIENTRY glDisableVertexAttribArray(GLuint index)
1615 {
1616 TRACE("(GLuint index = %d)", index);
1617
1618 if(index >= gl::MAX_VERTEX_ATTRIBS)
1619 {
1620 return error(GL_INVALID_VALUE);
1621 }
1622
1623 gl::Context *context = gl::getContext();
1624
1625 if(context)
1626 {
1627 context->setVertexAttribArrayEnabled(index, false);
1628 }
1629 }
1630
glCaptureAttribs()1631 void APIENTRY glCaptureAttribs()
1632 {
1633 TRACE("()");
1634
1635 gl::Context *context = gl::getContext();
1636
1637 if(context)
1638 {
1639 context->captureAttribs();
1640 }
1641 }
1642
glRestoreAttribs()1643 void APIENTRY glRestoreAttribs()
1644 {
1645 TRACE("()");
1646
1647 gl::Context *context = gl::getContext();
1648
1649 if(context)
1650 {
1651 context->restoreAttribs();
1652 }
1653 }
1654
glDrawArrays(GLenum mode,GLint first,GLsizei count)1655 void APIENTRY glDrawArrays(GLenum mode, GLint first, GLsizei count)
1656 {
1657 TRACE("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d)", mode, first, count);
1658
1659 if(count < 0 || first < 0)
1660 {
1661 return error(GL_INVALID_VALUE);
1662 }
1663
1664 gl::Context *context = gl::getContext();
1665
1666 if(context)
1667 {
1668 if(context->getListIndex() != 0)
1669 {
1670 ASSERT(context->getListMode() != GL_COMPILE_AND_EXECUTE); // UNIMPLEMENTED!
1671
1672 context->listCommand(gl::newCommand(glCaptureAttribs));
1673 context->captureDrawArrays(mode, first, count);
1674 context->listCommand(gl::newCommand(glDrawArrays, mode, first, count));
1675 context->listCommand(gl::newCommand(glRestoreAttribs));
1676
1677 return;
1678 }
1679
1680 context->drawArrays(mode, first, count);
1681 }
1682 }
1683
glDrawElements(GLenum mode,GLsizei count,GLenum type,const GLvoid * indices)1684 void APIENTRY glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
1685 {
1686 TRACE("(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const GLvoid* indices = %p)",
1687 mode, count, type, indices);
1688
1689 if(count < 0)
1690 {
1691 return error(GL_INVALID_VALUE);
1692 }
1693
1694 gl::Context *context = gl::getContext();
1695
1696 if(context)
1697 {
1698 if(context->getListIndex() != 0)
1699 {
1700 UNIMPLEMENTED();
1701 }
1702
1703 switch(type)
1704 {
1705 case GL_UNSIGNED_BYTE:
1706 case GL_UNSIGNED_SHORT:
1707 case GL_UNSIGNED_INT:
1708 break;
1709 default:
1710 return error(GL_INVALID_ENUM);
1711 }
1712
1713 context->drawElements(mode, count, type, indices);
1714 }
1715 }
1716
glEnable(GLenum cap)1717 void APIENTRY glEnable(GLenum cap)
1718 {
1719 TRACE("(GLenum cap = 0x%X)", cap);
1720
1721 gl::Context *context = gl::getContext();
1722
1723 if(context)
1724 {
1725 if(context->getListIndex() != 0)
1726 {
1727 UNIMPLEMENTED();
1728 }
1729
1730 switch(cap)
1731 {
1732 case GL_CULL_FACE: context->setCullFaceEnabled(true); break;
1733 case GL_POLYGON_OFFSET_FILL: context->setPolygonOffsetFillEnabled(true); break;
1734 case GL_SAMPLE_ALPHA_TO_COVERAGE: context->setSampleAlphaToCoverageEnabled(true); break;
1735 case GL_SAMPLE_COVERAGE: context->setSampleCoverageEnabled(true); break;
1736 case GL_SCISSOR_TEST: context->setScissorTestEnabled(true); break;
1737 case GL_STENCIL_TEST: context->setStencilTestEnabled(true); break;
1738 case GL_DEPTH_TEST: context->setDepthTestEnabled(true); break;
1739 case GL_BLEND: context->setBlendEnabled(true); break;
1740 case GL_DITHER: context->setDitherEnabled(true); break;
1741 case GL_TEXTURE_2D: context->setTexture2DEnabled(true); break;
1742 case GL_ALPHA_TEST: context->setAlphaTestEnabled(true); break;
1743 case GL_COLOR_MATERIAL: context->setColorMaterialEnabled(true); break;
1744 case GL_FOG: context->setFogEnabled(true); break;
1745 case GL_LIGHTING: context->setLightingEnabled(true); break;
1746 case GL_LIGHT0: context->setLightEnabled(0, true); break;
1747 case GL_LIGHT1: context->setLightEnabled(1, true); break;
1748 case GL_LIGHT2: context->setLightEnabled(2, true); break;
1749 case GL_LIGHT3: context->setLightEnabled(3, true); break;
1750 case GL_LIGHT4: context->setLightEnabled(4, true); break;
1751 case GL_LIGHT5: context->setLightEnabled(5, true); break;
1752 case GL_LIGHT6: context->setLightEnabled(6, true); break;
1753 case GL_LIGHT7: context->setLightEnabled(7, true); break;
1754 case GL_RESCALE_NORMAL: context->setNormalizeNormalsEnabled(true); break;
1755 case GL_COLOR_LOGIC_OP: context->setColorLogicOpEnabled(true); break;
1756 case GL_INDEX_LOGIC_OP: UNIMPLEMENTED();
1757 default:
1758 return error(GL_INVALID_ENUM);
1759 }
1760 }
1761 }
1762
glEnableVertexAttribArray(GLuint index)1763 void APIENTRY glEnableVertexAttribArray(GLuint index)
1764 {
1765 TRACE("(GLuint index = %d)", index);
1766
1767 if(index >= gl::MAX_VERTEX_ATTRIBS)
1768 {
1769 return error(GL_INVALID_VALUE);
1770 }
1771
1772 gl::Context *context = gl::getContext();
1773
1774 if(context)
1775 {
1776 context->setVertexAttribArrayEnabled(index, true);
1777 }
1778 }
1779
glEndQueryEXT(GLenum target)1780 void APIENTRY glEndQueryEXT(GLenum target)
1781 {
1782 TRACE("GLenum target = 0x%X)", target);
1783
1784 switch(target)
1785 {
1786 case GL_ANY_SAMPLES_PASSED:
1787 case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
1788 break;
1789 default:
1790 return error(GL_INVALID_ENUM);
1791 }
1792
1793 gl::Context *context = gl::getContext();
1794
1795 if(context)
1796 {
1797 if(context->getListIndex() != 0)
1798 {
1799 UNIMPLEMENTED();
1800 }
1801
1802 context->endQuery(target);
1803 }
1804 }
1805
glFinishFenceNV(GLuint fence)1806 void APIENTRY glFinishFenceNV(GLuint fence)
1807 {
1808 TRACE("(GLuint fence = %d)", fence);
1809
1810 gl::Context *context = gl::getContext();
1811
1812 if(context)
1813 {
1814 if(context->getListIndex() != 0)
1815 {
1816 UNIMPLEMENTED();
1817 }
1818
1819 gl::Fence* fenceObject = context->getFence(fence);
1820
1821 if(!fenceObject)
1822 {
1823 return error(GL_INVALID_OPERATION);
1824 }
1825
1826 fenceObject->finishFence();
1827 }
1828 }
1829
glFinish(void)1830 void APIENTRY glFinish(void)
1831 {
1832 TRACE("()");
1833
1834 gl::Context *context = gl::getContext();
1835
1836 if(context)
1837 {
1838 context->finish();
1839 }
1840 }
1841
glFlush(void)1842 void APIENTRY glFlush(void)
1843 {
1844 TRACE("()");
1845
1846 gl::Context *context = gl::getContext();
1847
1848 if(context)
1849 {
1850 context->flush();
1851 }
1852 }
1853
glFramebufferRenderbuffer(GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer)1854 void APIENTRY glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
1855 {
1856 TRACE("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum renderbuffertarget = 0x%X, "
1857 "GLuint renderbuffer = %d)", target, attachment, renderbuffertarget, renderbuffer);
1858
1859 if((target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_EXT && target != GL_READ_FRAMEBUFFER_EXT) ||
1860 (renderbuffertarget != GL_RENDERBUFFER && renderbuffer != 0))
1861 {
1862 return error(GL_INVALID_ENUM);
1863 }
1864
1865 gl::Context *context = gl::getContext();
1866
1867 if(context)
1868 {
1869 if(context->getListIndex() != 0)
1870 {
1871 UNIMPLEMENTED();
1872 }
1873
1874 gl::Framebuffer *framebuffer = nullptr;
1875 GLuint framebufferName = 0;
1876 if(target == GL_READ_FRAMEBUFFER_EXT)
1877 {
1878 framebuffer = context->getReadFramebuffer();
1879 framebufferName = context->getReadFramebufferName();
1880 }
1881 else
1882 {
1883 framebuffer = context->getDrawFramebuffer();
1884 framebufferName = context->getDrawFramebufferName();
1885 }
1886
1887 if(!framebuffer || (framebufferName == 0 && renderbuffer != 0))
1888 {
1889 return error(GL_INVALID_OPERATION);
1890 }
1891
1892 switch(attachment)
1893 {
1894 case GL_COLOR_ATTACHMENT0:
1895 framebuffer->setColorbuffer(GL_RENDERBUFFER, renderbuffer);
1896 break;
1897 case GL_DEPTH_ATTACHMENT:
1898 framebuffer->setDepthbuffer(GL_RENDERBUFFER, renderbuffer);
1899 break;
1900 case GL_STENCIL_ATTACHMENT:
1901 framebuffer->setStencilbuffer(GL_RENDERBUFFER, renderbuffer);
1902 break;
1903 default:
1904 return error(GL_INVALID_ENUM);
1905 }
1906 }
1907 }
1908
glFramebufferTexture1D(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)1909 void APIENTRY glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1910 {
1911 UNIMPLEMENTED();
1912 }
1913
glFramebufferTexture2D(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)1914 void APIENTRY glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1915 {
1916 TRACE("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum textarget = 0x%X, "
1917 "GLuint texture = %d, GLint level = %d)", target, attachment, textarget, texture, level);
1918
1919 if(target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_EXT && target != GL_READ_FRAMEBUFFER_EXT)
1920 {
1921 return error(GL_INVALID_ENUM);
1922 }
1923
1924 switch(attachment)
1925 {
1926 case GL_COLOR_ATTACHMENT0:
1927 case GL_DEPTH_ATTACHMENT:
1928 case GL_STENCIL_ATTACHMENT:
1929 break;
1930 default:
1931 return error(GL_INVALID_ENUM);
1932 }
1933
1934 gl::Context *context = gl::getContext();
1935
1936 if(context)
1937 {
1938 if(context->getListIndex() != 0)
1939 {
1940 UNIMPLEMENTED();
1941 }
1942
1943 if(texture == 0)
1944 {
1945 textarget = GL_NONE;
1946 }
1947 else
1948 {
1949 gl::Texture *tex = context->getTexture(texture);
1950
1951 if(!tex)
1952 {
1953 return error(GL_INVALID_OPERATION);
1954 }
1955
1956 if(tex->isCompressed(textarget, level))
1957 {
1958 return error(GL_INVALID_OPERATION);
1959 }
1960
1961 switch(textarget)
1962 {
1963 case GL_TEXTURE_2D:
1964 if(tex->getTarget() != GL_TEXTURE_2D)
1965 {
1966 return error(GL_INVALID_OPERATION);
1967 }
1968 break;
1969 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
1970 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
1971 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
1972 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
1973 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
1974 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
1975 if(tex->getTarget() != GL_TEXTURE_CUBE_MAP)
1976 {
1977 return error(GL_INVALID_OPERATION);
1978 }
1979 break;
1980 default:
1981 return error(GL_INVALID_ENUM);
1982 }
1983
1984 if(level != 0)
1985 {
1986 return error(GL_INVALID_VALUE);
1987 }
1988 }
1989
1990 gl::Framebuffer *framebuffer = nullptr;
1991 GLuint framebufferName = 0;
1992 if(target == GL_READ_FRAMEBUFFER_EXT)
1993 {
1994 framebuffer = context->getReadFramebuffer();
1995 framebufferName = context->getReadFramebufferName();
1996 }
1997 else
1998 {
1999 framebuffer = context->getDrawFramebuffer();
2000 framebufferName = context->getDrawFramebufferName();
2001 }
2002
2003 if(framebufferName == 0 || !framebuffer)
2004 {
2005 return error(GL_INVALID_OPERATION);
2006 }
2007
2008 switch(attachment)
2009 {
2010 case GL_COLOR_ATTACHMENT0: framebuffer->setColorbuffer(textarget, texture); break;
2011 case GL_DEPTH_ATTACHMENT: framebuffer->setDepthbuffer(textarget, texture); break;
2012 case GL_STENCIL_ATTACHMENT: framebuffer->setStencilbuffer(textarget, texture); break;
2013 }
2014 }
2015 }
2016
glFramebufferTexture3D(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLint zoffset)2017 void APIENTRY glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
2018 {
2019 UNIMPLEMENTED();
2020 }
2021
glFrontFace(GLenum mode)2022 void APIENTRY glFrontFace(GLenum mode)
2023 {
2024 TRACE("(GLenum mode = 0x%X)", mode);
2025
2026 switch(mode)
2027 {
2028 case GL_CW:
2029 case GL_CCW:
2030 {
2031 gl::Context *context = gl::getContext();
2032
2033 if(context)
2034 {
2035 context->setFrontFace(mode);
2036 }
2037 }
2038 break;
2039 default:
2040 return error(GL_INVALID_ENUM);
2041 }
2042 }
2043
glGenBuffers(GLsizei n,GLuint * buffers)2044 void APIENTRY glGenBuffers(GLsizei n, GLuint* buffers)
2045 {
2046 TRACE("(GLsizei n = %d, GLuint* buffers = %p)", n, buffers);
2047
2048 if(n < 0)
2049 {
2050 return error(GL_INVALID_VALUE);
2051 }
2052
2053 gl::Context *context = gl::getContext();
2054
2055 if(context)
2056 {
2057 for(int i = 0; i < n; i++)
2058 {
2059 buffers[i] = context->createBuffer();
2060 }
2061 }
2062 }
2063
glGenerateMipmap(GLenum target)2064 void APIENTRY glGenerateMipmap(GLenum target)
2065 {
2066 TRACE("(GLenum target = 0x%X)", target);
2067
2068 gl::Context *context = gl::getContext();
2069
2070 if(context)
2071 {
2072 if(context->getListIndex() != 0)
2073 {
2074 UNIMPLEMENTED();
2075 }
2076
2077 gl::Texture *texture;
2078
2079 switch(target)
2080 {
2081 case GL_TEXTURE_2D:
2082 texture = context->getTexture2D(target);
2083 break;
2084 case GL_TEXTURE_CUBE_MAP:
2085 texture = context->getTextureCubeMap();
2086 break;
2087 default:
2088 return error(GL_INVALID_ENUM);
2089 }
2090
2091 if(texture->isCompressed(target, 0) || texture->isDepth(target, 0))
2092 {
2093 return error(GL_INVALID_OPERATION);
2094 }
2095
2096 texture->generateMipmaps();
2097 }
2098 }
2099
glGenFencesNV(GLsizei n,GLuint * fences)2100 void APIENTRY glGenFencesNV(GLsizei n, GLuint* fences)
2101 {
2102 TRACE("(GLsizei n = %d, GLuint* fences = %p)", n, fences);
2103
2104 if(n < 0)
2105 {
2106 return error(GL_INVALID_VALUE);
2107 }
2108
2109 gl::Context *context = gl::getContext();
2110
2111 if(context)
2112 {
2113 if(context->getListIndex() != 0)
2114 {
2115 UNIMPLEMENTED();
2116 }
2117
2118 for(int i = 0; i < n; i++)
2119 {
2120 fences[i] = context->createFence();
2121 }
2122 }
2123 }
2124
glGenFramebuffers(GLsizei n,GLuint * framebuffers)2125 void APIENTRY glGenFramebuffers(GLsizei n, GLuint* framebuffers)
2126 {
2127 TRACE("(GLsizei n = %d, GLuint* framebuffers = %p)", n, framebuffers);
2128
2129 if(n < 0)
2130 {
2131 return error(GL_INVALID_VALUE);
2132 }
2133
2134 gl::Context *context = gl::getContext();
2135
2136 if(context)
2137 {
2138 if(context->getListIndex() != 0)
2139 {
2140 UNIMPLEMENTED();
2141 }
2142
2143 for(int i = 0; i < n; i++)
2144 {
2145 framebuffers[i] = context->createFramebuffer();
2146 }
2147 }
2148 }
2149
glGenQueriesEXT(GLsizei n,GLuint * ids)2150 void APIENTRY glGenQueriesEXT(GLsizei n, GLuint* ids)
2151 {
2152 TRACE("(GLsizei n = %d, GLuint* ids = %p)", n, ids);
2153
2154 if(n < 0)
2155 {
2156 return error(GL_INVALID_VALUE);
2157 }
2158
2159 gl::Context *context = gl::getContext();
2160
2161 if(context)
2162 {
2163 for(int i = 0; i < n; i++)
2164 {
2165 ids[i] = context->createQuery();
2166 }
2167 }
2168 }
2169
glGenRenderbuffers(GLsizei n,GLuint * renderbuffers)2170 void APIENTRY glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
2171 {
2172 TRACE("(GLsizei n = %d, GLuint* renderbuffers = %p)", n, renderbuffers);
2173
2174 if(n < 0)
2175 {
2176 return error(GL_INVALID_VALUE);
2177 }
2178
2179 gl::Context *context = gl::getContext();
2180
2181 if(context)
2182 {
2183 if(context->getListIndex() != 0)
2184 {
2185 UNIMPLEMENTED();
2186 }
2187
2188 for(int i = 0; i < n; i++)
2189 {
2190 renderbuffers[i] = context->createRenderbuffer();
2191 }
2192 }
2193 }
2194
glGenTextures(GLsizei n,GLuint * textures)2195 void APIENTRY glGenTextures(GLsizei n, GLuint* textures)
2196 {
2197 TRACE("(GLsizei n = %d, GLuint* textures = %p)", n, textures);
2198
2199 if(n < 0)
2200 {
2201 return error(GL_INVALID_VALUE);
2202 }
2203
2204 gl::Context *context = gl::getContext();
2205
2206 if(context)
2207 {
2208 for(int i = 0; i < n; i++)
2209 {
2210 textures[i] = context->createTexture();
2211 }
2212 }
2213 }
2214
glGetActiveAttrib(GLuint program,GLuint index,GLsizei bufsize,GLsizei * length,GLint * size,GLenum * type,GLchar * name)2215 void APIENTRY glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
2216 {
2217 TRACE("(GLuint program = %d, GLuint index = %d, GLsizei bufsize = %d, GLsizei *length = %p, "
2218 "GLint *size = %p, GLenum *type = %p, GLchar *name = %p)",
2219 program, index, bufsize, length, size, type, name);
2220
2221 if(bufsize < 0)
2222 {
2223 return error(GL_INVALID_VALUE);
2224 }
2225
2226 gl::Context *context = gl::getContext();
2227
2228 if(context)
2229 {
2230 gl::Program *programObject = context->getProgram(program);
2231
2232 if(!programObject)
2233 {
2234 if(context->getShader(program))
2235 {
2236 return error(GL_INVALID_OPERATION);
2237 }
2238 else
2239 {
2240 return error(GL_INVALID_VALUE);
2241 }
2242 }
2243
2244 if(index >= programObject->getActiveAttributeCount())
2245 {
2246 return error(GL_INVALID_VALUE);
2247 }
2248
2249 programObject->getActiveAttribute(index, bufsize, length, size, type, name);
2250 }
2251 }
2252
glGetActiveUniform(GLuint program,GLuint index,GLsizei bufsize,GLsizei * length,GLint * size,GLenum * type,GLchar * name)2253 void APIENTRY glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
2254 {
2255 TRACE("(GLuint program = %d, GLuint index = %d, GLsizei bufsize = %d, "
2256 "GLsizei* length = %p, GLint* size = %p, GLenum* type = %p, GLchar* name = %s)",
2257 program, index, bufsize, length, size, type, name);
2258
2259 if(bufsize < 0)
2260 {
2261 return error(GL_INVALID_VALUE);
2262 }
2263
2264 gl::Context *context = gl::getContext();
2265
2266 if(context)
2267 {
2268 gl::Program *programObject = context->getProgram(program);
2269
2270 if(!programObject)
2271 {
2272 if(context->getShader(program))
2273 {
2274 return error(GL_INVALID_OPERATION);
2275 }
2276 else
2277 {
2278 return error(GL_INVALID_VALUE);
2279 }
2280 }
2281
2282 if(index >= programObject->getActiveUniformCount())
2283 {
2284 return error(GL_INVALID_VALUE);
2285 }
2286
2287 programObject->getActiveUniform(index, bufsize, length, size, type, name);
2288 }
2289 }
2290
glGetAttachedShaders(GLuint program,GLsizei maxcount,GLsizei * count,GLuint * shaders)2291 void APIENTRY glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
2292 {
2293 TRACE("(GLuint program = %d, GLsizei maxcount = %d, GLsizei* count = %p, GLuint* shaders = %p)",
2294 program, maxcount, count, shaders);
2295
2296 if(maxcount < 0)
2297 {
2298 return error(GL_INVALID_VALUE);
2299 }
2300
2301 gl::Context *context = gl::getContext();
2302
2303 if(context)
2304 {
2305 gl::Program *programObject = context->getProgram(program);
2306
2307 if(!programObject)
2308 {
2309 if(context->getShader(program))
2310 {
2311 return error(GL_INVALID_OPERATION);
2312 }
2313 else
2314 {
2315 return error(GL_INVALID_VALUE);
2316 }
2317 }
2318
2319 return programObject->getAttachedShaders(maxcount, count, shaders);
2320 }
2321 }
2322
glGetAttribLocation(GLuint program,const GLchar * name)2323 int APIENTRY glGetAttribLocation(GLuint program, const GLchar* name)
2324 {
2325 TRACE("(GLuint program = %d, const GLchar* name = %s)", program, name);
2326
2327 gl::Context *context = gl::getContext();
2328
2329 if(context)
2330 {
2331 gl::Program *programObject = context->getProgram(program);
2332
2333 if(!programObject)
2334 {
2335 if(context->getShader(program))
2336 {
2337 return error(GL_INVALID_OPERATION, -1);
2338 }
2339 else
2340 {
2341 return error(GL_INVALID_VALUE, -1);
2342 }
2343 }
2344
2345 if(!programObject->isLinked())
2346 {
2347 return error(GL_INVALID_OPERATION, -1);
2348 }
2349
2350 return programObject->getAttributeLocation(name);
2351 }
2352
2353 return -1;
2354 }
2355
glGetBooleanv(GLenum pname,GLboolean * params)2356 void APIENTRY glGetBooleanv(GLenum pname, GLboolean* params)
2357 {
2358 TRACE("(GLenum pname = 0x%X, GLboolean* params = %p)", pname, params);
2359
2360 gl::Context *context = gl::getContext();
2361
2362 if(context)
2363 {
2364 if(!(context->getBooleanv(pname, params)))
2365 {
2366 GLenum nativeType;
2367 unsigned int numParams = 0;
2368 if(!context->getQueryParameterInfo(pname, &nativeType, &numParams))
2369 return error(GL_INVALID_ENUM);
2370
2371 if(numParams == 0)
2372 return; // it is known that the pname is valid, but there are no parameters to return
2373
2374 if(nativeType == GL_FLOAT)
2375 {
2376 GLfloat *floatParams = nullptr;
2377 floatParams = new GLfloat[numParams];
2378
2379 context->getFloatv(pname, floatParams);
2380
2381 for(unsigned int i = 0; i < numParams; ++i)
2382 {
2383 if(floatParams[i] == 0.0f)
2384 params[i] = GL_FALSE;
2385 else
2386 params[i] = GL_TRUE;
2387 }
2388
2389 delete [] floatParams;
2390 }
2391 else if(nativeType == GL_INT)
2392 {
2393 GLint *intParams = nullptr;
2394 intParams = new GLint[numParams];
2395
2396 context->getIntegerv(pname, intParams);
2397
2398 for(unsigned int i = 0; i < numParams; ++i)
2399 {
2400 if(intParams[i] == 0)
2401 params[i] = GL_FALSE;
2402 else
2403 params[i] = GL_TRUE;
2404 }
2405
2406 delete [] intParams;
2407 }
2408 }
2409 }
2410 }
2411
glGetBufferParameteriv(GLenum target,GLenum pname,GLint * params)2412 void APIENTRY glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
2413 {
2414 TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = %p)", target, pname, params);
2415
2416 gl::Context *context = gl::getContext();
2417
2418 if(context)
2419 {
2420 gl::Buffer *buffer;
2421
2422 switch(target)
2423 {
2424 case GL_ARRAY_BUFFER:
2425 buffer = context->getArrayBuffer();
2426 break;
2427 case GL_ELEMENT_ARRAY_BUFFER:
2428 buffer = context->getElementArrayBuffer();
2429 break;
2430 default:
2431 return error(GL_INVALID_ENUM);
2432 }
2433
2434 if(!buffer)
2435 {
2436 // A null buffer means that "0" is bound to the requested buffer target
2437 return error(GL_INVALID_OPERATION);
2438 }
2439
2440 switch(pname)
2441 {
2442 case GL_BUFFER_USAGE:
2443 *params = buffer->usage();
2444 break;
2445 case GL_BUFFER_SIZE:
2446 *params = buffer->size();
2447 break;
2448 default:
2449 return error(GL_INVALID_ENUM);
2450 }
2451 }
2452 }
2453
glGetError(void)2454 GLenum APIENTRY glGetError(void)
2455 {
2456 TRACE("()");
2457
2458 gl::Context *context = gl::getContext();
2459
2460 if(context)
2461 {
2462 return context->getError();
2463 }
2464
2465 return GL_NO_ERROR;
2466 }
2467
glGetFenceivNV(GLuint fence,GLenum pname,GLint * params)2468 void APIENTRY glGetFenceivNV(GLuint fence, GLenum pname, GLint *params)
2469 {
2470 TRACE("(GLuint fence = %d, GLenum pname = 0x%X, GLint *params = %p)", fence, pname, params);
2471
2472 gl::Context *context = gl::getContext();
2473
2474 if(context)
2475 {
2476 gl::Fence *fenceObject = context->getFence(fence);
2477
2478 if(!fenceObject)
2479 {
2480 return error(GL_INVALID_OPERATION);
2481 }
2482
2483 fenceObject->getFenceiv(pname, params);
2484 }
2485 }
2486
glGetFloatv(GLenum pname,GLfloat * params)2487 void APIENTRY glGetFloatv(GLenum pname, GLfloat* params)
2488 {
2489 TRACE("(GLenum pname = 0x%X, GLfloat* params = %p)", pname, params);
2490
2491 gl::Context *context = gl::getContext();
2492
2493 if(context)
2494 {
2495 if(!(context->getFloatv(pname, params)))
2496 {
2497 GLenum nativeType;
2498 unsigned int numParams = 0;
2499 if(!context->getQueryParameterInfo(pname, &nativeType, &numParams))
2500 return error(GL_INVALID_ENUM);
2501
2502 if(numParams == 0)
2503 return; // it is known that the pname is valid, but that there are no parameters to return.
2504
2505 if(nativeType == GL_BOOL)
2506 {
2507 GLboolean *boolParams = nullptr;
2508 boolParams = new GLboolean[numParams];
2509
2510 context->getBooleanv(pname, boolParams);
2511
2512 for(unsigned int i = 0; i < numParams; ++i)
2513 {
2514 if(boolParams[i] == GL_FALSE)
2515 params[i] = 0.0f;
2516 else
2517 params[i] = 1.0f;
2518 }
2519
2520 delete [] boolParams;
2521 }
2522 else if(nativeType == GL_INT)
2523 {
2524 GLint *intParams = nullptr;
2525 intParams = new GLint[numParams];
2526
2527 context->getIntegerv(pname, intParams);
2528
2529 for(unsigned int i = 0; i < numParams; ++i)
2530 {
2531 params[i] = (GLfloat)intParams[i];
2532 }
2533
2534 delete [] intParams;
2535 }
2536 }
2537 }
2538 }
2539
glGetFramebufferAttachmentParameteriv(GLenum target,GLenum attachment,GLenum pname,GLint * params)2540 void APIENTRY glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
2541 {
2542 TRACE("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum pname = 0x%X, GLint* params = %p)",
2543 target, attachment, pname, params);
2544
2545 gl::Context *context = gl::getContext();
2546
2547 if(context)
2548 {
2549 if(target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_EXT && target != GL_READ_FRAMEBUFFER_EXT)
2550 {
2551 return error(GL_INVALID_ENUM);
2552 }
2553
2554 gl::Framebuffer *framebuffer = nullptr;
2555 if(target == GL_READ_FRAMEBUFFER_EXT)
2556 {
2557 if(context->getReadFramebufferName() == 0)
2558 {
2559 return error(GL_INVALID_OPERATION);
2560 }
2561
2562 framebuffer = context->getReadFramebuffer();
2563 }
2564 else
2565 {
2566 if(context->getDrawFramebufferName() == 0)
2567 {
2568 return error(GL_INVALID_OPERATION);
2569 }
2570
2571 framebuffer = context->getDrawFramebuffer();
2572 }
2573
2574 GLenum attachmentType;
2575 GLuint attachmentHandle;
2576 switch(attachment)
2577 {
2578 case GL_COLOR_ATTACHMENT0:
2579 attachmentType = framebuffer->getColorbufferType();
2580 attachmentHandle = framebuffer->getColorbufferName();
2581 break;
2582 case GL_DEPTH_ATTACHMENT:
2583 attachmentType = framebuffer->getDepthbufferType();
2584 attachmentHandle = framebuffer->getDepthbufferName();
2585 break;
2586 case GL_STENCIL_ATTACHMENT:
2587 attachmentType = framebuffer->getStencilbufferType();
2588 attachmentHandle = framebuffer->getStencilbufferName();
2589 break;
2590 default:
2591 return error(GL_INVALID_ENUM);
2592 }
2593
2594 GLenum attachmentObjectType; // Type category
2595 if(attachmentType == GL_NONE || attachmentType == GL_RENDERBUFFER)
2596 {
2597 attachmentObjectType = attachmentType;
2598 }
2599 else if(gl::IsTextureTarget(attachmentType))
2600 {
2601 attachmentObjectType = GL_TEXTURE;
2602 }
2603 else UNREACHABLE(attachmentType);
2604
2605 switch(pname)
2606 {
2607 case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
2608 *params = attachmentObjectType;
2609 break;
2610 case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
2611 if(attachmentObjectType == GL_RENDERBUFFER || attachmentObjectType == GL_TEXTURE)
2612 {
2613 *params = attachmentHandle;
2614 }
2615 else
2616 {
2617 return error(GL_INVALID_ENUM);
2618 }
2619 break;
2620 case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
2621 if(attachmentObjectType == GL_TEXTURE)
2622 {
2623 *params = 0; // FramebufferTexture2D will not allow level to be set to anything else in GL ES 2.0
2624 }
2625 else
2626 {
2627 return error(GL_INVALID_ENUM);
2628 }
2629 break;
2630 case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
2631 if(attachmentObjectType == GL_TEXTURE)
2632 {
2633 if(gl::IsCubemapTextureTarget(attachmentType))
2634 {
2635 *params = attachmentType;
2636 }
2637 else
2638 {
2639 *params = 0;
2640 }
2641 }
2642 else
2643 {
2644 return error(GL_INVALID_ENUM);
2645 }
2646 break;
2647 default:
2648 return error(GL_INVALID_ENUM);
2649 }
2650 }
2651 }
2652
glGetGraphicsResetStatusEXT(void)2653 GLenum APIENTRY glGetGraphicsResetStatusEXT(void)
2654 {
2655 TRACE("()");
2656
2657 return GL_NO_ERROR;
2658 }
2659
glGetIntegerv(GLenum pname,GLint * params)2660 void APIENTRY glGetIntegerv(GLenum pname, GLint* params)
2661 {
2662 TRACE("(GLenum pname = 0x%X, GLint* params = %p)", pname, params);
2663
2664 gl::Context *context = gl::getContext();
2665
2666 if(context)
2667 {
2668 if(!(context->getIntegerv(pname, params)))
2669 {
2670 GLenum nativeType;
2671 unsigned int numParams = 0;
2672 if(!context->getQueryParameterInfo(pname, &nativeType, &numParams))
2673 return error(GL_INVALID_ENUM);
2674
2675 if(numParams == 0)
2676 return; // it is known that pname is valid, but there are no parameters to return
2677
2678 if(nativeType == GL_BOOL)
2679 {
2680 GLboolean *boolParams = nullptr;
2681 boolParams = new GLboolean[numParams];
2682
2683 context->getBooleanv(pname, boolParams);
2684
2685 for(unsigned int i = 0; i < numParams; ++i)
2686 {
2687 if(boolParams[i] == GL_FALSE)
2688 params[i] = 0;
2689 else
2690 params[i] = 1;
2691 }
2692
2693 delete [] boolParams;
2694 }
2695 else if(nativeType == GL_FLOAT)
2696 {
2697 GLfloat *floatParams = nullptr;
2698 floatParams = new GLfloat[numParams];
2699
2700 context->getFloatv(pname, floatParams);
2701
2702 for(unsigned int i = 0; i < numParams; ++i)
2703 {
2704 if(pname == GL_DEPTH_RANGE || pname == GL_COLOR_CLEAR_VALUE || pname == GL_DEPTH_CLEAR_VALUE || pname == GL_BLEND_COLOR)
2705 {
2706 params[i] = (GLint)(((GLfloat)(0xFFFFFFFF) * floatParams[i] - 1.0f) / 2.0f);
2707 }
2708 else
2709 {
2710 params[i] = (GLint)(floatParams[i] > 0.0f ? floor(floatParams[i] + 0.5) : ceil(floatParams[i] - 0.5));
2711 }
2712 }
2713
2714 delete [] floatParams;
2715 }
2716 }
2717 }
2718 }
2719
glGetProgramiv(GLuint program,GLenum pname,GLint * params)2720 void APIENTRY glGetProgramiv(GLuint program, GLenum pname, GLint* params)
2721 {
2722 TRACE("(GLuint program = %d, GLenum pname = 0x%X, GLint* params = %p)", program, pname, params);
2723
2724 gl::Context *context = gl::getContext();
2725
2726 if(context)
2727 {
2728 gl::Program *programObject = context->getProgram(program);
2729
2730 if(!programObject)
2731 {
2732 return error(GL_INVALID_VALUE);
2733 }
2734
2735 switch(pname)
2736 {
2737 case GL_DELETE_STATUS:
2738 *params = programObject->isFlaggedForDeletion();
2739 return;
2740 case GL_LINK_STATUS:
2741 *params = programObject->isLinked();
2742 return;
2743 case GL_VALIDATE_STATUS:
2744 *params = programObject->isValidated();
2745 return;
2746 case GL_INFO_LOG_LENGTH:
2747 *params = programObject->getInfoLogLength();
2748 return;
2749 case GL_ATTACHED_SHADERS:
2750 *params = programObject->getAttachedShadersCount();
2751 return;
2752 case GL_ACTIVE_ATTRIBUTES:
2753 *params = programObject->getActiveAttributeCount();
2754 return;
2755 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
2756 *params = programObject->getActiveAttributeMaxLength();
2757 return;
2758 case GL_ACTIVE_UNIFORMS:
2759 *params = programObject->getActiveUniformCount();
2760 return;
2761 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
2762 *params = programObject->getActiveUniformMaxLength();
2763 return;
2764 default:
2765 return error(GL_INVALID_ENUM);
2766 }
2767 }
2768 }
2769
glGetProgramInfoLog(GLuint program,GLsizei bufsize,GLsizei * length,GLchar * infolog)2770 void APIENTRY glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog)
2771 {
2772 TRACE("(GLuint program = %d, GLsizei bufsize = %d, GLsizei* length = %p, GLchar* infolog = %p)",
2773 program, bufsize, length, infolog);
2774
2775 if(bufsize < 0)
2776 {
2777 return error(GL_INVALID_VALUE);
2778 }
2779
2780 gl::Context *context = gl::getContext();
2781
2782 if(context)
2783 {
2784 gl::Program *programObject = context->getProgram(program);
2785
2786 if(!programObject)
2787 {
2788 return error(GL_INVALID_VALUE);
2789 }
2790
2791 programObject->getInfoLog(bufsize, length, infolog);
2792 }
2793 }
2794
glGetQueryivEXT(GLenum target,GLenum pname,GLint * params)2795 void APIENTRY glGetQueryivEXT(GLenum target, GLenum pname, GLint *params)
2796 {
2797 TRACE("GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = %p)", target, pname, params);
2798
2799 switch(pname)
2800 {
2801 case GL_CURRENT_QUERY:
2802 break;
2803 default:
2804 return error(GL_INVALID_ENUM);
2805 }
2806
2807 gl::Context *context = gl::getContext();
2808
2809 if(context)
2810 {
2811 params[0] = context->getActiveQuery(target);
2812 }
2813 }
2814
glGetQueryObjectuivEXT(GLuint name,GLenum pname,GLuint * params)2815 void APIENTRY glGetQueryObjectuivEXT(GLuint name, GLenum pname, GLuint *params)
2816 {
2817 TRACE("(GLuint name = %d, GLenum pname = 0x%X, GLuint *params = %p)", name, pname, params);
2818
2819 switch(pname)
2820 {
2821 case GL_QUERY_RESULT:
2822 case GL_QUERY_RESULT_AVAILABLE:
2823 break;
2824 default:
2825 return error(GL_INVALID_ENUM);
2826 }
2827
2828 gl::Context *context = gl::getContext();
2829
2830 if(context)
2831 {
2832 gl::Query *queryObject = context->getQuery(name, false, GL_NONE);
2833
2834 if(!queryObject)
2835 {
2836 return error(GL_INVALID_OPERATION);
2837 }
2838
2839 if(context->getActiveQuery(queryObject->getType()) == name)
2840 {
2841 return error(GL_INVALID_OPERATION);
2842 }
2843
2844 switch(pname)
2845 {
2846 case GL_QUERY_RESULT:
2847 params[0] = queryObject->getResult();
2848 break;
2849 case GL_QUERY_RESULT_AVAILABLE:
2850 params[0] = queryObject->isResultAvailable();
2851 break;
2852 default:
2853 ASSERT(false);
2854 }
2855 }
2856 }
2857
glGetRenderbufferParameteriv(GLenum target,GLenum pname,GLint * params)2858 void APIENTRY glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
2859 {
2860 TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = %p)", target, pname, params);
2861
2862 gl::Context *context = gl::getContext();
2863
2864 if(context)
2865 {
2866 if(target != GL_RENDERBUFFER)
2867 {
2868 return error(GL_INVALID_ENUM);
2869 }
2870
2871 if(context->getRenderbufferName() == 0)
2872 {
2873 return error(GL_INVALID_OPERATION);
2874 }
2875
2876 gl::Renderbuffer *renderbuffer = context->getRenderbuffer(context->getRenderbufferName());
2877
2878 switch(pname)
2879 {
2880 case GL_RENDERBUFFER_WIDTH: *params = renderbuffer->getWidth(); break;
2881 case GL_RENDERBUFFER_HEIGHT: *params = renderbuffer->getHeight(); break;
2882 case GL_RENDERBUFFER_INTERNAL_FORMAT: *params = renderbuffer->getFormat(); break;
2883 case GL_RENDERBUFFER_RED_SIZE: *params = renderbuffer->getRedSize(); break;
2884 case GL_RENDERBUFFER_GREEN_SIZE: *params = renderbuffer->getGreenSize(); break;
2885 case GL_RENDERBUFFER_BLUE_SIZE: *params = renderbuffer->getBlueSize(); break;
2886 case GL_RENDERBUFFER_ALPHA_SIZE: *params = renderbuffer->getAlphaSize(); break;
2887 case GL_RENDERBUFFER_DEPTH_SIZE: *params = renderbuffer->getDepthSize(); break;
2888 case GL_RENDERBUFFER_STENCIL_SIZE: *params = renderbuffer->getStencilSize(); break;
2889 case GL_RENDERBUFFER_SAMPLES_EXT: *params = renderbuffer->getSamples(); break;
2890 default:
2891 return error(GL_INVALID_ENUM);
2892 }
2893 }
2894 }
2895
glGetShaderiv(GLuint shader,GLenum pname,GLint * params)2896 void APIENTRY glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
2897 {
2898 TRACE("(GLuint shader = %d, GLenum pname = %d, GLint* params = %p)", shader, pname, params);
2899
2900 gl::Context *context = gl::getContext();
2901
2902 if(context)
2903 {
2904 gl::Shader *shaderObject = context->getShader(shader);
2905
2906 if(!shaderObject)
2907 {
2908 return error(GL_INVALID_VALUE);
2909 }
2910
2911 switch(pname)
2912 {
2913 case GL_SHADER_TYPE:
2914 *params = shaderObject->getType();
2915 return;
2916 case GL_DELETE_STATUS:
2917 *params = shaderObject->isFlaggedForDeletion();
2918 return;
2919 case GL_COMPILE_STATUS:
2920 *params = shaderObject->isCompiled() ? GL_TRUE : GL_FALSE;
2921 return;
2922 case GL_INFO_LOG_LENGTH:
2923 *params = shaderObject->getInfoLogLength();
2924 return;
2925 case GL_SHADER_SOURCE_LENGTH:
2926 *params = shaderObject->getSourceLength();
2927 return;
2928 default:
2929 return error(GL_INVALID_ENUM);
2930 }
2931 }
2932 }
2933
glGetShaderInfoLog(GLuint shader,GLsizei bufsize,GLsizei * length,GLchar * infolog)2934 void APIENTRY glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog)
2935 {
2936 TRACE("(GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = %p, GLchar* infolog = %p)",
2937 shader, bufsize, length, infolog);
2938
2939 if(bufsize < 0)
2940 {
2941 return error(GL_INVALID_VALUE);
2942 }
2943
2944 gl::Context *context = gl::getContext();
2945
2946 if(context)
2947 {
2948 gl::Shader *shaderObject = context->getShader(shader);
2949
2950 if(!shaderObject)
2951 {
2952 return error(GL_INVALID_VALUE);
2953 }
2954
2955 shaderObject->getInfoLog(bufsize, length, infolog);
2956 }
2957 }
2958
glGetShaderPrecisionFormat(GLenum shadertype,GLenum precisiontype,GLint * range,GLint * precision)2959 void APIENTRY glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
2960 {
2961 TRACE("(GLenum shadertype = 0x%X, GLenum precisiontype = 0x%X, GLint* range = %p, GLint* precision = %p)",
2962 shadertype, precisiontype, range, precision);
2963
2964 switch(shadertype)
2965 {
2966 case GL_VERTEX_SHADER:
2967 case GL_FRAGMENT_SHADER:
2968 break;
2969 default:
2970 return error(GL_INVALID_ENUM);
2971 }
2972
2973 switch(precisiontype)
2974 {
2975 case GL_LOW_FLOAT:
2976 case GL_MEDIUM_FLOAT:
2977 case GL_HIGH_FLOAT:
2978 // IEEE 754 single-precision
2979 range[0] = 127;
2980 range[1] = 127;
2981 *precision = 23;
2982 break;
2983 case GL_LOW_INT:
2984 case GL_MEDIUM_INT:
2985 case GL_HIGH_INT:
2986 // Full integer precision is supported
2987 range[0] = 31;
2988 range[1] = 30;
2989 *precision = 0;
2990 break;
2991 default:
2992 return error(GL_INVALID_ENUM);
2993 }
2994 }
2995
glGetShaderSource(GLuint shader,GLsizei bufsize,GLsizei * length,GLchar * source)2996 void APIENTRY glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source)
2997 {
2998 TRACE("(GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = %p, GLchar* source = %p)",
2999 shader, bufsize, length, source);
3000
3001 if(bufsize < 0)
3002 {
3003 return error(GL_INVALID_VALUE);
3004 }
3005
3006 gl::Context *context = gl::getContext();
3007
3008 if(context)
3009 {
3010 gl::Shader *shaderObject = context->getShader(shader);
3011
3012 if(!shaderObject)
3013 {
3014 return error(GL_INVALID_OPERATION);
3015 }
3016
3017 shaderObject->getSource(bufsize, length, source);
3018 }
3019 }
3020
glGetString(GLenum name)3021 const GLubyte* APIENTRY glGetString(GLenum name)
3022 {
3023 TRACE("(GLenum name = 0x%X)", name);
3024
3025 switch(name)
3026 {
3027 case GL_VENDOR:
3028 return (GLubyte*)"Google Inc.";
3029 case GL_RENDERER:
3030 return (GLubyte*)"SwiftShader";
3031 case GL_VERSION:
3032 return (GLubyte*)"2.1 SwiftShader " VERSION_STRING;
3033 case GL_SHADING_LANGUAGE_VERSION:
3034 return (GLubyte*)"3.30 SwiftShader " VERSION_STRING;
3035 case GL_EXTENSIONS:
3036 // Keep list sorted in following order:
3037 // OES extensions
3038 // EXT extensions
3039 // Vendor extensions
3040 return (GLubyte*)
3041 "GL_ARB_framebuffer_object "
3042 "GL_EXT_blend_minmax "
3043 "GL_EXT_depth_texture "
3044 "GL_EXT_depth_texture_cube_map "
3045 "GL_EXT_element_index_uint "
3046 "GL_EXT_packed_depth_stencil "
3047 "GL_EXT_rgb8_rgba8 "
3048 "GL_EXT_standard_derivatives "
3049 "GL_EXT_texture_float "
3050 "GL_EXT_texture_float_linear "
3051 "GL_EXT_texture_half_float "
3052 "GL_EXT_texture_half_float_linear "
3053 "GL_EXT_texture_npot "
3054 "GL_EXT_occlusion_query_boolean "
3055 "GL_EXT_read_format_bgra "
3056 "GL_EXT_texture_compression_dxt1 "
3057 "GL_EXT_blend_func_separate "
3058 "GL_EXT_secondary_color "
3059 "GL_EXT_texture_filter_anisotropic "
3060 "GL_EXT_texture_format_BGRA8888 "
3061 "GL_EXT_framebuffer_blit "
3062 "GL_EXT_framebuffer_multisample "
3063 "GL_EXT_texture_compression_dxt3 "
3064 "GL_EXT_texture_compression_dxt5 "
3065 "GL_NV_fence";
3066 default:
3067 return error(GL_INVALID_ENUM, (GLubyte*)nullptr);
3068 }
3069
3070 return nullptr;
3071 }
3072
glGetTexParameterfv(GLenum target,GLenum pname,GLfloat * params)3073 void APIENTRY glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
3074 {
3075 TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat* params = %p)", target, pname, params);
3076
3077 gl::Context *context = gl::getContext();
3078
3079 if(context)
3080 {
3081 gl::Texture *texture;
3082
3083 switch(target)
3084 {
3085 case GL_TEXTURE_2D:
3086 texture = context->getTexture2D(target);
3087 break;
3088 case GL_TEXTURE_CUBE_MAP:
3089 texture = context->getTextureCubeMap();
3090 break;
3091 default:
3092 return error(GL_INVALID_ENUM);
3093 }
3094
3095 switch(pname)
3096 {
3097 case GL_TEXTURE_MAG_FILTER:
3098 *params = (GLfloat)texture->getMagFilter();
3099 break;
3100 case GL_TEXTURE_MIN_FILTER:
3101 *params = (GLfloat)texture->getMinFilter();
3102 break;
3103 case GL_TEXTURE_WRAP_S:
3104 *params = (GLfloat)texture->getWrapS();
3105 break;
3106 case GL_TEXTURE_WRAP_T:
3107 *params = (GLfloat)texture->getWrapT();
3108 break;
3109 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
3110 *params = texture->getMaxAnisotropy();
3111 break;
3112 default:
3113 return error(GL_INVALID_ENUM);
3114 }
3115 }
3116 }
3117
glGetTexParameteriv(GLenum target,GLenum pname,GLint * params)3118 void APIENTRY glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
3119 {
3120 TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = %p)", target, pname, params);
3121
3122 gl::Context *context = gl::getContext();
3123
3124 if(context)
3125 {
3126 gl::Texture *texture;
3127
3128 switch(target)
3129 {
3130 case GL_TEXTURE_2D:
3131 texture = context->getTexture2D(target);
3132 break;
3133 case GL_TEXTURE_CUBE_MAP:
3134 texture = context->getTextureCubeMap();
3135 break;
3136 default:
3137 return error(GL_INVALID_ENUM);
3138 }
3139
3140 switch(pname)
3141 {
3142 case GL_TEXTURE_MAG_FILTER:
3143 *params = texture->getMagFilter();
3144 break;
3145 case GL_TEXTURE_MIN_FILTER:
3146 *params = texture->getMinFilter();
3147 break;
3148 case GL_TEXTURE_WRAP_S:
3149 *params = texture->getWrapS();
3150 break;
3151 case GL_TEXTURE_WRAP_T:
3152 *params = texture->getWrapT();
3153 break;
3154 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
3155 *params = (GLint)texture->getMaxAnisotropy();
3156 break;
3157 default:
3158 return error(GL_INVALID_ENUM);
3159 }
3160 }
3161 }
3162
glGetnUniformfvEXT(GLuint program,GLint location,GLsizei bufSize,GLfloat * params)3163 void APIENTRY glGetnUniformfvEXT(GLuint program, GLint location, GLsizei bufSize, GLfloat* params)
3164 {
3165 TRACE("(GLuint program = %d, GLint location = %d, GLsizei bufSize = %d, GLfloat* params = %p)",
3166 program, location, bufSize, params);
3167
3168 if(bufSize < 0)
3169 {
3170 return error(GL_INVALID_VALUE);
3171 }
3172
3173 gl::Context *context = gl::getContext();
3174
3175 if(context)
3176 {
3177 if(program == 0)
3178 {
3179 return error(GL_INVALID_VALUE);
3180 }
3181
3182 gl::Program *programObject = context->getProgram(program);
3183
3184 if(!programObject || !programObject->isLinked())
3185 {
3186 return error(GL_INVALID_OPERATION);
3187 }
3188
3189 if(!programObject->getUniformfv(location, &bufSize, params))
3190 {
3191 return error(GL_INVALID_OPERATION);
3192 }
3193 }
3194 }
3195
glGetUniformfv(GLuint program,GLint location,GLfloat * params)3196 void APIENTRY glGetUniformfv(GLuint program, GLint location, GLfloat* params)
3197 {
3198 TRACE("(GLuint program = %d, GLint location = %d, GLfloat* params = %p)", program, location, params);
3199
3200 gl::Context *context = gl::getContext();
3201
3202 if(context)
3203 {
3204 if(program == 0)
3205 {
3206 return error(GL_INVALID_VALUE);
3207 }
3208
3209 gl::Program *programObject = context->getProgram(program);
3210
3211 if(!programObject || !programObject->isLinked())
3212 {
3213 return error(GL_INVALID_OPERATION);
3214 }
3215
3216 if(!programObject->getUniformfv(location, nullptr, params))
3217 {
3218 return error(GL_INVALID_OPERATION);
3219 }
3220 }
3221 }
3222
glGetnUniformivEXT(GLuint program,GLint location,GLsizei bufSize,GLint * params)3223 void APIENTRY glGetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint* params)
3224 {
3225 TRACE("(GLuint program = %d, GLint location = %d, GLsizei bufSize = %d, GLint* params = %p)",
3226 program, location, bufSize, params);
3227
3228 if(bufSize < 0)
3229 {
3230 return error(GL_INVALID_VALUE);
3231 }
3232
3233 gl::Context *context = gl::getContext();
3234
3235 if(context)
3236 {
3237 if(program == 0)
3238 {
3239 return error(GL_INVALID_VALUE);
3240 }
3241
3242 gl::Program *programObject = context->getProgram(program);
3243
3244 if(!programObject || !programObject->isLinked())
3245 {
3246 return error(GL_INVALID_OPERATION);
3247 }
3248
3249 if(!programObject)
3250 {
3251 return error(GL_INVALID_OPERATION);
3252 }
3253
3254 if(!programObject->getUniformiv(location, &bufSize, params))
3255 {
3256 return error(GL_INVALID_OPERATION);
3257 }
3258 }
3259 }
3260
glGetUniformiv(GLuint program,GLint location,GLint * params)3261 void APIENTRY glGetUniformiv(GLuint program, GLint location, GLint* params)
3262 {
3263 TRACE("(GLuint program = %d, GLint location = %d, GLint* params = %p)", program, location, params);
3264
3265 gl::Context *context = gl::getContext();
3266
3267 if(context)
3268 {
3269 if(program == 0)
3270 {
3271 return error(GL_INVALID_VALUE);
3272 }
3273
3274 gl::Program *programObject = context->getProgram(program);
3275
3276 if(!programObject || !programObject->isLinked())
3277 {
3278 return error(GL_INVALID_OPERATION);
3279 }
3280
3281 if(!programObject)
3282 {
3283 return error(GL_INVALID_OPERATION);
3284 }
3285
3286 if(!programObject->getUniformiv(location, nullptr, params))
3287 {
3288 return error(GL_INVALID_OPERATION);
3289 }
3290 }
3291 }
3292
glGetUniformLocation(GLuint program,const GLchar * name)3293 int APIENTRY glGetUniformLocation(GLuint program, const GLchar* name)
3294 {
3295 TRACE("(GLuint program = %d, const GLchar* name = %s)", program, name);
3296
3297 gl::Context *context = gl::getContext();
3298
3299 if(strstr(name, "gl_") == name)
3300 {
3301 return -1;
3302 }
3303
3304 if(context)
3305 {
3306 gl::Program *programObject = context->getProgram(program);
3307
3308 if(!programObject)
3309 {
3310 if(context->getShader(program))
3311 {
3312 return error(GL_INVALID_OPERATION, -1);
3313 }
3314 else
3315 {
3316 return error(GL_INVALID_VALUE, -1);
3317 }
3318 }
3319
3320 if(!programObject->isLinked())
3321 {
3322 return error(GL_INVALID_OPERATION, -1);
3323 }
3324
3325 return programObject->getUniformLocation(name);
3326 }
3327
3328 return -1;
3329 }
3330
glGetVertexAttribfv(GLuint index,GLenum pname,GLfloat * params)3331 void APIENTRY glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
3332 {
3333 TRACE("(GLuint index = %d, GLenum pname = 0x%X, GLfloat* params = %p)", index, pname, params);
3334
3335 gl::Context *context = gl::getContext();
3336
3337 if(context)
3338 {
3339 if(index >= gl::MAX_VERTEX_ATTRIBS)
3340 {
3341 return error(GL_INVALID_VALUE);
3342 }
3343
3344 const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
3345
3346 switch(pname)
3347 {
3348 case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
3349 *params = (GLfloat)(attribState.mArrayEnabled ? GL_TRUE : GL_FALSE);
3350 break;
3351 case GL_VERTEX_ATTRIB_ARRAY_SIZE:
3352 *params = (GLfloat)attribState.mSize;
3353 break;
3354 case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
3355 *params = (GLfloat)attribState.mStride;
3356 break;
3357 case GL_VERTEX_ATTRIB_ARRAY_TYPE:
3358 *params = (GLfloat)attribState.mType;
3359 break;
3360 case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
3361 *params = (GLfloat)(attribState.mNormalized ? GL_TRUE : GL_FALSE);
3362 break;
3363 case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
3364 *params = (GLfloat)attribState.mBoundBuffer.name();
3365 break;
3366 case GL_CURRENT_VERTEX_ATTRIB:
3367 for(int i = 0; i < 4; ++i)
3368 {
3369 params[i] = attribState.mCurrentValue[i];
3370 }
3371 break;
3372 default: return error(GL_INVALID_ENUM);
3373 }
3374 }
3375 }
3376
glGetVertexAttribiv(GLuint index,GLenum pname,GLint * params)3377 void APIENTRY glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
3378 {
3379 TRACE("(GLuint index = %d, GLenum pname = 0x%X, GLint* params = %p)", index, pname, params);
3380
3381 gl::Context *context = gl::getContext();
3382
3383 if(context)
3384 {
3385 if(index >= gl::MAX_VERTEX_ATTRIBS)
3386 {
3387 return error(GL_INVALID_VALUE);
3388 }
3389
3390 const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
3391
3392 switch(pname)
3393 {
3394 case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
3395 *params = (attribState.mArrayEnabled ? GL_TRUE : GL_FALSE);
3396 break;
3397 case GL_VERTEX_ATTRIB_ARRAY_SIZE:
3398 *params = attribState.mSize;
3399 break;
3400 case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
3401 *params = attribState.mStride;
3402 break;
3403 case GL_VERTEX_ATTRIB_ARRAY_TYPE:
3404 *params = attribState.mType;
3405 break;
3406 case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
3407 *params = (attribState.mNormalized ? GL_TRUE : GL_FALSE);
3408 break;
3409 case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
3410 *params = attribState.mBoundBuffer.name();
3411 break;
3412 case GL_CURRENT_VERTEX_ATTRIB:
3413 for(int i = 0; i < 4; ++i)
3414 {
3415 float currentValue = attribState.mCurrentValue[i];
3416 params[i] = (GLint)(currentValue > 0.0f ? floor(currentValue + 0.5f) : ceil(currentValue - 0.5f));
3417 }
3418 break;
3419 default: return error(GL_INVALID_ENUM);
3420 }
3421 }
3422 }
3423
glGetVertexAttribPointerv(GLuint index,GLenum pname,GLvoid ** pointer)3424 void APIENTRY glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer)
3425 {
3426 TRACE("(GLuint index = %d, GLenum pname = 0x%X, GLvoid** pointer = %p)", index, pname, pointer);
3427
3428 gl::Context *context = gl::getContext();
3429
3430 if(context)
3431 {
3432 if(index >= gl::MAX_VERTEX_ATTRIBS)
3433 {
3434 return error(GL_INVALID_VALUE);
3435 }
3436
3437 if(pname != GL_VERTEX_ATTRIB_ARRAY_POINTER)
3438 {
3439 return error(GL_INVALID_ENUM);
3440 }
3441
3442 *pointer = const_cast<GLvoid*>(context->getVertexAttribPointer(index));
3443 }
3444 }
3445
glHint(GLenum target,GLenum mode)3446 void APIENTRY glHint(GLenum target, GLenum mode)
3447 {
3448 TRACE("(GLenum target = 0x%X, GLenum mode = 0x%X)", target, mode);
3449
3450 switch(mode)
3451 {
3452 case GL_FASTEST:
3453 case GL_NICEST:
3454 case GL_DONT_CARE:
3455 break;
3456 default:
3457 return error(GL_INVALID_ENUM);
3458 }
3459
3460 gl::Context *context = gl::getContext();
3461 switch(target)
3462 {
3463 case GL_GENERATE_MIPMAP_HINT:
3464 if(context) context->setGenerateMipmapHint(mode);
3465 break;
3466 case GL_FRAGMENT_SHADER_DERIVATIVE_HINT:
3467 if(context) context->setFragmentShaderDerivativeHint(mode);
3468 break;
3469 default:
3470 return error(GL_INVALID_ENUM);
3471 }
3472 }
3473
glIsBuffer(GLuint buffer)3474 GLboolean APIENTRY glIsBuffer(GLuint buffer)
3475 {
3476 TRACE("(GLuint buffer = %d)", buffer);
3477
3478 gl::Context *context = gl::getContext();
3479
3480 if(context && buffer)
3481 {
3482 gl::Buffer *bufferObject = context->getBuffer(buffer);
3483
3484 if(bufferObject)
3485 {
3486 return GL_TRUE;
3487 }
3488 }
3489
3490 return GL_FALSE;
3491 }
3492
glIsEnabled(GLenum cap)3493 GLboolean APIENTRY glIsEnabled(GLenum cap)
3494 {
3495 TRACE("(GLenum cap = 0x%X)", cap);
3496
3497 gl::Context *context = gl::getContext();
3498
3499 if(context)
3500 {
3501 switch(cap)
3502 {
3503 case GL_CULL_FACE: return context->isCullFaceEnabled();
3504 case GL_POLYGON_OFFSET_FILL: return context->isPolygonOffsetFillEnabled();
3505 case GL_SAMPLE_ALPHA_TO_COVERAGE: return context->isSampleAlphaToCoverageEnabled();
3506 case GL_SAMPLE_COVERAGE: return context->isSampleCoverageEnabled();
3507 case GL_SCISSOR_TEST: return context->isScissorTestEnabled();
3508 case GL_STENCIL_TEST: return context->isStencilTestEnabled();
3509 case GL_DEPTH_TEST: return context->isDepthTestEnabled();
3510 case GL_BLEND: return context->isBlendEnabled();
3511 case GL_DITHER: return context->isDitherEnabled();
3512 case GL_COLOR_LOGIC_OP: return context->isColorLogicOpEnabled();
3513 case GL_INDEX_LOGIC_OP: UNIMPLEMENTED();
3514 default:
3515 return error(GL_INVALID_ENUM, false);
3516 }
3517 }
3518
3519 return false;
3520 }
3521
glIsFenceNV(GLuint fence)3522 GLboolean APIENTRY glIsFenceNV(GLuint fence)
3523 {
3524 TRACE("(GLuint fence = %d)", fence);
3525
3526 gl::Context *context = gl::getContext();
3527
3528 if(context)
3529 {
3530 gl::Fence *fenceObject = context->getFence(fence);
3531
3532 if(!fenceObject)
3533 {
3534 return GL_FALSE;
3535 }
3536
3537 return fenceObject->isFence();
3538 }
3539
3540 return GL_FALSE;
3541 }
3542
glIsFramebuffer(GLuint framebuffer)3543 GLboolean APIENTRY glIsFramebuffer(GLuint framebuffer)
3544 {
3545 TRACE("(GLuint framebuffer = %d)", framebuffer);
3546
3547 gl::Context *context = gl::getContext();
3548
3549 if(context && framebuffer)
3550 {
3551 gl::Framebuffer *framebufferObject = context->getFramebuffer(framebuffer);
3552
3553 if(framebufferObject)
3554 {
3555 return GL_TRUE;
3556 }
3557 }
3558
3559 return GL_FALSE;
3560 }
3561
glIsProgram(GLuint program)3562 GLboolean APIENTRY glIsProgram(GLuint program)
3563 {
3564 TRACE("(GLuint program = %d)", program);
3565
3566 gl::Context *context = gl::getContext();
3567
3568 if(context && program)
3569 {
3570 gl::Program *programObject = context->getProgram(program);
3571
3572 if(programObject)
3573 {
3574 return GL_TRUE;
3575 }
3576 }
3577
3578 return GL_FALSE;
3579 }
3580
glIsQueryEXT(GLuint name)3581 GLboolean APIENTRY glIsQueryEXT(GLuint name)
3582 {
3583 TRACE("(GLuint name = %d)", name);
3584
3585 if(name == 0)
3586 {
3587 return GL_FALSE;
3588 }
3589
3590 gl::Context *context = gl::getContext();
3591
3592 if(context)
3593 {
3594 gl::Query *queryObject = context->getQuery(name, false, GL_NONE);
3595
3596 if(queryObject)
3597 {
3598 return GL_TRUE;
3599 }
3600 }
3601
3602 return GL_FALSE;
3603 }
3604
glIsRenderbuffer(GLuint renderbuffer)3605 GLboolean APIENTRY glIsRenderbuffer(GLuint renderbuffer)
3606 {
3607 TRACE("(GLuint renderbuffer = %d)", renderbuffer);
3608
3609 gl::Context *context = gl::getContext();
3610
3611 if(context && renderbuffer)
3612 {
3613 gl::Renderbuffer *renderbufferObject = context->getRenderbuffer(renderbuffer);
3614
3615 if(renderbufferObject)
3616 {
3617 return GL_TRUE;
3618 }
3619 }
3620
3621 return GL_FALSE;
3622 }
3623
glIsShader(GLuint shader)3624 GLboolean APIENTRY glIsShader(GLuint shader)
3625 {
3626 TRACE("(GLuint shader = %d)", shader);
3627
3628 gl::Context *context = gl::getContext();
3629
3630 if(context && shader)
3631 {
3632 gl::Shader *shaderObject = context->getShader(shader);
3633
3634 if(shaderObject)
3635 {
3636 return GL_TRUE;
3637 }
3638 }
3639
3640 return GL_FALSE;
3641 }
3642
glIsTexture(GLuint texture)3643 GLboolean APIENTRY glIsTexture(GLuint texture)
3644 {
3645 TRACE("(GLuint texture = %d)", texture);
3646
3647 gl::Context *context = gl::getContext();
3648
3649 if(context && texture)
3650 {
3651 gl::Texture *textureObject = context->getTexture(texture);
3652
3653 if(textureObject)
3654 {
3655 return GL_TRUE;
3656 }
3657 }
3658
3659 return GL_FALSE;
3660 }
3661
glLineWidth(GLfloat width)3662 void APIENTRY glLineWidth(GLfloat width)
3663 {
3664 TRACE("(GLfloat width = %f)", width);
3665
3666 if(width <= 0.0f)
3667 {
3668 return error(GL_INVALID_VALUE);
3669 }
3670
3671 gl::Context *context = gl::getContext();
3672
3673 if(context)
3674 {
3675 if(context->getListIndex() != 0)
3676 {
3677 UNIMPLEMENTED();
3678 }
3679
3680 context->setLineWidth(width);
3681 }
3682 }
3683
glLinkProgram(GLuint program)3684 void APIENTRY glLinkProgram(GLuint program)
3685 {
3686 TRACE("(GLuint program = %d)", program);
3687
3688 gl::Context *context = gl::getContext();
3689
3690 if(context)
3691 {
3692 gl::Program *programObject = context->getProgram(program);
3693
3694 if(!programObject)
3695 {
3696 if(context->getShader(program))
3697 {
3698 return error(GL_INVALID_OPERATION);
3699 }
3700 else
3701 {
3702 return error(GL_INVALID_VALUE);
3703 }
3704 }
3705
3706 programObject->link();
3707 }
3708 }
3709
glPixelStorei(GLenum pname,GLint param)3710 void APIENTRY glPixelStorei(GLenum pname, GLint param)
3711 {
3712 TRACE("(GLenum pname = 0x%X, GLint param = %d)", pname, param);
3713
3714 gl::Context *context = gl::getContext();
3715
3716 if(context)
3717 {
3718 switch(pname)
3719 {
3720 case GL_UNPACK_ALIGNMENT:
3721 if(param != 1 && param != 2 && param != 4 && param != 8)
3722 {
3723 return error(GL_INVALID_VALUE);
3724 }
3725 context->setUnpackAlignment(param);
3726 break;
3727 case GL_PACK_ALIGNMENT:
3728 if(param != 1 && param != 2 && param != 4 && param != 8)
3729 {
3730 return error(GL_INVALID_VALUE);
3731 }
3732 context->setPackAlignment(param);
3733 break;
3734 default:
3735 return error(GL_INVALID_ENUM);
3736 }
3737 }
3738 }
3739
glPolygonOffset(GLfloat factor,GLfloat units)3740 void APIENTRY glPolygonOffset(GLfloat factor, GLfloat units)
3741 {
3742 TRACE("(GLfloat factor = %f, GLfloat units = %f)", factor, units);
3743
3744 gl::Context *context = gl::getContext();
3745
3746 if(context)
3747 {
3748 if(context->getListIndex() != 0)
3749 {
3750 UNIMPLEMENTED();
3751 }
3752
3753 context->setPolygonOffsetParams(factor, units);
3754 }
3755 }
3756
glReadnPixelsEXT(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,GLvoid * data)3757 void APIENTRY glReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height,
3758 GLenum format, GLenum type, GLsizei bufSize, GLvoid *data)
3759 {
3760 TRACE("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
3761 "GLenum format = 0x%X, GLenum type = 0x%X, GLsizei bufSize = 0x%d, GLvoid *data = %p)",
3762 x, y, width, height, format, type, bufSize, data);
3763
3764 if(width < 0 || height < 0 || bufSize < 0)
3765 {
3766 return error(GL_INVALID_VALUE);
3767 }
3768
3769 if(!validReadFormatType(format, type))
3770 {
3771 return error(GL_INVALID_OPERATION);
3772 }
3773
3774 gl::Context *context = gl::getContext();
3775
3776 if(context)
3777 {
3778 if(context->getListIndex() != 0)
3779 {
3780 UNIMPLEMENTED();
3781 }
3782
3783 context->readPixels(x, y, width, height, format, type, &bufSize, data);
3784 }
3785 }
3786
glReadPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLvoid * pixels)3787 void APIENTRY glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
3788 {
3789 TRACE("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
3790 "GLenum format = 0x%X, GLenum type = 0x%X, GLvoid* pixels = %p)",
3791 x, y, width, height, format, type, pixels);
3792
3793 if(width < 0 || height < 0)
3794 {
3795 return error(GL_INVALID_VALUE);
3796 }
3797
3798 if(!validReadFormatType(format, type))
3799 {
3800 return error(GL_INVALID_OPERATION);
3801 }
3802
3803 gl::Context *context = gl::getContext();
3804
3805 if(context)
3806 {
3807 context->readPixels(x, y, width, height, format, type, nullptr, pixels);
3808 }
3809 }
3810
glReleaseShaderCompiler(void)3811 void APIENTRY glReleaseShaderCompiler(void)
3812 {
3813 TRACE("()");
3814
3815 gl::Shader::releaseCompiler();
3816 }
3817
glRenderbufferStorageMultisampleANGLE(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)3818 void APIENTRY glRenderbufferStorageMultisampleANGLE(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
3819 {
3820 TRACE("(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = %d)",
3821 target, samples, internalformat, width, height);
3822
3823 switch(target)
3824 {
3825 case GL_RENDERBUFFER:
3826 break;
3827 default:
3828 return error(GL_INVALID_ENUM);
3829 }
3830
3831 if(!gl::IsColorRenderable(internalformat) && !gl::IsDepthRenderable(internalformat) && !gl::IsStencilRenderable(internalformat))
3832 {
3833 return error(GL_INVALID_ENUM);
3834 }
3835
3836 if(width < 0 || height < 0 || samples < 0)
3837 {
3838 return error(GL_INVALID_VALUE);
3839 }
3840
3841 gl::Context *context = gl::getContext();
3842
3843 if(context)
3844 {
3845 if(context->getListIndex() != 0)
3846 {
3847 UNIMPLEMENTED();
3848 }
3849
3850 if(width > gl::IMPLEMENTATION_MAX_RENDERBUFFER_SIZE ||
3851 height > gl::IMPLEMENTATION_MAX_RENDERBUFFER_SIZE ||
3852 samples > gl::IMPLEMENTATION_MAX_SAMPLES)
3853 {
3854 return error(GL_INVALID_VALUE);
3855 }
3856
3857 GLuint handle = context->getRenderbufferName();
3858 if(handle == 0)
3859 {
3860 return error(GL_INVALID_OPERATION);
3861 }
3862
3863 switch(internalformat)
3864 {
3865 case GL_DEPTH_COMPONENT16:
3866 case GL_DEPTH_COMPONENT24:
3867 context->setRenderbufferStorage(new gl::Depthbuffer(width, height, samples));
3868 break;
3869 case GL_RGBA4:
3870 case GL_RGB5_A1:
3871 case GL_RGB565:
3872 case GL_RGB8_EXT:
3873 case GL_RGBA8_EXT:
3874 context->setRenderbufferStorage(new gl::Colorbuffer(width, height, internalformat, samples));
3875 break;
3876 case GL_STENCIL_INDEX8:
3877 context->setRenderbufferStorage(new gl::Stencilbuffer(width, height, samples));
3878 break;
3879 case GL_DEPTH24_STENCIL8_EXT:
3880 context->setRenderbufferStorage(new gl::DepthStencilbuffer(width, height, samples));
3881 break;
3882 default:
3883 return error(GL_INVALID_ENUM);
3884 }
3885 }
3886 }
3887
glRenderbufferStorage(GLenum target,GLenum internalformat,GLsizei width,GLsizei height)3888 void APIENTRY glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
3889 {
3890 glRenderbufferStorageMultisampleANGLE(target, 0, internalformat, width, height);
3891 }
3892
glSampleCoverage(GLclampf value,GLboolean invert)3893 void APIENTRY glSampleCoverage(GLclampf value, GLboolean invert)
3894 {
3895 TRACE("(GLclampf value = %f, GLboolean invert = %d)", value, invert);
3896
3897 gl::Context* context = gl::getContext();
3898
3899 if(context)
3900 {
3901 if(context->getListIndex() != 0)
3902 {
3903 UNIMPLEMENTED();
3904 }
3905
3906 context->setSampleCoverageParams(gl::clamp01(value), invert == GL_TRUE);
3907 }
3908 }
3909
glSetFenceNV(GLuint fence,GLenum condition)3910 void APIENTRY glSetFenceNV(GLuint fence, GLenum condition)
3911 {
3912 TRACE("(GLuint fence = %d, GLenum condition = 0x%X)", fence, condition);
3913
3914 if(condition != GL_ALL_COMPLETED_NV)
3915 {
3916 return error(GL_INVALID_ENUM);
3917 }
3918
3919 gl::Context *context = gl::getContext();
3920
3921 if(context)
3922 {
3923 if(context->getListIndex() != 0)
3924 {
3925 UNIMPLEMENTED();
3926 }
3927
3928 gl::Fence *fenceObject = context->getFence(fence);
3929
3930 if(!fenceObject)
3931 {
3932 return error(GL_INVALID_OPERATION);
3933 }
3934
3935 fenceObject->setFence(condition);
3936 }
3937 }
3938
glScissor(GLint x,GLint y,GLsizei width,GLsizei height)3939 void APIENTRY glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
3940 {
3941 TRACE("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)", x, y, width, height);
3942
3943 if(width < 0 || height < 0)
3944 {
3945 return error(GL_INVALID_VALUE);
3946 }
3947
3948 gl::Context* context = gl::getContext();
3949
3950 if(context)
3951 {
3952 if(context->getListIndex() != 0)
3953 {
3954 UNIMPLEMENTED();
3955 }
3956
3957 context->setScissorParams(x, y, width, height);
3958 }
3959 }
3960
glShaderBinary(GLsizei n,const GLuint * shaders,GLenum binaryformat,const GLvoid * binary,GLsizei length)3961 void APIENTRY glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length)
3962 {
3963 TRACE("(GLsizei n = %d, const GLuint* shaders = %p, GLenum binaryformat = 0x%X, "
3964 "const GLvoid* binary = %p, GLsizei length = %d)",
3965 n, shaders, binaryformat, binary, length);
3966
3967 // No binary shader formats are supported.
3968 return error(GL_INVALID_ENUM);
3969 }
3970
glShaderSource(GLuint shader,GLsizei count,const GLchar * const * string,const GLint * length)3971 void APIENTRY glShaderSource(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length)
3972 {
3973 TRACE("(GLuint shader = %d, GLsizei count = %d, const GLchar** string = %p, const GLint* length = %p)",
3974 shader, count, string, length);
3975
3976 if(count < 0)
3977 {
3978 return error(GL_INVALID_VALUE);
3979 }
3980
3981 gl::Context *context = gl::getContext();
3982
3983 if(context)
3984 {
3985 if(context->getListIndex() != 0)
3986 {
3987 UNIMPLEMENTED();
3988 }
3989
3990 gl::Shader *shaderObject = context->getShader(shader);
3991
3992 if(!shaderObject)
3993 {
3994 if(context->getProgram(shader))
3995 {
3996 return error(GL_INVALID_OPERATION);
3997 }
3998 else
3999 {
4000 return error(GL_INVALID_VALUE);
4001 }
4002 }
4003
4004 shaderObject->setSource(count, string, length);
4005 }
4006 }
4007
glStencilFunc(GLenum func,GLint ref,GLuint mask)4008 void APIENTRY glStencilFunc(GLenum func, GLint ref, GLuint mask)
4009 {
4010 glStencilFuncSeparate(GL_FRONT_AND_BACK, func, ref, mask);
4011 }
4012
glStencilFuncSeparate(GLenum face,GLenum func,GLint ref,GLuint mask)4013 void APIENTRY glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
4014 {
4015 TRACE("(GLenum face = 0x%X, GLenum func = 0x%X, GLint ref = %d, GLuint mask = %d)", face, func, ref, mask);
4016
4017 switch(face)
4018 {
4019 case GL_FRONT:
4020 case GL_BACK:
4021 case GL_FRONT_AND_BACK:
4022 break;
4023 default:
4024 return error(GL_INVALID_ENUM);
4025 }
4026
4027 switch(func)
4028 {
4029 case GL_NEVER:
4030 case GL_ALWAYS:
4031 case GL_LESS:
4032 case GL_LEQUAL:
4033 case GL_EQUAL:
4034 case GL_GEQUAL:
4035 case GL_GREATER:
4036 case GL_NOTEQUAL:
4037 break;
4038 default:
4039 return error(GL_INVALID_ENUM);
4040 }
4041
4042 gl::Context *context = gl::getContext();
4043
4044 if(context)
4045 {
4046 if(context->getListIndex() != 0)
4047 {
4048 UNIMPLEMENTED();
4049 }
4050
4051 if(face == GL_FRONT || face == GL_FRONT_AND_BACK)
4052 {
4053 context->setStencilParams(func, ref, mask);
4054 }
4055
4056 if(face == GL_BACK || face == GL_FRONT_AND_BACK)
4057 {
4058 context->setStencilBackParams(func, ref, mask);
4059 }
4060 }
4061 }
4062
glStencilMask(GLuint mask)4063 void APIENTRY glStencilMask(GLuint mask)
4064 {
4065 glStencilMaskSeparate(GL_FRONT_AND_BACK, mask);
4066 }
4067
glStencilMaskSeparate(GLenum face,GLuint mask)4068 void APIENTRY glStencilMaskSeparate(GLenum face, GLuint mask)
4069 {
4070 TRACE("(GLenum face = 0x%X, GLuint mask = %d)", face, mask);
4071
4072 switch(face)
4073 {
4074 case GL_FRONT:
4075 case GL_BACK:
4076 case GL_FRONT_AND_BACK:
4077 break;
4078 default:
4079 return error(GL_INVALID_ENUM);
4080 }
4081
4082 gl::Context *context = gl::getContext();
4083
4084 if(context)
4085 {
4086 if(context->getListIndex() != 0)
4087 {
4088 UNIMPLEMENTED();
4089 }
4090
4091 if(face == GL_FRONT || face == GL_FRONT_AND_BACK)
4092 {
4093 context->setStencilWritemask(mask);
4094 }
4095
4096 if(face == GL_BACK || face == GL_FRONT_AND_BACK)
4097 {
4098 context->setStencilBackWritemask(mask);
4099 }
4100 }
4101 }
4102
glStencilOp(GLenum fail,GLenum zfail,GLenum zpass)4103 void APIENTRY glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
4104 {
4105 glStencilOpSeparate(GL_FRONT_AND_BACK, fail, zfail, zpass);
4106 }
4107
glStencilOpSeparate(GLenum face,GLenum fail,GLenum zfail,GLenum zpass)4108 void APIENTRY glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
4109 {
4110 TRACE("(GLenum face = 0x%X, GLenum fail = 0x%X, GLenum zfail = 0x%X, GLenum zpas = 0x%Xs)",
4111 face, fail, zfail, zpass);
4112
4113 switch(face)
4114 {
4115 case GL_FRONT:
4116 case GL_BACK:
4117 case GL_FRONT_AND_BACK:
4118 break;
4119 default:
4120 return error(GL_INVALID_ENUM);
4121 }
4122
4123 switch(fail)
4124 {
4125 case GL_ZERO:
4126 case GL_KEEP:
4127 case GL_REPLACE:
4128 case GL_INCR:
4129 case GL_DECR:
4130 case GL_INVERT:
4131 case GL_INCR_WRAP:
4132 case GL_DECR_WRAP:
4133 break;
4134 default:
4135 return error(GL_INVALID_ENUM);
4136 }
4137
4138 switch(zfail)
4139 {
4140 case GL_ZERO:
4141 case GL_KEEP:
4142 case GL_REPLACE:
4143 case GL_INCR:
4144 case GL_DECR:
4145 case GL_INVERT:
4146 case GL_INCR_WRAP:
4147 case GL_DECR_WRAP:
4148 break;
4149 default:
4150 return error(GL_INVALID_ENUM);
4151 }
4152
4153 switch(zpass)
4154 {
4155 case GL_ZERO:
4156 case GL_KEEP:
4157 case GL_REPLACE:
4158 case GL_INCR:
4159 case GL_DECR:
4160 case GL_INVERT:
4161 case GL_INCR_WRAP:
4162 case GL_DECR_WRAP:
4163 break;
4164 default:
4165 return error(GL_INVALID_ENUM);
4166 }
4167
4168 gl::Context *context = gl::getContext();
4169
4170 if(context)
4171 {
4172 if(context->getListIndex() != 0)
4173 {
4174 UNIMPLEMENTED();
4175 }
4176
4177 if(face == GL_FRONT || face == GL_FRONT_AND_BACK)
4178 {
4179 context->setStencilOperations(fail, zfail, zpass);
4180 }
4181
4182 if(face == GL_BACK || face == GL_FRONT_AND_BACK)
4183 {
4184 context->setStencilBackOperations(fail, zfail, zpass);
4185 }
4186 }
4187 }
4188
glTestFenceNV(GLuint fence)4189 GLboolean APIENTRY glTestFenceNV(GLuint fence)
4190 {
4191 TRACE("(GLuint fence = %d)", fence);
4192
4193 gl::Context *context = gl::getContext();
4194
4195 if(context)
4196 {
4197 if(context->getListIndex() != 0)
4198 {
4199 UNIMPLEMENTED();
4200 }
4201
4202 gl::Fence *fenceObject = context->getFence(fence);
4203
4204 if(!fenceObject)
4205 {
4206 return error(GL_INVALID_OPERATION, GL_TRUE);
4207 }
4208
4209 return fenceObject->testFence();
4210 }
4211
4212 return GL_TRUE;
4213 }
4214
glTexImage2D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const GLvoid * pixels)4215 void APIENTRY glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
4216 GLint border, GLenum format, GLenum type, const GLvoid* pixels)
4217 {
4218 TRACE("(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, GLsizei height = %d, "
4219 "GLint border = %d, GLenum format = 0x%X, GLenum type = 0x%X, const GLvoid* pixels = %p)",
4220 target, level, internalformat, width, height, border, format, type, pixels);
4221
4222 if(!validImageSize(level, width, height))
4223 {
4224 return error(GL_INVALID_VALUE);
4225 }
4226
4227 if(internalformat != (GLint)format)
4228 {
4229 //TRACE("UNIMPLEMENTED!!");
4230 //return error(GL_INVALID_OPERATION);
4231 }
4232
4233 switch(format)
4234 {
4235 case GL_ALPHA:
4236 case GL_LUMINANCE:
4237 case GL_LUMINANCE_ALPHA:
4238 switch(type)
4239 {
4240 case GL_UNSIGNED_BYTE:
4241 case GL_FLOAT:
4242 case GL_HALF_FLOAT:
4243 break;
4244 default:
4245 return error(GL_INVALID_ENUM);
4246 }
4247 break;
4248 case GL_RGB:
4249 switch(type)
4250 {
4251 case GL_UNSIGNED_BYTE:
4252 case GL_UNSIGNED_SHORT_5_6_5:
4253 case GL_FLOAT:
4254 case GL_HALF_FLOAT:
4255 break;
4256 default:
4257 return error(GL_INVALID_ENUM);
4258 }
4259 break;
4260 case GL_RGBA:
4261 switch(type)
4262 {
4263 case GL_UNSIGNED_BYTE:
4264 case GL_UNSIGNED_SHORT_4_4_4_4:
4265 case GL_UNSIGNED_SHORT_5_5_5_1:
4266 case GL_FLOAT:
4267 case GL_HALF_FLOAT:
4268 break;
4269 default:
4270 return error(GL_INVALID_ENUM);
4271 }
4272 break;
4273 case GL_BGRA_EXT:
4274 switch(type)
4275 {
4276 case GL_UNSIGNED_BYTE:
4277 case GL_UNSIGNED_SHORT_5_6_5:
4278 case GL_UNSIGNED_INT_8_8_8_8_REV:
4279 break;
4280 default:
4281 return error(GL_INVALID_ENUM);
4282 }
4283 break;
4284 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: // error cases for compressed textures are handled below
4285 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
4286 case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
4287 case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
4288 break;
4289 case GL_DEPTH_COMPONENT:
4290 switch(type)
4291 {
4292 case GL_UNSIGNED_SHORT:
4293 case GL_UNSIGNED_INT:
4294 break;
4295 default:
4296 return error(GL_INVALID_ENUM);
4297 }
4298 break;
4299 case GL_DEPTH_STENCIL_EXT:
4300 switch(type)
4301 {
4302 case GL_UNSIGNED_INT_24_8_EXT:
4303 break;
4304 default:
4305 return error(GL_INVALID_ENUM);
4306 }
4307 break;
4308 default:
4309 return error(GL_INVALID_VALUE);
4310 }
4311
4312 if(border != 0)
4313 {
4314 return error(GL_INVALID_VALUE);
4315 }
4316
4317 switch(target)
4318 {
4319 case GL_TEXTURE_2D:
4320 if(width > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level) ||
4321 height > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level))
4322 {
4323 return error(GL_INVALID_VALUE);
4324 }
4325 break;
4326 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
4327 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
4328 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
4329 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
4330 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
4331 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
4332 if(width != height)
4333 {
4334 return error(GL_INVALID_VALUE);
4335 }
4336
4337 if(width > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level) ||
4338 height > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level))
4339 {
4340 return error(GL_INVALID_VALUE);
4341 }
4342 break;
4343 case GL_PROXY_TEXTURE_2D:
4344 pixels = 0;
4345
4346 if(width > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level) ||
4347 height > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level))
4348 {
4349 //UNIMPLEMENTED();
4350 width = 0;
4351 height = 0;
4352 internalformat = GL_NONE;
4353 format = GL_NONE;
4354 type = GL_NONE;
4355
4356 //return;// error(GL_INVALID_VALUE);
4357 }
4358 break;
4359 default:
4360 return error(GL_INVALID_ENUM);
4361 }
4362
4363 if(format == GL_COMPRESSED_RGB_S3TC_DXT1_EXT ||
4364 format == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ||
4365 format == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ||
4366 format == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
4367 {
4368 return error(GL_INVALID_OPERATION);
4369 }
4370
4371 gl::Context *context = gl::getContext();
4372
4373 if(context)
4374 {
4375 if(context->getListIndex() != 0)
4376 {
4377 UNIMPLEMENTED();
4378 }
4379
4380 if(target == GL_TEXTURE_2D || target == GL_PROXY_TEXTURE_2D)
4381 {
4382 gl::Texture2D *texture = context->getTexture2D(target);
4383
4384 if(!texture)
4385 {
4386 return error(GL_INVALID_OPERATION);
4387 }
4388
4389 texture->setImage(level, width, height, format, type, context->getUnpackAlignment(), pixels);
4390 }
4391 else
4392 {
4393 gl::TextureCubeMap *texture = context->getTextureCubeMap();
4394
4395 if(!texture)
4396 {
4397 return error(GL_INVALID_OPERATION);
4398 }
4399
4400 texture->setImage(target, level, width, height, format, type, context->getUnpackAlignment(), pixels);
4401 }
4402 }
4403 }
4404
glTexParameterf(GLenum target,GLenum pname,GLfloat param)4405 void APIENTRY glTexParameterf(GLenum target, GLenum pname, GLfloat param)
4406 {
4407 TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat param = %f)", target, pname, param);
4408
4409 gl::Context *context = gl::getContext();
4410
4411 if(context)
4412 {
4413 if(context->getListIndex() != 0)
4414 {
4415 UNIMPLEMENTED();
4416 }
4417
4418 gl::Texture *texture;
4419
4420 switch(target)
4421 {
4422 case GL_TEXTURE_2D:
4423 texture = context->getTexture2D(target);
4424 break;
4425 case GL_TEXTURE_CUBE_MAP:
4426 texture = context->getTextureCubeMap();
4427 break;
4428 default:
4429 return error(GL_INVALID_ENUM);
4430 }
4431
4432 switch(pname)
4433 {
4434 case GL_TEXTURE_WRAP_S:
4435 if(!texture->setWrapS((GLenum)param))
4436 {
4437 return error(GL_INVALID_ENUM);
4438 }
4439 break;
4440 case GL_TEXTURE_WRAP_T:
4441 if(!texture->setWrapT((GLenum)param))
4442 {
4443 return error(GL_INVALID_ENUM);
4444 }
4445 break;
4446 case GL_TEXTURE_MIN_FILTER:
4447 if(!texture->setMinFilter((GLenum)param))
4448 {
4449 return error(GL_INVALID_ENUM);
4450 }
4451 break;
4452 case GL_TEXTURE_MAG_FILTER:
4453 if(!texture->setMagFilter((GLenum)param))
4454 {
4455 return error(GL_INVALID_ENUM);
4456 }
4457 break;
4458 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
4459 if(!texture->setMaxAnisotropy(param))
4460 {
4461 return error(GL_INVALID_VALUE);
4462 }
4463 break;
4464 case GL_TEXTURE_MIN_LOD:
4465 //TRACE("() UNIMPLEMENTED!!"); // FIXME
4466 //UNIMPLEMENTED();
4467 break;
4468 case GL_TEXTURE_MAX_LOD:
4469 //TRACE("() UNIMPLEMENTED!!"); // FIXME
4470 //UNIMPLEMENTED();
4471 break;
4472 case GL_TEXTURE_LOD_BIAS:
4473 if(param != 0.0f)
4474 {
4475 UNIMPLEMENTED();
4476 }
4477 break;
4478 default:
4479 return error(GL_INVALID_ENUM);
4480 }
4481 }
4482 }
4483
glTexParameterfv(GLenum target,GLenum pname,const GLfloat * params)4484 void APIENTRY glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
4485 {
4486 glTexParameterf(target, pname, *params);
4487 }
4488
glTexParameteri(GLenum target,GLenum pname,GLint param)4489 void APIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param)
4490 {
4491 TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint param = %d)", target, pname, param);
4492
4493 gl::Context *context = gl::getContext();
4494
4495 if(context)
4496 {
4497 if(context->getListIndex() != 0)
4498 {
4499 UNIMPLEMENTED();
4500 }
4501
4502 gl::Texture *texture;
4503
4504 switch(target)
4505 {
4506 case GL_TEXTURE_2D:
4507 texture = context->getTexture2D(target);
4508 break;
4509 case GL_TEXTURE_CUBE_MAP:
4510 texture = context->getTextureCubeMap();
4511 break;
4512 default:
4513 return error(GL_INVALID_ENUM);
4514 }
4515
4516 switch(pname)
4517 {
4518 case GL_TEXTURE_WRAP_S:
4519 if(!texture->setWrapS((GLenum)param))
4520 {
4521 return error(GL_INVALID_ENUM);
4522 }
4523 break;
4524 case GL_TEXTURE_WRAP_T:
4525 if(!texture->setWrapT((GLenum)param))
4526 {
4527 return error(GL_INVALID_ENUM);
4528 }
4529 break;
4530 case GL_TEXTURE_MIN_FILTER:
4531 if(!texture->setMinFilter((GLenum)param))
4532 {
4533 return error(GL_INVALID_ENUM);
4534 }
4535 break;
4536 case GL_TEXTURE_MAG_FILTER:
4537 if(!texture->setMagFilter((GLenum)param))
4538 {
4539 return error(GL_INVALID_ENUM);
4540 }
4541 break;
4542 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
4543 if(!texture->setMaxAnisotropy((GLfloat)param))
4544 {
4545 return error(GL_INVALID_VALUE);
4546 }
4547 break;
4548 case GL_TEXTURE_MAX_LEVEL:
4549 if(!texture->setMaxLevel(param))
4550 {
4551 return error(GL_INVALID_ENUM);
4552 }
4553 break;
4554 default:
4555 return error(GL_INVALID_ENUM);
4556 }
4557 }
4558 }
4559
glTexParameteriv(GLenum target,GLenum pname,const GLint * params)4560 void APIENTRY glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
4561 {
4562 glTexParameteri(target, pname, *params);
4563 }
4564
glTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid * pixels)4565 void APIENTRY glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
4566 GLenum format, GLenum type, const GLvoid* pixels)
4567 {
4568 TRACE("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
4569 "GLsizei width = %d, GLsizei height = %d, GLenum format = 0x%X, GLenum type = 0x%X, "
4570 "const GLvoid* pixels = %p)",
4571 target, level, xoffset, yoffset, width, height, format, type, pixels);
4572
4573 if(!gl::IsTextureTarget(target))
4574 {
4575 return error(GL_INVALID_ENUM);
4576 }
4577
4578 if(level < 0 || xoffset < 0 || yoffset < 0 || width < 0 || height < 0)
4579 {
4580 return error(GL_INVALID_VALUE);
4581 }
4582
4583 if(std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height)
4584 {
4585 return error(GL_INVALID_VALUE);
4586 }
4587
4588 if(!gl::CheckTextureFormatType(format, type))
4589 {
4590 return error(GL_INVALID_ENUM);
4591 }
4592
4593 if(width == 0 || height == 0 || !pixels)
4594 {
4595 return;
4596 }
4597
4598 gl::Context *context = gl::getContext();
4599
4600 if(context)
4601 {
4602 if(context->getListIndex() != 0)
4603 {
4604 UNIMPLEMENTED();
4605 }
4606
4607 if(level > gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS)
4608 {
4609 return error(GL_INVALID_VALUE);
4610 }
4611
4612 if(target == GL_TEXTURE_2D)
4613 {
4614 gl::Texture2D *texture = context->getTexture2D(target);
4615
4616 if(validateSubImageParams(false, width, height, xoffset, yoffset, target, level, format, texture))
4617 {
4618 texture->subImage(level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);
4619 }
4620 }
4621 else if(gl::IsCubemapTextureTarget(target))
4622 {
4623 gl::TextureCubeMap *texture = context->getTextureCubeMap();
4624
4625 if(validateSubImageParams(false, width, height, xoffset, yoffset, target, level, format, texture))
4626 {
4627 texture->subImage(target, level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);
4628 }
4629 }
4630 else UNREACHABLE(target);
4631 }
4632 }
4633
glUniform1f(GLint location,GLfloat x)4634 void APIENTRY glUniform1f(GLint location, GLfloat x)
4635 {
4636 glUniform1fv(location, 1, &x);
4637 }
4638
glUniform1fv(GLint location,GLsizei count,const GLfloat * v)4639 void APIENTRY glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
4640 {
4641 TRACE("(GLint location = %d, GLsizei count = %d, const GLfloat* v = %p)", location, count, v);
4642
4643 if(count < 0)
4644 {
4645 return error(GL_INVALID_VALUE);
4646 }
4647
4648 if(location == -1)
4649 {
4650 return;
4651 }
4652
4653 gl::Context *context = gl::getContext();
4654
4655 if(context)
4656 {
4657 if(context->getListIndex() != 0)
4658 {
4659 UNIMPLEMENTED();
4660 }
4661
4662 gl::Program *program = context->getCurrentProgram();
4663
4664 if(!program)
4665 {
4666 return error(GL_INVALID_OPERATION);
4667 }
4668
4669 if(!program->setUniform1fv(location, count, v))
4670 {
4671 return error(GL_INVALID_OPERATION);
4672 }
4673 }
4674 }
4675
glUniform1i(GLint location,GLint x)4676 void APIENTRY glUniform1i(GLint location, GLint x)
4677 {
4678 glUniform1iv(location, 1, &x);
4679 }
4680
glUniform1iv(GLint location,GLsizei count,const GLint * v)4681 void APIENTRY glUniform1iv(GLint location, GLsizei count, const GLint* v)
4682 {
4683 TRACE("(GLint location = %d, GLsizei count = %d, const GLint* v = %p)", location, count, v);
4684
4685 if(count < 0)
4686 {
4687 return error(GL_INVALID_VALUE);
4688 }
4689
4690 if(location == -1)
4691 {
4692 return;
4693 }
4694
4695 gl::Context *context = gl::getContext();
4696
4697 if(context)
4698 {
4699 if(context->getListIndex() != 0)
4700 {
4701 UNIMPLEMENTED();
4702 }
4703
4704 gl::Program *program = context->getCurrentProgram();
4705
4706 if(!program)
4707 {
4708 return error(GL_INVALID_OPERATION);
4709 }
4710
4711 if(!program->setUniform1iv(location, count, v))
4712 {
4713 return error(GL_INVALID_OPERATION);
4714 }
4715 }
4716 }
4717
glUniform2f(GLint location,GLfloat x,GLfloat y)4718 void APIENTRY glUniform2f(GLint location, GLfloat x, GLfloat y)
4719 {
4720 GLfloat xy[2] = {x, y};
4721
4722 glUniform2fv(location, 1, (GLfloat*)&xy);
4723 }
4724
glUniform2fv(GLint location,GLsizei count,const GLfloat * v)4725 void APIENTRY glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
4726 {
4727 TRACE("(GLint location = %d, GLsizei count = %d, const GLfloat* v = %p)", location, count, v);
4728
4729 if(count < 0)
4730 {
4731 return error(GL_INVALID_VALUE);
4732 }
4733
4734 if(location == -1)
4735 {
4736 return;
4737 }
4738
4739 gl::Context *context = gl::getContext();
4740
4741 if(context)
4742 {
4743 if(context->getListIndex() != 0)
4744 {
4745 UNIMPLEMENTED();
4746 }
4747
4748 gl::Program *program = context->getCurrentProgram();
4749
4750 if(!program)
4751 {
4752 return error(GL_INVALID_OPERATION);
4753 }
4754
4755 if(!program->setUniform2fv(location, count, v))
4756 {
4757 return error(GL_INVALID_OPERATION);
4758 }
4759 }
4760 }
4761
glUniform2i(GLint location,GLint x,GLint y)4762 void APIENTRY glUniform2i(GLint location, GLint x, GLint y)
4763 {
4764 GLint xy[4] = {x, y};
4765
4766 glUniform2iv(location, 1, (GLint*)&xy);
4767 }
4768
glUniform2iv(GLint location,GLsizei count,const GLint * v)4769 void APIENTRY glUniform2iv(GLint location, GLsizei count, const GLint* v)
4770 {
4771 TRACE("(GLint location = %d, GLsizei count = %d, const GLint* v = %p)", location, count, v);
4772
4773 if(count < 0)
4774 {
4775 return error(GL_INVALID_VALUE);
4776 }
4777
4778 if(location == -1)
4779 {
4780 return;
4781 }
4782
4783 gl::Context *context = gl::getContext();
4784
4785 if(context)
4786 {
4787 if(context->getListIndex() != 0)
4788 {
4789 UNIMPLEMENTED();
4790 }
4791
4792 gl::Program *program = context->getCurrentProgram();
4793
4794 if(!program)
4795 {
4796 return error(GL_INVALID_OPERATION);
4797 }
4798
4799 if(!program->setUniform2iv(location, count, v))
4800 {
4801 return error(GL_INVALID_OPERATION);
4802 }
4803 }
4804 }
4805
glUniform3f(GLint location,GLfloat x,GLfloat y,GLfloat z)4806 void APIENTRY glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
4807 {
4808 GLfloat xyz[3] = {x, y, z};
4809
4810 glUniform3fv(location, 1, (GLfloat*)&xyz);
4811 }
4812
glUniform3fv(GLint location,GLsizei count,const GLfloat * v)4813 void APIENTRY glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
4814 {
4815 TRACE("(GLint location = %d, GLsizei count = %d, const GLfloat* v = %p)", location, count, v);
4816
4817 if(count < 0)
4818 {
4819 return error(GL_INVALID_VALUE);
4820 }
4821
4822 if(location == -1)
4823 {
4824 return;
4825 }
4826
4827 gl::Context *context = gl::getContext();
4828
4829 if(context)
4830 {
4831 if(context->getListIndex() != 0)
4832 {
4833 UNIMPLEMENTED();
4834 }
4835
4836 gl::Program *program = context->getCurrentProgram();
4837
4838 if(!program)
4839 {
4840 return error(GL_INVALID_OPERATION);
4841 }
4842
4843 if(!program->setUniform3fv(location, count, v))
4844 {
4845 return error(GL_INVALID_OPERATION);
4846 }
4847 }
4848 }
4849
glUniform3i(GLint location,GLint x,GLint y,GLint z)4850 void APIENTRY glUniform3i(GLint location, GLint x, GLint y, GLint z)
4851 {
4852 GLint xyz[3] = {x, y, z};
4853
4854 glUniform3iv(location, 1, (GLint*)&xyz);
4855 }
4856
glUniform3iv(GLint location,GLsizei count,const GLint * v)4857 void APIENTRY glUniform3iv(GLint location, GLsizei count, const GLint* v)
4858 {
4859 TRACE("(GLint location = %d, GLsizei count = %d, const GLint* v = %p)", location, count, v);
4860
4861 if(count < 0)
4862 {
4863 return error(GL_INVALID_VALUE);
4864 }
4865
4866 if(location == -1)
4867 {
4868 return;
4869 }
4870
4871 gl::Context *context = gl::getContext();
4872
4873 if(context)
4874 {
4875 if(context->getListIndex() != 0)
4876 {
4877 UNIMPLEMENTED();
4878 }
4879
4880 gl::Program *program = context->getCurrentProgram();
4881
4882 if(!program)
4883 {
4884 return error(GL_INVALID_OPERATION);
4885 }
4886
4887 if(!program->setUniform3iv(location, count, v))
4888 {
4889 return error(GL_INVALID_OPERATION);
4890 }
4891 }
4892 }
4893
glUniform4f(GLint location,GLfloat x,GLfloat y,GLfloat z,GLfloat w)4894 void APIENTRY glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
4895 {
4896 GLfloat xyzw[4] = {x, y, z, w};
4897
4898 glUniform4fv(location, 1, (GLfloat*)&xyzw);
4899 }
4900
glUniform4fv(GLint location,GLsizei count,const GLfloat * v)4901 void APIENTRY glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
4902 {
4903 TRACE("(GLint location = %d, GLsizei count = %d, const GLfloat* v = %p)", location, count, v);
4904
4905 if(count < 0)
4906 {
4907 return error(GL_INVALID_VALUE);
4908 }
4909
4910 if(location == -1)
4911 {
4912 return;
4913 }
4914
4915 gl::Context *context = gl::getContext();
4916
4917 if(context)
4918 {
4919 if(context->getListIndex() != 0)
4920 {
4921 UNIMPLEMENTED();
4922 }
4923
4924 gl::Program *program = context->getCurrentProgram();
4925
4926 if(!program)
4927 {
4928 return error(GL_INVALID_OPERATION);
4929 }
4930
4931 if(!program->setUniform4fv(location, count, v))
4932 {
4933 return error(GL_INVALID_OPERATION);
4934 }
4935 }
4936 }
4937
glUniform4i(GLint location,GLint x,GLint y,GLint z,GLint w)4938 void APIENTRY glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
4939 {
4940 GLint xyzw[4] = {x, y, z, w};
4941
4942 glUniform4iv(location, 1, (GLint*)&xyzw);
4943 }
4944
glUniform4iv(GLint location,GLsizei count,const GLint * v)4945 void APIENTRY glUniform4iv(GLint location, GLsizei count, const GLint* v)
4946 {
4947 TRACE("(GLint location = %d, GLsizei count = %d, const GLint* v = %p)", location, count, v);
4948
4949 if(count < 0)
4950 {
4951 return error(GL_INVALID_VALUE);
4952 }
4953
4954 if(location == -1)
4955 {
4956 return;
4957 }
4958
4959 gl::Context *context = gl::getContext();
4960
4961 if(context)
4962 {
4963 if(context->getListIndex() != 0)
4964 {
4965 UNIMPLEMENTED();
4966 }
4967
4968 gl::Program *program = context->getCurrentProgram();
4969
4970 if(!program)
4971 {
4972 return error(GL_INVALID_OPERATION);
4973 }
4974
4975 if(!program->setUniform4iv(location, count, v))
4976 {
4977 return error(GL_INVALID_OPERATION);
4978 }
4979 }
4980 }
4981
glUniformMatrix2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)4982 void APIENTRY glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
4983 {
4984 TRACE("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = %p)",
4985 location, count, transpose, value);
4986
4987 if(count < 0 || transpose != GL_FALSE)
4988 {
4989 return error(GL_INVALID_VALUE);
4990 }
4991
4992 if(location == -1)
4993 {
4994 return;
4995 }
4996
4997 gl::Context *context = gl::getContext();
4998
4999 if(context)
5000 {
5001 if(context->getListIndex() != 0)
5002 {
5003 UNIMPLEMENTED();
5004 }
5005
5006 gl::Program *program = context->getCurrentProgram();
5007
5008 if(!program)
5009 {
5010 return error(GL_INVALID_OPERATION);
5011 }
5012
5013 if(!program->setUniformMatrix2fv(location, count, value))
5014 {
5015 return error(GL_INVALID_OPERATION);
5016 }
5017 }
5018 }
5019
glUniformMatrix3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)5020 void APIENTRY glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
5021 {
5022 TRACE("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = %p)",
5023 location, count, transpose, value);
5024
5025 if(count < 0 || transpose != GL_FALSE)
5026 {
5027 return error(GL_INVALID_VALUE);
5028 }
5029
5030 if(location == -1)
5031 {
5032 return;
5033 }
5034
5035 gl::Context *context = gl::getContext();
5036
5037 if(context)
5038 {
5039 if(context->getListIndex() != 0)
5040 {
5041 UNIMPLEMENTED();
5042 }
5043
5044 gl::Program *program = context->getCurrentProgram();
5045
5046 if(!program)
5047 {
5048 return error(GL_INVALID_OPERATION);
5049 }
5050
5051 if(!program->setUniformMatrix3fv(location, count, value))
5052 {
5053 return error(GL_INVALID_OPERATION);
5054 }
5055 }
5056 }
5057
glUniformMatrix4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)5058 void APIENTRY glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
5059 {
5060 TRACE("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = %p)",
5061 location, count, transpose, value);
5062
5063 if(count < 0 || transpose != GL_FALSE)
5064 {
5065 return error(GL_INVALID_VALUE);
5066 }
5067
5068 if(location == -1)
5069 {
5070 return;
5071 }
5072
5073 gl::Context *context = gl::getContext();
5074
5075 if(context)
5076 {
5077 if(context->getListIndex() != 0)
5078 {
5079 UNIMPLEMENTED();
5080 }
5081
5082 gl::Program *program = context->getCurrentProgram();
5083
5084 if(!program)
5085 {
5086 return error(GL_INVALID_OPERATION);
5087 }
5088
5089 if(!program->setUniformMatrix4fv(location, count, value))
5090 {
5091 return error(GL_INVALID_OPERATION);
5092 }
5093 }
5094 }
5095
glUseProgram(GLuint program)5096 void APIENTRY glUseProgram(GLuint program)
5097 {
5098 TRACE("(GLuint program = %d)", program);
5099
5100 gl::Context *context = gl::getContext();
5101
5102 if(context)
5103 {
5104 if(context->getListIndex() != 0)
5105 {
5106 UNIMPLEMENTED();
5107 }
5108
5109 gl::Program *programObject = context->getProgram(program);
5110
5111 if(!programObject && program != 0)
5112 {
5113 if(context->getShader(program))
5114 {
5115 return error(GL_INVALID_OPERATION);
5116 }
5117 else
5118 {
5119 return error(GL_INVALID_VALUE);
5120 }
5121 }
5122
5123 if(program != 0 && !programObject->isLinked())
5124 {
5125 return error(GL_INVALID_OPERATION);
5126 }
5127
5128 context->useProgram(program);
5129 }
5130 }
5131
glValidateProgram(GLuint program)5132 void APIENTRY glValidateProgram(GLuint program)
5133 {
5134 TRACE("(GLuint program = %d)", program);
5135
5136 gl::Context *context = gl::getContext();
5137
5138 if(context)
5139 {
5140 gl::Program *programObject = context->getProgram(program);
5141
5142 if(!programObject)
5143 {
5144 if(context->getShader(program))
5145 {
5146 return error(GL_INVALID_OPERATION);
5147 }
5148 else
5149 {
5150 return error(GL_INVALID_VALUE);
5151 }
5152 }
5153
5154 programObject->validate();
5155 }
5156 }
5157
glVertexAttrib1f(GLuint index,GLfloat x)5158 void APIENTRY glVertexAttrib1f(GLuint index, GLfloat x)
5159 {
5160 TRACE("(GLuint index = %d, GLfloat x = %f)", index, x);
5161
5162 if(index >= gl::MAX_VERTEX_ATTRIBS)
5163 {
5164 return error(GL_INVALID_VALUE);
5165 }
5166
5167 gl::Context *context = gl::getContext();
5168
5169 if(context)
5170 {
5171 if(context->getListIndex() != 0)
5172 {
5173 UNIMPLEMENTED();
5174 }
5175
5176 //GLfloat vals[4] = { x, 0, 0, 1 };
5177 context->setVertexAttrib(index, x, 0, 0, 1);
5178 }
5179 }
5180
glVertexAttrib1fv(GLuint index,const GLfloat * values)5181 void APIENTRY glVertexAttrib1fv(GLuint index, const GLfloat* values)
5182 {
5183 TRACE("(GLuint index = %d, const GLfloat* values = %p)", index, values);
5184
5185 if(index >= gl::MAX_VERTEX_ATTRIBS)
5186 {
5187 return error(GL_INVALID_VALUE);
5188 }
5189
5190 gl::Context *context = gl::getContext();
5191
5192 if(context)
5193 {
5194 if(context->getListIndex() != 0)
5195 {
5196 UNIMPLEMENTED();
5197 }
5198
5199 //GLfloat vals[4] = { values[0], 0, 0, 1 };
5200 context->setVertexAttrib(index, values[0], 0, 0, 1);
5201 }
5202 }
5203
glVertexAttrib2f(GLuint index,GLfloat x,GLfloat y)5204 void APIENTRY glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
5205 {
5206 TRACE("(GLuint index = %d, GLfloat x = %f, GLfloat y = %f)", index, x, y);
5207
5208 if(index >= gl::MAX_VERTEX_ATTRIBS)
5209 {
5210 return error(GL_INVALID_VALUE);
5211 }
5212
5213 gl::Context *context = gl::getContext();
5214
5215 if(context)
5216 {
5217 if(context->getListIndex() != 0)
5218 {
5219 UNIMPLEMENTED();
5220 }
5221
5222 //GLfloat vals[4] = { x, y, 0, 1 };
5223 context->setVertexAttrib(index, x, y, 0, 1);
5224 }
5225 }
5226
glVertexAttrib2fv(GLuint index,const GLfloat * values)5227 void APIENTRY glVertexAttrib2fv(GLuint index, const GLfloat* values)
5228 {
5229 TRACE("(GLuint index = %d, const GLfloat* values = %p)", index, values);
5230
5231 if(index >= gl::MAX_VERTEX_ATTRIBS)
5232 {
5233 return error(GL_INVALID_VALUE);
5234 }
5235
5236 gl::Context *context = gl::getContext();
5237
5238 if(context)
5239 {
5240 if(context->getListIndex() != 0)
5241 {
5242 UNIMPLEMENTED();
5243 }
5244
5245 //GLfloat vals[4] = { };
5246 context->setVertexAttrib(index, values[0], values[1], 0, 1);
5247 }
5248 }
5249
glVertexAttrib3f(GLuint index,GLfloat x,GLfloat y,GLfloat z)5250 void APIENTRY glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
5251 {
5252 TRACE("(GLuint index = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", index, x, y, z);
5253
5254 if(index >= gl::MAX_VERTEX_ATTRIBS)
5255 {
5256 return error(GL_INVALID_VALUE);
5257 }
5258
5259 gl::Context *context = gl::getContext();
5260
5261 if(context)
5262 {
5263 if(context->getListIndex() != 0)
5264 {
5265 UNIMPLEMENTED();
5266 }
5267
5268 //GLfloat vals[4] = { x, y, z, 1 };
5269 context->setVertexAttrib(index, x, y, z, 1);
5270 }
5271 }
5272
glVertexAttrib3fv(GLuint index,const GLfloat * values)5273 void APIENTRY glVertexAttrib3fv(GLuint index, const GLfloat* values)
5274 {
5275 TRACE("(GLuint index = %d, const GLfloat* values = %p)", index, values);
5276
5277 if(index >= gl::MAX_VERTEX_ATTRIBS)
5278 {
5279 return error(GL_INVALID_VALUE);
5280 }
5281
5282 gl::Context *context = gl::getContext();
5283
5284 if(context)
5285 {
5286 if(context->getListIndex() != 0)
5287 {
5288 UNIMPLEMENTED();
5289 }
5290
5291 //GLfloat vals[4] = { values[0], values[1], values[2], 1 };
5292 context->setVertexAttrib(index, values[0], values[1], values[2], 1);
5293 }
5294 }
5295
glVertexAttrib4f(GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w)5296 void APIENTRY glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
5297 {
5298 TRACE("(GLuint index = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f, GLfloat w = %f)", index, x, y, z, w);
5299
5300 if(index >= gl::MAX_VERTEX_ATTRIBS)
5301 {
5302 return error(GL_INVALID_VALUE);
5303 }
5304
5305 gl::Context *context = gl::getContext();
5306
5307 if(context)
5308 {
5309 if(context->getListIndex() != 0)
5310 {
5311 UNIMPLEMENTED();
5312 }
5313
5314 //GLfloat vals[4] = { x, y, z, w };
5315 context->setVertexAttrib(index, x, y, z, w);
5316 }
5317 }
5318
glVertexAttrib4fv(GLuint index,const GLfloat * values)5319 void APIENTRY glVertexAttrib4fv(GLuint index, const GLfloat* values)
5320 {
5321 TRACE("(GLuint index = %d, const GLfloat* values = %p)", index, values);
5322
5323 if(index >= gl::MAX_VERTEX_ATTRIBS)
5324 {
5325 return error(GL_INVALID_VALUE);
5326 }
5327
5328 gl::Context *context = gl::getContext();
5329
5330 if(context)
5331 {
5332 if(context->getListIndex() != 0)
5333 {
5334 UNIMPLEMENTED();
5335 }
5336
5337 context->setVertexAttrib(index, values[0], values[1], values[2], values[3]);
5338 }
5339 }
5340
glVertexAttribPointer(GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const GLvoid * ptr)5341 void APIENTRY glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr)
5342 {
5343 TRACE("(GLuint index = %d, GLint size = %d, GLenum type = 0x%X, "
5344 "GLboolean normalized = %d, GLsizei stride = %d, const GLvoid* ptr = %p)",
5345 index, size, type, normalized, stride, ptr);
5346
5347 if(index >= gl::MAX_VERTEX_ATTRIBS)
5348 {
5349 return error(GL_INVALID_VALUE);
5350 }
5351
5352 if(size < 1 || size > 4)
5353 {
5354 return error(GL_INVALID_VALUE);
5355 }
5356
5357 switch(type)
5358 {
5359 case GL_BYTE:
5360 case GL_UNSIGNED_BYTE:
5361 case GL_SHORT:
5362 case GL_UNSIGNED_SHORT:
5363 case GL_FIXED:
5364 case GL_FLOAT:
5365 break;
5366 default:
5367 return error(GL_INVALID_ENUM);
5368 }
5369
5370 if(stride < 0)
5371 {
5372 return error(GL_INVALID_VALUE);
5373 }
5374
5375 gl::Context *context = gl::getContext();
5376
5377 if(context)
5378 {
5379 context->setVertexAttribState(index, context->getArrayBuffer(), size, type, (normalized == GL_TRUE), stride, ptr);
5380 }
5381 }
5382
glViewport(GLint x,GLint y,GLsizei width,GLsizei height)5383 void APIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
5384 {
5385 TRACE("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)", x, y, width, height);
5386
5387 if(width < 0 || height < 0)
5388 {
5389 return error(GL_INVALID_VALUE);
5390 }
5391
5392 gl::Context *context = gl::getContext();
5393
5394 if(context)
5395 {
5396 if(context->getListIndex() != 0)
5397 {
5398 UNIMPLEMENTED();
5399 }
5400
5401 context->setViewportParams(x, y, width, height);
5402 }
5403 }
5404
glBlitFramebufferANGLE(GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter)5405 void APIENTRY glBlitFramebufferANGLE(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
5406 GLbitfield mask, GLenum filter)
5407 {
5408 TRACE("(GLint srcX0 = %d, GLint srcY0 = %d, GLint srcX1 = %d, GLint srcY1 = %d, "
5409 "GLint dstX0 = %d, GLint dstY0 = %d, GLint dstX1 = %d, GLint dstY1 = %d, "
5410 "GLbitfield mask = 0x%X, GLenum filter = 0x%X)",
5411 srcX0, srcY0, srcX1, srcX1, dstX0, dstY0, dstX1, dstY1, mask, filter);
5412
5413 switch(filter)
5414 {
5415 case GL_NEAREST:
5416 break;
5417 default:
5418 return error(GL_INVALID_ENUM);
5419 }
5420
5421 if((mask & ~(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)) != 0)
5422 {
5423 return error(GL_INVALID_VALUE);
5424 }
5425
5426 if(srcX1 - srcX0 != dstX1 - dstX0 || srcY1 - srcY0 != dstY1 - dstY0)
5427 {
5428 ERR("Scaling and flipping in BlitFramebufferANGLE not supported by this implementation");
5429 return error(GL_INVALID_OPERATION);
5430 }
5431
5432 gl::Context *context = gl::getContext();
5433
5434 if(context)
5435 {
5436 if(context->getListIndex() != 0)
5437 {
5438 UNIMPLEMENTED();
5439 }
5440
5441 if(context->getReadFramebufferName() == context->getDrawFramebufferName())
5442 {
5443 ERR("Blits with the same source and destination framebuffer are not supported by this implementation.");
5444 return error(GL_INVALID_OPERATION);
5445 }
5446
5447 context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask);
5448 }
5449 }
5450
glTexImage3DOES(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const GLvoid * pixels)5451 void APIENTRY glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
5452 GLint border, GLenum format, GLenum type, const GLvoid* pixels)
5453 {
5454 TRACE("(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, "
5455 "GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, "
5456 "GLenum format = 0x%X, GLenum type = 0x%x, const GLvoid* pixels = %p)",
5457 target, level, internalformat, width, height, depth, border, format, type, pixels);
5458
5459 UNIMPLEMENTED(); // FIXME
5460 }
5461
GlmfBeginGlsBlock()5462 void WINAPI GlmfBeginGlsBlock()
5463 {
5464 UNIMPLEMENTED();
5465 }
5466
GlmfCloseMetaFile()5467 void WINAPI GlmfCloseMetaFile()
5468 {
5469 UNIMPLEMENTED();
5470 }
5471
GlmfEndGlsBlock()5472 void WINAPI GlmfEndGlsBlock()
5473 {
5474 UNIMPLEMENTED();
5475 }
5476
GlmfEndPlayback()5477 void WINAPI GlmfEndPlayback()
5478 {
5479 UNIMPLEMENTED();
5480 }
5481
GlmfInitPlayback()5482 void WINAPI GlmfInitPlayback()
5483 {
5484 UNIMPLEMENTED();
5485 }
5486
GlmfPlayGlsRecord()5487 void WINAPI GlmfPlayGlsRecord()
5488 {
5489 UNIMPLEMENTED();
5490 }
5491
glAccum(GLenum op,GLfloat value)5492 void APIENTRY glAccum(GLenum op, GLfloat value)
5493 {
5494 UNIMPLEMENTED();
5495 }
5496
glAlphaFunc(GLenum func,GLclampf ref)5497 void APIENTRY glAlphaFunc(GLenum func, GLclampf ref)
5498 {
5499 TRACE("(GLenum func = 0x%X, GLclampf ref = %f)", func, ref);
5500
5501 gl::Context *context = gl::getContext();
5502
5503 if(context)
5504 {
5505 if(context->getListIndex() != 0)
5506 {
5507 UNIMPLEMENTED();
5508 }
5509
5510 context->alphaFunc(func, ref);
5511 }
5512 }
5513
glAreTexturesResident(GLsizei n,const GLuint * textures,GLboolean * residences)5514 GLboolean APIENTRY glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
5515 {
5516 UNIMPLEMENTED();
5517 return GL_FALSE;
5518 }
5519
glArrayElement(GLint i)5520 void APIENTRY glArrayElement(GLint i)
5521 {
5522 UNIMPLEMENTED();
5523 }
5524
glBegin(GLenum mode)5525 void APIENTRY glBegin(GLenum mode)
5526 {
5527 TRACE("(GLenum mode = 0x%X)", mode);
5528
5529 switch(mode)
5530 {
5531 case GL_POINTS:
5532 case GL_LINES:
5533 case GL_LINE_STRIP:
5534 case GL_LINE_LOOP:
5535 case GL_TRIANGLES:
5536 case GL_TRIANGLE_STRIP:
5537 case GL_TRIANGLE_FAN:
5538 case GL_QUADS:
5539 case GL_QUAD_STRIP:
5540 case GL_POLYGON:
5541 break;
5542 default:
5543 return error(GL_INVALID_ENUM);
5544 }
5545
5546 gl::Context *context = gl::getContext();
5547
5548 if(context)
5549 {
5550 if(context->getListIndex() != 0)
5551 {
5552 UNIMPLEMENTED();
5553 }
5554
5555 context->begin(mode);
5556 }
5557 }
5558
glBitmap(GLsizei width,GLsizei height,GLfloat xorig,GLfloat yorig,GLfloat xmove,GLfloat ymove,const GLubyte * bitmap)5559 void APIENTRY glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
5560 {
5561 UNIMPLEMENTED();
5562 }
5563
glCallList(GLuint list)5564 void APIENTRY glCallList(GLuint list)
5565 {
5566 TRACE("(GLuint list = %d)", list);
5567
5568 if(list == 0)
5569 {
5570 return error(GL_INVALID_VALUE);
5571 }
5572
5573 gl::Context *context = gl::getContext();
5574
5575 if(context)
5576 {
5577 if(context->getListIndex() != 0)
5578 {
5579 UNIMPLEMENTED();
5580 }
5581
5582 context->callList(list);
5583 }
5584 }
5585
glCallLists(GLsizei n,GLenum type,const GLvoid * lists)5586 void APIENTRY glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
5587 {
5588 TRACE("(GLsizei n = %d, GLenum type = 0x%X, const GLvoid *lists)", n, type);
5589
5590 gl::Context *context = gl::getContext();
5591
5592 if(context)
5593 {
5594 if(context->getListIndex() != 0)
5595 {
5596 UNIMPLEMENTED();
5597 }
5598
5599 for(int i = 0; i < n; i++)
5600 {
5601 switch(type)
5602 {
5603 case GL_UNSIGNED_INT: context->callList(((unsigned int*)lists)[i]); break;
5604 default:
5605 UNIMPLEMENTED();
5606 UNREACHABLE(type);
5607 }
5608 }
5609 }
5610 }
5611
glClearAccum(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)5612 void APIENTRY glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
5613 {
5614 UNIMPLEMENTED();
5615 }
5616
glClearDepth(GLclampd depth)5617 void APIENTRY glClearDepth(GLclampd depth)
5618 {
5619 TRACE("(GLclampd depth = %d)", depth);
5620
5621 glClearDepthf((float)depth); // FIXME
5622 }
5623
glClearIndex(GLfloat c)5624 void APIENTRY glClearIndex(GLfloat c)
5625 {
5626 UNIMPLEMENTED();
5627 }
5628
glClipPlane(GLenum plane,const GLdouble * equation)5629 void APIENTRY glClipPlane(GLenum plane, const GLdouble *equation)
5630 {
5631 UNIMPLEMENTED();
5632 }
5633
glColor3b(GLbyte red,GLbyte green,GLbyte blue)5634 void APIENTRY glColor3b(GLbyte red, GLbyte green, GLbyte blue)
5635 {
5636 UNIMPLEMENTED();
5637 }
5638
glColor3bv(const GLbyte * v)5639 void APIENTRY glColor3bv(const GLbyte *v)
5640 {
5641 UNIMPLEMENTED();
5642 }
5643
glColor3d(GLdouble red,GLdouble green,GLdouble blue)5644 void APIENTRY glColor3d(GLdouble red, GLdouble green, GLdouble blue)
5645 {
5646 UNIMPLEMENTED();
5647 }
5648
glColor3dv(const GLdouble * v)5649 void APIENTRY glColor3dv(const GLdouble *v)
5650 {
5651 UNIMPLEMENTED();
5652 }
5653
glColor3f(GLfloat red,GLfloat green,GLfloat blue)5654 void APIENTRY glColor3f(GLfloat red, GLfloat green, GLfloat blue)
5655 {
5656 TRACE("(GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f)", red, green, blue);
5657
5658 gl::Context *context = gl::getContext();
5659
5660 if(context)
5661 {
5662 if(context->getListIndex() != 0)
5663 {
5664 UNIMPLEMENTED();
5665 }
5666
5667 //context->color(red, green, blue, 1.0f);
5668 //GLfloat vals[4] = {};
5669 context->setVertexAttrib(sw::Color0, red, green, blue, 1);
5670 }
5671 }
5672
glColor3fv(const GLfloat * v)5673 void APIENTRY glColor3fv(const GLfloat *v)
5674 {
5675 UNIMPLEMENTED();
5676 }
5677
glColor3i(GLint red,GLint green,GLint blue)5678 void APIENTRY glColor3i(GLint red, GLint green, GLint blue)
5679 {
5680 UNIMPLEMENTED();
5681 }
5682
glColor3iv(const GLint * v)5683 void APIENTRY glColor3iv(const GLint *v)
5684 {
5685 UNIMPLEMENTED();
5686 }
5687
glColor3s(GLshort red,GLshort green,GLshort blue)5688 void APIENTRY glColor3s(GLshort red, GLshort green, GLshort blue)
5689 {
5690 UNIMPLEMENTED();
5691 }
5692
glColor3sv(const GLshort * v)5693 void APIENTRY glColor3sv(const GLshort *v)
5694 {
5695 UNIMPLEMENTED();
5696 }
5697
glColor3ub(GLubyte red,GLubyte green,GLubyte blue)5698 void APIENTRY glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
5699 {
5700 UNIMPLEMENTED();
5701 }
5702
glColor3ubv(const GLubyte * v)5703 void APIENTRY glColor3ubv(const GLubyte *v)
5704 {
5705 UNIMPLEMENTED();
5706 }
5707
glColor3ui(GLuint red,GLuint green,GLuint blue)5708 void APIENTRY glColor3ui(GLuint red, GLuint green, GLuint blue)
5709 {
5710 UNIMPLEMENTED();
5711 }
5712
glColor3uiv(const GLuint * v)5713 void APIENTRY glColor3uiv(const GLuint *v)
5714 {
5715 UNIMPLEMENTED();
5716 }
5717
glColor3us(GLushort red,GLushort green,GLushort blue)5718 void APIENTRY glColor3us(GLushort red, GLushort green, GLushort blue)
5719 {
5720 UNIMPLEMENTED();
5721 }
5722
glColor3usv(const GLushort * v)5723 void APIENTRY glColor3usv(const GLushort *v)
5724 {
5725 UNIMPLEMENTED();
5726 }
5727
glColor4b(GLbyte red,GLbyte green,GLbyte blue,GLbyte alpha)5728 void APIENTRY glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
5729 {
5730 UNIMPLEMENTED();
5731 }
5732
glColor4bv(const GLbyte * v)5733 void APIENTRY glColor4bv(const GLbyte *v)
5734 {
5735 UNIMPLEMENTED();
5736 }
5737
glColor4d(GLdouble red,GLdouble green,GLdouble blue,GLdouble alpha)5738 void APIENTRY glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
5739 {
5740 UNIMPLEMENTED();
5741 }
5742
glColor4dv(const GLdouble * v)5743 void APIENTRY glColor4dv(const GLdouble *v)
5744 {
5745 UNIMPLEMENTED();
5746 }
5747
glColor4f(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)5748 void APIENTRY glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
5749 {
5750 TRACE("(GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f)", red, green, blue, alpha);
5751
5752 gl::Context *context = gl::getContext();
5753
5754 if(context)
5755 {
5756 if(context->getListIndex() != 0)
5757 {
5758 UNIMPLEMENTED();
5759 }
5760
5761 //context->color(red, green, blue, alpha);
5762 //GLfloat vals[4] = {red, green, blue, alpha};
5763 context->setVertexAttrib(sw::Color0, red, green, blue, alpha);
5764 }
5765 }
5766
glColor4fv(const GLfloat * v)5767 void APIENTRY glColor4fv(const GLfloat *v)
5768 {
5769 UNIMPLEMENTED();
5770 }
5771
glColor4i(GLint red,GLint green,GLint blue,GLint alpha)5772 void APIENTRY glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
5773 {
5774 UNIMPLEMENTED();
5775 }
5776
glColor4iv(const GLint * v)5777 void APIENTRY glColor4iv(const GLint *v)
5778 {
5779 UNIMPLEMENTED();
5780 }
5781
glColor4s(GLshort red,GLshort green,GLshort blue,GLshort alpha)5782 void APIENTRY glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
5783 {
5784 UNIMPLEMENTED();
5785 }
5786
glColor4sv(const GLshort * v)5787 void APIENTRY glColor4sv(const GLshort *v)
5788 {
5789 UNIMPLEMENTED();
5790 }
5791
glColor4ub(GLubyte red,GLubyte green,GLubyte blue,GLubyte alpha)5792 void APIENTRY glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
5793 {
5794 UNIMPLEMENTED();
5795 }
5796
glColor4ubv(const GLubyte * v)5797 void APIENTRY glColor4ubv(const GLubyte *v)
5798 {
5799 UNIMPLEMENTED();
5800 }
5801
glColor4ui(GLuint red,GLuint green,GLuint blue,GLuint alpha)5802 void APIENTRY glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
5803 {
5804 UNIMPLEMENTED();
5805 }
5806
glColor4uiv(const GLuint * v)5807 void APIENTRY glColor4uiv(const GLuint *v)
5808 {
5809 UNIMPLEMENTED();
5810 }
5811
glColor4us(GLushort red,GLushort green,GLushort blue,GLushort alpha)5812 void APIENTRY glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
5813 {
5814 UNIMPLEMENTED();
5815 }
5816
glColor4usv(const GLushort * v)5817 void APIENTRY glColor4usv(const GLushort *v)
5818 {
5819 UNIMPLEMENTED();
5820 }
5821
glColorMaterial(GLenum face,GLenum mode)5822 void APIENTRY glColorMaterial(GLenum face, GLenum mode)
5823 {
5824 TRACE("(GLenum face = 0x%X, GLenum mode = 0x%X)", face, mode);
5825
5826 // FIXME: Validate enums
5827
5828 gl::Context *context = gl::getContext();
5829
5830 if(context)
5831 {
5832 if(context->getListIndex() != 0)
5833 {
5834 UNIMPLEMENTED();
5835 }
5836
5837 switch(face)
5838 {
5839 case GL_FRONT:
5840 context->setColorMaterialMode(mode); // FIXME: Front only
5841 break;
5842 case GL_FRONT_AND_BACK:
5843 context->setColorMaterialMode(mode);
5844 break;
5845 default:
5846 UNIMPLEMENTED();
5847 return error(GL_INVALID_ENUM);
5848 }
5849 }
5850 }
5851
glColorPointer(GLint size,GLenum type,GLsizei stride,const GLvoid * pointer)5852 void APIENTRY glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
5853 {
5854 TRACE("(*)");
5855
5856 glVertexAttribPointer(sw::Color0, size, type, true, stride, pointer);
5857 }
5858
glCopyPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum type)5859 void APIENTRY glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
5860 {
5861 UNIMPLEMENTED();
5862 }
5863
glCopyTexImage1D(GLenum target,GLint level,GLenum internalFormat,GLint x,GLint y,GLsizei width,GLint border)5864 void APIENTRY glCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
5865 {
5866 UNIMPLEMENTED();
5867 }
5868
glCopyTexSubImage1D(GLenum target,GLint level,GLint xoffset,GLint x,GLint y,GLsizei width)5869 void APIENTRY glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
5870 {
5871 UNIMPLEMENTED();
5872 }
5873
glDebugEntry()5874 void APIENTRY glDebugEntry()
5875 {
5876 UNIMPLEMENTED();
5877 }
5878
glDeleteLists(GLuint list,GLsizei range)5879 void APIENTRY glDeleteLists(GLuint list, GLsizei range)
5880 {
5881 TRACE("(GLuint list = %d, GLsizei range = %d)", list, range);
5882
5883 if(range < 0)
5884 {
5885 return error(GL_INVALID_VALUE);
5886 }
5887
5888 gl::Context *context = gl::getContext();
5889
5890 if(context)
5891 {
5892 for(GLuint i = list; i < list + range; i++)
5893 {
5894 context->deleteList(i);
5895 }
5896 }
5897 }
5898
glDepthRange(GLclampd zNear,GLclampd zFar)5899 void APIENTRY glDepthRange(GLclampd zNear, GLclampd zFar)
5900 {
5901 UNIMPLEMENTED();
5902 }
5903
glDisableClientState(GLenum array)5904 void APIENTRY glDisableClientState(GLenum array)
5905 {
5906 TRACE("(GLenum array = 0x%X)", array);
5907
5908 gl::Context *context = gl::getContext();
5909
5910 if(context)
5911 {
5912 GLenum texture = context->getClientActiveTexture();
5913
5914 switch(array)
5915 {
5916 case GL_VERTEX_ARRAY: context->setVertexAttribArrayEnabled(sw::Position, false); break;
5917 case GL_COLOR_ARRAY: context->setVertexAttribArrayEnabled(sw::Color0, false); break;
5918 case GL_TEXTURE_COORD_ARRAY: context->setVertexAttribArrayEnabled(sw::TexCoord0 + (texture - GL_TEXTURE0), false); break;
5919 case GL_NORMAL_ARRAY: context->setVertexAttribArrayEnabled(sw::Normal, false); break;
5920 default: UNIMPLEMENTED();
5921 }
5922 }
5923 }
5924
glDrawBuffer(GLenum mode)5925 void APIENTRY glDrawBuffer(GLenum mode)
5926 {
5927 UNIMPLEMENTED();
5928 }
5929
glDrawPixels(GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid * pixels)5930 void APIENTRY glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
5931 {
5932 UNIMPLEMENTED();
5933 }
5934
glEdgeFlag(GLboolean flag)5935 void APIENTRY glEdgeFlag(GLboolean flag)
5936 {
5937 UNIMPLEMENTED();
5938 }
5939
glEdgeFlagPointer(GLsizei stride,const GLvoid * pointer)5940 void APIENTRY glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
5941 {
5942 UNIMPLEMENTED();
5943 }
5944
glEdgeFlagv(const GLboolean * flag)5945 void APIENTRY glEdgeFlagv(const GLboolean *flag)
5946 {
5947 UNIMPLEMENTED();
5948 }
5949
glEnableClientState(GLenum array)5950 void APIENTRY glEnableClientState(GLenum array)
5951 {
5952 TRACE("(GLenum array = 0x%X)", array);
5953
5954 gl::Context *context = gl::getContext();
5955
5956 if(context)
5957 {
5958 GLenum texture = context->getClientActiveTexture();
5959
5960 switch(array)
5961 {
5962 case GL_VERTEX_ARRAY: context->setVertexAttribArrayEnabled(sw::Position, true); break;
5963 case GL_COLOR_ARRAY: context->setVertexAttribArrayEnabled(sw::Color0, true); break;
5964 case GL_TEXTURE_COORD_ARRAY: context->setVertexAttribArrayEnabled(sw::TexCoord0 + (texture - GL_TEXTURE0), true); break;
5965 case GL_NORMAL_ARRAY: context->setVertexAttribArrayEnabled(sw::Normal, true); break;
5966 default: UNIMPLEMENTED();
5967 }
5968 }
5969 }
5970
glEnd()5971 void APIENTRY glEnd()
5972 {
5973 TRACE("()");
5974
5975 gl::Context *context = gl::getContext();
5976
5977 if(context)
5978 {
5979 if(context->getListIndex() != 0)
5980 {
5981 UNIMPLEMENTED();
5982 }
5983
5984 context->end();
5985 }
5986 }
5987
glEndList()5988 void APIENTRY glEndList()
5989 {
5990 TRACE("()");
5991
5992 gl::Context *context = gl::getContext();
5993
5994 if(context)
5995 {
5996 context->endList();
5997 }
5998 }
5999
glEvalCoord1d(GLdouble u)6000 void APIENTRY glEvalCoord1d(GLdouble u)
6001 {
6002 UNIMPLEMENTED();
6003 }
6004
glEvalCoord1dv(const GLdouble * u)6005 void APIENTRY glEvalCoord1dv(const GLdouble *u)
6006 {
6007 UNIMPLEMENTED();
6008 }
6009
glEvalCoord1f(GLfloat u)6010 void APIENTRY glEvalCoord1f(GLfloat u)
6011 {
6012 UNIMPLEMENTED();
6013 }
6014
glEvalCoord1fv(const GLfloat * u)6015 void APIENTRY glEvalCoord1fv(const GLfloat *u)
6016 {
6017 UNIMPLEMENTED();
6018 }
6019
glEvalCoord2d(GLdouble u,GLdouble v)6020 void APIENTRY glEvalCoord2d(GLdouble u, GLdouble v)
6021 {
6022 UNIMPLEMENTED();
6023 }
6024
glEvalCoord2dv(const GLdouble * u)6025 void APIENTRY glEvalCoord2dv(const GLdouble *u)
6026 {
6027 UNIMPLEMENTED();
6028 }
6029
glEvalCoord2f(GLfloat u,GLfloat v)6030 void APIENTRY glEvalCoord2f(GLfloat u, GLfloat v)
6031 {
6032 UNIMPLEMENTED();
6033 }
6034
glEvalCoord2fv(const GLfloat * u)6035 void APIENTRY glEvalCoord2fv(const GLfloat *u)
6036 {
6037 UNIMPLEMENTED();
6038 }
6039
glEvalMesh1(GLenum mode,GLint i1,GLint i2)6040 void APIENTRY glEvalMesh1(GLenum mode, GLint i1, GLint i2)
6041 {
6042 UNIMPLEMENTED();
6043 }
6044
glEvalMesh2(GLenum mode,GLint i1,GLint i2,GLint j1,GLint j2)6045 void APIENTRY glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
6046 {
6047 UNIMPLEMENTED();
6048 }
6049
glEvalPoint1(GLint i)6050 void APIENTRY glEvalPoint1(GLint i)
6051 {
6052 UNIMPLEMENTED();
6053 }
6054
glEvalPoint2(GLint i,GLint j)6055 void APIENTRY glEvalPoint2(GLint i, GLint j)
6056 {
6057 UNIMPLEMENTED();
6058 }
6059
glFeedbackBuffer(GLsizei size,GLenum type,GLfloat * buffer)6060 void APIENTRY glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
6061 {
6062 UNIMPLEMENTED();
6063 }
6064
glFogf(GLenum pname,GLfloat param)6065 void APIENTRY glFogf(GLenum pname, GLfloat param)
6066 {
6067 TRACE("(GLenum pname = 0x%X, GLfloat param = %f)", pname, param);
6068
6069 gl::Context *context = gl::getContext();
6070
6071 if(context)
6072 {
6073 if(context->getListIndex() != 0)
6074 {
6075 UNIMPLEMENTED();
6076 }
6077
6078 gl::Device *device = gl::getDevice(); // FIXME
6079
6080 switch(pname)
6081 {
6082 case GL_FOG_START: device->setFogStart(param); break;
6083 case GL_FOG_END: device->setFogEnd(param); break;
6084 default:
6085 UNIMPLEMENTED();
6086 return error(GL_INVALID_ENUM);
6087 }
6088 }
6089 }
6090
glFogfv(GLenum pname,const GLfloat * params)6091 void APIENTRY glFogfv(GLenum pname, const GLfloat *params)
6092 {
6093 TRACE("(GLenum pname = 0x%X, const GLfloat *params)", pname);
6094
6095 gl::Context *context = gl::getContext();
6096
6097 if(context)
6098 {
6099 if(context->getListIndex() != 0)
6100 {
6101 UNIMPLEMENTED();
6102 }
6103
6104 switch(pname)
6105 {
6106 case GL_FOG_COLOR:
6107 {
6108 gl::Device *device = gl::getDevice(); // FIXME
6109 device->setFogColor(sw::Color<float>(params[0], params[1], params[2], params[3]));
6110 }
6111 break;
6112 default:
6113 UNIMPLEMENTED();
6114 return error(GL_INVALID_ENUM);
6115 }
6116 }
6117 }
6118
glFogi(GLenum pname,GLint param)6119 void APIENTRY glFogi(GLenum pname, GLint param)
6120 {
6121 TRACE("(GLenum pname = 0x%X, GLint param = %d)", pname, param);
6122
6123 gl::Context *context = gl::getContext();
6124
6125 if(context)
6126 {
6127 if(context->getListIndex() != 0)
6128 {
6129 UNIMPLEMENTED();
6130 }
6131
6132 switch(pname)
6133 {
6134 case GL_FOG_MODE:
6135 {
6136 gl::Device *device = gl::getDevice(); // FIXME
6137 switch(param)
6138 {
6139 case GL_LINEAR: device->setVertexFogMode(sw::FOG_LINEAR); break;
6140 default:
6141 UNIMPLEMENTED();
6142 return error(GL_INVALID_ENUM);
6143 }
6144 }
6145 break;
6146 default:
6147 UNIMPLEMENTED();
6148 return error(GL_INVALID_ENUM);
6149 }
6150 }
6151 }
6152
glFogiv(GLenum pname,const GLint * params)6153 void APIENTRY glFogiv(GLenum pname, const GLint *params)
6154 {
6155 UNIMPLEMENTED();
6156 }
6157
glFrustum(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar)6158 void APIENTRY glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
6159 {
6160 TRACE("(GLdouble left = %f, GLdouble right = %f, GLdouble bottom = %f, GLdouble top = %f, GLdouble zNear = %f, GLdouble zFar = %f)", left, right, bottom, top, zNear, zFar);
6161
6162 gl::Context *context = gl::getContext();
6163
6164 if(context)
6165 {
6166 if(context->getListIndex() != 0)
6167 {
6168 UNIMPLEMENTED();
6169 }
6170
6171 context->frustum(left, right, bottom, top, zNear, zFar);
6172 }
6173 }
6174
glGenLists(GLsizei range)6175 GLuint APIENTRY glGenLists(GLsizei range)
6176 {
6177 TRACE("(GLsizei range = %d)", range);
6178
6179 if(range < 0)
6180 {
6181 return error(GL_INVALID_VALUE, 0);
6182 }
6183
6184 gl::Context *context = gl::getContext();
6185
6186 if(context)
6187 {
6188 return context->genLists(range);
6189 }
6190
6191 return 0;
6192 }
6193
glGetClipPlane(GLenum plane,GLdouble * equation)6194 void APIENTRY glGetClipPlane(GLenum plane, GLdouble *equation)
6195 {
6196 UNIMPLEMENTED();
6197 }
6198
glGetDoublev(GLenum pname,GLdouble * params)6199 void APIENTRY glGetDoublev(GLenum pname, GLdouble *params)
6200 {
6201 UNIMPLEMENTED();
6202 }
6203
glGetLightfv(GLenum light,GLenum pname,GLfloat * params)6204 void APIENTRY glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
6205 {
6206 UNIMPLEMENTED();
6207 }
6208
glGetLightiv(GLenum light,GLenum pname,GLint * params)6209 void APIENTRY glGetLightiv(GLenum light, GLenum pname, GLint *params)
6210 {
6211 UNIMPLEMENTED();
6212 }
6213
glGetMapdv(GLenum target,GLenum query,GLdouble * v)6214 void APIENTRY glGetMapdv(GLenum target, GLenum query, GLdouble *v)
6215 {
6216 UNIMPLEMENTED();
6217 }
6218
glGetMapfv(GLenum target,GLenum query,GLfloat * v)6219 void APIENTRY glGetMapfv(GLenum target, GLenum query, GLfloat *v)
6220 {
6221 UNIMPLEMENTED();
6222 }
6223
glGetMapiv(GLenum target,GLenum query,GLint * v)6224 void APIENTRY glGetMapiv(GLenum target, GLenum query, GLint *v)
6225 {
6226 UNIMPLEMENTED();
6227 }
6228
glGetMaterialfv(GLenum face,GLenum pname,GLfloat * params)6229 void APIENTRY glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
6230 {
6231 UNIMPLEMENTED();
6232 }
6233
glGetMaterialiv(GLenum face,GLenum pname,GLint * params)6234 void APIENTRY glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
6235 {
6236 UNIMPLEMENTED();
6237 }
6238
glGetPixelMapfv(GLenum map,GLfloat * values)6239 void APIENTRY glGetPixelMapfv(GLenum map, GLfloat *values)
6240 {
6241 UNIMPLEMENTED();
6242 }
6243
glGetPixelMapuiv(GLenum map,GLuint * values)6244 void APIENTRY glGetPixelMapuiv(GLenum map, GLuint *values)
6245 {
6246 UNIMPLEMENTED();
6247 }
6248
glGetPixelMapusv(GLenum map,GLushort * values)6249 void APIENTRY glGetPixelMapusv(GLenum map, GLushort *values)
6250 {
6251 UNIMPLEMENTED();
6252 }
6253
glGetPointerv(GLenum pname,GLvoid ** params)6254 void APIENTRY glGetPointerv(GLenum pname, GLvoid* *params)
6255 {
6256 UNIMPLEMENTED();
6257 }
6258
glGetPolygonStipple(GLubyte * mask)6259 void APIENTRY glGetPolygonStipple(GLubyte *mask)
6260 {
6261 UNIMPLEMENTED();
6262 }
6263
glGetTexEnvfv(GLenum target,GLenum pname,GLfloat * params)6264 void APIENTRY glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
6265 {
6266 UNIMPLEMENTED();
6267 }
6268
glGetTexEnviv(GLenum target,GLenum pname,GLint * params)6269 void APIENTRY glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
6270 {
6271 UNIMPLEMENTED();
6272 }
6273
glGetTexGendv(GLenum coord,GLenum pname,GLdouble * params)6274 void APIENTRY glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
6275 {
6276 UNIMPLEMENTED();
6277 }
6278
glGetTexGenfv(GLenum coord,GLenum pname,GLfloat * params)6279 void APIENTRY glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
6280 {
6281 UNIMPLEMENTED();
6282 }
6283
glGetTexGeniv(GLenum coord,GLenum pname,GLint * params)6284 void APIENTRY glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
6285 {
6286 UNIMPLEMENTED();
6287 }
6288
glGetTexImage(GLenum target,GLint level,GLenum format,GLenum type,GLvoid * pixels)6289 void APIENTRY glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
6290 {
6291 TRACE("(GLenum target = 0x%X, GLint level = %d, GLenum format = 0x%X, GLenum type = 0x%X, GLint *pixels%p)", target, level, format, type, pixels);
6292
6293 gl::Context *context = gl::getContext();
6294
6295 if(context)
6296 {
6297 gl::Texture *texture;
6298
6299 switch(target)
6300 {
6301 case GL_TEXTURE_2D:
6302 texture = context->getTexture2D(target);
6303 break;
6304 case GL_TEXTURE_CUBE_MAP:
6305 texture = context->getTextureCubeMap();
6306 break;
6307 default:
6308 UNIMPLEMENTED();
6309 return error(GL_INVALID_ENUM);
6310 }
6311
6312 if(format == texture->getFormat(target, level) && type == texture->getType(target, level))
6313 {
6314 gl::Image *image = texture->getRenderTarget(target, level);
6315 void *source = image->lock(0, 0, sw::LOCK_READONLY);
6316 memcpy(pixels, source, image->getPitch() * image->getHeight());
6317 image->unlock();
6318 }
6319 else
6320 {
6321 UNIMPLEMENTED();
6322 }
6323 }
6324 }
6325
glGetTexLevelParameterfv(GLenum target,GLint level,GLenum pname,GLfloat * params)6326 void APIENTRY glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
6327 {
6328 UNIMPLEMENTED();
6329 }
6330
glGetTexLevelParameteriv(GLenum target,GLint level,GLenum pname,GLint * params)6331 void APIENTRY glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
6332 {
6333 TRACE("(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLint *params = %p)", target, level, pname, params);
6334
6335 gl::Context *context = gl::getContext();
6336
6337 if(context)
6338 {
6339 gl::Texture *texture;
6340
6341 switch(target)
6342 {
6343 case GL_TEXTURE_2D:
6344 case GL_PROXY_TEXTURE_2D:
6345 texture = context->getTexture2D(target);
6346 break;
6347 case GL_TEXTURE_CUBE_MAP:
6348 texture = context->getTextureCubeMap();
6349 break;
6350 default:
6351 UNIMPLEMENTED();
6352 return error(GL_INVALID_ENUM);
6353 }
6354
6355 switch(pname)
6356 {
6357 case GL_TEXTURE_MAG_FILTER:
6358 *params = texture->getMagFilter();
6359 break;
6360 case GL_TEXTURE_MIN_FILTER:
6361 *params = texture->getMinFilter();
6362 break;
6363 case GL_TEXTURE_WRAP_S:
6364 *params = texture->getWrapS();
6365 break;
6366 case GL_TEXTURE_WRAP_T:
6367 *params = texture->getWrapT();
6368 break;
6369 case GL_TEXTURE_WIDTH:
6370 *params = texture->getWidth(target, level);
6371 break;
6372 case GL_TEXTURE_HEIGHT:
6373 *params = texture->getHeight(target, level);
6374 break;
6375 case GL_TEXTURE_INTERNAL_FORMAT:
6376 *params = texture->getInternalFormat(target, level);
6377 break;
6378 case GL_TEXTURE_BORDER_COLOR:
6379 UNIMPLEMENTED();
6380 break;
6381 case GL_TEXTURE_BORDER:
6382 UNIMPLEMENTED();
6383 break;
6384 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
6385 *params = (GLint)texture->getMaxAnisotropy();
6386 break;
6387 default:
6388 return error(GL_INVALID_ENUM);
6389 }
6390 }
6391 }
6392
glIndexMask(GLuint mask)6393 void APIENTRY glIndexMask(GLuint mask)
6394 {
6395 UNIMPLEMENTED();
6396 }
6397
glIndexPointer(GLenum type,GLsizei stride,const GLvoid * pointer)6398 void APIENTRY glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
6399 {
6400 UNIMPLEMENTED();
6401 }
6402
glIndexd(GLdouble c)6403 void APIENTRY glIndexd(GLdouble c)
6404 {
6405 UNIMPLEMENTED();
6406 }
6407
glIndexdv(const GLdouble * c)6408 void APIENTRY glIndexdv(const GLdouble *c)
6409 {
6410 UNIMPLEMENTED();
6411 }
6412
glIndexf(GLfloat c)6413 void APIENTRY glIndexf(GLfloat c)
6414 {
6415 UNIMPLEMENTED();
6416 }
6417
glIndexfv(const GLfloat * c)6418 void APIENTRY glIndexfv(const GLfloat *c)
6419 {
6420 UNIMPLEMENTED();
6421 }
6422
glIndexi(GLint c)6423 void APIENTRY glIndexi(GLint c)
6424 {
6425 UNIMPLEMENTED();
6426 }
6427
glIndexiv(const GLint * c)6428 void APIENTRY glIndexiv(const GLint *c)
6429 {
6430 UNIMPLEMENTED();
6431 }
6432
glIndexs(GLshort c)6433 void APIENTRY glIndexs(GLshort c)
6434 {
6435 UNIMPLEMENTED();
6436 }
6437
glIndexsv(const GLshort * c)6438 void APIENTRY glIndexsv(const GLshort *c)
6439 {
6440 UNIMPLEMENTED();
6441 }
6442
glIndexub(GLubyte c)6443 void APIENTRY glIndexub(GLubyte c)
6444 {
6445 UNIMPLEMENTED();
6446 }
6447
glIndexubv(const GLubyte * c)6448 void APIENTRY glIndexubv(const GLubyte *c)
6449 {
6450 UNIMPLEMENTED();
6451 }
6452
glInitNames(void)6453 void APIENTRY glInitNames(void)
6454 {
6455 UNIMPLEMENTED();
6456 }
6457
glInterleavedArrays(GLenum format,GLsizei stride,const GLvoid * pointer)6458 void APIENTRY glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
6459 {
6460 UNIMPLEMENTED();
6461 }
6462
glIsList(GLuint list)6463 GLboolean APIENTRY glIsList(GLuint list)
6464 {
6465 UNIMPLEMENTED();
6466 return GL_FALSE;
6467 }
6468
glLightModelf(GLenum pname,GLfloat param)6469 void APIENTRY glLightModelf(GLenum pname, GLfloat param)
6470 {
6471 UNIMPLEMENTED();
6472 }
6473
glLightModelfv(GLenum pname,const GLfloat * params)6474 void APIENTRY glLightModelfv(GLenum pname, const GLfloat *params)
6475 {
6476 TRACE("(GLenum pname = 0x%X, const GLint *params)", pname);
6477
6478 gl::Context *context = gl::getContext();
6479
6480 if(context)
6481 {
6482 if(context->getListIndex() != 0)
6483 {
6484 UNIMPLEMENTED();
6485 }
6486
6487 gl::Device *device = gl::getDevice(); // FIXME
6488
6489 switch(pname)
6490 {
6491 case GL_LIGHT_MODEL_AMBIENT:
6492 device->setGlobalAmbient(sw::Color<float>(params[0], params[1], params[2], params[3]));
6493 break;
6494 default:
6495 UNIMPLEMENTED();
6496 return error(GL_INVALID_ENUM);
6497 }
6498 }
6499 }
6500
glLightModeli(GLenum pname,GLint param)6501 void APIENTRY glLightModeli(GLenum pname, GLint param)
6502 {
6503 UNIMPLEMENTED();
6504 }
6505
glLightModeliv(GLenum pname,const GLint * params)6506 void APIENTRY glLightModeliv(GLenum pname, const GLint *params)
6507 {
6508 TRACE("(GLenum pname = 0x%X, const GLint *params)", pname);
6509 UNIMPLEMENTED();
6510 }
6511
glLightf(GLenum light,GLenum pname,GLfloat param)6512 void APIENTRY glLightf(GLenum light, GLenum pname, GLfloat param)
6513 {
6514 UNIMPLEMENTED();
6515 }
6516
glLightfv(GLenum light,GLenum pname,const GLfloat * params)6517 void APIENTRY glLightfv(GLenum light, GLenum pname, const GLfloat *params)
6518 {
6519 TRACE("(GLenum light = 0x%X, GLenum pname = 0x%X, const GLint *params)", light, pname);
6520
6521 gl::Context *context = gl::getContext();
6522
6523 if(context)
6524 {
6525 if(context->getListIndex() != 0)
6526 {
6527 UNIMPLEMENTED();
6528 }
6529
6530 gl::Device *device = gl::getDevice(); // FIXME
6531
6532 switch(pname)
6533 {
6534 case GL_AMBIENT: device->setLightAmbient(light - GL_LIGHT0, sw::Color<float>(params[0], params[1], params[2], params[3])); break;
6535 case GL_DIFFUSE: device->setLightDiffuse(light - GL_LIGHT0, sw::Color<float>(params[0], params[1], params[2], params[3])); break;
6536 case GL_SPECULAR: device->setLightSpecular(light - GL_LIGHT0, sw::Color<float>(params[0], params[1], params[2], params[3])); break;
6537 case GL_POSITION:
6538 if(params[3] == 0.0f) // Directional light
6539 {
6540 // Create a very far out point light
6541 float max = sw::max(abs(params[0]), abs(params[1]), abs(params[2]));
6542 device->setLightPosition(light - GL_LIGHT0, sw::Point(params[0] / max * 1e10f, params[1] / max * 1e10f, params[2] / max * 1e10f));
6543 }
6544 else
6545 {
6546 device->setLightPosition(light - GL_LIGHT0, sw::Point(params[0] / params[3], params[1] / params[3], params[2] / params[3]));
6547 }
6548 break;
6549 default:
6550 UNIMPLEMENTED();
6551 return error(GL_INVALID_ENUM);
6552 }
6553 }
6554 }
6555
glLighti(GLenum light,GLenum pname,GLint param)6556 void APIENTRY glLighti(GLenum light, GLenum pname, GLint param)
6557 {
6558 UNIMPLEMENTED();
6559 }
6560
glLightiv(GLenum light,GLenum pname,const GLint * params)6561 void APIENTRY glLightiv(GLenum light, GLenum pname, const GLint *params)
6562 {
6563 UNIMPLEMENTED();
6564 }
6565
glLineStipple(GLint factor,GLushort pattern)6566 void APIENTRY glLineStipple(GLint factor, GLushort pattern)
6567 {
6568 UNIMPLEMENTED();
6569 }
6570
glListBase(GLuint base)6571 void APIENTRY glListBase(GLuint base)
6572 {
6573 UNIMPLEMENTED();
6574 }
6575
glLoadIdentity()6576 void APIENTRY glLoadIdentity()
6577 {
6578 TRACE("()");
6579
6580 gl::Context *context = gl::getContext();
6581
6582 if(context)
6583 {
6584 if(context->getListIndex() != 0)
6585 {
6586 UNIMPLEMENTED();
6587 }
6588
6589 context->loadIdentity();
6590 }
6591 }
6592
glLoadMatrixd(const GLdouble * m)6593 void APIENTRY glLoadMatrixd(const GLdouble *m)
6594 {
6595 UNIMPLEMENTED();
6596 }
6597
glLoadMatrixf(const GLfloat * m)6598 void APIENTRY glLoadMatrixf(const GLfloat *m)
6599 {
6600 UNIMPLEMENTED();
6601 }
6602
glLoadName(GLuint name)6603 void APIENTRY glLoadName(GLuint name)
6604 {
6605 UNIMPLEMENTED();
6606 }
6607
glLogicOp(GLenum opcode)6608 void APIENTRY glLogicOp(GLenum opcode)
6609 {
6610 TRACE("(GLenum opcode = 0x%X)", opcode);
6611
6612 switch(opcode)
6613 {
6614 case GL_CLEAR:
6615 case GL_SET:
6616 case GL_COPY:
6617 case GL_COPY_INVERTED:
6618 case GL_NOOP:
6619 case GL_INVERT:
6620 case GL_AND:
6621 case GL_NAND:
6622 case GL_OR:
6623 case GL_NOR:
6624 case GL_XOR:
6625 case GL_EQUIV:
6626 case GL_AND_REVERSE:
6627 case GL_AND_INVERTED:
6628 case GL_OR_REVERSE:
6629 case GL_OR_INVERTED:
6630 break;
6631 default:
6632 return error(GL_INVALID_ENUM);
6633 }
6634
6635 gl::Context *context = gl::getContext();
6636
6637 if(context)
6638 {
6639 if(context->getListIndex() != 0)
6640 {
6641 UNIMPLEMENTED();
6642 }
6643
6644 context->setLogicalOperation(opcode);
6645 }
6646 }
6647
glMap1d(GLenum target,GLdouble u1,GLdouble u2,GLint stride,GLint order,const GLdouble * points)6648 void APIENTRY glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
6649 {
6650 UNIMPLEMENTED();
6651 }
6652
glMap1f(GLenum target,GLfloat u1,GLfloat u2,GLint stride,GLint order,const GLfloat * points)6653 void APIENTRY glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
6654 {
6655 UNIMPLEMENTED();
6656 }
6657
glMap2d(GLenum target,GLdouble u1,GLdouble u2,GLint ustride,GLint uorder,GLdouble v1,GLdouble v2,GLint vstride,GLint vorder,const GLdouble * points)6658 void APIENTRY glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
6659 {
6660 UNIMPLEMENTED();
6661 }
6662
glMap2f(GLenum target,GLfloat u1,GLfloat u2,GLint ustride,GLint uorder,GLfloat v1,GLfloat v2,GLint vstride,GLint vorder,const GLfloat * points)6663 void APIENTRY glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
6664 {
6665 UNIMPLEMENTED();
6666 }
6667
glMapGrid1d(GLint un,GLdouble u1,GLdouble u2)6668 void APIENTRY glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
6669 {
6670 UNIMPLEMENTED();
6671 }
6672
glMapGrid1f(GLint un,GLfloat u1,GLfloat u2)6673 void APIENTRY glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
6674 {
6675 UNIMPLEMENTED();
6676 }
6677
glMapGrid2d(GLint un,GLdouble u1,GLdouble u2,GLint vn,GLdouble v1,GLdouble v2)6678 void APIENTRY glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
6679 {
6680 UNIMPLEMENTED();
6681 }
6682
glMapGrid2f(GLint un,GLfloat u1,GLfloat u2,GLint vn,GLfloat v1,GLfloat v2)6683 void APIENTRY glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
6684 {
6685 UNIMPLEMENTED();
6686 }
6687
glMaterialf(GLenum face,GLenum pname,GLfloat param)6688 void APIENTRY glMaterialf(GLenum face, GLenum pname, GLfloat param)
6689 {
6690 UNIMPLEMENTED();
6691 }
6692
glMaterialfv(GLenum face,GLenum pname,const GLfloat * params)6693 void APIENTRY glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
6694 {
6695 UNIMPLEMENTED();
6696 }
6697
glMateriali(GLenum face,GLenum pname,GLint param)6698 void APIENTRY glMateriali(GLenum face, GLenum pname, GLint param)
6699 {
6700 UNIMPLEMENTED();
6701 }
6702
glMaterialiv(GLenum face,GLenum pname,const GLint * params)6703 void APIENTRY glMaterialiv(GLenum face, GLenum pname, const GLint *params)
6704 {
6705 UNIMPLEMENTED();
6706 }
6707
glMatrixMode(GLenum mode)6708 void APIENTRY glMatrixMode(GLenum mode)
6709 {
6710 TRACE("(*)");
6711
6712 gl::Context *context = gl::getContext();
6713
6714 if(context)
6715 {
6716 if(context->getListIndex() != 0)
6717 {
6718 UNIMPLEMENTED();
6719 }
6720
6721 context->setMatrixMode(mode);
6722 }
6723 }
6724
glMultMatrixd(const GLdouble * m)6725 void APIENTRY glMultMatrixd(const GLdouble *m)
6726 {
6727 TRACE("(*)");
6728
6729 gl::Context *context = gl::getContext();
6730
6731 if(context)
6732 {
6733 if(context->getListIndex() != 0)
6734 {
6735 UNIMPLEMENTED();
6736 }
6737
6738 context->multiply(m);
6739 }
6740 }
6741
glMultMatrixm(sw::Matrix m)6742 void APIENTRY glMultMatrixm(sw::Matrix m)
6743 {
6744 gl::Context *context = gl::getContext();
6745
6746 if(context)
6747 {
6748 context->multiply((GLfloat*)m.m);
6749 }
6750 }
6751
glMultMatrixf(const GLfloat * m)6752 void APIENTRY glMultMatrixf(const GLfloat *m)
6753 {
6754 TRACE("(*)");
6755
6756 gl::Context *context = gl::getContext();
6757
6758 if(context)
6759 {
6760 if(context->getListIndex() != 0)
6761 {
6762 return context->listCommand(gl::newCommand(glMultMatrixm, sw::Matrix(m)));
6763 }
6764
6765 context->multiply(m);
6766 }
6767 }
6768
glNewList(GLuint list,GLenum mode)6769 void APIENTRY glNewList(GLuint list, GLenum mode)
6770 {
6771 TRACE("(GLuint list = %d, GLenum mode = 0x%X)", list, mode);
6772
6773 if(list == 0)
6774 {
6775 return error(GL_INVALID_VALUE);
6776 }
6777
6778 switch(mode)
6779 {
6780 case GL_COMPILE:
6781 case GL_COMPILE_AND_EXECUTE:
6782 break;
6783 default:
6784 return error(GL_INVALID_ENUM);
6785 }
6786
6787 gl::Context *context = gl::getContext();
6788
6789 if(context)
6790 {
6791 if(context->getListIndex() != 0)
6792 {
6793 UNIMPLEMENTED();
6794 }
6795
6796 context->newList(list, mode);
6797 }
6798 }
6799
glNormal3b(GLbyte nx,GLbyte ny,GLbyte nz)6800 void APIENTRY glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
6801 {
6802 UNIMPLEMENTED();
6803 }
6804
glNormal3bv(const GLbyte * v)6805 void APIENTRY glNormal3bv(const GLbyte *v)
6806 {
6807 UNIMPLEMENTED();
6808 }
6809
glNormal3d(GLdouble nx,GLdouble ny,GLdouble nz)6810 void APIENTRY glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
6811 {
6812 UNIMPLEMENTED();
6813 }
6814
glNormal3dv(const GLdouble * v)6815 void APIENTRY glNormal3dv(const GLdouble *v)
6816 {
6817 UNIMPLEMENTED();
6818 }
6819
glNormal3f(GLfloat nx,GLfloat ny,GLfloat nz)6820 void APIENTRY glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
6821 {
6822 TRACE("(GLfloat nx = %f, GLfloat ny = %f, GLfloat nz = %f)", nx, ny, nz);
6823
6824 gl::Context *context = gl::getContext();
6825
6826 if(context)
6827 {
6828 if(context->getListIndex() != 0)
6829 {
6830 UNIMPLEMENTED();
6831 }
6832
6833 //context->normal(nx, ny, nz);
6834 context->setVertexAttrib(sw::Normal, nx, ny, nz, 0);
6835 }
6836 }
6837
glNormal3fv(const GLfloat * v)6838 void APIENTRY glNormal3fv(const GLfloat *v)
6839 {
6840 UNIMPLEMENTED();
6841 }
6842
glNormal3i(GLint nx,GLint ny,GLint nz)6843 void APIENTRY glNormal3i(GLint nx, GLint ny, GLint nz)
6844 {
6845 UNIMPLEMENTED();
6846 }
6847
glNormal3iv(const GLint * v)6848 void APIENTRY glNormal3iv(const GLint *v)
6849 {
6850 UNIMPLEMENTED();
6851 }
6852
glNormal3s(GLshort nx,GLshort ny,GLshort nz)6853 void APIENTRY glNormal3s(GLshort nx, GLshort ny, GLshort nz)
6854 {
6855 UNIMPLEMENTED();
6856 }
6857
glNormal3sv(const GLshort * v)6858 void APIENTRY glNormal3sv(const GLshort *v)
6859 {
6860 UNIMPLEMENTED();
6861 }
6862
glNormalPointer(GLenum type,GLsizei stride,const GLvoid * pointer)6863 void APIENTRY glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
6864 {
6865 TRACE("(*)");
6866
6867 glVertexAttribPointer(sw::Normal, 3, type, true, stride, pointer);
6868 }
6869
glOrtho(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar)6870 void APIENTRY glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
6871 {
6872 TRACE("(*)");
6873
6874 gl::Context *context = gl::getContext();
6875
6876 if(context)
6877 {
6878 if(context->getListIndex() != 0)
6879 {
6880 UNIMPLEMENTED();
6881 }
6882
6883 context->ortho(left, right, bottom, top, zNear, zFar);
6884 }
6885 }
6886
glPassThrough(GLfloat token)6887 void APIENTRY glPassThrough(GLfloat token)
6888 {
6889 UNIMPLEMENTED();
6890 }
6891
glPixelMapfv(GLenum map,GLsizei mapsize,const GLfloat * values)6892 void APIENTRY glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
6893 {
6894 UNIMPLEMENTED();
6895 }
6896
glPixelMapuiv(GLenum map,GLsizei mapsize,const GLuint * values)6897 void APIENTRY glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
6898 {
6899 UNIMPLEMENTED();
6900 }
6901
glPixelMapusv(GLenum map,GLsizei mapsize,const GLushort * values)6902 void APIENTRY glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
6903 {
6904 UNIMPLEMENTED();
6905 }
6906
glPixelStoref(GLenum pname,GLfloat param)6907 void APIENTRY glPixelStoref(GLenum pname, GLfloat param)
6908 {
6909 UNIMPLEMENTED();
6910 }
6911
glPixelTransferf(GLenum pname,GLfloat param)6912 void APIENTRY glPixelTransferf(GLenum pname, GLfloat param)
6913 {
6914 UNIMPLEMENTED();
6915 }
6916
glPixelTransferi(GLenum pname,GLint param)6917 void APIENTRY glPixelTransferi(GLenum pname, GLint param)
6918 {
6919 UNIMPLEMENTED();
6920 }
6921
glPixelZoom(GLfloat xfactor,GLfloat yfactor)6922 void APIENTRY glPixelZoom(GLfloat xfactor, GLfloat yfactor)
6923 {
6924 UNIMPLEMENTED();
6925 }
6926
glPointSize(GLfloat size)6927 void APIENTRY glPointSize(GLfloat size)
6928 {
6929 UNIMPLEMENTED();
6930 }
6931
glPolygonMode(GLenum face,GLenum mode)6932 void APIENTRY glPolygonMode(GLenum face, GLenum mode)
6933 {
6934 UNIMPLEMENTED();
6935 }
6936
glPolygonStipple(const GLubyte * mask)6937 void APIENTRY glPolygonStipple(const GLubyte *mask)
6938 {
6939 UNIMPLEMENTED();
6940 }
6941
glPopAttrib(void)6942 void APIENTRY glPopAttrib(void)
6943 {
6944 UNIMPLEMENTED();
6945 }
6946
glPopClientAttrib(void)6947 void APIENTRY glPopClientAttrib(void)
6948 {
6949 UNIMPLEMENTED();
6950 }
6951
glPopMatrix(void)6952 void APIENTRY glPopMatrix(void)
6953 {
6954 TRACE("()");
6955
6956 gl::Context *context = gl::getContext();
6957
6958 if(context)
6959 {
6960 if(context->getListIndex() != 0)
6961 {
6962 return context->listCommand(gl::newCommand(glPopMatrix));
6963 }
6964
6965 context->popMatrix();
6966 }
6967 }
6968
glPopName(void)6969 void APIENTRY glPopName(void)
6970 {
6971 UNIMPLEMENTED();
6972 }
6973
glPrioritizeTextures(GLsizei n,const GLuint * textures,const GLclampf * priorities)6974 void APIENTRY glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
6975 {
6976 UNIMPLEMENTED();
6977 }
6978
glPushAttrib(GLbitfield mask)6979 void APIENTRY glPushAttrib(GLbitfield mask)
6980 {
6981 UNIMPLEMENTED();
6982 }
6983
glPushClientAttrib(GLbitfield mask)6984 void APIENTRY glPushClientAttrib(GLbitfield mask)
6985 {
6986 UNIMPLEMENTED();
6987 }
6988
glPushMatrix(void)6989 void APIENTRY glPushMatrix(void)
6990 {
6991 TRACE("()");
6992
6993 gl::Context *context = gl::getContext();
6994
6995 if(context)
6996 {
6997 if(context->getListIndex() != 0)
6998 {
6999 return context->listCommand(gl::newCommand(glPushMatrix));
7000 }
7001
7002 context->pushMatrix();
7003 }
7004 }
7005
glPushName(GLuint name)7006 void APIENTRY glPushName(GLuint name)
7007 {
7008 UNIMPLEMENTED();
7009 }
7010
glRasterPos2d(GLdouble x,GLdouble y)7011 void APIENTRY glRasterPos2d(GLdouble x, GLdouble y)
7012 {
7013 UNIMPLEMENTED();
7014 }
7015
glRasterPos2dv(const GLdouble * v)7016 void APIENTRY glRasterPos2dv(const GLdouble *v)
7017 {
7018 UNIMPLEMENTED();
7019 }
7020
glRasterPos2f(GLfloat x,GLfloat y)7021 void APIENTRY glRasterPos2f(GLfloat x, GLfloat y)
7022 {
7023 UNIMPLEMENTED();
7024 }
7025
glRasterPos2fv(const GLfloat * v)7026 void APIENTRY glRasterPos2fv(const GLfloat *v)
7027 {
7028 UNIMPLEMENTED();
7029 }
7030
glRasterPos2i(GLint x,GLint y)7031 void APIENTRY glRasterPos2i(GLint x, GLint y)
7032 {
7033 UNIMPLEMENTED();
7034 }
7035
glRasterPos2iv(const GLint * v)7036 void APIENTRY glRasterPos2iv(const GLint *v)
7037 {
7038 UNIMPLEMENTED();
7039 }
7040
glRasterPos2s(GLshort x,GLshort y)7041 void APIENTRY glRasterPos2s(GLshort x, GLshort y)
7042 {
7043 UNIMPLEMENTED();
7044 }
7045
glRasterPos2sv(const GLshort * v)7046 void APIENTRY glRasterPos2sv(const GLshort *v)
7047 {
7048 UNIMPLEMENTED();
7049 }
7050
glRasterPos3d(GLdouble x,GLdouble y,GLdouble z)7051 void APIENTRY glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
7052 {
7053 UNIMPLEMENTED();
7054 }
7055
glRasterPos3dv(const GLdouble * v)7056 void APIENTRY glRasterPos3dv(const GLdouble *v)
7057 {
7058 UNIMPLEMENTED();
7059 }
7060
glRasterPos3f(GLfloat x,GLfloat y,GLfloat z)7061 void APIENTRY glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
7062 {
7063 UNIMPLEMENTED();
7064 }
7065
glRasterPos3fv(const GLfloat * v)7066 void APIENTRY glRasterPos3fv(const GLfloat *v)
7067 {
7068 UNIMPLEMENTED();
7069 }
7070
glRasterPos3i(GLint x,GLint y,GLint z)7071 void APIENTRY glRasterPos3i(GLint x, GLint y, GLint z)
7072 {
7073 UNIMPLEMENTED();
7074 }
7075
glRasterPos3iv(const GLint * v)7076 void APIENTRY glRasterPos3iv(const GLint *v)
7077 {
7078 UNIMPLEMENTED();
7079 }
7080
glRasterPos3s(GLshort x,GLshort y,GLshort z)7081 void APIENTRY glRasterPos3s(GLshort x, GLshort y, GLshort z)
7082 {
7083 UNIMPLEMENTED();
7084 }
7085
glRasterPos3sv(const GLshort * v)7086 void APIENTRY glRasterPos3sv(const GLshort *v)
7087 {
7088 UNIMPLEMENTED();
7089 }
7090
glRasterPos4d(GLdouble x,GLdouble y,GLdouble z,GLdouble w)7091 void APIENTRY glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
7092 {
7093 UNIMPLEMENTED();
7094 }
7095
glRasterPos4dv(const GLdouble * v)7096 void APIENTRY glRasterPos4dv(const GLdouble *v)
7097 {
7098 UNIMPLEMENTED();
7099 }
7100
glRasterPos4f(GLfloat x,GLfloat y,GLfloat z,GLfloat w)7101 void APIENTRY glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
7102 {
7103 UNIMPLEMENTED();
7104 }
7105
glRasterPos4fv(const GLfloat * v)7106 void APIENTRY glRasterPos4fv(const GLfloat *v)
7107 {
7108 UNIMPLEMENTED();
7109 }
7110
glRasterPos4i(GLint x,GLint y,GLint z,GLint w)7111 void APIENTRY glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
7112 {
7113 UNIMPLEMENTED();
7114 }
7115
glRasterPos4iv(const GLint * v)7116 void APIENTRY glRasterPos4iv(const GLint *v)
7117 {
7118 UNIMPLEMENTED();
7119 }
7120
glRasterPos4s(GLshort x,GLshort y,GLshort z,GLshort w)7121 void APIENTRY glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
7122 {
7123 UNIMPLEMENTED();
7124 }
7125
glRasterPos4sv(const GLshort * v)7126 void APIENTRY glRasterPos4sv(const GLshort *v)
7127 {
7128 UNIMPLEMENTED();
7129 }
7130
glReadBuffer(GLenum mode)7131 void APIENTRY glReadBuffer(GLenum mode)
7132 {
7133 UNIMPLEMENTED();
7134 }
7135
glRectd(GLdouble x1,GLdouble y1,GLdouble x2,GLdouble y2)7136 void APIENTRY glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
7137 {
7138 UNIMPLEMENTED();
7139 }
7140
glRectdv(const GLdouble * v1,const GLdouble * v2)7141 void APIENTRY glRectdv(const GLdouble *v1, const GLdouble *v2)
7142 {
7143 UNIMPLEMENTED();
7144 }
7145
glRectf(GLfloat x1,GLfloat y1,GLfloat x2,GLfloat y2)7146 void APIENTRY glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
7147 {
7148 UNIMPLEMENTED();
7149 }
7150
glRectfv(const GLfloat * v1,const GLfloat * v2)7151 void APIENTRY glRectfv(const GLfloat *v1, const GLfloat *v2)
7152 {
7153 UNIMPLEMENTED();
7154 }
7155
glRecti(GLint x1,GLint y1,GLint x2,GLint y2)7156 void APIENTRY glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
7157 {
7158 UNIMPLEMENTED();
7159 }
7160
glRectiv(const GLint * v1,const GLint * v2)7161 void APIENTRY glRectiv(const GLint *v1, const GLint *v2)
7162 {
7163 UNIMPLEMENTED();
7164 }
7165
glRects(GLshort x1,GLshort y1,GLshort x2,GLshort y2)7166 void APIENTRY glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
7167 {
7168 UNIMPLEMENTED();
7169 }
7170
glRectsv(const GLshort * v1,const GLshort * v2)7171 void APIENTRY glRectsv(const GLshort *v1, const GLshort *v2)
7172 {
7173 UNIMPLEMENTED();
7174 }
7175
glRenderMode(GLenum mode)7176 GLint APIENTRY glRenderMode(GLenum mode)
7177 {
7178 UNIMPLEMENTED();
7179 return 0;
7180 }
7181
glRotated(GLdouble angle,GLdouble x,GLdouble y,GLdouble z)7182 void APIENTRY glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
7183 {
7184 UNIMPLEMENTED();
7185 }
7186
glRotatef(GLfloat angle,GLfloat x,GLfloat y,GLfloat z)7187 void APIENTRY glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
7188 {
7189 TRACE("(*)");
7190
7191 gl::Context *context = gl::getContext();
7192
7193 if(context)
7194 {
7195 if(context->getListIndex() != 0)
7196 {
7197 UNIMPLEMENTED();
7198 }
7199
7200 context->rotate(angle, x, y, z);
7201 }
7202 }
7203
glScaled(GLdouble x,GLdouble y,GLdouble z)7204 void APIENTRY glScaled(GLdouble x, GLdouble y, GLdouble z)
7205 {
7206 UNIMPLEMENTED();
7207 }
7208
glScalef(GLfloat x,GLfloat y,GLfloat z)7209 void APIENTRY glScalef(GLfloat x, GLfloat y, GLfloat z)
7210 {
7211 TRACE("(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", x, y, z);
7212
7213 gl::Context *context = gl::getContext();
7214
7215 if(context)
7216 {
7217 if(context->getListIndex() != 0)
7218 {
7219 return context->listCommand(gl::newCommand(glScalef, x, y, z));
7220 }
7221
7222 context->scale(x, y, z);
7223 }
7224 }
7225
glSelectBuffer(GLsizei size,GLuint * buffer)7226 void APIENTRY glSelectBuffer(GLsizei size, GLuint *buffer)
7227 {
7228 UNIMPLEMENTED();
7229 }
7230
glShadeModel(GLenum mode)7231 void APIENTRY glShadeModel(GLenum mode)
7232 {
7233 TRACE("(*)");
7234
7235 gl::Context *context = gl::getContext();
7236
7237 if(context)
7238 {
7239 if(context->getListIndex() != 0)
7240 {
7241 UNIMPLEMENTED();
7242 }
7243
7244 context->setShadeModel(mode);
7245 }
7246 }
7247
glTexCoord1d(GLdouble s)7248 void APIENTRY glTexCoord1d(GLdouble s)
7249 {
7250 UNIMPLEMENTED();
7251 }
7252
glTexCoord1dv(const GLdouble * v)7253 void APIENTRY glTexCoord1dv(const GLdouble *v)
7254 {
7255 UNIMPLEMENTED();
7256 }
7257
glTexCoord1f(GLfloat s)7258 void APIENTRY glTexCoord1f(GLfloat s)
7259 {
7260 UNIMPLEMENTED();
7261 }
7262
glTexCoord1fv(const GLfloat * v)7263 void APIENTRY glTexCoord1fv(const GLfloat *v)
7264 {
7265 UNIMPLEMENTED();
7266 }
7267
glTexCoord1i(GLint s)7268 void APIENTRY glTexCoord1i(GLint s)
7269 {
7270 UNIMPLEMENTED();
7271 }
7272
glTexCoord1iv(const GLint * v)7273 void APIENTRY glTexCoord1iv(const GLint *v)
7274 {
7275 UNIMPLEMENTED();
7276 }
7277
glTexCoord1s(GLshort s)7278 void APIENTRY glTexCoord1s(GLshort s)
7279 {
7280 UNIMPLEMENTED();
7281 }
7282
glTexCoord1sv(const GLshort * v)7283 void APIENTRY glTexCoord1sv(const GLshort *v)
7284 {
7285 UNIMPLEMENTED();
7286 }
7287
glTexCoord2d(GLdouble s,GLdouble t)7288 void APIENTRY glTexCoord2d(GLdouble s, GLdouble t)
7289 {
7290 UNIMPLEMENTED();
7291 }
7292
glTexCoord2dv(const GLdouble * v)7293 void APIENTRY glTexCoord2dv(const GLdouble *v)
7294 {
7295 UNIMPLEMENTED();
7296 }
7297
glTexCoord2f(GLfloat s,GLfloat t)7298 void APIENTRY glTexCoord2f(GLfloat s, GLfloat t)
7299 {
7300 TRACE("(GLfloat s = %f, GLfloat t = %f)", s, t);
7301
7302 gl::Context *context = gl::getContext();
7303
7304 if(context)
7305 {
7306 if(context->getListIndex() != 0)
7307 {
7308 UNIMPLEMENTED();
7309 }
7310
7311 //context->texCoord(s, t, 0.0f, 1.0f);
7312 unsigned int texture = context->getActiveTexture();
7313 context->setVertexAttrib(sw::TexCoord0/* + texture*/, s, t, 0.0f, 1.0f);
7314 }
7315 }
7316
glTexCoord2fv(const GLfloat * v)7317 void APIENTRY glTexCoord2fv(const GLfloat *v)
7318 {
7319 UNIMPLEMENTED();
7320 }
7321
glTexCoord2i(GLint s,GLint t)7322 void APIENTRY glTexCoord2i(GLint s, GLint t)
7323 {
7324 UNIMPLEMENTED();
7325 }
7326
glTexCoord2iv(const GLint * v)7327 void APIENTRY glTexCoord2iv(const GLint *v)
7328 {
7329 UNIMPLEMENTED();
7330 }
7331
glTexCoord2s(GLshort s,GLshort t)7332 void APIENTRY glTexCoord2s(GLshort s, GLshort t)
7333 {
7334 UNIMPLEMENTED();
7335 }
7336
glTexCoord2sv(const GLshort * v)7337 void APIENTRY glTexCoord2sv(const GLshort *v)
7338 {
7339 UNIMPLEMENTED();
7340 }
7341
glTexCoord3d(GLdouble s,GLdouble t,GLdouble r)7342 void APIENTRY glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
7343 {
7344 UNIMPLEMENTED();
7345 }
7346
glTexCoord3dv(const GLdouble * v)7347 void APIENTRY glTexCoord3dv(const GLdouble *v)
7348 {
7349 UNIMPLEMENTED();
7350 }
7351
glTexCoord3f(GLfloat s,GLfloat t,GLfloat r)7352 void APIENTRY glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
7353 {
7354 UNIMPLEMENTED();
7355 }
7356
glTexCoord3fv(const GLfloat * v)7357 void APIENTRY glTexCoord3fv(const GLfloat *v)
7358 {
7359 UNIMPLEMENTED();
7360 }
7361
glTexCoord3i(GLint s,GLint t,GLint r)7362 void APIENTRY glTexCoord3i(GLint s, GLint t, GLint r)
7363 {
7364 UNIMPLEMENTED();
7365 }
7366
glTexCoord3iv(const GLint * v)7367 void APIENTRY glTexCoord3iv(const GLint *v)
7368 {
7369 UNIMPLEMENTED();
7370 }
7371
glTexCoord3s(GLshort s,GLshort t,GLshort r)7372 void APIENTRY glTexCoord3s(GLshort s, GLshort t, GLshort r)
7373 {
7374 UNIMPLEMENTED();
7375 }
7376
glTexCoord3sv(const GLshort * v)7377 void APIENTRY glTexCoord3sv(const GLshort *v)
7378 {
7379 UNIMPLEMENTED();
7380 }
7381
glTexCoord4d(GLdouble s,GLdouble t,GLdouble r,GLdouble q)7382 void APIENTRY glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
7383 {
7384 UNIMPLEMENTED();
7385 }
7386
glTexCoord4dv(const GLdouble * v)7387 void APIENTRY glTexCoord4dv(const GLdouble *v)
7388 {
7389 UNIMPLEMENTED();
7390 }
7391
glTexCoord4f(GLfloat s,GLfloat t,GLfloat r,GLfloat q)7392 void APIENTRY glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
7393 {
7394 UNIMPLEMENTED();
7395 }
7396
glTexCoord4fv(const GLfloat * v)7397 void APIENTRY glTexCoord4fv(const GLfloat *v)
7398 {
7399 UNIMPLEMENTED();
7400 }
7401
glTexCoord4i(GLint s,GLint t,GLint r,GLint q)7402 void APIENTRY glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
7403 {
7404 UNIMPLEMENTED();
7405 }
7406
glTexCoord4iv(const GLint * v)7407 void APIENTRY glTexCoord4iv(const GLint *v)
7408 {
7409 UNIMPLEMENTED();
7410 }
7411
glTexCoord4s(GLshort s,GLshort t,GLshort r,GLshort q)7412 void APIENTRY glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
7413 {
7414 UNIMPLEMENTED();
7415 }
7416
glTexCoord4sv(const GLshort * v)7417 void APIENTRY glTexCoord4sv(const GLshort *v)
7418 {
7419 UNIMPLEMENTED();
7420 }
7421
glTexCoordPointer(GLint size,GLenum type,GLsizei stride,const GLvoid * pointer)7422 void APIENTRY glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
7423 {
7424 TRACE("(*)");
7425
7426 gl::Context *context = gl::getContext();
7427
7428 if(context)
7429 {
7430 GLenum texture = context->getClientActiveTexture();
7431
7432 glVertexAttribPointer(sw::TexCoord0 + (texture - GL_TEXTURE0), size, type, false, stride, pointer);
7433 }
7434 }
7435
glTexEnvf(GLenum target,GLenum pname,GLfloat param)7436 void APIENTRY glTexEnvf(GLenum target, GLenum pname, GLfloat param)
7437 {
7438 UNIMPLEMENTED();
7439 }
7440
glTexEnvfv(GLenum target,GLenum pname,const GLfloat * params)7441 void APIENTRY glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
7442 {
7443 UNIMPLEMENTED();
7444 }
7445
glTexEnvi(GLenum target,GLenum pname,GLint param)7446 void APIENTRY glTexEnvi(GLenum target, GLenum pname, GLint param)
7447 {
7448 UNIMPLEMENTED();
7449 }
7450
glTexEnviv(GLenum target,GLenum pname,const GLint * params)7451 void APIENTRY glTexEnviv(GLenum target, GLenum pname, const GLint *params)
7452 {
7453 UNIMPLEMENTED();
7454 }
7455
glTexGend(GLenum coord,GLenum pname,GLdouble param)7456 void APIENTRY glTexGend(GLenum coord, GLenum pname, GLdouble param)
7457 {
7458 UNIMPLEMENTED();
7459 }
7460
glTexGendv(GLenum coord,GLenum pname,const GLdouble * params)7461 void APIENTRY glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
7462 {
7463 UNIMPLEMENTED();
7464 }
7465
glTexGenf(GLenum coord,GLenum pname,GLfloat param)7466 void APIENTRY glTexGenf(GLenum coord, GLenum pname, GLfloat param)
7467 {
7468 UNIMPLEMENTED();
7469 }
7470
glTexGenfv(GLenum coord,GLenum pname,const GLfloat * params)7471 void APIENTRY glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
7472 {
7473 UNIMPLEMENTED();
7474 }
7475
glTexGeni(GLenum coord,GLenum pname,GLint param)7476 void APIENTRY glTexGeni(GLenum coord, GLenum pname, GLint param)
7477 {
7478 UNIMPLEMENTED();
7479 }
7480
glTexGeniv(GLenum coord,GLenum pname,const GLint * params)7481 void APIENTRY glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
7482 {
7483 UNIMPLEMENTED();
7484 }
7485
glTexImage1D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLint border,GLenum format,GLenum type,const GLvoid * pixels)7486 void APIENTRY glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
7487 {
7488 UNIMPLEMENTED();
7489 }
7490
glTexSubImage1D(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const GLvoid * pixels)7491 void APIENTRY glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
7492 {
7493 UNIMPLEMENTED();
7494 }
7495
glTranslated(GLdouble x,GLdouble y,GLdouble z)7496 void APIENTRY glTranslated(GLdouble x, GLdouble y, GLdouble z)
7497 {
7498 TRACE("(*)");
7499
7500 gl::Context *context = gl::getContext();
7501
7502 if(context)
7503 {
7504 if(context->getListIndex() != 0)
7505 {
7506 return context->listCommand(gl::newCommand(glTranslated, x, y, z));
7507 }
7508
7509 context->translate(x, y, z); // FIXME
7510 }
7511 }
7512
glTranslatef(GLfloat x,GLfloat y,GLfloat z)7513 void APIENTRY glTranslatef(GLfloat x, GLfloat y, GLfloat z)
7514 {
7515 TRACE("(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", x, y, z);
7516
7517 gl::Context *context = gl::getContext();
7518
7519 if(context)
7520 {
7521 if(context->getListIndex() != 0)
7522 {
7523 return context->listCommand(gl::newCommand(glTranslatef, x, y, z));
7524 }
7525
7526 context->translate(x, y, z);
7527 }
7528 }
7529
glVertex2d(GLdouble x,GLdouble y)7530 void APIENTRY glVertex2d(GLdouble x, GLdouble y)
7531 {
7532 UNIMPLEMENTED();
7533 }
7534
glVertex2dv(const GLdouble * v)7535 void APIENTRY glVertex2dv(const GLdouble *v)
7536 {
7537 UNIMPLEMENTED();
7538 }
7539
glVertex2f(GLfloat x,GLfloat y)7540 void APIENTRY glVertex2f(GLfloat x, GLfloat y)
7541 {
7542 UNIMPLEMENTED();
7543 }
7544
glVertex2fv(const GLfloat * v)7545 void APIENTRY glVertex2fv(const GLfloat *v)
7546 {
7547 UNIMPLEMENTED();
7548 }
7549
glVertex2i(GLint x,GLint y)7550 void APIENTRY glVertex2i(GLint x, GLint y)
7551 {
7552 UNIMPLEMENTED();
7553 }
7554
glVertex2iv(const GLint * v)7555 void APIENTRY glVertex2iv(const GLint *v)
7556 {
7557 UNIMPLEMENTED();
7558 }
7559
glVertex2s(GLshort x,GLshort y)7560 void APIENTRY glVertex2s(GLshort x, GLshort y)
7561 {
7562 UNIMPLEMENTED();
7563 }
7564
glVertex2sv(const GLshort * v)7565 void APIENTRY glVertex2sv(const GLshort *v)
7566 {
7567 UNIMPLEMENTED();
7568 }
7569
glVertex3d(GLdouble x,GLdouble y,GLdouble z)7570 void APIENTRY glVertex3d(GLdouble x, GLdouble y, GLdouble z)
7571 {
7572 UNIMPLEMENTED();
7573 }
7574
glVertex3dv(const GLdouble * v)7575 void APIENTRY glVertex3dv(const GLdouble *v)
7576 {
7577 UNIMPLEMENTED();
7578 }
7579
glVertex3f(GLfloat x,GLfloat y,GLfloat z)7580 void APIENTRY glVertex3f(GLfloat x, GLfloat y, GLfloat z)
7581 {
7582 TRACE("(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", x, y, z);
7583
7584 gl::Context *context = gl::getContext();
7585
7586 if(context)
7587 {
7588 if(context->getListIndex() != 0)
7589 {
7590 UNIMPLEMENTED();
7591 }
7592
7593 context->position(x, y, z, 1.0f);
7594 }
7595 }
7596
glVertex3fv(const GLfloat * v)7597 void APIENTRY glVertex3fv(const GLfloat *v)
7598 {
7599 UNIMPLEMENTED();
7600 }
7601
glVertex3i(GLint x,GLint y,GLint z)7602 void APIENTRY glVertex3i(GLint x, GLint y, GLint z)
7603 {
7604 UNIMPLEMENTED();
7605 }
7606
glVertex3iv(const GLint * v)7607 void APIENTRY glVertex3iv(const GLint *v)
7608 {
7609 UNIMPLEMENTED();
7610 }
7611
glVertex3s(GLshort x,GLshort y,GLshort z)7612 void APIENTRY glVertex3s(GLshort x, GLshort y, GLshort z)
7613 {
7614 UNIMPLEMENTED();
7615 }
7616
glVertex3sv(const GLshort * v)7617 void APIENTRY glVertex3sv(const GLshort *v)
7618 {
7619 UNIMPLEMENTED();
7620 }
7621
glVertex4d(GLdouble x,GLdouble y,GLdouble z,GLdouble w)7622 void APIENTRY glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
7623 {
7624 UNIMPLEMENTED();
7625 }
7626
glVertex4dv(const GLdouble * v)7627 void APIENTRY glVertex4dv(const GLdouble *v)
7628 {
7629 UNIMPLEMENTED();
7630 }
7631
glVertex4f(GLfloat x,GLfloat y,GLfloat z,GLfloat w)7632 void APIENTRY glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
7633 {
7634 UNIMPLEMENTED();
7635 }
7636
glVertex4fv(const GLfloat * v)7637 void APIENTRY glVertex4fv(const GLfloat *v)
7638 {
7639 UNIMPLEMENTED();
7640 }
7641
glVertex4i(GLint x,GLint y,GLint z,GLint w)7642 void APIENTRY glVertex4i(GLint x, GLint y, GLint z, GLint w)
7643 {
7644 UNIMPLEMENTED();
7645 }
7646
glVertex4iv(const GLint * v)7647 void APIENTRY glVertex4iv(const GLint *v)
7648 {
7649 UNIMPLEMENTED();
7650 }
7651
glVertex4s(GLshort x,GLshort y,GLshort z,GLshort w)7652 void APIENTRY glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
7653 {
7654 UNIMPLEMENTED();
7655 }
7656
glVertex4sv(const GLshort * v)7657 void APIENTRY glVertex4sv(const GLshort *v)
7658 {
7659 UNIMPLEMENTED();
7660 }
7661
glVertexPointer(GLint size,GLenum type,GLsizei stride,const GLvoid * pointer)7662 void APIENTRY glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
7663 {
7664 TRACE("(GLint size = %d, GLenum type = 0x%X, GLsizei stride = %d, const GLvoid *pointer = %p)", size, type, stride, pointer);
7665
7666 glVertexAttribPointer(sw::Position, size, type, false, stride, pointer);
7667 }
7668
glDrawRangeElements(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void * indices)7669 void APIENTRY glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) {UNIMPLEMENTED();}
glTexImage3D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const void * pixels)7670 void APIENTRY glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) {UNIMPLEMENTED();}
glTexSubImage3D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const void * pixels)7671 void APIENTRY glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) {UNIMPLEMENTED();}
glCopyTexSubImage3D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height)7672 void APIENTRY glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {UNIMPLEMENTED();}
7673
glClientActiveTexture(GLenum texture)7674 void APIENTRY glClientActiveTexture(GLenum texture)
7675 {
7676 TRACE("(GLenum texture = 0x%X)", texture);
7677
7678 switch(texture)
7679 {
7680 case GL_TEXTURE0:
7681 case GL_TEXTURE1:
7682 break;
7683 default:
7684 UNIMPLEMENTED();
7685 UNREACHABLE(texture);
7686 }
7687
7688 gl::Context *context = gl::getContext();
7689
7690 if(context)
7691 {
7692 context->clientActiveTexture(texture);
7693 }
7694 }
7695
glCompressedTexImage1D(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLsizei imageSize,const void * data)7696 void APIENTRY glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data) {UNIMPLEMENTED();}
glCompressedTexImage3D(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const void * data)7697 void APIENTRY glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data) {UNIMPLEMENTED();}
glCompressedTexSubImage1D(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei imageSize,const void * data)7698 void APIENTRY glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data) {UNIMPLEMENTED();}
glCompressedTexSubImage3D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const void * data)7699 void APIENTRY glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data) {UNIMPLEMENTED();}
glGetCompressedTexImage(GLenum target,GLint level,void * img)7700 void APIENTRY glGetCompressedTexImage(GLenum target, GLint level, void *img) {UNIMPLEMENTED();}
glMultiTexCoord1f(GLenum target,GLfloat s)7701 void APIENTRY glMultiTexCoord1f(GLenum target, GLfloat s) {UNIMPLEMENTED();}
glMultiTexCoord1d(GLenum target,GLdouble s)7702 void APIENTRY glMultiTexCoord1d(GLenum target, GLdouble s) {UNIMPLEMENTED();}
7703
glMultiTexCoord2f(GLenum texture,GLfloat s,GLfloat t)7704 void APIENTRY glMultiTexCoord2f(GLenum texture, GLfloat s, GLfloat t)
7705 {
7706 TRACE("(GLenum texture = 0x%X, GLfloat s = %f, GLfloat t = %f)", texture, s, t);
7707
7708 gl::Context *context = gl::getContext();
7709
7710 if(context)
7711 {
7712 if(context->getListIndex() != 0)
7713 {
7714 UNIMPLEMENTED();
7715 }
7716
7717 //context->texCoord(s, t, 0.0f, 1.0f);
7718 context->setVertexAttrib(sw::TexCoord0 + (texture - GL_TEXTURE0), s, t, 0.0f, 1.0f);
7719 }
7720 }
7721
glMultiTexCoord2d(GLenum target,GLdouble s,GLdouble t)7722 void APIENTRY glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t) {UNIMPLEMENTED();}
glMultiTexCoord3f(GLenum target,GLfloat s,GLfloat t,GLfloat r)7723 void APIENTRY glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r) {UNIMPLEMENTED();}
glMultiTexCoord3d(GLenum target,GLdouble s,GLdouble t,GLdouble r)7724 void APIENTRY glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r) {UNIMPLEMENTED();}
glMultiTexCoord4f(GLenum target,GLfloat s,GLfloat t,GLfloat r,GLfloat q)7725 void APIENTRY glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {UNIMPLEMENTED();}
glMultiTexCoord4d(GLenum target,GLdouble s,GLdouble t,GLdouble r,GLdouble q)7726 void APIENTRY glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) {UNIMPLEMENTED();}
glLoadTransposeMatrixf(const GLfloat * m)7727 void APIENTRY glLoadTransposeMatrixf(const GLfloat *m) {UNIMPLEMENTED();}
glLoadTransposeMatrixd(const GLdouble * m)7728 void APIENTRY glLoadTransposeMatrixd(const GLdouble *m) {UNIMPLEMENTED();}
glMultTransposeMatrixf(const GLfloat * m)7729 void APIENTRY glMultTransposeMatrixf(const GLfloat *m) {UNIMPLEMENTED();}
glMultTransposeMatrixd(const GLdouble * m)7730 void APIENTRY glMultTransposeMatrixd(const GLdouble *m) {UNIMPLEMENTED();}
glFogCoordf(GLfloat coord)7731 void APIENTRY glFogCoordf(GLfloat coord) {UNIMPLEMENTED();}
glFogCoordd(GLdouble coord)7732 void APIENTRY glFogCoordd(GLdouble coord) {UNIMPLEMENTED();}
glFogCoordPointer(GLenum type,GLsizei stride,const void * pointer)7733 void APIENTRY glFogCoordPointer(GLenum type, GLsizei stride, const void *pointer) {UNIMPLEMENTED();}
glMultiDrawArrays(GLenum mode,const GLint * first,const GLsizei * count,GLsizei drawcount)7734 void APIENTRY glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount) {UNIMPLEMENTED();}
glPointParameteri(GLenum pname,GLint param)7735 void APIENTRY glPointParameteri(GLenum pname, GLint param) {UNIMPLEMENTED();}
glPointParameterf(GLenum pname,GLfloat param)7736 void APIENTRY glPointParameterf(GLenum pname, GLfloat param) {UNIMPLEMENTED();}
glPointParameteriv(GLenum pname,const GLint * params)7737 void APIENTRY glPointParameteriv(GLenum pname, const GLint *params) {UNIMPLEMENTED();}
glPointParameterfv(GLenum pname,const GLfloat * params)7738 void APIENTRY glPointParameterfv(GLenum pname, const GLfloat *params) {UNIMPLEMENTED();}
glSecondaryColor3b(GLbyte red,GLbyte green,GLbyte blue)7739 void APIENTRY glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue) {UNIMPLEMENTED();}
glSecondaryColor3f(GLfloat red,GLfloat green,GLfloat blue)7740 void APIENTRY glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue) {UNIMPLEMENTED();}
glSecondaryColor3d(GLdouble red,GLdouble green,GLdouble blue)7741 void APIENTRY glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue) {UNIMPLEMENTED();}
glSecondaryColor3ub(GLubyte red,GLubyte green,GLubyte blue)7742 void APIENTRY glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue) {UNIMPLEMENTED();}
glSecondaryColorPointer(GLint size,GLenum type,GLsizei stride,const void * pointer)7743 void APIENTRY glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) {UNIMPLEMENTED();}
glWindowPos2f(GLfloat x,GLfloat y)7744 void APIENTRY glWindowPos2f(GLfloat x, GLfloat y) {UNIMPLEMENTED();}
glWindowPos2d(GLdouble x,GLdouble y)7745 void APIENTRY glWindowPos2d(GLdouble x, GLdouble y) {UNIMPLEMENTED();}
glWindowPos2i(GLint x,GLint y)7746 void APIENTRY glWindowPos2i(GLint x, GLint y) {UNIMPLEMENTED();}
glWindowPos3f(GLfloat x,GLfloat y,GLfloat z)7747 void APIENTRY glWindowPos3f(GLfloat x, GLfloat y, GLfloat z) {UNIMPLEMENTED();}
glWindowPos3d(GLdouble x,GLdouble y,GLdouble z)7748 void APIENTRY glWindowPos3d(GLdouble x, GLdouble y, GLdouble z) {UNIMPLEMENTED();}
glWindowPos3i(GLint x,GLint y,GLint z)7749 void APIENTRY glWindowPos3i(GLint x, GLint y, GLint z) {UNIMPLEMENTED();}
glGetBufferSubData(GLenum target,GLintptr offset,GLsizeiptr size,void * data)7750 void APIENTRY glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data) {UNIMPLEMENTED();}
glMapBuffer(GLenum target,GLenum access)7751 void *APIENTRY glMapBuffer(GLenum target, GLenum access) {UNIMPLEMENTED(); return 0;}
glUnmapBuffer(GLenum target)7752 GLboolean APIENTRY glUnmapBuffer(GLenum target) {UNIMPLEMENTED(); return GL_FALSE;}
glGetBufferPointerv(GLenum target,GLenum pname,void ** params)7753 void APIENTRY glGetBufferPointerv(GLenum target, GLenum pname, void **params) {UNIMPLEMENTED();}
glGenQueries(GLsizei n,GLuint * ids)7754 void APIENTRY glGenQueries(GLsizei n, GLuint *ids) {UNIMPLEMENTED();}
glDeleteQueries(GLsizei n,const GLuint * ids)7755 void APIENTRY glDeleteQueries(GLsizei n, const GLuint *ids) {UNIMPLEMENTED();}
glIsQuery(GLuint id)7756 GLboolean APIENTRY glIsQuery(GLuint id) {UNIMPLEMENTED(); return 0;}
glBeginQuery(GLenum target,GLuint id)7757 void APIENTRY glBeginQuery(GLenum target, GLuint id) {UNIMPLEMENTED();}
glEndQuery(GLenum target)7758 void APIENTRY glEndQuery(GLenum target) {UNIMPLEMENTED();}
glGetQueryiv(GLenum target,GLenum pname,GLint * params)7759 void APIENTRY glGetQueryiv(GLenum target, GLenum pname, GLint *params) {UNIMPLEMENTED();}
glGetQueryObjectiv(GLuint id,GLenum pname,GLint * params)7760 void APIENTRY glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params) {UNIMPLEMENTED();}
glGetQueryObjectuiv(GLuint id,GLenum pname,GLuint * params)7761 void APIENTRY glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params) {UNIMPLEMENTED();}
glVertexAttrib1s(GLuint index,GLshort x)7762 void APIENTRY glVertexAttrib1s(GLuint index, GLshort x) {UNIMPLEMENTED();}
glVertexAttrib1d(GLuint index,GLdouble x)7763 void APIENTRY glVertexAttrib1d(GLuint index, GLdouble x) {UNIMPLEMENTED();}
glVertexAttrib2s(GLuint index,GLshort x,GLshort y)7764 void APIENTRY glVertexAttrib2s(GLuint index, GLshort x, GLshort y) {UNIMPLEMENTED();}
glVertexAttrib2d(GLuint index,GLdouble x,GLdouble y)7765 void APIENTRY glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y) {UNIMPLEMENTED();}
glVertexAttrib3s(GLuint index,GLshort x,GLshort y,GLshort z)7766 void APIENTRY glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z) {UNIMPLEMENTED();}
glVertexAttrib3d(GLuint index,GLdouble x,GLdouble y,GLdouble z)7767 void APIENTRY glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z) {UNIMPLEMENTED();}
glVertexAttrib4s(GLuint index,GLshort x,GLshort y,GLshort z,GLshort w)7768 void APIENTRY glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) {UNIMPLEMENTED();}
glVertexAttrib4d(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w)7769 void APIENTRY glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {UNIMPLEMENTED();}
glVertexAttrib4Nub(GLuint index,GLubyte x,GLubyte y,GLubyte z,GLubyte w)7770 void APIENTRY glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {UNIMPLEMENTED();}
glGetVertexAttribdv(GLuint index,GLenum pname,GLdouble * params)7771 void APIENTRY glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params) {UNIMPLEMENTED();}
glDrawBuffers(GLsizei n,const GLenum * bufs)7772 void APIENTRY glDrawBuffers(GLsizei n, const GLenum *bufs) {UNIMPLEMENTED();}
glUniformMatrix2x3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)7773 void APIENTRY glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {UNIMPLEMENTED();}
glUniformMatrix3x2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)7774 void APIENTRY glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {UNIMPLEMENTED();}
glUniformMatrix2x4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)7775 void APIENTRY glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {UNIMPLEMENTED();}
glUniformMatrix4x2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)7776 void APIENTRY glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {UNIMPLEMENTED();}
glUniformMatrix3x4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)7777 void APIENTRY glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {UNIMPLEMENTED();}
glUniformMatrix4x3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat * value)7778 void APIENTRY glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {UNIMPLEMENTED();}
7779
glFramebufferTextureLayer(GLenum target,GLenum attachment,GLuint texture,GLint level,GLint layer)7780 void APIENTRY glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) {UNIMPLEMENTED();}
glRenderbufferStorageMultisample(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)7781 void APIENTRY glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) {UNIMPLEMENTED();}
glBlitFramebuffer(GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter)7782 void APIENTRY glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {UNIMPLEMENTED();}
7783
wglSwapIntervalEXT(int interval)7784 BOOL WINAPI wglSwapIntervalEXT(int interval)
7785 {
7786 gl::Surface *drawSurface = static_cast<gl::Surface*>(gl::getCurrentDrawSurface());
7787
7788 if(drawSurface)
7789 {
7790 drawSurface->setSwapInterval(interval);
7791 return TRUE;
7792 }
7793
7794 SetLastError(ERROR_DC_NOT_FOUND);
7795 return FALSE;
7796 }
7797
wglChoosePixelFormat(HDC hdc,const PIXELFORMATDESCRIPTOR * ppfd)7798 int WINAPI wglChoosePixelFormat(HDC hdc, const PIXELFORMATDESCRIPTOR *ppfd)
7799 {
7800 TRACE("(*)");
7801
7802 return 1;
7803 }
7804
wglCopyContext(HGLRC,HGLRC,UINT)7805 BOOL WINAPI wglCopyContext(HGLRC, HGLRC, UINT)
7806 {
7807 UNIMPLEMENTED();
7808 return FALSE;
7809 }
7810
wglCreateContext(HDC hdc)7811 HGLRC WINAPI wglCreateContext(HDC hdc)
7812 {
7813 TRACE("(*)");
7814
7815 gl::Display *display = gl::Display::getDisplay(hdc);
7816 display->initialize();
7817
7818 gl::Context *context = display->createContext(nullptr);
7819
7820 return (HGLRC)context;
7821 }
7822
wglCreateLayerContext(HDC,int)7823 HGLRC WINAPI wglCreateLayerContext(HDC, int)
7824 {
7825 UNIMPLEMENTED();
7826 return 0;
7827 }
7828
wglDeleteContext(HGLRC context)7829 BOOL WINAPI wglDeleteContext(HGLRC context)
7830 {
7831 gl::Display *display = gl::getDisplay();
7832
7833 if(display && context)
7834 {
7835 display->destroyContext(reinterpret_cast<gl::Context*>(context));
7836
7837 return TRUE;
7838 }
7839
7840 return FALSE;
7841 }
7842
wglDescribeLayerPlane(HDC,int,int,UINT,LPLAYERPLANEDESCRIPTOR)7843 BOOL WINAPI wglDescribeLayerPlane(HDC, int, int, UINT, LPLAYERPLANEDESCRIPTOR)
7844 {
7845 UNIMPLEMENTED();
7846 return FALSE;
7847 }
7848
wglDescribePixelFormat(HDC hdc,int iPixelFormat,UINT nBytes,LPPIXELFORMATDESCRIPTOR ppfd)7849 int WINAPI wglDescribePixelFormat(HDC hdc, int iPixelFormat, UINT nBytes, LPPIXELFORMATDESCRIPTOR ppfd)
7850 {
7851 TRACE("(*)");
7852
7853 ASSERT(nBytes == sizeof(PIXELFORMATDESCRIPTOR)); // FIXME
7854
7855 ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
7856 ppfd->nVersion = 1;
7857 ppfd->dwFlags = PFD_DRAW_TO_WINDOW | PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
7858 ppfd->iPixelType = PFD_TYPE_RGBA;
7859 ppfd->cColorBits = 32;
7860 ppfd->cRedBits = 8;
7861 ppfd->cRedShift = 16;
7862 ppfd->cGreenBits = 8;
7863 ppfd->cGreenShift = 8;
7864 ppfd->cBlueBits = 8;
7865 ppfd->cBlueShift = 0;
7866 ppfd->cAlphaBits = 0;
7867 ppfd->cAlphaShift = 24;
7868 ppfd->cAccumBits = 0;
7869 ppfd->cAccumRedBits = 0;
7870 ppfd->cAccumGreenBits = 0;
7871 ppfd->cAccumBlueBits = 0;
7872 ppfd->cAccumAlphaBits = 0;
7873 ppfd->cDepthBits = 24;
7874 ppfd->cStencilBits = 0;
7875 ppfd->cAuxBuffers = 0;
7876 ppfd->iLayerType = 0;
7877 ppfd->bReserved = 0;
7878 ppfd->dwLayerMask = 0;
7879 ppfd->dwVisibleMask = 0;
7880 ppfd->dwDamageMask = 0;
7881
7882 return 1;
7883 }
7884
wglGetCurrentContext(VOID)7885 HGLRC WINAPI wglGetCurrentContext(VOID)
7886 {
7887 TRACE("(*)");
7888 return (HGLRC)gl::getContext();
7889 }
7890
wglGetCurrentDC(VOID)7891 HDC WINAPI wglGetCurrentDC(VOID)
7892 {
7893 TRACE("(*)");
7894 gl::Display *display = gl::getDisplay();
7895 return display ? display->getNativeDisplay() : 0;
7896 }
7897
wglGetDefaultProcAddress()7898 void WINAPI wglGetDefaultProcAddress()
7899 {
7900 UNIMPLEMENTED();
7901 }
7902
wglGetLayerPaletteEntries(HDC,int,int,int,COLORREF *)7903 int WINAPI wglGetLayerPaletteEntries(HDC, int, int, int, COLORREF*)
7904 {
7905 UNIMPLEMENTED();
7906 return 0;
7907 }
7908
wglGetPixelFormat()7909 void WINAPI wglGetPixelFormat()
7910 {
7911 UNIMPLEMENTED();
7912 }
7913
wglGetExtensionsStringARB(HDC hdc)7914 const char *WINAPI wglGetExtensionsStringARB(HDC hdc)
7915 {
7916 TRACE("(*)");
7917
7918 return "GL_ARB_framebuffer_object "
7919 "WGL_EXT_extensions_string "
7920 "WGL_EXT_swap_control";
7921 }
7922
wglGetExtensionsStringEXT()7923 const char *WINAPI wglGetExtensionsStringEXT()
7924 {
7925 TRACE("(*)");
7926 return wglGetExtensionsStringARB(0);
7927 }
7928
wglGetProcAddress(LPCSTR lpszProc)7929 PROC WINAPI wglGetProcAddress(LPCSTR lpszProc)
7930 {
7931 TRACE("(LPCSTR lpszProc = \"%s\")", lpszProc);
7932
7933 struct Extension
7934 {
7935 const char *name;
7936 PROC address;
7937 };
7938
7939 static const Extension glExtensions[] =
7940 {
7941 #define EXT(function) {#function, (PROC)function}
7942
7943 // Core 2.1
7944 EXT(glDrawRangeElements),
7945 EXT(glTexImage3D),
7946 EXT(glTexSubImage3D),
7947 EXT(glCopyTexSubImage3D),
7948 EXT(glActiveTexture),
7949 EXT(glClientActiveTexture),
7950 EXT(glCompressedTexImage1D),
7951 EXT(glCompressedTexImage2D),
7952 EXT(glCompressedTexImage3D),
7953 EXT(glCompressedTexSubImage1D),
7954 EXT(glCompressedTexSubImage2D),
7955 EXT(glCompressedTexSubImage3D),
7956 EXT(glGetCompressedTexImage),
7957 EXT(glMultiTexCoord1f),
7958 EXT(glMultiTexCoord1d),
7959 EXT(glMultiTexCoord2f),
7960 EXT(glMultiTexCoord2d),
7961 EXT(glMultiTexCoord3f),
7962 EXT(glMultiTexCoord3d),
7963 EXT(glMultiTexCoord4f),
7964 EXT(glMultiTexCoord4d),
7965 EXT(glLoadTransposeMatrixf),
7966 EXT(glLoadTransposeMatrixd),
7967 EXT(glMultTransposeMatrixf),
7968 EXT(glMultTransposeMatrixd),
7969 EXT(glSampleCoverage),
7970 EXT(glBlendEquation),
7971 EXT(glBlendColor),
7972 EXT(glFogCoordf),
7973 EXT(glFogCoordd),
7974 EXT(glFogCoordPointer),
7975 EXT(glMultiDrawArrays),
7976 EXT(glPointParameteri),
7977 EXT(glPointParameterf),
7978 EXT(glPointParameteriv),
7979 EXT(glPointParameterfv),
7980 EXT(glSecondaryColor3b),
7981 EXT(glSecondaryColor3f),
7982 EXT(glSecondaryColor3d),
7983 EXT(glSecondaryColor3ub),
7984 EXT(glSecondaryColorPointer),
7985 EXT(glBlendFuncSeparate),
7986 EXT(glWindowPos2f),
7987 EXT(glWindowPos2d),
7988 EXT(glWindowPos2i),
7989 EXT(glWindowPos3f),
7990 EXT(glWindowPos3d),
7991 EXT(glWindowPos3i),
7992 EXT(glBindBuffer),
7993 EXT(glDeleteBuffers),
7994 EXT(glGenBuffers),
7995 EXT(glIsBuffer),
7996 EXT(glBufferData),
7997 EXT(glBufferSubData),
7998 EXT(glGetBufferSubData),
7999 EXT(glMapBuffer),
8000 EXT(glUnmapBuffer),
8001 EXT(glGetBufferParameteriv),
8002 EXT(glGetBufferPointerv),
8003 EXT(glGenQueries),
8004 EXT(glDeleteQueries),
8005 EXT(glIsQuery),
8006 EXT(glBeginQuery),
8007 EXT(glEndQuery),
8008 EXT(glGetQueryiv),
8009 EXT(glGetQueryObjectiv),
8010 EXT(glGetQueryObjectuiv),
8011 EXT(glShaderSource),
8012 EXT(glCreateShader),
8013 EXT(glIsShader),
8014 EXT(glCompileShader),
8015 EXT(glDeleteShader),
8016 EXT(glCreateProgram),
8017 EXT(glIsProgram),
8018 EXT(glAttachShader),
8019 EXT(glDetachShader),
8020 EXT(glLinkProgram),
8021 EXT(glUseProgram),
8022 EXT(glValidateProgram),
8023 EXT(glDeleteProgram),
8024 EXT(glUniform1f),
8025 EXT(glUniform2f),
8026 EXT(glUniform3f),
8027 EXT(glUniform4f),
8028 EXT(glUniform1i),
8029 EXT(glUniform2i),
8030 EXT(glUniform3i),
8031 EXT(glUniform4i),
8032 EXT(glUniform1fv),
8033 EXT(glUniform2fv),
8034 EXT(glUniform3fv),
8035 EXT(glUniform4fv),
8036 EXT(glUniform1iv),
8037 EXT(glUniform2iv),
8038 EXT(glUniform3iv),
8039 EXT(glUniform4iv),
8040 EXT(glUniformMatrix2fv),
8041 EXT(glUniformMatrix3fv),
8042 EXT(glUniformMatrix4fv),
8043 EXT(glGetShaderiv),
8044 EXT(glGetProgramiv),
8045 EXT(glGetShaderInfoLog),
8046 EXT(glGetProgramInfoLog),
8047 EXT(glGetAttachedShaders),
8048 EXT(glGetUniformLocation),
8049 EXT(glGetActiveUniform),
8050 EXT(glGetUniformfv),
8051 EXT(glGetUniformiv),
8052 EXT(glGetShaderSource),
8053 EXT(glVertexAttrib1s),
8054 EXT(glVertexAttrib1f),
8055 EXT(glVertexAttrib1d),
8056 EXT(glVertexAttrib2s),
8057 EXT(glVertexAttrib2f),
8058 EXT(glVertexAttrib2d),
8059 EXT(glVertexAttrib3s),
8060 EXT(glVertexAttrib3f),
8061 EXT(glVertexAttrib3d),
8062 EXT(glVertexAttrib4s),
8063 EXT(glVertexAttrib4f),
8064 EXT(glVertexAttrib4d),
8065 EXT(glVertexAttrib4Nub),
8066 EXT(glVertexAttribPointer),
8067 EXT(glEnableVertexAttribArray),
8068 EXT(glDisableVertexAttribArray),
8069 EXT(glGetVertexAttribfv),
8070 EXT(glGetVertexAttribdv),
8071 EXT(glGetVertexAttribiv),
8072 EXT(glGetVertexAttribPointerv),
8073 EXT(glBindAttribLocation),
8074 EXT(glGetActiveAttrib),
8075 EXT(glGetAttribLocation),
8076 EXT(glDrawBuffers),
8077 EXT(glStencilOpSeparate),
8078 EXT(glStencilFuncSeparate),
8079 EXT(glStencilMaskSeparate),
8080 EXT(glBlendEquationSeparate),
8081 EXT(glUniformMatrix2x3fv),
8082 EXT(glUniformMatrix3x2fv),
8083 EXT(glUniformMatrix2x4fv),
8084 EXT(glUniformMatrix4x2fv),
8085 EXT(glUniformMatrix3x4fv),
8086 EXT(glUniformMatrix4x3fv),
8087 EXT(glGenFencesNV),
8088 EXT(glDeleteFencesNV),
8089 EXT(glSetFenceNV),
8090 EXT(glTestFenceNV),
8091 EXT(glFinishFenceNV),
8092 EXT(glIsFenceNV),
8093 EXT(glGetFenceivNV),
8094
8095 EXT(glIsRenderbuffer),
8096 EXT(glBindRenderbuffer),
8097 EXT(glDeleteRenderbuffers),
8098 EXT(glGenRenderbuffers),
8099 EXT(glRenderbufferStorage),
8100 EXT(glGetRenderbufferParameteriv),
8101 EXT(glIsFramebuffer),
8102 EXT(glBindFramebuffer),
8103 EXT(glDeleteFramebuffers),
8104 EXT(glGenFramebuffers),
8105 EXT(glCheckFramebufferStatus),
8106 EXT(glFramebufferTexture1D),
8107 EXT(glFramebufferTexture2D),
8108 EXT(glFramebufferTexture3D),
8109 EXT(glFramebufferRenderbuffer),
8110 EXT(glGetFramebufferAttachmentParameteriv),
8111 EXT(glGenerateMipmap),
8112 EXT(glReleaseShaderCompiler),
8113 EXT(glShaderBinary),
8114 EXT(glGetShaderPrecisionFormat),
8115 EXT(glDepthRangef),
8116 EXT(glClearDepthf),
8117
8118 // ARB
8119 EXT(wglGetExtensionsStringARB),
8120 EXT(glIsRenderbuffer),
8121 EXT(glBindRenderbuffer),
8122 EXT(glDeleteRenderbuffers),
8123 EXT(glGenRenderbuffers),
8124 EXT(glRenderbufferStorage),
8125 EXT(glRenderbufferStorageMultisample),
8126 EXT(glGetRenderbufferParameteriv),
8127 EXT(glIsFramebuffer),
8128 EXT(glBindFramebuffer),
8129 EXT(glDeleteFramebuffers),
8130 EXT(glGenFramebuffers),
8131 EXT(glCheckFramebufferStatus),
8132 EXT(glFramebufferTexture1D),
8133 EXT(glFramebufferTexture2D),
8134 EXT(glFramebufferTexture3D),
8135 EXT(glFramebufferTextureLayer),
8136 EXT(glFramebufferRenderbuffer),
8137 EXT(glGetFramebufferAttachmentParameteriv),
8138 EXT(glBlitFramebuffer),
8139 EXT(glGenerateMipmap),
8140
8141 // EXT
8142 EXT(wglSwapIntervalEXT),
8143 EXT(wglGetExtensionsStringEXT),
8144 #undef EXT
8145 };
8146
8147 for(int ext = 0; ext < sizeof(glExtensions) / sizeof(Extension); ext++)
8148 {
8149 if(strcmp(lpszProc, glExtensions[ext].name) == 0)
8150 {
8151 return (PROC)glExtensions[ext].address;
8152 }
8153 }
8154
8155 FARPROC proc = GetProcAddress(GetModuleHandle("opengl32.dll"), lpszProc); // FIXME?
8156
8157 if(proc)
8158 {
8159 return proc;
8160 }
8161
8162 TRACE("(LPCSTR lpszProc = \"%s\") NOT FOUND!!!", lpszProc);
8163
8164 return 0;
8165 }
8166
wglMakeCurrent(HDC hdc,HGLRC hglrc)8167 BOOL WINAPI wglMakeCurrent(HDC hdc, HGLRC hglrc)
8168 {
8169 TRACE("(*)");
8170
8171 if(hdc && hglrc)
8172 {
8173 gl::Display *display = (gl::Display*)gl::Display::getDisplay(hdc);
8174 gl::makeCurrent((gl::Context*)hglrc, display, display->getPrimarySurface());
8175 gl::setCurrentDrawSurface(display->getPrimarySurface());
8176 gl::setCurrentDisplay(display);
8177 }
8178 else
8179 {
8180 gl::makeCurrent(0, 0, 0);
8181 }
8182
8183 return TRUE;
8184 }
8185
wglRealizeLayerPalette(HDC,int,BOOL)8186 BOOL WINAPI wglRealizeLayerPalette(HDC, int, BOOL)
8187 {
8188 UNIMPLEMENTED();
8189 return FALSE;
8190 }
8191
wglSetLayerPaletteEntries(HDC,int,int,int,CONST COLORREF *)8192 int WINAPI wglSetLayerPaletteEntries(HDC, int, int, int, CONST COLORREF*)
8193 {
8194 UNIMPLEMENTED();
8195 return 0;
8196 }
8197
wglSetPixelFormat(HDC hdc,int iPixelFormat,const PIXELFORMATDESCRIPTOR * ppfd)8198 BOOL WINAPI wglSetPixelFormat(HDC hdc, int iPixelFormat, const PIXELFORMATDESCRIPTOR *ppfd)
8199 {
8200 TRACE("(*)");
8201 //UNIMPLEMENTED();
8202
8203 return TRUE;
8204 }
8205
wglShareLists(HGLRC,HGLRC)8206 BOOL WINAPI wglShareLists(HGLRC, HGLRC)
8207 {
8208 UNIMPLEMENTED();
8209 return FALSE;
8210 }
8211
wglSwapBuffers(HDC hdc)8212 BOOL WINAPI wglSwapBuffers(HDC hdc)
8213 {
8214 TRACE("(*)");
8215
8216 gl::Display *display = gl::getDisplay();
8217
8218 if(display)
8219 {
8220 display->getPrimarySurface()->swap();
8221 return TRUE;
8222 }
8223
8224 return FALSE;
8225 }
8226
wglSwapLayerBuffers(HDC,UINT)8227 BOOL WINAPI wglSwapLayerBuffers(HDC, UINT)
8228 {
8229 UNIMPLEMENTED();
8230 return FALSE;
8231 }
8232
wglSwapMultipleBuffers(UINT,CONST WGLSWAP *)8233 DWORD WINAPI wglSwapMultipleBuffers(UINT, CONST WGLSWAP*)
8234 {
8235 UNIMPLEMENTED();
8236 return 0;
8237 }
8238
wglUseFontBitmapsA(HDC,DWORD,DWORD,DWORD)8239 BOOL WINAPI wglUseFontBitmapsA(HDC, DWORD, DWORD, DWORD)
8240 {
8241 UNIMPLEMENTED();
8242 return FALSE;
8243 }
8244
wglUseFontBitmapsW(HDC,DWORD,DWORD,DWORD)8245 BOOL WINAPI wglUseFontBitmapsW(HDC, DWORD, DWORD, DWORD)
8246 {
8247 UNIMPLEMENTED();
8248 return FALSE;
8249 }
8250
wglUseFontOutlinesA(HDC,DWORD,DWORD,DWORD,FLOAT,FLOAT,int,LPGLYPHMETRICSFLOAT)8251 BOOL WINAPI wglUseFontOutlinesA(HDC, DWORD, DWORD, DWORD, FLOAT, FLOAT, int, LPGLYPHMETRICSFLOAT)
8252 {
8253 UNIMPLEMENTED();
8254 return FALSE;
8255 }
8256
wglUseFontOutlinesW(HDC,DWORD,DWORD,DWORD,FLOAT,FLOAT,int,LPGLYPHMETRICSFLOAT)8257 BOOL WINAPI wglUseFontOutlinesW(HDC, DWORD, DWORD, DWORD, FLOAT, FLOAT, int, LPGLYPHMETRICSFLOAT)
8258 {
8259 UNIMPLEMENTED();
8260 return FALSE;
8261 }
8262
8263 }
8264