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