Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / angle / 45d035808ab6bb3afbe40590b1b17837b2f307b5 / . / libGLESv2 / libGLESv2.cpp
blob: b76224e88e42546010dfb62e96de3c744331b84d [file] [log] [blame]
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]1//
2// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
3// Use of this source code is governed by a BSD-style license that can be
4// found in the LICENSE file.
5//
6
7// libGLESv2.cpp: Implements the exported OpenGL ES 2.0 functions.
8
9#define GL_APICALL
10#include <GLES2/gl2.h>
11#include <GLES2/gl2ext.h>
12
13#include "Context.h"
14#include "main.h"
15#include "Program.h"
16#include "Shader.h"
17#include "Buffer.h"
18#include "Texture.h"
19#include "Renderbuffer.h"
20#include "Framebuffer.h"
21#include "mathutil.h"
22#include "debug.h"
23
24#include <exception>
25
26extern "C"
27{
28
29void __stdcall glActiveTexture(GLenum texture)
30{
31 TRACE("GLenum texture = 0x%X", texture);
32
33 try
34 {
35 if (texture < GL_TEXTURE0 || texture > GL_TEXTURE0 + gl::MAX_TEXTURE_IMAGE_UNITS - 1)
36 {
37 return error(GL_INVALID_ENUM);
38 }
39
40 gl::Context *context = gl::getContext();
41
42 if (context)
43 {
44 context->activeSampler = texture - GL_TEXTURE0;
45 }
46 }
47 catch(std::bad_alloc&)
48 {
49 return error(GL_OUT_OF_MEMORY);
50 }
51}
52
53void __stdcall glAttachShader(GLuint program, GLuint shader)
54{
55 TRACE("GLuint program = %d, GLuint shader = %d", program, shader);
56
57 try
58 {
59 gl::Context *context = gl::getContext();
60
61 if (context)
62 {
63 gl::Program *programObject = context->getProgram(program);
64 gl::Shader *shaderObject = context->getShader(shader);
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]65
daniel@transgaming.come2b22122010-03-11 19:22:14 +0000[diff] [blame]66 if (!programObject || !shaderObject)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]67 {
68 return error(GL_INVALID_VALUE);
69 }
70
71 if (!programObject->attachShader(shaderObject))
72 {
73 return error(GL_INVALID_OPERATION);
74 }
75 }
76 }
77 catch(std::bad_alloc&)
78 {
79 return error(GL_OUT_OF_MEMORY);
80 }
81}
82
83void __stdcall glBindAttribLocation(GLuint program, GLuint index, const char* name)
84{
85 TRACE("GLuint program = %d, GLuint index = %d, const char* name = 0x%0.8p", program, index, name);
86
87 try
88 {
89 if (index >= gl::MAX_VERTEX_ATTRIBS)
90 {
91 return error(GL_INVALID_VALUE);
92 }
93
94 gl::Context *context = gl::getContext();
95
96 if (context)
97 {
98 gl::Program *programObject = context->getProgram(program);
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]99
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]100 if (!programObject)
101 {
102 return error(GL_INVALID_VALUE);
103 }
104
105 programObject->bindAttributeLocation(index, name);
106 }
107 }
108 catch(std::bad_alloc&)
109 {
110 return error(GL_OUT_OF_MEMORY);
111 }
112}
113
114void __stdcall glBindBuffer(GLenum target, GLuint buffer)
115{
116 TRACE("GLenum target = 0x%X, GLuint buffer = %d", target, buffer);
117
118 try
119 {
120 gl::Context *context = gl::getContext();
121
122 if (context)
123 {
124 switch (target)
125 {
126 case GL_ARRAY_BUFFER:
127 context->bindArrayBuffer(buffer);
128 return;
129 case GL_ELEMENT_ARRAY_BUFFER:
130 context->bindElementArrayBuffer(buffer);
131 return;
132 default:
133 return error(GL_INVALID_ENUM);
134 }
135 }
136 }
137 catch(std::bad_alloc&)
138 {
139 return error(GL_OUT_OF_MEMORY);
140 }
141}
142
143void __stdcall glBindFramebuffer(GLenum target, GLuint framebuffer)
144{
145 TRACE("GLenum target = 0x%X, GLuint framebuffer = %d", target, framebuffer);
146
147 try
148 {
149 if (target != GL_FRAMEBUFFER)
150 {
151 return error(GL_INVALID_ENUM);
152 }
153
154 gl::Context *context = gl::getContext();
155
156 if (context)
157 {
158 context->bindFramebuffer(framebuffer);
159 }
160 }
161 catch(std::bad_alloc&)
162 {
163 return error(GL_OUT_OF_MEMORY);
164 }
165}
166
167void __stdcall glBindRenderbuffer(GLenum target, GLuint renderbuffer)
168{
169 TRACE("GLenum target = 0x%X, GLuint renderbuffer = %d", target, renderbuffer);
170
171 try
172 {
173 if (target != GL_RENDERBUFFER)
174 {
175 return error(GL_INVALID_ENUM);
176 }
177
178 gl::Context *context = gl::getContext();
179
180 if (context)
181 {
182 context->bindRenderbuffer(renderbuffer);
183 }
184 }
185 catch(std::bad_alloc&)
186 {
187 return error(GL_OUT_OF_MEMORY);
188 }
189}
190
191void __stdcall glBindTexture(GLenum target, GLuint texture)
192{
193 TRACE("GLenum target = 0x%X, GLuint texture = %d", target, texture);
194
195 try
196 {
197 gl::Context *context = gl::getContext();
198
199 if (context)
200 {
201 gl::Texture *textureObject = context->getTexture(texture);
202
203 if (textureObject && textureObject->getTarget() != target && texture != 0)
204 {
205 return error(GL_INVALID_OPERATION);
206 }
207
208 switch (target)
209 {
210 case GL_TEXTURE_2D:
211 context->bindTexture2D(texture);
212 return;
213 case GL_TEXTURE_CUBE_MAP:
214 context->bindTextureCubeMap(texture);
215 return;
216 default:
217 return error(GL_INVALID_ENUM);
218 }
219 }
220 }
221 catch(std::bad_alloc&)
222 {
223 return error(GL_OUT_OF_MEMORY);
224 }
225}
226
227void __stdcall glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
228{
229 TRACE("GLclampf red = %f, GLclampf green = %f, GLclampf blue = %f, GLclampf alpha = %f", red, green, blue, alpha);
230
231 try
232 {
233 gl::Context* context = gl::getContext();
234
235 if (context)
236 {
237 context->blendColor.red = gl::clamp01(red);
238 context->blendColor.blue = gl::clamp01(blue);
239 context->blendColor.green = gl::clamp01(green);
240 context->blendColor.alpha = gl::clamp01(alpha);
241 }
242 }
243 catch(std::bad_alloc&)
244 {
245 return error(GL_OUT_OF_MEMORY);
246 }
247}
248
249void __stdcall glBlendEquation(GLenum mode)
250{
251 glBlendEquationSeparate(mode, mode);
252}
253
254void __stdcall glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
255{
256 TRACE("GLenum modeRGB = 0x%X, GLenum modeAlpha = 0x%X", modeRGB, modeAlpha);
257
258 try
259 {
260 switch (modeRGB)
261 {
262 case GL_FUNC_ADD:
263 case GL_FUNC_SUBTRACT:
264 case GL_FUNC_REVERSE_SUBTRACT:
265 break;
266 default:
267 return error(GL_INVALID_ENUM);
268 }
269
270 switch (modeAlpha)
271 {
272 case GL_FUNC_ADD:
273 case GL_FUNC_SUBTRACT:
274 case GL_FUNC_REVERSE_SUBTRACT:
275 break;
276 default:
277 return error(GL_INVALID_ENUM);
278 }
279
280 gl::Context *context = gl::getContext();
281
282 if (context)
283 {
284 context->blendEquationRGB = modeRGB;
285 context->blendEquationAlpha = modeAlpha;
286 }
287 }
288 catch(std::bad_alloc&)
289 {
290 return error(GL_OUT_OF_MEMORY);
291 }
292}
293
294void __stdcall glBlendFunc(GLenum sfactor, GLenum dfactor)
295{
296 glBlendFuncSeparate(sfactor, dfactor, sfactor, dfactor);
297}
298
299void __stdcall glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
300{
301 TRACE("GLenum srcRGB = 0x%X, GLenum dstRGB = 0x%X, GLenum srcAlpha = 0x%X, GLenum dstAlpha = 0x%X", srcRGB, dstRGB, srcAlpha, dstAlpha);
302
303 try
304 {
305 switch (srcRGB)
306 {
307 case GL_ZERO:
308 case GL_ONE:
309 case GL_SRC_COLOR:
310 case GL_ONE_MINUS_SRC_COLOR:
311 case GL_DST_COLOR:
312 case GL_ONE_MINUS_DST_COLOR:
313 case GL_SRC_ALPHA:
314 case GL_ONE_MINUS_SRC_ALPHA:
315 case GL_DST_ALPHA:
316 case GL_ONE_MINUS_DST_ALPHA:
317 case GL_CONSTANT_COLOR:
318 case GL_ONE_MINUS_CONSTANT_COLOR:
319 case GL_CONSTANT_ALPHA:
320 case GL_ONE_MINUS_CONSTANT_ALPHA:
321 case GL_SRC_ALPHA_SATURATE:
322 break;
323 default:
324 return error(GL_INVALID_ENUM);
325 }
326
327 switch (dstRGB)
328 {
329 case GL_ZERO:
330 case GL_ONE:
331 case GL_SRC_COLOR:
332 case GL_ONE_MINUS_SRC_COLOR:
333 case GL_DST_COLOR:
334 case GL_ONE_MINUS_DST_COLOR:
335 case GL_SRC_ALPHA:
336 case GL_ONE_MINUS_SRC_ALPHA:
337 case GL_DST_ALPHA:
338 case GL_ONE_MINUS_DST_ALPHA:
339 case GL_CONSTANT_COLOR:
340 case GL_ONE_MINUS_CONSTANT_COLOR:
341 case GL_CONSTANT_ALPHA:
342 case GL_ONE_MINUS_CONSTANT_ALPHA:
343 break;
344 default:
345 return error(GL_INVALID_ENUM);
346 }
347
348 switch (srcAlpha)
349 {
350 case GL_ZERO:
351 case GL_ONE:
352 case GL_SRC_COLOR:
353 case GL_ONE_MINUS_SRC_COLOR:
354 case GL_DST_COLOR:
355 case GL_ONE_MINUS_DST_COLOR:
356 case GL_SRC_ALPHA:
357 case GL_ONE_MINUS_SRC_ALPHA:
358 case GL_DST_ALPHA:
359 case GL_ONE_MINUS_DST_ALPHA:
360 case GL_CONSTANT_COLOR:
361 case GL_ONE_MINUS_CONSTANT_COLOR:
362 case GL_CONSTANT_ALPHA:
363 case GL_ONE_MINUS_CONSTANT_ALPHA:
364 case GL_SRC_ALPHA_SATURATE:
365 break;
366 default:
367 return error(GL_INVALID_ENUM);
368 }
369
370 switch (dstAlpha)
371 {
372 case GL_ZERO:
373 case GL_ONE:
374 case GL_SRC_COLOR:
375 case GL_ONE_MINUS_SRC_COLOR:
376 case GL_DST_COLOR:
377 case GL_ONE_MINUS_DST_COLOR:
378 case GL_SRC_ALPHA:
379 case GL_ONE_MINUS_SRC_ALPHA:
380 case GL_DST_ALPHA:
381 case GL_ONE_MINUS_DST_ALPHA:
382 case GL_CONSTANT_COLOR:
383 case GL_ONE_MINUS_CONSTANT_COLOR:
384 case GL_CONSTANT_ALPHA:
385 case GL_ONE_MINUS_CONSTANT_ALPHA:
386 break;
387 default:
388 return error(GL_INVALID_ENUM);
389 }
390
391 if ((srcRGB == GL_CONSTANT_COLOR && dstRGB == GL_CONSTANT_ALPHA) ||
392 (srcRGB == GL_CONSTANT_ALPHA && dstRGB == GL_CONSTANT_COLOR))
393 {
394 UNIMPLEMENTED();
395 }
396
397 gl::Context *context = gl::getContext();
398
399 if (context)
400 {
401 context->sourceBlendRGB = srcRGB;
402 context->sourceBlendAlpha = srcAlpha;
403 context->destBlendRGB = dstRGB;
404 context->destBlendAlpha = dstAlpha;
405 }
406 }
407 catch(std::bad_alloc&)
408 {
409 return error(GL_OUT_OF_MEMORY);
410 }
411}
412
413void __stdcall glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
414{
415 TRACE("GLenum target = 0x%X, GLsizeiptr size = %d, const void* data = 0x%0.8p, GLenum usage = %d", target, size, data, usage);
416
417 try
418 {
419 if (size < 0)
420 {
421 return error(GL_INVALID_VALUE);
422 }
423
424 switch (usage)
425 {
426 case GL_STREAM_DRAW:
427 case GL_STATIC_DRAW:
428 case GL_DYNAMIC_DRAW:
429 break;
430 default:
431 return error(GL_INVALID_ENUM);
432 }
433
434 gl::Context *context = gl::getContext();
435
436 if (context)
437 {
438 gl::Buffer *buffer;
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]439
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]440 switch (target)
441 {
442 case GL_ARRAY_BUFFER:
443 buffer = context->getArrayBuffer();
444 break;
445 case GL_ELEMENT_ARRAY_BUFFER:
446 buffer = context->getElementArrayBuffer();
447 break;
448 default:
449 return error(GL_INVALID_ENUM);
450 }
451
452 if (!buffer)
453 {
454 return error(GL_INVALID_OPERATION);
455 }
456
457 buffer->storeData(size, data);
458 }
459 }
460 catch(std::bad_alloc&)
461 {
462 return error(GL_OUT_OF_MEMORY);
463 }
464}
465
466void __stdcall glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
467{
468 TRACE("GLenum target = 0x%X, GLintptr offset = %d, GLsizeiptr size = %d, const void* data = 0x%0.8p", target, offset, size, data);
469
470 try
471 {
472 if (size < 0)
473 {
474 return error(GL_INVALID_VALUE);
475 }
476
477 UNIMPLEMENTED(); // FIXME
478 }
479 catch(std::bad_alloc&)
480 {
481 return error(GL_OUT_OF_MEMORY);
482 }
483}
484
485GLenum __stdcall glCheckFramebufferStatus(GLenum target)
486{
487 TRACE("GLenum target = 0x%X", target);
488
489 try
490 {
491 if (target != GL_FRAMEBUFFER)
492 {
493 return error(GL_INVALID_ENUM, 0);
494 }
495
496 gl::Context *context = gl::getContext();
497
498 if (context)
499 {
500 gl::Framebuffer *framebuffer = context->getFramebuffer();
501
502 return framebuffer->completeness();
503 }
504 }
505 catch(std::bad_alloc&)
506 {
507 return error(GL_OUT_OF_MEMORY, 0);
508 }
509
510 return 0;
511}
512
513void __stdcall glClear(GLbitfield mask)
514{
515 TRACE("GLbitfield mask = %X", mask);
516
517 try
518 {
519 gl::Context *context = gl::getContext();
520
521 if (context)
522 {
523 context->clear(mask);
524 }
525 }
526 catch(std::bad_alloc&)
527 {
528 return error(GL_OUT_OF_MEMORY);
529 }
530}
531
532void __stdcall glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
533{
534 TRACE("GLclampf red = %f, GLclampf green = %f, GLclampf blue = %f, GLclampf alpha = %f", red, green, blue, alpha);
535
536 try
537 {
538 gl::Context *context = gl::getContext();
539
540 if (context)
541 {
542 context->setClearColor(red, green, blue, alpha);
543 }
544 }
545 catch(std::bad_alloc&)
546 {
547 return error(GL_OUT_OF_MEMORY);
548 }
549}
550
551void __stdcall glClearDepthf(GLclampf depth)
552{
553 TRACE("GLclampf depth = %f", depth);
554
555 try
556 {
557 gl::Context *context = gl::getContext();
558
559 if (context)
560 {
561 context->setClearDepth(depth);
562 }
563 }
564 catch(std::bad_alloc&)
565 {
566 return error(GL_OUT_OF_MEMORY);
567 }
568}
569
570void __stdcall glClearStencil(GLint s)
571{
572 TRACE("GLint s = %d", s);
573
574 try
575 {
576 gl::Context *context = gl::getContext();
577
578 if (context)
579 {
580 context->setClearStencil(s);
581 }
582 }
583 catch(std::bad_alloc&)
584 {
585 return error(GL_OUT_OF_MEMORY);
586 }
587}
588
589void __stdcall glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
590{
591 TRACE("GLboolean red = %d, GLboolean green = %d, GLboolean blue = %d, GLboolean alpha = %d", red, green, blue, alpha);
592
593 try
594 {
595 gl::Context *context = gl::getContext();
596
597 if (context)
598 {
599 context->colorMaskRed = red != GL_FALSE;
600 context->colorMaskGreen = green != GL_FALSE;
601 context->colorMaskBlue = blue != GL_FALSE;
602 context->colorMaskAlpha = alpha != GL_FALSE;
603 }
604 }
605 catch(std::bad_alloc&)
606 {
607 return error(GL_OUT_OF_MEMORY);
608 }
609}
610
611void __stdcall glCompileShader(GLuint shader)
612{
613 TRACE("GLuint shader = %d", shader);
614
615 try
616 {
617 gl::Context *context = gl::getContext();
618
619 if (context)
620 {
621 gl::Shader *shaderObject = context->getShader(shader);
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]622
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]623 if (!shaderObject)
624 {
625 return error(GL_INVALID_VALUE);
626 }
627
628 shaderObject->compile();
629 }
630 }
631 catch(std::bad_alloc&)
632 {
633 return error(GL_OUT_OF_MEMORY);
634 }
635}
636
637void __stdcall glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
638{
639 TRACE("GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = %d, GLint border = %d, GLsizei imageSize = %d, const void* data = 0x%0.8p",
640 target, level, internalformat, width, height, border, imageSize, data);
641
642 try
643 {
644 if (width < 0 || height < 0 || imageSize < 0)
645 {
646 return error(GL_INVALID_VALUE);
647 }
648
649 UNIMPLEMENTED(); // FIXME
650 }
651 catch(std::bad_alloc&)
652 {
653 return error(GL_OUT_OF_MEMORY);
654 }
655}
656
657void __stdcall glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
658{
659 TRACE("GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLsizei width = %d, GLsizei height = %d, GLenum format = 0x%X, GLsizei imageSize = %d, const void* data = 0x%0.8p",
660 target, level, xoffset, yoffset, width, height, format, imageSize, data);
661
662 try
663 {
664 if (width < 0 || height < 0 || imageSize < 0)
665 {
666 return error(GL_INVALID_VALUE);
667 }
668
669 UNIMPLEMENTED(); // FIXME
670 }
671 catch(std::bad_alloc&)
672 {
673 return error(GL_OUT_OF_MEMORY);
674 }
675}
676
677void __stdcall glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
678{
679 TRACE("GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLint border = %d",
680 target, level, internalformat, x, y, width, height, border);
681
682 try
683 {
684 if (width < 0 || height < 0)
685 {
686 return error(GL_INVALID_VALUE);
687 }
688
689 UNIMPLEMENTED(); // FIXME
690 }
691 catch(std::bad_alloc&)
692 {
693 return error(GL_OUT_OF_MEMORY);
694 }
695}
696
697void __stdcall glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
698{
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]699 TRACE("GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d",
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]700 target, level, xoffset, yoffset, x, y, width, height);
701
702 try
703 {
704 if (width < 0 || height < 0)
705 {
706 return error(GL_INVALID_VALUE);
707 }
708
709 UNIMPLEMENTED(); // FIXME
710 }
711 catch(std::bad_alloc&)
712 {
713 return error(GL_OUT_OF_MEMORY);
714 }
715}
716
717GLuint __stdcall glCreateProgram(void)
718{
719 TRACE("");
720
721 try
722 {
723 gl::Context *context = gl::getContext();
724
725 if (context)
726 {
727 return context->createProgram();
728 }
729 }
730 catch(std::bad_alloc&)
731 {
732 return error(GL_OUT_OF_MEMORY, 0);
733 }
734
735 return 0;
736}
737
738GLuint __stdcall glCreateShader(GLenum type)
739{
740 TRACE("GLenum type = 0x%X", type);
741
742 try
743 {
744 gl::Context *context = gl::getContext();
745
746 if (context)
747 {
748 switch (type)
749 {
750 case GL_FRAGMENT_SHADER:
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]751 case GL_VERTEX_SHADER:
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]752 return context->createShader(type);
753 default:
754 return error(GL_INVALID_ENUM, 0);
755 }
756 }
757 }
758 catch(std::bad_alloc&)
759 {
760 return error(GL_OUT_OF_MEMORY, 0);
761 }
762
763 return 0;
764}
765
766void __stdcall glCullFace(GLenum mode)
767{
768 TRACE("GLenum mode = 0x%X", mode);
769
770 try
771 {
772 switch (mode)
773 {
774 case GL_FRONT:
775 case GL_BACK:
776 case GL_FRONT_AND_BACK:
777 {
778 gl::Context *context = gl::getContext();
779
780 if (context)
781 {
782 context->cullMode = mode;
783 }
784 }
785 break;
786 default:
787 return error(GL_INVALID_ENUM);
788 }
789 }
790 catch(std::bad_alloc&)
791 {
792 return error(GL_OUT_OF_MEMORY);
793 }
794}
795
796void __stdcall glDeleteBuffers(GLsizei n, const GLuint* buffers)
797{
798 TRACE("GLsizei n = %d, const GLuint* buffers = 0x%0.8p", n, buffers);
799
800 try
801 {
802 if (n < 0)
803 {
804 return error(GL_INVALID_VALUE);
805 }
806
807 gl::Context *context = gl::getContext();
808
809 if (context)
810 {
811 for (int i = 0; i < n; i++)
812 {
813 context->deleteBuffer(buffers[i]);
814 }
815 }
816 }
817 catch(std::bad_alloc&)
818 {
819 return error(GL_OUT_OF_MEMORY);
820 }
821}
822
823void __stdcall glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
824{
825 TRACE("GLsizei n = %d, const GLuint* framebuffers = 0x%0.8p", n, framebuffers);
826
827 try
828 {
829 if (n < 0)
830 {
831 return error(GL_INVALID_VALUE);
832 }
833
834 gl::Context *context = gl::getContext();
835
836 if (context)
837 {
838 for (int i = 0; i < n; i++)
839 {
840 if (framebuffers[i] != 0)
841 {
842 context->deleteFramebuffer(framebuffers[i]);
843 }
844 }
845 }
846 }
847 catch(std::bad_alloc&)
848 {
849 return error(GL_OUT_OF_MEMORY);
850 }
851}
852
853void __stdcall glDeleteProgram(GLuint program)
854{
855 TRACE("GLuint program = %d", program);
856
857 try
858 {
859 gl::Context *context = gl::getContext();
860
861 if (context)
862 {
863 context->deleteProgram(program);
864 }
865 }
866 catch(std::bad_alloc&)
867 {
868 return error(GL_OUT_OF_MEMORY);
869 }
870}
871
872void __stdcall glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
873{
874 TRACE("GLsizei n = %d, const GLuint* renderbuffers = 0x%0.8p", n, renderbuffers);
875
876 try
877 {
878 if (n < 0)
879 {
880 return error(GL_INVALID_VALUE);
881 }
882
883 gl::Context *context = gl::getContext();
884
885 if (context)
886 {
daniel@transgaming.come2b22122010-03-11 19:22:14 +0000[diff] [blame]887 for (int i = 0; i < n; i++)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]888 {
889 context->deleteRenderbuffer(renderbuffers[i]);
890 }
891 }
892 }
893 catch(std::bad_alloc&)
894 {
895 return error(GL_OUT_OF_MEMORY);
896 }
897}
898
899void __stdcall glDeleteShader(GLuint shader)
900{
901 TRACE("GLuint shader = %d", shader);
902
903 try
904 {
905 gl::Context *context = gl::getContext();
906
907 if (context)
908 {
909 context->deleteShader(shader);
910 }
911 }
912 catch(std::bad_alloc&)
913 {
914 return error(GL_OUT_OF_MEMORY);
915 }
916}
917
918void __stdcall glDeleteTextures(GLsizei n, const GLuint* textures)
919{
920 TRACE("GLsizei n = %d, const GLuint* textures = 0x%0.8p", n, textures);
921
922 try
923 {
924 if (n < 0)
925 {
926 return error(GL_INVALID_VALUE);
927 }
928
929 gl::Context *context = gl::getContext();
930
931 if (context)
932 {
933 for (int i = 0; i < n; i++)
934 {
935 if (textures[i] != 0)
936 {
937 context->deleteTexture(textures[i]);
938 }
939 }
940 }
941 }
942 catch(std::bad_alloc&)
943 {
944 return error(GL_OUT_OF_MEMORY);
945 }
946}
947
948void __stdcall glDepthFunc(GLenum func)
949{
950 TRACE("GLenum func = 0x%X", func);
951
952 try
953 {
954 switch (func)
955 {
956 case GL_NEVER:
957 case GL_ALWAYS:
958 case GL_LESS:
959 case GL_LEQUAL:
960 case GL_EQUAL:
961 case GL_GREATER:
962 case GL_GEQUAL:
963 case GL_NOTEQUAL:
964 break;
965 default:
966 return error(GL_INVALID_ENUM);
967 }
968
969 gl::Context *context = gl::getContext();
970
971 if (context)
972 {
973 context->depthFunc = func;
974 }
975 }
976 catch(std::bad_alloc&)
977 {
978 return error(GL_OUT_OF_MEMORY);
979 }
980}
981
982void __stdcall glDepthMask(GLboolean flag)
983{
984 TRACE("GLboolean flag = %d", flag);
985
986 try
987 {
988 gl::Context *context = gl::getContext();
989
990 if (context)
991 {
992 context->depthMask = flag != GL_FALSE;
993 }
994 }
995 catch(std::bad_alloc&)
996 {
997 return error(GL_OUT_OF_MEMORY);
998 }
999}
1000
1001void __stdcall glDepthRangef(GLclampf zNear, GLclampf zFar)
1002{
1003 TRACE("GLclampf zNear = %f, GLclampf zFar = %f", zNear, zFar);
1004
1005 try
1006 {
1007 gl::Context *context = gl::getContext();
1008
1009 if (context)
1010 {
1011 context->zNear = zNear;
1012 context->zFar = zFar;
1013 }
1014 }
1015 catch(std::bad_alloc&)
1016 {
1017 return error(GL_OUT_OF_MEMORY);
1018 }
1019}
1020
1021void __stdcall glDetachShader(GLuint program, GLuint shader)
1022{
1023 TRACE("GLuint program = %d, GLuint shader = %d", program, shader);
1024
1025 try
1026 {
1027 gl::Context *context = gl::getContext();
1028
1029 if (context)
1030 {
1031 gl::Program *programObject = context->getProgram(program);
1032 gl::Shader *shaderObject = context->getShader(shader);
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]1033
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]1034 if (!programObject || !shaderObject)
1035 {
1036 return error(GL_INVALID_VALUE);
1037 }
1038
1039 if (!programObject->detachShader(shaderObject))
1040 {
1041 return error(GL_INVALID_OPERATION);
1042 }
1043
1044 if (shaderObject->isDeletable())
1045 {
1046 context->deleteShader(shader);
1047 }
1048 }
1049 }
1050 catch(std::bad_alloc&)
1051 {
1052 return error(GL_OUT_OF_MEMORY);
1053 }
1054}
1055
1056void __stdcall glDisable(GLenum cap)
1057{
1058 TRACE("GLenum cap = 0x%X", cap);
1059
1060 try
1061 {
1062 gl::Context *context = gl::getContext();
1063
1064 if (context)
1065 {
1066 switch (cap)
1067 {
1068 case GL_CULL_FACE: context->cullFace = false; break;
1069 case GL_POLYGON_OFFSET_FILL: context->polygonOffsetFill = false; break;
1070 case GL_SAMPLE_ALPHA_TO_COVERAGE: context->sampleAlphaToCoverage = false; break;
1071 case GL_SAMPLE_COVERAGE: context->sampleCoverage = false; break;
1072 case GL_SCISSOR_TEST: context->scissorTest = false; break;
1073 case GL_STENCIL_TEST: context->stencilTest = false; break;
1074 case GL_DEPTH_TEST: context->depthTest = false; break;
1075 case GL_BLEND: context->blend = false; break;
1076 case GL_DITHER: context->dither = false; break;
1077 default:
1078 return error(GL_INVALID_ENUM);
1079 }
1080 }
1081 }
1082 catch(std::bad_alloc&)
1083 {
1084 return error(GL_OUT_OF_MEMORY);
1085 }
1086}
1087
1088void __stdcall glDisableVertexAttribArray(GLuint index)
1089{
1090 TRACE("GLuint index = %d", index);
1091
1092 try
1093 {
1094 if (index >= gl::MAX_VERTEX_ATTRIBS)
1095 {
1096 return error(GL_INVALID_VALUE);
1097 }
1098
1099 gl::Context *context = gl::getContext();
1100
1101 if (context)
1102 {
1103 context->vertexAttribute[index].enabled = false;
1104 }
1105 }
1106 catch(std::bad_alloc&)
1107 {
1108 return error(GL_OUT_OF_MEMORY);
1109 }
1110}
1111
1112void __stdcall glDrawArrays(GLenum mode, GLint first, GLsizei count)
1113{
1114 TRACE("GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d", mode, first, count);
1115
1116 try
1117 {
1118 if (count < 0 || first < 0)
1119 {
1120 return error(GL_INVALID_VALUE);
1121 }
1122
1123 gl::Context *context = gl::getContext();
1124
1125 if (context)
1126 {
1127 context->drawArrays(mode, first, count);
1128 }
1129 }
1130 catch(std::bad_alloc&)
1131 {
1132 return error(GL_OUT_OF_MEMORY);
1133 }
1134}
1135
1136void __stdcall glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
1137{
1138 TRACE("GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const void* indices = 0x%0.8p", mode, count, type, indices);
1139
1140 try
1141 {
1142 if (count < 0)
1143 {
1144 return error(GL_INVALID_VALUE);
1145 }
1146
1147 switch (type)
1148 {
1149 case GL_UNSIGNED_BYTE:
1150 UNIMPLEMENTED(); // FIXME
1151 case GL_UNSIGNED_SHORT:
1152 break;
1153 default:
1154 return error(GL_INVALID_ENUM);
1155 }
1156
1157 gl::Context *context = gl::getContext();
1158
1159 if (context)
1160 {
1161 context->drawElements(mode, count, type, indices);
1162 }
1163 }
1164 catch(std::bad_alloc&)
1165 {
1166 return error(GL_OUT_OF_MEMORY);
1167 }
1168}
1169
1170void __stdcall glEnable(GLenum cap)
1171{
1172 TRACE("GLenum cap = 0x%X", cap);
1173
1174 try
1175 {
1176 gl::Context *context = gl::getContext();
1177
1178 if (context)
1179 {
1180 switch (cap)
1181 {
1182 case GL_CULL_FACE: context->cullFace = true; break;
1183 case GL_POLYGON_OFFSET_FILL: context->polygonOffsetFill = true; break;
1184 case GL_SAMPLE_ALPHA_TO_COVERAGE: context->sampleAlphaToCoverage = true; break;
1185 case GL_SAMPLE_COVERAGE: context->sampleCoverage = true; break;
1186 case GL_SCISSOR_TEST: context->scissorTest = true; break;
1187 case GL_STENCIL_TEST: context->stencilTest = true; break;
1188 case GL_DEPTH_TEST: context->depthTest = true; break;
1189 case GL_BLEND: context->blend = true; break;
1190 case GL_DITHER: context->dither = true; break;
1191 default:
1192 return error(GL_INVALID_ENUM);
1193 }
1194 }
1195 }
1196 catch(std::bad_alloc&)
1197 {
1198 return error(GL_OUT_OF_MEMORY);
1199 }
1200}
1201
1202void __stdcall glEnableVertexAttribArray(GLuint index)
1203{
1204 TRACE("GLuint index = %d", index);
1205
1206 try
1207 {
1208 if (index >= gl::MAX_VERTEX_ATTRIBS)
1209 {
1210 return error(GL_INVALID_VALUE);
1211 }
1212
1213 gl::Context *context = gl::getContext();
1214
1215 if (context)
1216 {
1217 context->vertexAttribute[index].enabled = true;
1218 }
1219 }
1220 catch(std::bad_alloc&)
1221 {
1222 return error(GL_OUT_OF_MEMORY);
1223 }
1224}
1225
1226void __stdcall glFinish(void)
1227{
1228 TRACE("");
1229
1230 try
1231 {
1232 gl::Context *context = gl::getContext();
1233
1234 if (context)
1235 {
1236 context->finish();
1237 }
1238 }
1239 catch(std::bad_alloc&)
1240 {
1241 return error(GL_OUT_OF_MEMORY);
1242 }
1243}
1244
1245void __stdcall glFlush(void)
1246{
1247 TRACE("");
1248
1249 try
1250 {
1251 gl::Context *context = gl::getContext();
1252
1253 if (context)
1254 {
1255 context->flush();
1256 }
1257 }
1258 catch(std::bad_alloc&)
1259 {
1260 return error(GL_OUT_OF_MEMORY);
1261 }
1262}
1263
1264void __stdcall glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
1265{
1266 TRACE("GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum renderbuffertarget = 0x%X, GLuint renderbuffer = %d", target, attachment, renderbuffertarget, renderbuffer);
1267
1268 try
1269 {
1270 if (target != GL_FRAMEBUFFER || renderbuffertarget != GL_RENDERBUFFER)
1271 {
1272 return error(GL_INVALID_ENUM);
1273 }
1274
1275 gl::Context *context = gl::getContext();
1276
1277 if (context)
1278 {
1279 gl::Framebuffer *framebuffer = context->getFramebuffer();
1280
1281 if (context->framebuffer == 0 || !framebuffer)
1282 {
1283 return error(GL_INVALID_OPERATION);
1284 }
1285
1286 switch (attachment)
1287 {
1288 case GL_COLOR_ATTACHMENT0:
1289 framebuffer->setColorbuffer(GL_RENDERBUFFER, renderbuffer);
1290 break;
1291 case GL_DEPTH_ATTACHMENT:
1292 framebuffer->setDepthbuffer(GL_RENDERBUFFER, renderbuffer);
1293 break;
1294 case GL_STENCIL_ATTACHMENT:
1295 framebuffer->setStencilbuffer(GL_RENDERBUFFER, renderbuffer);
1296 break;
1297 default:
1298 return error(GL_INVALID_ENUM);
1299 }
1300 }
1301 }
1302 catch(std::bad_alloc&)
1303 {
1304 return error(GL_OUT_OF_MEMORY);
1305 }
1306}
1307
1308void __stdcall glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1309{
1310 TRACE("GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum textarget = 0x%X, GLuint texture = %d, GLint level = %d", target, attachment, textarget, texture, level);
1311
1312 try
1313 {
1314 if (target != GL_FRAMEBUFFER)
1315 {
1316 return error(GL_INVALID_ENUM);
1317 }
1318
1319 switch (attachment)
1320 {
1321 case GL_COLOR_ATTACHMENT0:
1322 break;
1323 default:
1324 return error(GL_INVALID_ENUM);
1325 }
1326
1327 gl::Context *context = gl::getContext();
1328
1329 if (context)
1330 {
1331 if (texture)
1332 {
1333 switch (textarget)
1334 {
1335 case GL_TEXTURE_2D:
1336 if (!context->getTexture2D())
1337 {
1338 return error(GL_INVALID_OPERATION);
1339 }
1340 break;
1341 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
1342 UNIMPLEMENTED(); // FIXME
1343 break;
1344 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
1345 UNIMPLEMENTED(); // FIXME
1346 break;
1347 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
1348 UNIMPLEMENTED(); // FIXME
1349 break;
1350 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
1351 UNIMPLEMENTED(); // FIXME
1352 break;
1353 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
1354 UNIMPLEMENTED(); // FIXME
1355 break;
1356 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
1357 UNIMPLEMENTED(); // FIXME
1358 break;
1359 default:
1360 return error(GL_INVALID_ENUM);
1361 }
1362
1363 if (level != 0)
1364 {
1365 return error(GL_INVALID_VALUE);
1366 }
1367 }
1368
1369 gl::Framebuffer *framebuffer = context->getFramebuffer();
1370
1371 if (context->framebuffer == 0 || !framebuffer)
1372 {
1373 return error(GL_INVALID_OPERATION);
1374 }
1375
1376 framebuffer->setColorbuffer(GL_TEXTURE, texture);
1377 }
1378 }
1379 catch(std::bad_alloc&)
1380 {
1381 return error(GL_OUT_OF_MEMORY);
1382 }
1383}
1384
1385void __stdcall glFrontFace(GLenum mode)
1386{
1387 TRACE("GLenum mode = 0x%X", mode);
1388
1389 try
1390 {
1391 switch (mode)
1392 {
1393 case GL_CW:
1394 case GL_CCW:
1395 {
1396 gl::Context *context = gl::getContext();
1397
1398 if (context)
1399 {
1400 context->frontFace = mode;
1401 }
1402 }
1403 break;
1404 default:
1405 return error(GL_INVALID_ENUM);
1406 }
1407 }
1408 catch(std::bad_alloc&)
1409 {
1410 return error(GL_OUT_OF_MEMORY);
1411 }
1412}
1413
1414void __stdcall glGenBuffers(GLsizei n, GLuint* buffers)
1415{
1416 TRACE("GLsizei n = %d, GLuint* buffers = 0x%0.8p", n, buffers);
1417
1418 try
1419 {
1420 if (n < 0)
1421 {
1422 return error(GL_INVALID_VALUE);
1423 }
1424
1425 gl::Context *context = gl::getContext();
1426
1427 if (context)
1428 {
1429 for (int i = 0; i < n; i++)
1430 {
1431 buffers[i] = context->createBuffer();
1432 }
1433 }
1434 }
1435 catch(std::bad_alloc&)
1436 {
1437 return error(GL_OUT_OF_MEMORY);
1438 }
1439}
1440
1441void __stdcall glGenerateMipmap(GLenum target)
1442{
1443 TRACE("GLenum target = 0x%X", target);
1444
1445 try
1446 {
1447 UNIMPLEMENTED(); // FIXME
1448 }
1449 catch(std::bad_alloc&)
1450 {
1451 return error(GL_OUT_OF_MEMORY);
1452 }
1453}
1454
1455void __stdcall glGenFramebuffers(GLsizei n, GLuint* framebuffers)
1456{
1457 TRACE("GLsizei n = %d, GLuint* framebuffers = 0x%0.8p", n, framebuffers);
1458
1459 try
1460 {
1461 if (n < 0)
1462 {
1463 return error(GL_INVALID_VALUE);
1464 }
1465
1466 gl::Context *context = gl::getContext();
1467
1468 if (context)
1469 {
1470 for (int i = 0; i < n; i++)
1471 {
1472 framebuffers[i] = context->createFramebuffer();
1473 }
1474 }
1475 }
1476 catch(std::bad_alloc&)
1477 {
1478 return error(GL_OUT_OF_MEMORY);
1479 }
1480}
1481
1482void __stdcall glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
1483{
1484 TRACE("GLsizei n = %d, GLuint* renderbuffers = 0x%0.8p", n, renderbuffers);
1485
1486 try
1487 {
1488 if (n < 0)
1489 {
1490 return error(GL_INVALID_VALUE);
1491 }
1492
1493 gl::Context *context = gl::getContext();
1494
1495 if (context)
1496 {
1497 for (int i = 0; i < n; i++)
1498 {
1499 renderbuffers[i] = context->createRenderbuffer();
1500 }
1501 }
1502 }
1503 catch(std::bad_alloc&)
1504 {
1505 return error(GL_OUT_OF_MEMORY);
1506 }
1507}
1508
1509void __stdcall glGenTextures(GLsizei n, GLuint* textures)
1510{
1511 TRACE("GLsizei n = %d, GLuint* textures = 0x%0.8p", n, textures);
1512
1513 try
1514 {
1515 if (n < 0)
1516 {
1517 return error(GL_INVALID_VALUE);
1518 }
1519
1520 gl::Context *context = gl::getContext();
1521
1522 if (context)
1523 {
1524 for (int i = 0; i < n; i++)
1525 {
1526 textures[i] = context->createTexture();
1527 }
1528 }
1529 }
1530 catch(std::bad_alloc&)
1531 {
1532 return error(GL_OUT_OF_MEMORY);
1533 }
1534}
1535
1536void __stdcall glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
1537{
1538 TRACE("GLuint program = %d, GLuint index = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLint* size = 0x%0.8p, GLenum* type = %0.8p, char* name = %0.8p",
1539 program, index, bufsize, length, size, type, name);
1540
1541 try
1542 {
1543 if (bufsize < 0)
1544 {
1545 return error(GL_INVALID_VALUE);
1546 }
1547
1548 UNIMPLEMENTED(); // FIXME
1549 }
1550 catch(std::bad_alloc&)
1551 {
1552 return error(GL_OUT_OF_MEMORY);
1553 }
1554}
1555
1556void __stdcall glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
1557{
1558 TRACE("GLuint program = %d, GLuint index = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLint* size = 0x%0.8p, GLenum* type = 0x%0.8p, char* name = 0x%0.8p",
1559 program, index, bufsize, length, size, type, name);
1560
1561 try
1562 {
1563 if (bufsize < 0)
1564 {
1565 return error(GL_INVALID_VALUE);
1566 }
1567
1568 UNIMPLEMENTED(); // FIXME
1569 }
1570 catch(std::bad_alloc&)
1571 {
1572 return error(GL_OUT_OF_MEMORY);
1573 }
1574}
1575
1576void __stdcall glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
1577{
1578 TRACE("GLuint program = %d, GLsizei maxcount = %d, GLsizei* count = 0x%0.8p, GLuint* shaders = 0x%0.8p", program, maxcount, count, shaders);
1579
1580 try
1581 {
1582 if (maxcount < 0)
1583 {
1584 return error(GL_INVALID_VALUE);
1585 }
1586
1587 UNIMPLEMENTED(); // FIXME
1588 }
1589 catch(std::bad_alloc&)
1590 {
1591 return error(GL_OUT_OF_MEMORY);
1592 }
1593}
1594
1595int __stdcall glGetAttribLocation(GLuint program, const char* name)
1596{
1597 TRACE("GLuint program = %d, const char* name = %s", program, name);
1598
1599 try
1600 {
1601 gl::Context *context = gl::getContext();
1602
1603 if (context)
1604 {
1605 gl::Program *programObject = context->getProgram(program);
1606
1607 if (!programObject)
1608 {
1609 return error(GL_INVALID_VALUE, -1);
1610 }
1611
1612 return programObject->getAttributeLocation(name);
1613 }
1614 }
1615 catch(std::bad_alloc&)
1616 {
1617 return error(GL_OUT_OF_MEMORY, -1);
1618 }
1619
1620 return -1;
1621}
1622
1623void __stdcall glGetBooleanv(GLenum pname, GLboolean* params)
1624{
1625 TRACE("GLenum pname = 0x%X, GLboolean* params = 0x%0.8p", pname, params);
1626
1627 try
1628 {
1629 switch (pname)
1630 {
1631 case GL_SHADER_COMPILER: *params = GL_TRUE; break;
1632 default:
1633 UNIMPLEMENTED(); // FIXME
1634 return error(GL_INVALID_ENUM);
1635 }
1636 }
1637 catch(std::bad_alloc&)
1638 {
1639 return error(GL_OUT_OF_MEMORY);
1640 }
1641}
1642
1643void __stdcall glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
1644{
1645 TRACE("GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p", target, pname, params);
1646
1647 try
1648 {
1649 UNIMPLEMENTED(); // FIXME
1650 }
1651 catch(std::bad_alloc&)
1652 {
1653 return error(GL_OUT_OF_MEMORY);
1654 }
1655}
1656
1657GLenum __stdcall glGetError(void)
1658{
1659 TRACE("");
1660
1661 gl::Context *context = gl::getContext();
1662
1663 if (context)
1664 {
1665 return context->getError();
1666 }
1667
1668 return GL_NO_ERROR;
1669}
1670
1671void __stdcall glGetFloatv(GLenum pname, GLfloat* params)
1672{
1673 TRACE("GLenum pname = 0x%X, GLfloat* params = 0x%0.8p", pname, params);
1674
1675 try
1676 {
1677 UNIMPLEMENTED(); // FIXME
1678 }
1679 catch(std::bad_alloc&)
1680 {
1681 return error(GL_OUT_OF_MEMORY);
1682 }
1683}
1684
1685void __stdcall glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
1686{
1687 TRACE("GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p", target, attachment, pname, params);
1688
1689 try
1690 {
1691 gl::Context *context = gl::getContext();
1692
1693 if (context)
1694 {
1695 if (context->framebuffer == 0)
1696 {
1697 return error(GL_INVALID_OPERATION);
1698 }
1699
1700 UNIMPLEMENTED(); // FIXME
1701 }
1702 }
1703 catch(std::bad_alloc&)
1704 {
1705 return error(GL_OUT_OF_MEMORY);
1706 }
1707}
1708
1709void __stdcall glGetIntegerv(GLenum pname, GLint* params)
1710{
1711 TRACE("GLenum pname = 0x%X, GLint* params = 0x%0.8p", pname, params);
1712
1713 try
1714 {
1715 gl::Context *context = gl::getContext();
1716
1717 if (context)
1718 {
1719 switch (pname)
1720 {
1721 case GL_MAX_VERTEX_ATTRIBS: *params = gl::MAX_VERTEX_ATTRIBS; break;
1722 case GL_MAX_VERTEX_UNIFORM_VECTORS: *params = gl::MAX_VERTEX_UNIFORM_VECTORS; break;
1723 case GL_MAX_VARYING_VECTORS: *params = gl::MAX_VARYING_VECTORS; break;
1724 case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: *params = gl::MAX_COMBINED_TEXTURE_IMAGE_UNITS; break;
1725 case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: *params = gl::MAX_VERTEX_TEXTURE_IMAGE_UNITS; break;
1726 case GL_MAX_TEXTURE_IMAGE_UNITS: *params = gl::MAX_TEXTURE_IMAGE_UNITS; break;
1727 case GL_MAX_FRAGMENT_UNIFORM_VECTORS: *params = gl::MAX_FRAGMENT_UNIFORM_VECTORS; break;
1728 case GL_MAX_RENDERBUFFER_SIZE: *params = gl::MAX_RENDERBUFFER_SIZE; break;
1729 case GL_NUM_SHADER_BINARY_FORMATS: *params = 0; break;
1730 case GL_ARRAY_BUFFER_BINDING: *params = context->arrayBuffer; break;
1731 case GL_FRAMEBUFFER_BINDING: *params = context->framebuffer; break;
1732 case GL_RENDERBUFFER_BINDING: *params = context->renderbuffer; break;
1733 case GL_CURRENT_PROGRAM: *params = context->currentProgram; break;
1734 case GL_RED_BITS:
1735 case GL_GREEN_BITS:
1736 case GL_BLUE_BITS:
1737 case GL_ALPHA_BITS:
1738 {
1739 gl::Framebuffer *framebuffer = context->getFramebuffer();
1740 gl::Colorbuffer *colorbuffer = framebuffer->getColorbuffer();
1741
1742 if (colorbuffer)
1743 {
1744 switch (pname)
1745 {
1746 case GL_RED_BITS: *params = colorbuffer->getRedSize(); break;
1747 case GL_GREEN_BITS: *params = colorbuffer->getGreenSize(); break;
1748 case GL_BLUE_BITS: *params = colorbuffer->getBlueSize(); break;
1749 case GL_ALPHA_BITS: *params = colorbuffer->getAlphaSize(); break;
1750 }
1751 }
1752 else
1753 {
1754 *params = 0;
1755 }
1756 }
1757 break;
1758 case GL_DEPTH_BITS:
1759 {
1760 gl::Framebuffer *framebuffer = context->getFramebuffer();
1761 gl::Depthbuffer *depthbuffer = framebuffer->getDepthbuffer();
1762
1763 if (depthbuffer)
1764 {
1765 *params = depthbuffer->getDepthSize();
1766 }
1767 else
1768 {
1769 *params = 0;
1770 }
1771 }
1772 break;
1773 case GL_STENCIL_BITS:
1774 {
1775 gl::Framebuffer *framebuffer = context->getFramebuffer();
1776 gl::Stencilbuffer *stencilbuffer = framebuffer->getStencilbuffer();
1777
1778 if (stencilbuffer)
1779 {
1780 *params = stencilbuffer->getStencilSize();
1781 }
1782 else
1783 {
1784 *params = 0;
1785 }
1786 }
1787 break;
1788 default:
1789 UNIMPLEMENTED(); // FIXME
1790 return error(GL_INVALID_ENUM);
1791 }
1792 }
1793 }
1794 catch(std::bad_alloc&)
1795 {
1796 return error(GL_OUT_OF_MEMORY);
1797 }
1798}
1799
1800void __stdcall glGetProgramiv(GLuint program, GLenum pname, GLint* params)
1801{
1802 TRACE("GLuint program = %d, GLenum pname = %d, GLint* params = 0x%0.8p", program, pname, params);
1803
1804 try
1805 {
1806 gl::Context *context = gl::getContext();
1807
1808 if (context)
1809 {
1810 gl::Program *programObject = context->getProgram(program);
1811
1812 if (!programObject)
1813 {
1814 return error(GL_INVALID_VALUE);
1815 }
1816
1817 switch (pname)
1818 {
1819 case GL_DELETE_STATUS:
1820 UNIMPLEMENTED(); // FIXME
1821 *params = GL_FALSE;
1822 return;
1823 case GL_LINK_STATUS:
1824 *params = programObject->isLinked();
1825 return;
1826 case GL_VALIDATE_STATUS:
1827 UNIMPLEMENTED(); // FIXME
1828 *params = GL_TRUE;
1829 return;
1830 case GL_INFO_LOG_LENGTH:
1831 UNIMPLEMENTED(); // FIXME
1832 *params = 0;
1833 return;
1834 case GL_ATTACHED_SHADERS:
1835 UNIMPLEMENTED(); // FIXME
1836 *params = 2;
1837 return;
1838 case GL_ACTIVE_ATTRIBUTES:
1839 UNIMPLEMENTED(); // FIXME
1840 *params = 0;
1841 return;
1842 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
1843 UNIMPLEMENTED(); // FIXME
1844 *params = 0;
1845 return;
1846 case GL_ACTIVE_UNIFORMS:
1847 UNIMPLEMENTED(); // FIXME
1848 *params = 0;
1849 return;
1850 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
1851 UNIMPLEMENTED(); // FIXME
1852 *params = 0;
1853 return;
1854 default:
1855 return error(GL_INVALID_ENUM);
1856 }
1857 }
1858 }
1859 catch(std::bad_alloc&)
1860 {
1861 return error(GL_OUT_OF_MEMORY);
1862 }
1863}
1864
1865void __stdcall glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
1866{
1867 TRACE("GLuint program = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, char* infolog = 0x%0.8p", program, bufsize, length, infolog);
1868
1869 try
1870 {
1871 if (bufsize < 0)
1872 {
1873 return error(GL_INVALID_VALUE);
1874 }
1875
1876 UNIMPLEMENTED(); // FIXME
1877 }
1878 catch(std::bad_alloc&)
1879 {
1880 return error(GL_OUT_OF_MEMORY);
1881 }
1882}
1883
1884void __stdcall glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
1885{
1886 TRACE("GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p", target, pname, params);
1887
1888 try
1889 {
1890 UNIMPLEMENTED(); // FIXME
1891 }
1892 catch(std::bad_alloc&)
1893 {
1894 return error(GL_OUT_OF_MEMORY);
1895 }
1896}
1897
1898void __stdcall glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
1899{
1900 TRACE("GLuint shader = %d, GLenum pname = %d, GLint* params = 0x%0.8p", shader, pname, params);
1901
1902 try
1903 {
1904 gl::Context *context = gl::getContext();
1905
1906 if (context)
1907 {
1908 gl::Shader *shaderObject = context->getShader(shader);
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]1909
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]1910 if (!shaderObject)
1911 {
1912 return error(GL_INVALID_VALUE);
1913 }
1914
1915 switch (pname)
1916 {
1917 case GL_SHADER_TYPE:
1918 *params = shaderObject->getType();
1919 return;
1920 case GL_DELETE_STATUS:
1921 UNIMPLEMENTED(); // FIXME
1922 *params = GL_FALSE;
1923 return;
1924 case GL_COMPILE_STATUS:
1925 *params = shaderObject->isCompiled() ? GL_TRUE : GL_FALSE;
1926 return;
1927 case GL_INFO_LOG_LENGTH:
1928 UNIMPLEMENTED(); // FIXME
1929 *params = 0;
1930 return;
1931 case GL_SHADER_SOURCE_LENGTH:
1932 UNIMPLEMENTED(); // FIXME
1933 *params = 1;
1934 return;
1935 default:
1936 return error(GL_INVALID_ENUM);
1937 }
1938 }
1939 }
1940 catch(std::bad_alloc&)
1941 {
1942 return error(GL_OUT_OF_MEMORY);
1943 }
1944}
1945
1946void __stdcall glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
1947{
1948 TRACE("GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, char* infolog = 0x%0.8p", shader, bufsize, length, infolog);
1949
1950 try
1951 {
1952 if (bufsize < 0)
1953 {
1954 return error(GL_INVALID_VALUE);
1955 }
1956
1957 UNIMPLEMENTED(); // FIXME
1958 }
1959 catch(std::bad_alloc&)
1960 {
1961 return error(GL_OUT_OF_MEMORY);
1962 }
1963}
1964
1965void __stdcall glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
1966{
1967 TRACE("GLenum shadertype = 0x%X, GLenum precisiontype = 0x%X, GLint* range = 0x%0.8p, GLint* precision = 0x%0.8p", shadertype, precisiontype, range, precision);
1968
1969 try
1970 {
1971 UNIMPLEMENTED(); // FIXME
1972 }
1973 catch(std::bad_alloc&)
1974 {
1975 return error(GL_OUT_OF_MEMORY);
1976 }
1977}
1978
1979void __stdcall glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
1980{
1981 TRACE("GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, char* source = 0x%0.8p", shader, bufsize, length, source);
1982
1983 try
1984 {
1985 if (bufsize < 0)
1986 {
1987 return error(GL_INVALID_VALUE);
1988 }
1989
1990 UNIMPLEMENTED(); // FIXME
1991 }
1992 catch(std::bad_alloc&)
1993 {
1994 return error(GL_OUT_OF_MEMORY);
1995 }
1996}
1997
1998const GLubyte* __stdcall glGetString(GLenum name)
1999{
2000 TRACE("GLenum name = 0x%X", name);
2001
2002 try
2003 {
2004 switch (name)
2005 {
2006 case GL_VENDOR:
2007 return (GLubyte*)"TransGaming Inc.";
2008 case GL_RENDERER:
2009 return (GLubyte*)"ANGLE";
2010 case GL_VERSION:
2011 return (GLubyte*)"OpenGL ES 2.0 (git-devel "__DATE__ " " __TIME__")";
2012 case GL_SHADING_LANGUAGE_VERSION:
2013 return (GLubyte*)"OpenGL ES GLSL ES 1.00 (git-devel "__DATE__ " " __TIME__")";
2014 case GL_EXTENSIONS:
2015 return (GLubyte*)"";
2016 default:
2017 return error(GL_INVALID_ENUM, (GLubyte*)NULL);
2018 }
2019 }
2020 catch(std::bad_alloc&)
2021 {
2022 return error(GL_OUT_OF_MEMORY, (GLubyte*)NULL);
2023 }
2024
2025 return NULL;
2026}
2027
2028void __stdcall glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
2029{
2030 TRACE("GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat* params = 0x%0.8p", target, pname, params);
2031
2032 try
2033 {
2034 UNIMPLEMENTED(); // FIXME
2035 }
2036 catch(std::bad_alloc&)
2037 {
2038 return error(GL_OUT_OF_MEMORY);
2039 }
2040}
2041
2042void __stdcall glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
2043{
2044 TRACE("GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p", target, pname, params);
2045
2046 try
2047 {
2048 UNIMPLEMENTED(); // FIXME
2049 }
2050 catch(std::bad_alloc&)
2051 {
2052 return error(GL_OUT_OF_MEMORY);
2053 }
2054}
2055
2056void __stdcall glGetUniformfv(GLuint program, GLint location, GLfloat* params)
2057{
2058 TRACE("GLuint program = %d, GLint location = %d, GLfloat* params = 0x%0.8p", program, location, params);
2059
2060 try
2061 {
2062 UNIMPLEMENTED(); // FIXME
2063 }
2064 catch(std::bad_alloc&)
2065 {
2066 return error(GL_OUT_OF_MEMORY);
2067 }
2068}
2069
2070void __stdcall glGetUniformiv(GLuint program, GLint location, GLint* params)
2071{
2072 TRACE("GLuint program = %d, GLint location = %d, GLint* params = 0x%0.8p", program, location, params);
2073
2074 try
2075 {
2076 UNIMPLEMENTED(); // FIXME
2077 }
2078 catch(std::bad_alloc&)
2079 {
2080 return error(GL_OUT_OF_MEMORY);
2081 }
2082}
2083
2084int __stdcall glGetUniformLocation(GLuint program, const char* name)
2085{
2086 TRACE("GLuint program = %d, const char* name = 0x%0.8p", program, name);
2087
2088 try
2089 {
2090 gl::Context *context = gl::getContext();
2091
2092 if (strstr(name, "gl_") == name)
2093 {
2094 return -1;
2095 }
2096
2097 if (context)
2098 {
2099 gl::Program *programObject = context->getProgram(program);
2100
2101 if (!programObject)
2102 {
2103 return error(GL_INVALID_VALUE, -1);
2104 }
2105
2106 if (!programObject->isLinked())
2107 {
2108 return error(GL_INVALID_OPERATION, -1);
2109 }
2110
2111 return programObject->getUniformLocation(name);
2112 }
2113 }
2114 catch(std::bad_alloc&)
2115 {
2116 return error(GL_OUT_OF_MEMORY, -1);
2117 }
2118
2119 return -1;
2120}
2121
2122void __stdcall glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
2123{
2124 TRACE("GLuint index = %d, GLenum pname = 0x%X, GLfloat* params = 0x%0.8p", index, pname, params);
2125
2126 try
2127 {
2128 if (index >= gl::MAX_VERTEX_ATTRIBS)
2129 {
2130 return error(GL_INVALID_VALUE);
2131 }
2132
2133 UNIMPLEMENTED(); // FIXME
2134 }
2135 catch(std::bad_alloc&)
2136 {
2137 return error(GL_OUT_OF_MEMORY);
2138 }
2139}
2140
2141void __stdcall glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
2142{
2143 TRACE("GLuint index = %d, GLenum pname = 0x%X, GLint* params = 0x%0.8p", index, pname, params);
2144
2145 try
2146 {
2147 if (index >= gl::MAX_VERTEX_ATTRIBS)
2148 {
2149 return error(GL_INVALID_VALUE);
2150 }
2151
2152 UNIMPLEMENTED(); // FIXME
2153 }
2154 catch(std::bad_alloc&)
2155 {
2156 return error(GL_OUT_OF_MEMORY);
2157 }
2158}
2159
2160void __stdcall glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
2161{
2162 TRACE("GLuint index = %d, GLenum pname = 0x%X, void** pointer = 0x%0.8p", index, pname, pointer);
2163
2164 try
2165 {
2166 if (index >= gl::MAX_VERTEX_ATTRIBS)
2167 {
2168 return error(GL_INVALID_VALUE);
2169 }
2170
2171 UNIMPLEMENTED(); // FIXME
2172 }
2173 catch(std::bad_alloc&)
2174 {
2175 return error(GL_OUT_OF_MEMORY);
2176 }
2177}
2178
2179void __stdcall glHint(GLenum target, GLenum mode)
2180{
2181 TRACE("GLenum target = 0x%X, GLenum mode = 0x%X", target, mode);
2182
2183 try
2184 {
2185 UNIMPLEMENTED(); // FIXME
2186 }
2187 catch(std::bad_alloc&)
2188 {
2189 return error(GL_OUT_OF_MEMORY);
2190 }
2191}
2192
2193GLboolean __stdcall glIsBuffer(GLuint buffer)
2194{
2195 TRACE("GLuint buffer = %d", buffer);
2196
2197 try
2198 {
2199 gl::Context *context = gl::getContext();
2200
2201 if (context && buffer)
2202 {
2203 gl::Buffer *bufferObject = context->getBuffer(buffer);
2204
2205 if (bufferObject)
2206 {
2207 return GL_TRUE;
2208 }
2209 }
2210 }
2211 catch(std::bad_alloc&)
2212 {
2213 return error(GL_OUT_OF_MEMORY, GL_FALSE);
2214 }
2215
2216 return GL_FALSE;
2217}
2218
2219GLboolean __stdcall glIsEnabled(GLenum cap)
2220{
2221 TRACE("GLenum cap = 0x%X", cap);
2222
2223 try
2224 {
2225 gl::Context *context = gl::getContext();
2226
2227 if (context)
2228 {
2229 switch (cap)
2230 {
2231 case GL_CULL_FACE: return context->cullFace;
2232 case GL_POLYGON_OFFSET_FILL: return context->polygonOffsetFill;
2233 case GL_SAMPLE_ALPHA_TO_COVERAGE: return context->sampleAlphaToCoverage;
2234 case GL_SAMPLE_COVERAGE: return context->sampleCoverage;
2235 case GL_SCISSOR_TEST: return context->scissorTest;
2236 case GL_STENCIL_TEST: return context->stencilTest;
2237 case GL_DEPTH_TEST: return context->depthTest;
2238 case GL_BLEND: return context->blend;
2239 case GL_DITHER: return context->dither;
2240 default:
2241 return error(GL_INVALID_ENUM, false);
2242 }
2243 }
2244 }
2245 catch(std::bad_alloc&)
2246 {
2247 return error(GL_OUT_OF_MEMORY, false);
2248 }
2249
2250 return false;
2251}
2252
2253GLboolean __stdcall glIsFramebuffer(GLuint framebuffer)
2254{
2255 TRACE("GLuint framebuffer = %d", framebuffer);
2256
2257 try
2258 {
2259 gl::Context *context = gl::getContext();
2260
2261 if (context && framebuffer)
2262 {
2263 gl::Framebuffer *framebufferObject = context->getFramebuffer(framebuffer);
2264
2265 if (framebufferObject)
2266 {
2267 return GL_TRUE;
2268 }
2269 }
2270 }
2271 catch(std::bad_alloc&)
2272 {
2273 return error(GL_OUT_OF_MEMORY, GL_FALSE);
2274 }
2275
2276 return GL_FALSE;
2277}
2278
2279GLboolean __stdcall glIsProgram(GLuint program)
2280{
2281 TRACE("GLuint program = %d", program);
2282
2283 try
2284 {
2285 gl::Context *context = gl::getContext();
2286
2287 if (context && program)
2288 {
2289 gl::Program *programObject = context->getProgram(program);
2290
2291 if (programObject)
2292 {
2293 return GL_TRUE;
2294 }
2295 }
2296 }
2297 catch(std::bad_alloc&)
2298 {
2299 return error(GL_OUT_OF_MEMORY, GL_FALSE);
2300 }
2301
2302 return GL_FALSE;
2303}
2304
2305GLboolean __stdcall glIsRenderbuffer(GLuint renderbuffer)
2306{
2307 TRACE("GLuint renderbuffer = %d", renderbuffer);
2308
2309 try
2310 {
2311 gl::Context *context = gl::getContext();
2312
2313 if (context && renderbuffer)
2314 {
2315 gl::Renderbuffer *renderbufferObject = context->getRenderbuffer(renderbuffer);
2316
2317 if (renderbufferObject)
2318 {
2319 return GL_TRUE;
2320 }
2321 }
2322 }
2323 catch(std::bad_alloc&)
2324 {
2325 return error(GL_OUT_OF_MEMORY, GL_FALSE);
2326 }
2327
2328 return GL_FALSE;
2329}
2330
2331GLboolean __stdcall glIsShader(GLuint shader)
2332{
2333 TRACE("GLuint shader = %d", shader);
2334
2335 try
2336 {
2337 gl::Context *context = gl::getContext();
2338
2339 if (context && shader)
2340 {
2341 gl::Shader *shaderObject = context->getShader(shader);
2342
2343 if (shaderObject)
2344 {
2345 return GL_TRUE;
2346 }
2347 }
2348 }
2349 catch(std::bad_alloc&)
2350 {
2351 return error(GL_OUT_OF_MEMORY, GL_FALSE);
2352 }
2353
2354 return GL_FALSE;
2355}
2356
2357GLboolean __stdcall glIsTexture(GLuint texture)
2358{
2359 TRACE("GLuint texture = %d", texture);
2360
2361 try
2362 {
2363 gl::Context *context = gl::getContext();
2364
2365 if (context && texture)
2366 {
2367 gl::Texture *textureObject = context->getTexture(texture);
2368
2369 if (textureObject)
2370 {
2371 return GL_TRUE;
2372 }
2373 }
2374 }
2375 catch(std::bad_alloc&)
2376 {
2377 return error(GL_OUT_OF_MEMORY, GL_FALSE);
2378 }
2379
2380 return GL_FALSE;
2381}
2382
2383void __stdcall glLineWidth(GLfloat width)
2384{
2385 TRACE("GLfloat width = %f", width);
2386
2387 try
2388 {
2389 if (width <= 0.0f)
2390 {
2391 return error(GL_INVALID_VALUE);
2392 }
2393
2394 if (width != 1.0f)
2395 {
2396 UNIMPLEMENTED(); // FIXME
2397 }
2398 }
2399 catch(std::bad_alloc&)
2400 {
2401 return error(GL_OUT_OF_MEMORY);
2402 }
2403}
2404
2405void __stdcall glLinkProgram(GLuint program)
2406{
2407 TRACE("GLuint program = %d", program);
2408
2409 try
2410 {
2411 gl::Context *context = gl::getContext();
2412
2413 if (context)
2414 {
2415 gl::Program *programObject = context->getProgram(program);
2416
2417 if (!programObject)
2418 {
2419 return error(GL_INVALID_VALUE);
2420 }
2421
2422 programObject->link();
2423 }
2424 }
2425 catch(std::bad_alloc&)
2426 {
2427 return error(GL_OUT_OF_MEMORY);
2428 }
2429}
2430
2431void __stdcall glPixelStorei(GLenum pname, GLint param)
2432{
2433 TRACE("GLenum pname = 0x%X, GLint param = %d", pname, param);
2434
2435 try
2436 {
2437 switch (pname)
2438 {
2439 case GL_UNPACK_ALIGNMENT:
2440 // UNIMPLEMENTED(); // FIXME
2441 break;
2442 case GL_PACK_ALIGNMENT:
2443 // UNIMPLEMENTED(); // FIXME
2444 break;
2445 default:
2446 return error(GL_INVALID_ENUM);
2447 }
2448 }
2449 catch(std::bad_alloc&)
2450 {
2451 return error(GL_OUT_OF_MEMORY);
2452 }
2453}
2454
2455void __stdcall glPolygonOffset(GLfloat factor, GLfloat units)
2456{
2457 TRACE("GLfloat factor = %f, GLfloat units = %f", factor, units);
2458
2459 try
2460 {
2461 if (factor != 0.0f || units != 0.0f)
2462 {
2463 UNIMPLEMENTED(); // FIXME
2464 }
2465 }
2466 catch(std::bad_alloc&)
2467 {
2468 return error(GL_OUT_OF_MEMORY);
2469 }
2470}
2471
2472void __stdcall glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
2473{
2474 TRACE("GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLenum format = 0x%X, GLenum type = 0x%X, void* pixels = 0x%0.8p", x, y, width, height, format, type, pixels);
2475
2476 try
2477 {
2478 if (width < 0 || height < 0)
2479 {
2480 return error(GL_INVALID_VALUE);
2481 }
2482
2483 switch (format)
2484 {
2485 case GL_RGBA:
2486 switch (type)
2487 {
2488 case GL_UNSIGNED_BYTE:
2489 break;
2490 default:
2491 return error(GL_INVALID_OPERATION);
2492 }
2493 break;
2494 case gl::IMPLEMENTATION_COLOR_READ_FORMAT:
2495 switch (type)
2496 {
2497 case gl::IMPLEMENTATION_COLOR_READ_TYPE:
2498 break;
2499 default:
2500 return error(GL_INVALID_OPERATION);
2501 }
2502 break;
2503 default:
2504 return error(GL_INVALID_OPERATION);
2505 }
2506
2507 gl::Context *context = gl::getContext();
2508
2509 if (context)
2510 {
2511 context->readPixels(x, y, width, height, format, type, pixels);
2512 }
2513 }
2514 catch(std::bad_alloc&)
2515 {
2516 return error(GL_OUT_OF_MEMORY);
2517 }
2518}
2519
2520void __stdcall glReleaseShaderCompiler(void)
2521{
2522 TRACE("");
2523
2524 try
2525 {
2526 gl::Shader::releaseCompiler();
2527 }
2528 catch(std::bad_alloc&)
2529 {
2530 return error(GL_OUT_OF_MEMORY);
2531 }
2532}
2533
2534void __stdcall glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
2535{
2536 TRACE("GLenum target = 0x%X, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = %d", target, internalformat, width, height);
2537
2538 try
2539 {
2540 switch (target)
2541 {
2542 case GL_RENDERBUFFER:
2543 break;
2544 default:
2545 return error(GL_INVALID_ENUM);
2546 }
2547
2548 switch (internalformat)
2549 {
2550 case GL_DEPTH_COMPONENT16:
2551 case GL_RGBA4:
2552 case GL_RGB5_A1:
2553 case GL_RGB565:
2554 case GL_STENCIL_INDEX8:
2555 break;
2556 default:
2557 return error(GL_INVALID_ENUM);
2558 }
2559
2560 if (width < 0 || height < 0 || width > gl::MAX_RENDERBUFFER_SIZE || height > gl::MAX_RENDERBUFFER_SIZE)
2561 {
2562 return error(GL_INVALID_VALUE);
2563 }
2564
2565 gl::Context *context = gl::getContext();
2566
2567 if (context)
2568 {
2569 if (context->framebuffer == 0 || context->renderbuffer == 0)
2570 {
2571 return error(GL_INVALID_OPERATION);
2572 }
2573
2574 switch (internalformat)
2575 {
2576 case GL_DEPTH_COMPONENT16:
2577 context->setRenderbuffer(new gl::Depthbuffer(width, height));
2578 break;
2579 case GL_RGBA4:
2580 case GL_RGB5_A1:
2581 case GL_RGB565:
2582 UNIMPLEMENTED(); // FIXME
daniel@transgaming.com4a9d65c2010-03-08 21:30:56 +0000[diff] [blame]2583 // context->setRenderbuffer(new Colorbuffer(renderTarget));
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2584 break;
2585 case GL_STENCIL_INDEX8:
daniel@transgaming.com4a9d65c2010-03-08 21:30:56 +0000[diff] [blame]2586 context->setRenderbuffer(new gl::Stencilbuffer(width, height));
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2587 break;
2588 default:
2589 return error(GL_INVALID_ENUM);
2590 }
2591 }
2592 }
2593 catch(std::bad_alloc&)
2594 {
2595 return error(GL_OUT_OF_MEMORY);
2596 }
2597}
2598
2599void __stdcall glSampleCoverage(GLclampf value, GLboolean invert)
2600{
2601 TRACE("GLclampf value = %f, GLboolean invert = %d", value, invert);
2602
2603 try
2604 {
2605 gl::Context* context = gl::getContext();
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]2606
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2607 if (context)
2608 {
2609 context->sampleCoverageValue = gl::clamp01(value);
2610 context->sampleCoverageInvert = invert;
2611 }
2612 }
2613 catch(std::bad_alloc&)
2614 {
2615 return error(GL_OUT_OF_MEMORY);
2616 }
2617}
2618
2619void __stdcall glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
2620{
2621 TRACE("GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d", x, y, width, height);
2622
2623 try
2624 {
2625 if (width < 0 || height < 0)
2626 {
2627 return error(GL_INVALID_VALUE);
2628 }
2629
2630 gl::Context* context = gl::getContext();
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]2631
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2632 if (context)
2633 {
2634 context->scissorX = x;
2635 context->scissorY = y;
2636 context->scissorWidth = width;
2637 context->scissorHeight = height;
2638 }
2639 }
2640 catch(std::bad_alloc&)
2641 {
2642 return error(GL_OUT_OF_MEMORY);
2643 }
2644}
2645
2646void __stdcall glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length)
2647{
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]2648 TRACE("GLsizei n = %d, const GLuint* shaders = 0x%0.8p, GLenum binaryformat = 0x%X, const void* binary = 0x%0.8p, GLsizei length = %d",
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2649 n, shaders, binaryformat, binary, length);
2650
2651 try
2652 {
2653 if (n < 0 || length < 0)
2654 {
2655 return error(GL_INVALID_VALUE);
2656 }
2657
2658 UNIMPLEMENTED(); // FIXME
2659 }
2660 catch(std::bad_alloc&)
2661 {
2662 return error(GL_OUT_OF_MEMORY);
2663 }
2664}
2665
2666void __stdcall glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
2667{
2668 TRACE("GLuint shader = %d, GLsizei count = %d, const char** string = 0x%0.8p, const GLint* length = 0x%0.8p", shader, count, string, length);
2669
2670 try
2671 {
2672 if (count < 0)
2673 {
2674 return error(GL_INVALID_VALUE);
2675 }
2676
2677 gl::Context *context = gl::getContext();
2678
2679 if (context)
2680 {
2681 gl::Shader *shaderObject = context->getShader(shader);
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]2682
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2683 if (!shaderObject)
2684 {
2685 return error(GL_INVALID_VALUE);
2686 }
2687
2688 shaderObject->setSource(count, string, length);
2689 }
2690 }
2691 catch(std::bad_alloc&)
2692 {
2693 return error(GL_OUT_OF_MEMORY);
2694 }
2695}
2696
2697void __stdcall glStencilFunc(GLenum func, GLint ref, GLuint mask)
2698{
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]2699 glStencilFuncSeparate(GL_FRONT_AND_BACK, func, ref, mask);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2700}
2701
2702void __stdcall glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
2703{
2704 TRACE("GLenum face = 0x%X, GLenum func = 0x%X, GLint ref = %d, GLuint mask = %d", face, func, ref, mask);
2705
2706 try
2707 {
2708 switch (face)
2709 {
2710 case GL_FRONT:
2711 case GL_BACK:
2712 case GL_FRONT_AND_BACK:
2713 break;
2714 default:
2715 return error(GL_INVALID_ENUM);
2716 }
2717
2718 switch (func)
2719 {
2720 case GL_NEVER:
2721 case GL_ALWAYS:
2722 case GL_LESS:
2723 case GL_LEQUAL:
2724 case GL_EQUAL:
2725 case GL_GEQUAL:
2726 case GL_GREATER:
2727 case GL_NOTEQUAL:
2728 break;
2729 default:
2730 return error(GL_INVALID_ENUM);
2731 }
2732
2733 gl::Context *context = gl::getContext();
2734
2735 if (context)
2736 {
2737 if (face == GL_FRONT || face == GL_FRONT_AND_BACK)
2738 {
2739 context->stencilFunc = func;
2740 context->stencilRef = ref;
2741 context->stencilMask = mask;
2742 }
2743
2744 if (face == GL_BACK || face == GL_FRONT_AND_BACK)
2745 {
2746 context->stencilBackFunc = func;
2747 context->stencilBackRef = ref;
2748 context->stencilBackMask = mask;
2749 }
2750 }
2751 }
2752 catch(std::bad_alloc&)
2753 {
2754 return error(GL_OUT_OF_MEMORY);
2755 }
2756}
2757
2758void __stdcall glStencilMask(GLuint mask)
2759{
2760 glStencilMaskSeparate(GL_FRONT_AND_BACK, mask);
2761}
2762
2763void __stdcall glStencilMaskSeparate(GLenum face, GLuint mask)
2764{
2765 TRACE("GLenum face = 0x%X, GLuint mask = %d", face, mask);
2766
2767 try
2768 {
2769 switch (face)
2770 {
2771 case GL_FRONT:
2772 case GL_BACK:
2773 case GL_FRONT_AND_BACK:
2774 break;
2775 default:
2776 return error(GL_INVALID_ENUM);
2777 }
2778
2779 gl::Context *context = gl::getContext();
2780
2781 if (context)
2782 {
2783 if (face == GL_FRONT || face == GL_FRONT_AND_BACK)
2784 {
2785 context->stencilWritemask = mask;
2786 }
2787
2788 if (face == GL_BACK || face == GL_FRONT_AND_BACK)
2789 {
2790 context->stencilBackWritemask = mask;
2791 }
2792 }
2793 }
2794 catch(std::bad_alloc&)
2795 {
2796 return error(GL_OUT_OF_MEMORY);
2797 }
2798}
2799
2800void __stdcall glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
2801{
2802 glStencilOpSeparate(GL_FRONT_AND_BACK, fail, zfail, zpass);
2803}
2804
2805void __stdcall glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
2806{
2807 TRACE("GLenum face = 0x%X, GLenum fail = 0x%X, GLenum zfail = 0x%X, GLenum zpas = 0x%Xs", face, fail, zfail, zpass);
2808
2809 try
2810 {
2811 switch (face)
2812 {
2813 case GL_FRONT:
2814 case GL_BACK:
2815 case GL_FRONT_AND_BACK:
2816 break;
2817 default:
2818 return error(GL_INVALID_ENUM);
2819 }
2820
2821 switch (fail)
2822 {
2823 case GL_ZERO:
2824 case GL_KEEP:
2825 case GL_REPLACE:
2826 case GL_INCR:
2827 case GL_DECR:
2828 case GL_INVERT:
2829 case GL_INCR_WRAP:
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]2830 case GL_DECR_WRAP:
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2831 break;
2832 default:
2833 return error(GL_INVALID_ENUM);
2834 }
2835
2836 switch (zfail)
2837 {
2838 case GL_ZERO:
2839 case GL_KEEP:
2840 case GL_REPLACE:
2841 case GL_INCR:
2842 case GL_DECR:
2843 case GL_INVERT:
2844 case GL_INCR_WRAP:
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]2845 case GL_DECR_WRAP:
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2846 break;
2847 default:
2848 return error(GL_INVALID_ENUM);
2849 }
2850
2851 switch (zpass)
2852 {
2853 case GL_ZERO:
2854 case GL_KEEP:
2855 case GL_REPLACE:
2856 case GL_INCR:
2857 case GL_DECR:
2858 case GL_INVERT:
2859 case GL_INCR_WRAP:
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]2860 case GL_DECR_WRAP:
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2861 break;
2862 default:
2863 return error(GL_INVALID_ENUM);
2864 }
2865
2866 gl::Context *context = gl::getContext();
2867
2868 if (context)
2869 {
2870 if (face == GL_FRONT || face == GL_FRONT_AND_BACK)
2871 {
2872 context->stencilFail = fail;
2873 context->stencilPassDepthFail = zfail;
2874 context->stencilPassDepthPass = zpass;
2875 }
2876
2877 if (face == GL_BACK || face == GL_FRONT_AND_BACK)
2878 {
2879 context->stencilBackFail = fail;
2880 context->stencilBackPassDepthFail = zfail;
2881 context->stencilBackPassDepthPass = zpass;
2882 }
2883 }
2884 }
2885 catch(std::bad_alloc&)
2886 {
2887 return error(GL_OUT_OF_MEMORY);
2888 }
2889}
2890
2891void __stdcall glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
2892{
2893 TRACE("GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, GLsizei height = %d, GLint border = %d, GLenum format = 0x%X, GLenum type = 0x%X, const void* pixels = 0x%0.8p", target, level, internalformat, width, height, border, format, type, pixels);
2894
2895 try
2896 {
2897 if (level < 0 || width < 0 || height < 0)
2898 {
2899 return error(GL_INVALID_VALUE);
2900 }
2901
2902 if (level > 0 && (!gl::isPow2(width) || !gl::isPow2(height)))
2903 {
2904 return error(GL_INVALID_VALUE);
2905 }
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]2906
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2907 switch (target)
2908 {
2909 case GL_TEXTURE_2D:
2910 if (width > (gl::MAX_TEXTURE_SIZE >> level) || height > (gl::MAX_TEXTURE_SIZE >> level))
2911 {
2912 return error(GL_INVALID_VALUE);
2913 }
2914 break;
2915 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
2916 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
2917 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
2918 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
2919 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
2920 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
2921 if (!gl::isPow2(width) || !gl::isPow2(height))
2922 {
2923 return error(GL_INVALID_VALUE);
2924 }
2925
2926 if (width > (gl::MAX_CUBE_MAP_TEXTURE_SIZE >> level) || height > (gl::MAX_CUBE_MAP_TEXTURE_SIZE >> level))
2927 {
2928 return error(GL_INVALID_VALUE);
2929 }
2930 break;
2931 default:
2932 return error(GL_INVALID_ENUM);
2933 }
2934
2935 if (internalformat != format)
2936 {
2937 return error(GL_INVALID_OPERATION);
2938 }
2939
2940 switch (internalformat)
2941 {
2942 case GL_ALPHA:
2943 case GL_LUMINANCE:
2944 case GL_LUMINANCE_ALPHA:
2945 switch (type)
2946 {
2947 case GL_UNSIGNED_BYTE:
2948 break;
2949 default:
2950 return error(GL_INVALID_ENUM);
2951 }
2952 break;
2953 case GL_RGB:
2954 switch (type)
2955 {
2956 case GL_UNSIGNED_BYTE:
2957 case GL_UNSIGNED_SHORT_5_6_5:
2958 break;
2959 default:
2960 return error(GL_INVALID_ENUM);
2961 }
2962 break;
2963 case GL_RGBA:
2964 switch (type)
2965 {
2966 case GL_UNSIGNED_BYTE:
2967 case GL_UNSIGNED_SHORT_4_4_4_4:
2968 case GL_UNSIGNED_SHORT_5_5_5_1:
2969 break;
2970 default:
2971 return error(GL_INVALID_ENUM);
2972 }
2973 break;
2974 default:
2975 return error(GL_INVALID_VALUE);
2976 }
2977
2978 if (border != 0)
2979 {
2980 return error(GL_INVALID_VALUE);
2981 }
2982
2983 gl::Context *context = gl::getContext();
2984
2985 if (context)
2986 {
2987 if (target == GL_TEXTURE_2D)
2988 {
2989 gl::Texture2D *texture = context->getTexture2D();
2990
2991 if (!texture)
2992 {
2993 return error(GL_INVALID_OPERATION);
2994 }
2995
2996 texture->setImage(level, internalformat, width, height, format, type, pixels);
2997 }
2998 else
2999 {
3000 gl::TextureCubeMap *texture = context->getTextureCubeMap();
3001
3002 if (!texture)
3003 {
3004 return error(GL_INVALID_OPERATION);
3005 }
3006
3007 switch (target)
3008 {
3009 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
3010 texture->setImagePosX(level, internalformat, width, height, format, type, pixels);
3011 break;
3012 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
3013 texture->setImageNegX(level, internalformat, width, height, format, type, pixels);
3014 break;
3015 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
3016 texture->setImagePosY(level, internalformat, width, height, format, type, pixels);
3017 break;
3018 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
3019 texture->setImageNegY(level, internalformat, width, height, format, type, pixels);
3020 break;
3021 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
3022 texture->setImagePosZ(level, internalformat, width, height, format, type, pixels);
3023 break;
3024 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
3025 texture->setImageNegZ(level, internalformat, width, height, format, type, pixels);
3026 break;
3027 default: UNREACHABLE();
3028 }
3029 }
3030 }
3031 }
3032 catch(std::bad_alloc&)
3033 {
3034 return error(GL_OUT_OF_MEMORY);
3035 }
3036}
3037
3038void __stdcall glTexParameterf(GLenum target, GLenum pname, GLfloat param)
3039{
3040 glTexParameteri(target, pname, (GLint)param);
3041}
3042
3043void __stdcall glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
3044{
3045 glTexParameteri(target, pname, (GLint)*params);
3046}
3047
3048void __stdcall glTexParameteri(GLenum target, GLenum pname, GLint param)
3049{
3050 TRACE("GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat param = %f", target, pname, param);
3051
3052 try
3053 {
3054 gl::Context *context = gl::getContext();
3055
3056 if (context)
3057 {
3058 gl::Texture *texture;
3059
3060 switch (target)
3061 {
3062 case GL_TEXTURE_2D:
3063 texture = context->getTexture2D();
3064 break;
3065 case GL_TEXTURE_CUBE_MAP:
3066 texture = context->getTextureCubeMap();
3067 break;
3068 default:
3069 return error(GL_INVALID_ENUM);
3070 }
3071
3072 switch (pname)
3073 {
3074 case GL_TEXTURE_WRAP_S:
3075 if (!texture->setWrapS((GLenum)param))
3076 {
3077 return error(GL_INVALID_ENUM);
3078 }
3079 break;
3080 case GL_TEXTURE_WRAP_T:
3081 if (!texture->setWrapT((GLenum)param))
3082 {
3083 return error(GL_INVALID_ENUM);
3084 }
3085 break;
3086 case GL_TEXTURE_MIN_FILTER:
3087 if (!texture->setMinFilter((GLenum)param))
3088 {
3089 return error(GL_INVALID_ENUM);
3090 }
3091 break;
3092 case GL_TEXTURE_MAG_FILTER:
3093 if (!texture->setMagFilter((GLenum)param))
3094 {
3095 return error(GL_INVALID_ENUM);
3096 }
3097 break;
3098 default:
3099 return error(GL_INVALID_ENUM);
3100 }
3101 }
3102 }
3103 catch(std::bad_alloc&)
3104 {
3105 return error(GL_OUT_OF_MEMORY);
3106 }
3107}
3108
3109void __stdcall glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
3110{
3111 glTexParameteri(target, pname, *params);
3112}
3113
3114void __stdcall glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
3115{
3116 TRACE("GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLsizei width = %d, GLsizei height = %d, GLenum format = 0x%X, GLenum type = 0x%X, const void* pixels = 0x%0.8p",
3117 target, level, xoffset, yoffset, width, height, format, type, pixels);
3118
3119 try
3120 {
3121 if (width < 0 || height < 0)
3122 {
3123 return error(GL_INVALID_VALUE);
3124 }
3125
3126 UNIMPLEMENTED(); // FIXME
3127 }
3128 catch(std::bad_alloc&)
3129 {
3130 return error(GL_OUT_OF_MEMORY);
3131 }
3132}
3133
3134void __stdcall glUniform1f(GLint location, GLfloat x)
3135{
3136 glUniform1fv(location, 1, &x);
3137}
3138
3139void __stdcall glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
3140{
3141 TRACE("GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p", location, count, v);
3142
3143 try
3144 {
3145 if (location == -1)
3146 {
3147 return;
3148 }
3149
3150 if (count < 0)
3151 {
3152 return error(GL_INVALID_VALUE);
3153 }
3154
3155 gl::Context *context = gl::getContext();
3156
3157 if (context)
3158 {
3159 gl::Program *program = context->getCurrentProgram();
3160
3161 if (!program)
3162 {
3163 return error(GL_INVALID_OPERATION);
3164 }
3165
3166 if (!program->setUniform1fv(location, count, v))
3167 {
3168 return error(GL_INVALID_OPERATION);
3169 }
3170 }
3171 }
3172 catch(std::bad_alloc&)
3173 {
3174 return error(GL_OUT_OF_MEMORY);
3175 }
3176}
3177
3178void __stdcall glUniform1i(GLint location, GLint x)
3179{
3180 glUniform1iv(location, 1, &x);
3181}
3182
3183void __stdcall glUniform1iv(GLint location, GLsizei count, const GLint* v)
3184{
3185 TRACE("GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p", location, count, v);
3186
3187 try
3188 {
3189 if (count < 0)
3190 {
3191 return error(GL_INVALID_VALUE);
3192 }
3193
3194 gl::Context *context = gl::getContext();
3195
3196 if (context)
3197 {
3198 gl::Program *program = context->getCurrentProgram();
3199
3200 if (!program)
3201 {
3202 return error(GL_INVALID_OPERATION);
3203 }
3204
3205 if (!program->setUniform1iv(location, count, v))
3206 {
3207 return error(GL_INVALID_OPERATION);
3208 }
3209 }
3210 }
3211 catch(std::bad_alloc&)
3212 {
3213 return error(GL_OUT_OF_MEMORY);
3214 }
3215}
3216
3217void __stdcall glUniform2f(GLint location, GLfloat x, GLfloat y)
3218{
3219 GLfloat xy[2] = {x, y};
3220
3221 glUniform2fv(location, 1, (GLfloat*)&xy);
3222}
3223
3224void __stdcall glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
3225{
3226 TRACE("GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p", location, count, v);
3227
3228 try
3229 {
3230 if (location == -1)
3231 {
3232 return;
3233 }
3234
3235 if (count < 0)
3236 {
3237 return error(GL_INVALID_VALUE);
3238 }
3239
3240 gl::Context *context = gl::getContext();
3241
3242 if (context)
3243 {
3244 gl::Program *program = context->getCurrentProgram();
3245
3246 if (!program)
3247 {
3248 return error(GL_INVALID_OPERATION);
3249 }
3250
3251 if (!program->setUniform2fv(location, count, v))
3252 {
3253 return error(GL_INVALID_OPERATION);
3254 }
3255 }
3256 }
3257 catch(std::bad_alloc&)
3258 {
3259 return error(GL_OUT_OF_MEMORY);
3260 }
3261}
3262
3263void __stdcall glUniform2i(GLint location, GLint x, GLint y)
3264{
3265 GLint xy[4] = {x, y};
3266
3267 glUniform2iv(location, 1, (GLint*)&xy);
3268}
3269
3270void __stdcall glUniform2iv(GLint location, GLsizei count, const GLint* v)
3271{
3272 TRACE("GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p", location, count, v);
3273
3274 try
3275 {
3276 if (count < 0)
3277 {
3278 return error(GL_INVALID_VALUE);
3279 }
3280
3281 UNIMPLEMENTED(); // FIXME
3282 }
3283 catch(std::bad_alloc&)
3284 {
3285 return error(GL_OUT_OF_MEMORY);
3286 }
3287}
3288
3289void __stdcall glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
3290{
3291 GLfloat xyz[3] = {x, y, z};
3292
3293 glUniform3fv(location, 1, (GLfloat*)&xyz);
3294}
3295
3296void __stdcall glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
3297{
3298 TRACE("GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p", location, count, v);
3299
3300 try
3301 {
3302 if (count < 0)
3303 {
3304 return error(GL_INVALID_VALUE);
3305 }
3306
3307 if (location == -1)
3308 {
3309 return;
3310 }
3311
3312 gl::Context *context = gl::getContext();
3313
3314 if (context)
3315 {
3316 gl::Program *program = context->getCurrentProgram();
3317
3318 if (!program)
3319 {
3320 return error(GL_INVALID_OPERATION);
3321 }
3322
3323 if (!program->setUniform3fv(location, count, v))
3324 {
3325 return error(GL_INVALID_OPERATION);
3326 }
3327 }
3328 }
3329 catch(std::bad_alloc&)
3330 {
3331 return error(GL_OUT_OF_MEMORY);
3332 }
3333}
3334
3335void __stdcall glUniform3i(GLint location, GLint x, GLint y, GLint z)
3336{
3337 GLint xyz[3] = {x, y, z};
3338
3339 glUniform3iv(location, 1, (GLint*)&xyz);
3340}
3341
3342void __stdcall glUniform3iv(GLint location, GLsizei count, const GLint* v)
3343{
3344 TRACE("GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p", location, count, v);
3345
3346 try
3347 {
3348 if (count < 0)
3349 {
3350 return error(GL_INVALID_VALUE);
3351 }
3352
3353 UNIMPLEMENTED(); // FIXME
3354 }
3355 catch(std::bad_alloc&)
3356 {
3357 return error(GL_OUT_OF_MEMORY);
3358 }
3359}
3360
3361void __stdcall glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
3362{
3363 GLfloat xyzw[4] = {x, y, z, w};
3364
3365 glUniform4fv(location, 1, (GLfloat*)&xyzw);
3366}
3367
3368void __stdcall glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
3369{
3370 TRACE("GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p", location, count, v);
3371
3372 try
3373 {
3374 if (count < 0)
3375 {
3376 return error(GL_INVALID_VALUE);
3377 }
3378
3379 if (location == -1)
3380 {
3381 return;
3382 }
3383
3384 gl::Context *context = gl::getContext();
3385
3386 if (context)
3387 {
3388 gl::Program *program = context->getCurrentProgram();
3389
3390 if (!program)
3391 {
3392 return error(GL_INVALID_OPERATION);
3393 }
3394
3395 if (!program->setUniform4fv(location, count, v))
3396 {
3397 return error(GL_INVALID_OPERATION);
3398 }
3399 }
3400 }
3401 catch(std::bad_alloc&)
3402 {
3403 return error(GL_OUT_OF_MEMORY);
3404 }
3405}
3406
3407void __stdcall glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
3408{
3409 GLint xyzw[4] = {x, y, z, w};
3410
3411 glUniform4iv(location, 1, (GLint*)&xyzw);
3412}
3413
3414void __stdcall glUniform4iv(GLint location, GLsizei count, const GLint* v)
3415{
3416 TRACE("GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p", location, count, v);
3417
3418 try
3419 {
3420 if (count < 0)
3421 {
3422 return error(GL_INVALID_VALUE);
3423 }
3424
3425 UNIMPLEMENTED(); // FIXME
3426 }
3427 catch(std::bad_alloc&)
3428 {
3429 return error(GL_OUT_OF_MEMORY);
3430 }
3431}
3432
3433void __stdcall glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
3434{
3435 TRACE("GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = 0x%0.8p", location, count, transpose, value);
3436
3437 try
3438 {
3439 if (count < 0 || transpose != GL_FALSE)
3440 {
3441 return error(GL_INVALID_VALUE);
3442 }
3443
3444 if (location == -1)
3445 {
3446 return;
3447 }
3448
3449 gl::Context *context = gl::getContext();
3450
3451 if (context)
3452 {
3453 gl::Program *program = context->getCurrentProgram();
3454
3455 if (!program)
3456 {
3457 return error(GL_INVALID_OPERATION);
3458 }
3459
3460 if (!program->setUniformMatrix2fv(location, count, value))
3461 {
3462 return error(GL_INVALID_OPERATION);
3463 }
3464 }
3465 }
3466 catch(std::bad_alloc&)
3467 {
3468 return error(GL_OUT_OF_MEMORY);
3469 }
3470}
3471
3472void __stdcall glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
3473{
3474 TRACE("GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = 0x%0.8p", location, count, transpose, value);
3475
3476 try
3477 {
3478 if (count < 0 || transpose != GL_FALSE)
3479 {
3480 return error(GL_INVALID_VALUE);
3481 }
3482
3483 if (location == -1)
3484 {
3485 return;
3486 }
3487
3488 gl::Context *context = gl::getContext();
3489
3490 if (context)
3491 {
3492 gl::Program *program = context->getCurrentProgram();
3493
3494 if (!program)
3495 {
3496 return error(GL_INVALID_OPERATION);
3497 }
3498
3499 if (!program->setUniformMatrix3fv(location, count, value))
3500 {
3501 return error(GL_INVALID_OPERATION);
3502 }
3503 }
3504 }
3505 catch(std::bad_alloc&)
3506 {
3507 return error(GL_OUT_OF_MEMORY);
3508 }
3509}
3510
3511void __stdcall glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
3512{
3513 TRACE("GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = 0x%0.8p", location, count, transpose, value);
3514
3515 try
3516 {
3517 if (count < 0 || transpose != GL_FALSE)
3518 {
3519 return error(GL_INVALID_VALUE);
3520 }
3521
3522 if (location == -1)
3523 {
3524 return;
3525 }
3526
3527 gl::Context *context = gl::getContext();
3528
3529 if (context)
3530 {
3531 gl::Program *program = context->getCurrentProgram();
3532
3533 if (!program)
3534 {
3535 return error(GL_INVALID_OPERATION);
3536 }
3537
3538 if (!program->setUniformMatrix4fv(location, count, value))
3539 {
3540 return error(GL_INVALID_OPERATION);
3541 }
3542 }
3543 }
3544 catch(std::bad_alloc&)
3545 {
3546 return error(GL_OUT_OF_MEMORY);
3547 }
3548}
3549
3550void __stdcall glUseProgram(GLuint program)
3551{
3552 TRACE("GLuint program = %d", program);
3553
3554 try
3555 {
3556 gl::Context *context = gl::getContext();
3557
3558 if (context)
3559 {
3560 gl::Program *programObject = context->getProgram(program);
3561
3562 if (programObject && !programObject->isLinked())
3563 {
3564 return error(GL_INVALID_OPERATION);
3565 }
3566
3567 context->useProgram(program);
3568 }
3569 }
3570 catch(std::bad_alloc&)
3571 {
3572 return error(GL_OUT_OF_MEMORY);
3573 }
3574}
3575
3576void __stdcall glValidateProgram(GLuint program)
3577{
3578 TRACE("GLuint program = %d", program);
3579
3580 try
3581 {
3582 UNIMPLEMENTED(); // FIXME
3583 }
3584 catch(std::bad_alloc&)
3585 {
3586 return error(GL_OUT_OF_MEMORY);
3587 }
3588}
3589
3590void __stdcall glVertexAttrib1f(GLuint index, GLfloat x)
3591{
3592 TRACE("GLuint index = %d, GLfloat x = %f", index, x);
3593
3594 try
3595 {
3596 if (index >= gl::MAX_VERTEX_ATTRIBS)
3597 {
3598 return error(GL_INVALID_VALUE);
3599 }
3600
3601 UNIMPLEMENTED(); // FIXME
3602 }
3603 catch(std::bad_alloc&)
3604 {
3605 return error(GL_OUT_OF_MEMORY);
3606 }
3607}
3608
3609void __stdcall glVertexAttrib1fv(GLuint index, const GLfloat* values)
3610{
3611 TRACE("GLuint index = %d, const GLfloat* values = 0x%0.8p", index, values);
3612
3613 try
3614 {
3615 if (index >= gl::MAX_VERTEX_ATTRIBS)
3616 {
3617 return error(GL_INVALID_VALUE);
3618 }
3619
3620 UNIMPLEMENTED(); // FIXME
3621 }
3622 catch(std::bad_alloc&)
3623 {
3624 return error(GL_OUT_OF_MEMORY);
3625 }
3626}
3627
3628void __stdcall glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
3629{
3630 TRACE("GLuint index = %d, GLfloat x = %f, GLfloat y = %f", index, x, y);
3631
3632 try
3633 {
3634 if (index >= gl::MAX_VERTEX_ATTRIBS)
3635 {
3636 return error(GL_INVALID_VALUE);
3637 }
3638
3639 UNIMPLEMENTED(); // FIXME
3640 }
3641 catch(std::bad_alloc&)
3642 {
3643 return error(GL_OUT_OF_MEMORY);
3644 }
3645}
3646
3647void __stdcall glVertexAttrib2fv(GLuint index, const GLfloat* values)
3648{
3649 TRACE("GLuint index = %d, const GLfloat* values = 0x%0.8p", index, values);
3650
3651 try
3652 {
3653 if (index >= gl::MAX_VERTEX_ATTRIBS)
3654 {
3655 return error(GL_INVALID_VALUE);
3656 }
3657
3658 UNIMPLEMENTED(); // FIXME
3659 }
3660 catch(std::bad_alloc&)
3661 {
3662 return error(GL_OUT_OF_MEMORY);
3663 }
3664}
3665
3666void __stdcall glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
3667{
3668 TRACE("GLuint index = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f", index, x, y, z);
3669
3670 try
3671 {
3672 if (index >= gl::MAX_VERTEX_ATTRIBS)
3673 {
3674 return error(GL_INVALID_VALUE);
3675 }
3676
3677 UNIMPLEMENTED(); // FIXME
3678 }
3679 catch(std::bad_alloc&)
3680 {
3681 return error(GL_OUT_OF_MEMORY);
3682 }
3683}
3684
3685void __stdcall glVertexAttrib3fv(GLuint index, const GLfloat* values)
3686{
3687 TRACE("GLuint index = %d, const GLfloat* values = 0x%0.8p", index, values);
3688
3689 try
3690 {
3691 if (index >= gl::MAX_VERTEX_ATTRIBS)
3692 {
3693 return error(GL_INVALID_VALUE);
3694 }
3695
3696 UNIMPLEMENTED(); // FIXME
3697 }
3698 catch(std::bad_alloc&)
3699 {
3700 return error(GL_OUT_OF_MEMORY);
3701 }
3702}
3703
3704void __stdcall glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
3705{
3706 TRACE("GLuint index = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f, GLfloat w = %f", index, x, y, z, w);
3707
3708 try
3709 {
3710 if (index >= gl::MAX_VERTEX_ATTRIBS)
3711 {
3712 return error(GL_INVALID_VALUE);
3713 }
3714
3715 UNIMPLEMENTED(); // FIXME
3716 }
3717 catch(std::bad_alloc&)
3718 {
3719 return error(GL_OUT_OF_MEMORY);
3720 }
3721}
3722
3723void __stdcall glVertexAttrib4fv(GLuint index, const GLfloat* values)
3724{
3725 TRACE("GLuint index = %d, const GLfloat* values = 0x%0.8p", index, values);
3726
3727 try
3728 {
3729 if (index >= gl::MAX_VERTEX_ATTRIBS)
3730 {
3731 return error(GL_INVALID_VALUE);
3732 }
3733
3734 UNIMPLEMENTED(); // FIXME
3735 }
3736 catch(std::bad_alloc&)
3737 {
3738 return error(GL_OUT_OF_MEMORY);
3739 }
3740}
3741
3742void __stdcall glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
3743{
3744 TRACE("GLuint index = %d, GLint size = %d, GLenum type = 0x%X, GLboolean normalized = %d, GLsizei stride = %d, const void* ptr = 0x%0.8p", index, size, type, normalized, stride, ptr);
3745
3746 try
3747 {
3748 if (index >= gl::MAX_VERTEX_ATTRIBS)
3749 {
3750 return error(GL_INVALID_VALUE);
3751 }
3752
3753 if (size < 1 || size > 4)
3754 {
3755 return error(GL_INVALID_VALUE);
3756 }
3757
3758 switch (type)
3759 {
3760 case GL_BYTE:
3761 case GL_UNSIGNED_BYTE:
3762 case GL_SHORT:
3763 case GL_UNSIGNED_SHORT:
3764 case GL_FIXED:
3765 case GL_FLOAT:
3766 break;
3767 default:
3768 return error(GL_INVALID_ENUM);
3769 }
3770
3771 if (stride < 0)
3772 {
3773 return error(GL_INVALID_VALUE);
3774 }
3775
3776 gl::Context *context = gl::getContext();
3777
3778 if (context)
3779 {
3780 context->vertexAttribute[index].boundBuffer = context->arrayBuffer;
3781 context->vertexAttribute[index].size = size;
3782 context->vertexAttribute[index].type = type;
3783 context->vertexAttribute[index].normalized = normalized;
3784 context->vertexAttribute[index].stride = stride;
3785 context->vertexAttribute[index].pointer = ptr;
3786 }
3787 }
3788 catch(std::bad_alloc&)
3789 {
3790 return error(GL_OUT_OF_MEMORY);
3791 }
3792}
3793
3794void __stdcall glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
3795{
3796 TRACE("GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d", x, y, width, height);
3797
3798 try
3799 {
3800 if (width < 0 || height < 0)
3801 {
3802 return error(GL_INVALID_VALUE);
3803 }
3804
3805 gl::Context *context = gl::getContext();
3806
3807 if (context)
3808 {
3809 context->viewportX = x;
3810 context->viewportY = y;
3811 context->viewportWidth = width;
3812 context->viewportHeight = height;
3813 }
3814 }
3815 catch(std::bad_alloc&)
3816 {
3817 return error(GL_OUT_OF_MEMORY);
3818 }
3819}
3820
3821void __stdcall glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels)
3822{
3823 TRACE("GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLenum format = 0x%X, GLenum type = 0x%x, const void* pixels = 0x%0.8p",
3824 target, level, internalformat, width, height, depth, border, format, type, pixels);
3825
3826 try
3827 {
3828 UNIMPLEMENTED(); // FIXME
3829 }
3830 catch(std::bad_alloc&)
3831 {
3832 return error(GL_OUT_OF_MEMORY);
3833 }
3834}
3835}