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