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