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