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