Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / angle / 159acdf5f6370e89f3deda77cd3752ad11d3f76c / . / src / libGLESv2 / libGLESv2.cpp
blob: fcb86334710fa7ea0f00cea67134eb0f9c156a38 [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.com5949aa12010-03-21 04:31:15 +0000[diff] [blame]1800 case GL_GENERATE_MIPMAP_HINT: *params = context->generateMipmapHint; break;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]1801 case GL_RED_BITS:
1802 case GL_GREEN_BITS:
1803 case GL_BLUE_BITS:
1804 case GL_ALPHA_BITS:
1805 {
1806 gl::Framebuffer *framebuffer = context->getFramebuffer();
1807 gl::Colorbuffer *colorbuffer = framebuffer->getColorbuffer();
1808
1809 if (colorbuffer)
1810 {
1811 switch (pname)
1812 {
1813 case GL_RED_BITS: *params = colorbuffer->getRedSize(); break;
1814 case GL_GREEN_BITS: *params = colorbuffer->getGreenSize(); break;
1815 case GL_BLUE_BITS: *params = colorbuffer->getBlueSize(); break;
1816 case GL_ALPHA_BITS: *params = colorbuffer->getAlphaSize(); break;
1817 }
1818 }
1819 else
1820 {
1821 *params = 0;
1822 }
1823 }
1824 break;
1825 case GL_DEPTH_BITS:
1826 {
1827 gl::Framebuffer *framebuffer = context->getFramebuffer();
1828 gl::Depthbuffer *depthbuffer = framebuffer->getDepthbuffer();
1829
1830 if (depthbuffer)
1831 {
1832 *params = depthbuffer->getDepthSize();
1833 }
1834 else
1835 {
1836 *params = 0;
1837 }
1838 }
1839 break;
1840 case GL_STENCIL_BITS:
1841 {
1842 gl::Framebuffer *framebuffer = context->getFramebuffer();
1843 gl::Stencilbuffer *stencilbuffer = framebuffer->getStencilbuffer();
1844
1845 if (stencilbuffer)
1846 {
1847 *params = stencilbuffer->getStencilSize();
1848 }
1849 else
1850 {
1851 *params = 0;
1852 }
1853 }
1854 break;
1855 default:
1856 UNIMPLEMENTED(); // FIXME
1857 return error(GL_INVALID_ENUM);
1858 }
1859 }
1860 }
1861 catch(std::bad_alloc&)
1862 {
1863 return error(GL_OUT_OF_MEMORY);
1864 }
1865}
1866
1867void __stdcall glGetProgramiv(GLuint program, GLenum pname, GLint* params)
1868{
1869 TRACE("GLuint program = %d, GLenum pname = %d, GLint* params = 0x%0.8p", program, pname, params);
1870
1871 try
1872 {
1873 gl::Context *context = gl::getContext();
1874
1875 if (context)
1876 {
1877 gl::Program *programObject = context->getProgram(program);
1878
1879 if (!programObject)
1880 {
1881 return error(GL_INVALID_VALUE);
1882 }
1883
1884 switch (pname)
1885 {
1886 case GL_DELETE_STATUS:
1887 UNIMPLEMENTED(); // FIXME
1888 *params = GL_FALSE;
1889 return;
1890 case GL_LINK_STATUS:
1891 *params = programObject->isLinked();
1892 return;
1893 case GL_VALIDATE_STATUS:
1894 UNIMPLEMENTED(); // FIXME
1895 *params = GL_TRUE;
1896 return;
1897 case GL_INFO_LOG_LENGTH:
1898 UNIMPLEMENTED(); // FIXME
1899 *params = 0;
1900 return;
1901 case GL_ATTACHED_SHADERS:
1902 UNIMPLEMENTED(); // FIXME
1903 *params = 2;
1904 return;
1905 case GL_ACTIVE_ATTRIBUTES:
1906 UNIMPLEMENTED(); // FIXME
1907 *params = 0;
1908 return;
1909 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
1910 UNIMPLEMENTED(); // FIXME
1911 *params = 0;
1912 return;
1913 case GL_ACTIVE_UNIFORMS:
1914 UNIMPLEMENTED(); // FIXME
1915 *params = 0;
1916 return;
1917 case GL_ACTIVE_UNIFORM_MAX_LENGTH:
1918 UNIMPLEMENTED(); // FIXME
1919 *params = 0;
1920 return;
1921 default:
1922 return error(GL_INVALID_ENUM);
1923 }
1924 }
1925 }
1926 catch(std::bad_alloc&)
1927 {
1928 return error(GL_OUT_OF_MEMORY);
1929 }
1930}
1931
1932void __stdcall glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
1933{
1934 TRACE("GLuint program = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, char* infolog = 0x%0.8p", program, bufsize, length, infolog);
1935
1936 try
1937 {
1938 if (bufsize < 0)
1939 {
1940 return error(GL_INVALID_VALUE);
1941 }
1942
1943 UNIMPLEMENTED(); // FIXME
1944 }
1945 catch(std::bad_alloc&)
1946 {
1947 return error(GL_OUT_OF_MEMORY);
1948 }
1949}
1950
1951void __stdcall glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
1952{
1953 TRACE("GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p", target, pname, params);
1954
1955 try
1956 {
1957 UNIMPLEMENTED(); // FIXME
1958 }
1959 catch(std::bad_alloc&)
1960 {
1961 return error(GL_OUT_OF_MEMORY);
1962 }
1963}
1964
1965void __stdcall glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
1966{
1967 TRACE("GLuint shader = %d, GLenum pname = %d, GLint* params = 0x%0.8p", shader, pname, params);
1968
1969 try
1970 {
1971 gl::Context *context = gl::getContext();
1972
1973 if (context)
1974 {
1975 gl::Shader *shaderObject = context->getShader(shader);
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]1976
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]1977 if (!shaderObject)
1978 {
1979 return error(GL_INVALID_VALUE);
1980 }
1981
1982 switch (pname)
1983 {
1984 case GL_SHADER_TYPE:
1985 *params = shaderObject->getType();
1986 return;
1987 case GL_DELETE_STATUS:
1988 UNIMPLEMENTED(); // FIXME
1989 *params = GL_FALSE;
1990 return;
1991 case GL_COMPILE_STATUS:
1992 *params = shaderObject->isCompiled() ? GL_TRUE : GL_FALSE;
1993 return;
1994 case GL_INFO_LOG_LENGTH:
1995 UNIMPLEMENTED(); // FIXME
1996 *params = 0;
1997 return;
1998 case GL_SHADER_SOURCE_LENGTH:
1999 UNIMPLEMENTED(); // FIXME
2000 *params = 1;
2001 return;
2002 default:
2003 return error(GL_INVALID_ENUM);
2004 }
2005 }
2006 }
2007 catch(std::bad_alloc&)
2008 {
2009 return error(GL_OUT_OF_MEMORY);
2010 }
2011}
2012
2013void __stdcall glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
2014{
2015 TRACE("GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, char* infolog = 0x%0.8p", shader, bufsize, length, infolog);
2016
2017 try
2018 {
2019 if (bufsize < 0)
2020 {
2021 return error(GL_INVALID_VALUE);
2022 }
2023
2024 UNIMPLEMENTED(); // FIXME
2025 }
2026 catch(std::bad_alloc&)
2027 {
2028 return error(GL_OUT_OF_MEMORY);
2029 }
2030}
2031
2032void __stdcall glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
2033{
2034 TRACE("GLenum shadertype = 0x%X, GLenum precisiontype = 0x%X, GLint* range = 0x%0.8p, GLint* precision = 0x%0.8p", shadertype, precisiontype, range, precision);
2035
2036 try
2037 {
2038 UNIMPLEMENTED(); // FIXME
2039 }
2040 catch(std::bad_alloc&)
2041 {
2042 return error(GL_OUT_OF_MEMORY);
2043 }
2044}
2045
2046void __stdcall glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
2047{
2048 TRACE("GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, char* source = 0x%0.8p", shader, bufsize, length, source);
2049
2050 try
2051 {
2052 if (bufsize < 0)
2053 {
2054 return error(GL_INVALID_VALUE);
2055 }
2056
2057 UNIMPLEMENTED(); // FIXME
2058 }
2059 catch(std::bad_alloc&)
2060 {
2061 return error(GL_OUT_OF_MEMORY);
2062 }
2063}
2064
2065const GLubyte* __stdcall glGetString(GLenum name)
2066{
2067 TRACE("GLenum name = 0x%X", name);
2068
2069 try
2070 {
2071 switch (name)
2072 {
2073 case GL_VENDOR:
2074 return (GLubyte*)"TransGaming Inc.";
2075 case GL_RENDERER:
2076 return (GLubyte*)"ANGLE";
2077 case GL_VERSION:
2078 return (GLubyte*)"OpenGL ES 2.0 (git-devel "__DATE__ " " __TIME__")";
2079 case GL_SHADING_LANGUAGE_VERSION:
2080 return (GLubyte*)"OpenGL ES GLSL ES 1.00 (git-devel "__DATE__ " " __TIME__")";
2081 case GL_EXTENSIONS:
2082 return (GLubyte*)"";
2083 default:
2084 return error(GL_INVALID_ENUM, (GLubyte*)NULL);
2085 }
2086 }
2087 catch(std::bad_alloc&)
2088 {
2089 return error(GL_OUT_OF_MEMORY, (GLubyte*)NULL);
2090 }
2091
2092 return NULL;
2093}
2094
2095void __stdcall glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
2096{
2097 TRACE("GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat* params = 0x%0.8p", target, pname, params);
2098
2099 try
2100 {
2101 UNIMPLEMENTED(); // FIXME
2102 }
2103 catch(std::bad_alloc&)
2104 {
2105 return error(GL_OUT_OF_MEMORY);
2106 }
2107}
2108
2109void __stdcall glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
2110{
2111 TRACE("GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p", target, pname, params);
2112
2113 try
2114 {
2115 UNIMPLEMENTED(); // FIXME
2116 }
2117 catch(std::bad_alloc&)
2118 {
2119 return error(GL_OUT_OF_MEMORY);
2120 }
2121}
2122
2123void __stdcall glGetUniformfv(GLuint program, GLint location, GLfloat* params)
2124{
2125 TRACE("GLuint program = %d, GLint location = %d, GLfloat* params = 0x%0.8p", program, location, params);
2126
2127 try
2128 {
2129 UNIMPLEMENTED(); // FIXME
2130 }
2131 catch(std::bad_alloc&)
2132 {
2133 return error(GL_OUT_OF_MEMORY);
2134 }
2135}
2136
2137void __stdcall glGetUniformiv(GLuint program, GLint location, GLint* params)
2138{
2139 TRACE("GLuint program = %d, GLint location = %d, GLint* params = 0x%0.8p", program, location, params);
2140
2141 try
2142 {
2143 UNIMPLEMENTED(); // FIXME
2144 }
2145 catch(std::bad_alloc&)
2146 {
2147 return error(GL_OUT_OF_MEMORY);
2148 }
2149}
2150
2151int __stdcall glGetUniformLocation(GLuint program, const char* name)
2152{
2153 TRACE("GLuint program = %d, const char* name = 0x%0.8p", program, name);
2154
2155 try
2156 {
2157 gl::Context *context = gl::getContext();
2158
2159 if (strstr(name, "gl_") == name)
2160 {
2161 return -1;
2162 }
2163
2164 if (context)
2165 {
2166 gl::Program *programObject = context->getProgram(program);
2167
2168 if (!programObject)
2169 {
2170 return error(GL_INVALID_VALUE, -1);
2171 }
2172
2173 if (!programObject->isLinked())
2174 {
2175 return error(GL_INVALID_OPERATION, -1);
2176 }
2177
2178 return programObject->getUniformLocation(name);
2179 }
2180 }
2181 catch(std::bad_alloc&)
2182 {
2183 return error(GL_OUT_OF_MEMORY, -1);
2184 }
2185
2186 return -1;
2187}
2188
2189void __stdcall glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
2190{
2191 TRACE("GLuint index = %d, GLenum pname = 0x%X, GLfloat* params = 0x%0.8p", index, pname, params);
2192
2193 try
2194 {
2195 if (index >= gl::MAX_VERTEX_ATTRIBS)
2196 {
2197 return error(GL_INVALID_VALUE);
2198 }
2199
2200 UNIMPLEMENTED(); // FIXME
2201 }
2202 catch(std::bad_alloc&)
2203 {
2204 return error(GL_OUT_OF_MEMORY);
2205 }
2206}
2207
2208void __stdcall glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
2209{
2210 TRACE("GLuint index = %d, GLenum pname = 0x%X, GLint* params = 0x%0.8p", index, pname, params);
2211
2212 try
2213 {
2214 if (index >= gl::MAX_VERTEX_ATTRIBS)
2215 {
2216 return error(GL_INVALID_VALUE);
2217 }
2218
2219 UNIMPLEMENTED(); // FIXME
2220 }
2221 catch(std::bad_alloc&)
2222 {
2223 return error(GL_OUT_OF_MEMORY);
2224 }
2225}
2226
2227void __stdcall glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
2228{
2229 TRACE("GLuint index = %d, GLenum pname = 0x%X, void** pointer = 0x%0.8p", index, pname, pointer);
2230
2231 try
2232 {
2233 if (index >= gl::MAX_VERTEX_ATTRIBS)
2234 {
2235 return error(GL_INVALID_VALUE);
2236 }
2237
2238 UNIMPLEMENTED(); // FIXME
2239 }
2240 catch(std::bad_alloc&)
2241 {
2242 return error(GL_OUT_OF_MEMORY);
2243 }
2244}
2245
2246void __stdcall glHint(GLenum target, GLenum mode)
2247{
2248 TRACE("GLenum target = 0x%X, GLenum mode = 0x%X", target, mode);
2249
2250 try
2251 {
daniel@transgaming.com5949aa12010-03-21 04:31:15 +0000[diff] [blame]2252 switch (target)
2253 {
2254 case GL_GENERATE_MIPMAP_HINT:
2255 switch (mode)
2256 {
2257 case GL_FASTEST:
2258 case GL_NICEST:
2259 case GL_DONT_CARE:
2260 break;
2261 default:
2262 return error(GL_INVALID_ENUM);
2263 }
2264 break;
2265 default:
2266 return error(GL_INVALID_ENUM);
2267 }
2268
2269 gl::Context *context = gl::getContext();
2270 if (context)
2271 {
2272 if (target == GL_GENERATE_MIPMAP_HINT)
2273 context->generateMipmapHint = mode;
2274 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2275 }
2276 catch(std::bad_alloc&)
2277 {
2278 return error(GL_OUT_OF_MEMORY);
2279 }
2280}
2281
2282GLboolean __stdcall glIsBuffer(GLuint buffer)
2283{
2284 TRACE("GLuint buffer = %d", buffer);
2285
2286 try
2287 {
2288 gl::Context *context = gl::getContext();
2289
2290 if (context && buffer)
2291 {
2292 gl::Buffer *bufferObject = context->getBuffer(buffer);
2293
2294 if (bufferObject)
2295 {
2296 return GL_TRUE;
2297 }
2298 }
2299 }
2300 catch(std::bad_alloc&)
2301 {
2302 return error(GL_OUT_OF_MEMORY, GL_FALSE);
2303 }
2304
2305 return GL_FALSE;
2306}
2307
2308GLboolean __stdcall glIsEnabled(GLenum cap)
2309{
2310 TRACE("GLenum cap = 0x%X", cap);
2311
2312 try
2313 {
2314 gl::Context *context = gl::getContext();
2315
2316 if (context)
2317 {
2318 switch (cap)
2319 {
2320 case GL_CULL_FACE: return context->cullFace;
2321 case GL_POLYGON_OFFSET_FILL: return context->polygonOffsetFill;
2322 case GL_SAMPLE_ALPHA_TO_COVERAGE: return context->sampleAlphaToCoverage;
2323 case GL_SAMPLE_COVERAGE: return context->sampleCoverage;
2324 case GL_SCISSOR_TEST: return context->scissorTest;
2325 case GL_STENCIL_TEST: return context->stencilTest;
2326 case GL_DEPTH_TEST: return context->depthTest;
2327 case GL_BLEND: return context->blend;
2328 case GL_DITHER: return context->dither;
2329 default:
2330 return error(GL_INVALID_ENUM, false);
2331 }
2332 }
2333 }
2334 catch(std::bad_alloc&)
2335 {
2336 return error(GL_OUT_OF_MEMORY, false);
2337 }
2338
2339 return false;
2340}
2341
2342GLboolean __stdcall glIsFramebuffer(GLuint framebuffer)
2343{
2344 TRACE("GLuint framebuffer = %d", framebuffer);
2345
2346 try
2347 {
2348 gl::Context *context = gl::getContext();
2349
2350 if (context && framebuffer)
2351 {
2352 gl::Framebuffer *framebufferObject = context->getFramebuffer(framebuffer);
2353
2354 if (framebufferObject)
2355 {
2356 return GL_TRUE;
2357 }
2358 }
2359 }
2360 catch(std::bad_alloc&)
2361 {
2362 return error(GL_OUT_OF_MEMORY, GL_FALSE);
2363 }
2364
2365 return GL_FALSE;
2366}
2367
2368GLboolean __stdcall glIsProgram(GLuint program)
2369{
2370 TRACE("GLuint program = %d", program);
2371
2372 try
2373 {
2374 gl::Context *context = gl::getContext();
2375
2376 if (context && program)
2377 {
2378 gl::Program *programObject = context->getProgram(program);
2379
2380 if (programObject)
2381 {
2382 return GL_TRUE;
2383 }
2384 }
2385 }
2386 catch(std::bad_alloc&)
2387 {
2388 return error(GL_OUT_OF_MEMORY, GL_FALSE);
2389 }
2390
2391 return GL_FALSE;
2392}
2393
2394GLboolean __stdcall glIsRenderbuffer(GLuint renderbuffer)
2395{
2396 TRACE("GLuint renderbuffer = %d", renderbuffer);
2397
2398 try
2399 {
2400 gl::Context *context = gl::getContext();
2401
2402 if (context && renderbuffer)
2403 {
2404 gl::Renderbuffer *renderbufferObject = context->getRenderbuffer(renderbuffer);
2405
2406 if (renderbufferObject)
2407 {
2408 return GL_TRUE;
2409 }
2410 }
2411 }
2412 catch(std::bad_alloc&)
2413 {
2414 return error(GL_OUT_OF_MEMORY, GL_FALSE);
2415 }
2416
2417 return GL_FALSE;
2418}
2419
2420GLboolean __stdcall glIsShader(GLuint shader)
2421{
2422 TRACE("GLuint shader = %d", shader);
2423
2424 try
2425 {
2426 gl::Context *context = gl::getContext();
2427
2428 if (context && shader)
2429 {
2430 gl::Shader *shaderObject = context->getShader(shader);
2431
2432 if (shaderObject)
2433 {
2434 return GL_TRUE;
2435 }
2436 }
2437 }
2438 catch(std::bad_alloc&)
2439 {
2440 return error(GL_OUT_OF_MEMORY, GL_FALSE);
2441 }
2442
2443 return GL_FALSE;
2444}
2445
2446GLboolean __stdcall glIsTexture(GLuint texture)
2447{
2448 TRACE("GLuint texture = %d", texture);
2449
2450 try
2451 {
2452 gl::Context *context = gl::getContext();
2453
2454 if (context && texture)
2455 {
2456 gl::Texture *textureObject = context->getTexture(texture);
2457
2458 if (textureObject)
2459 {
2460 return GL_TRUE;
2461 }
2462 }
2463 }
2464 catch(std::bad_alloc&)
2465 {
2466 return error(GL_OUT_OF_MEMORY, GL_FALSE);
2467 }
2468
2469 return GL_FALSE;
2470}
2471
2472void __stdcall glLineWidth(GLfloat width)
2473{
2474 TRACE("GLfloat width = %f", width);
2475
2476 try
2477 {
2478 if (width <= 0.0f)
2479 {
2480 return error(GL_INVALID_VALUE);
2481 }
2482
2483 if (width != 1.0f)
2484 {
2485 UNIMPLEMENTED(); // FIXME
2486 }
2487 }
2488 catch(std::bad_alloc&)
2489 {
2490 return error(GL_OUT_OF_MEMORY);
2491 }
2492}
2493
2494void __stdcall glLinkProgram(GLuint program)
2495{
2496 TRACE("GLuint program = %d", program);
2497
2498 try
2499 {
2500 gl::Context *context = gl::getContext();
2501
2502 if (context)
2503 {
2504 gl::Program *programObject = context->getProgram(program);
2505
2506 if (!programObject)
2507 {
2508 return error(GL_INVALID_VALUE);
2509 }
2510
2511 programObject->link();
2512 }
2513 }
2514 catch(std::bad_alloc&)
2515 {
2516 return error(GL_OUT_OF_MEMORY);
2517 }
2518}
2519
2520void __stdcall glPixelStorei(GLenum pname, GLint param)
2521{
2522 TRACE("GLenum pname = 0x%X, GLint param = %d", pname, param);
2523
2524 try
2525 {
daniel@transgaming.com3489e3a2010-03-21 04:31:11 +0000[diff] [blame]2526 gl::Context *context = gl::getContext();
2527
2528 if (context)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2529 {
daniel@transgaming.com3489e3a2010-03-21 04:31:11 +0000[diff] [blame]2530 switch (pname)
2531 {
2532 case GL_UNPACK_ALIGNMENT:
2533 if (param != 1 && param != 2 && param != 4 && param != 8)
2534 {
2535 return error(GL_INVALID_VALUE);
2536 }
2537
2538 context->unpackAlignment = param;
2539 break;
2540
2541 case GL_PACK_ALIGNMENT:
2542 if (param != 1 && param != 2 && param != 4 && param != 8)
2543 {
2544 return error(GL_INVALID_VALUE);
2545 }
2546
2547 context->packAlignment = param;
2548 break;
2549
2550 default:
2551 return error(GL_INVALID_ENUM);
2552 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2553 }
2554 }
2555 catch(std::bad_alloc&)
2556 {
2557 return error(GL_OUT_OF_MEMORY);
2558 }
2559}
2560
2561void __stdcall glPolygonOffset(GLfloat factor, GLfloat units)
2562{
2563 TRACE("GLfloat factor = %f, GLfloat units = %f", factor, units);
2564
2565 try
2566 {
2567 if (factor != 0.0f || units != 0.0f)
2568 {
2569 UNIMPLEMENTED(); // FIXME
2570 }
2571 }
2572 catch(std::bad_alloc&)
2573 {
2574 return error(GL_OUT_OF_MEMORY);
2575 }
2576}
2577
2578void __stdcall glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
2579{
2580 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);
2581
2582 try
2583 {
2584 if (width < 0 || height < 0)
2585 {
2586 return error(GL_INVALID_VALUE);
2587 }
2588
2589 switch (format)
2590 {
2591 case GL_RGBA:
2592 switch (type)
2593 {
2594 case GL_UNSIGNED_BYTE:
2595 break;
2596 default:
2597 return error(GL_INVALID_OPERATION);
2598 }
2599 break;
2600 case gl::IMPLEMENTATION_COLOR_READ_FORMAT:
2601 switch (type)
2602 {
2603 case gl::IMPLEMENTATION_COLOR_READ_TYPE:
2604 break;
2605 default:
2606 return error(GL_INVALID_OPERATION);
2607 }
2608 break;
2609 default:
2610 return error(GL_INVALID_OPERATION);
2611 }
2612
2613 gl::Context *context = gl::getContext();
2614
2615 if (context)
2616 {
2617 context->readPixels(x, y, width, height, format, type, pixels);
2618 }
2619 }
2620 catch(std::bad_alloc&)
2621 {
2622 return error(GL_OUT_OF_MEMORY);
2623 }
2624}
2625
2626void __stdcall glReleaseShaderCompiler(void)
2627{
2628 TRACE("");
2629
2630 try
2631 {
2632 gl::Shader::releaseCompiler();
2633 }
2634 catch(std::bad_alloc&)
2635 {
2636 return error(GL_OUT_OF_MEMORY);
2637 }
2638}
2639
2640void __stdcall glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
2641{
2642 TRACE("GLenum target = 0x%X, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = %d", target, internalformat, width, height);
2643
2644 try
2645 {
2646 switch (target)
2647 {
2648 case GL_RENDERBUFFER:
2649 break;
2650 default:
2651 return error(GL_INVALID_ENUM);
2652 }
2653
2654 switch (internalformat)
2655 {
2656 case GL_DEPTH_COMPONENT16:
2657 case GL_RGBA4:
2658 case GL_RGB5_A1:
2659 case GL_RGB565:
2660 case GL_STENCIL_INDEX8:
2661 break;
2662 default:
2663 return error(GL_INVALID_ENUM);
2664 }
2665
2666 if (width < 0 || height < 0 || width > gl::MAX_RENDERBUFFER_SIZE || height > gl::MAX_RENDERBUFFER_SIZE)
2667 {
2668 return error(GL_INVALID_VALUE);
2669 }
2670
2671 gl::Context *context = gl::getContext();
2672
2673 if (context)
2674 {
2675 if (context->framebuffer == 0 || context->renderbuffer == 0)
2676 {
2677 return error(GL_INVALID_OPERATION);
2678 }
2679
2680 switch (internalformat)
2681 {
2682 case GL_DEPTH_COMPONENT16:
2683 context->setRenderbuffer(new gl::Depthbuffer(width, height));
2684 break;
2685 case GL_RGBA4:
2686 case GL_RGB5_A1:
2687 case GL_RGB565:
2688 UNIMPLEMENTED(); // FIXME
daniel@transgaming.com4a9d65c2010-03-08 21:30:56 +0000[diff] [blame]2689 // context->setRenderbuffer(new Colorbuffer(renderTarget));
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2690 break;
2691 case GL_STENCIL_INDEX8:
daniel@transgaming.com4a9d65c2010-03-08 21:30:56 +0000[diff] [blame]2692 context->setRenderbuffer(new gl::Stencilbuffer(width, height));
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2693 break;
2694 default:
2695 return error(GL_INVALID_ENUM);
2696 }
2697 }
2698 }
2699 catch(std::bad_alloc&)
2700 {
2701 return error(GL_OUT_OF_MEMORY);
2702 }
2703}
2704
2705void __stdcall glSampleCoverage(GLclampf value, GLboolean invert)
2706{
2707 TRACE("GLclampf value = %f, GLboolean invert = %d", value, invert);
2708
2709 try
2710 {
2711 gl::Context* context = gl::getContext();
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]2712
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2713 if (context)
2714 {
2715 context->sampleCoverageValue = gl::clamp01(value);
2716 context->sampleCoverageInvert = invert;
2717 }
2718 }
2719 catch(std::bad_alloc&)
2720 {
2721 return error(GL_OUT_OF_MEMORY);
2722 }
2723}
2724
2725void __stdcall glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
2726{
2727 TRACE("GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d", x, y, width, height);
2728
2729 try
2730 {
2731 if (width < 0 || height < 0)
2732 {
2733 return error(GL_INVALID_VALUE);
2734 }
2735
2736 gl::Context* context = gl::getContext();
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]2737
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2738 if (context)
2739 {
2740 context->scissorX = x;
2741 context->scissorY = y;
2742 context->scissorWidth = width;
2743 context->scissorHeight = height;
2744 }
2745 }
2746 catch(std::bad_alloc&)
2747 {
2748 return error(GL_OUT_OF_MEMORY);
2749 }
2750}
2751
2752void __stdcall glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length)
2753{
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]2754 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]2755 n, shaders, binaryformat, binary, length);
2756
2757 try
2758 {
2759 if (n < 0 || length < 0)
2760 {
2761 return error(GL_INVALID_VALUE);
2762 }
2763
2764 UNIMPLEMENTED(); // FIXME
2765 }
2766 catch(std::bad_alloc&)
2767 {
2768 return error(GL_OUT_OF_MEMORY);
2769 }
2770}
2771
2772void __stdcall glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
2773{
2774 TRACE("GLuint shader = %d, GLsizei count = %d, const char** string = 0x%0.8p, const GLint* length = 0x%0.8p", shader, count, string, length);
2775
2776 try
2777 {
2778 if (count < 0)
2779 {
2780 return error(GL_INVALID_VALUE);
2781 }
2782
2783 gl::Context *context = gl::getContext();
2784
2785 if (context)
2786 {
2787 gl::Shader *shaderObject = context->getShader(shader);
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]2788
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2789 if (!shaderObject)
2790 {
2791 return error(GL_INVALID_VALUE);
2792 }
2793
2794 shaderObject->setSource(count, string, length);
2795 }
2796 }
2797 catch(std::bad_alloc&)
2798 {
2799 return error(GL_OUT_OF_MEMORY);
2800 }
2801}
2802
2803void __stdcall glStencilFunc(GLenum func, GLint ref, GLuint mask)
2804{
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]2805 glStencilFuncSeparate(GL_FRONT_AND_BACK, func, ref, mask);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2806}
2807
2808void __stdcall glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
2809{
2810 TRACE("GLenum face = 0x%X, GLenum func = 0x%X, GLint ref = %d, GLuint mask = %d", face, func, ref, mask);
2811
2812 try
2813 {
2814 switch (face)
2815 {
2816 case GL_FRONT:
2817 case GL_BACK:
2818 case GL_FRONT_AND_BACK:
2819 break;
2820 default:
2821 return error(GL_INVALID_ENUM);
2822 }
2823
2824 switch (func)
2825 {
2826 case GL_NEVER:
2827 case GL_ALWAYS:
2828 case GL_LESS:
2829 case GL_LEQUAL:
2830 case GL_EQUAL:
2831 case GL_GEQUAL:
2832 case GL_GREATER:
2833 case GL_NOTEQUAL:
2834 break;
2835 default:
2836 return error(GL_INVALID_ENUM);
2837 }
2838
2839 gl::Context *context = gl::getContext();
2840
2841 if (context)
2842 {
2843 if (face == GL_FRONT || face == GL_FRONT_AND_BACK)
2844 {
2845 context->stencilFunc = func;
2846 context->stencilRef = ref;
2847 context->stencilMask = mask;
2848 }
2849
2850 if (face == GL_BACK || face == GL_FRONT_AND_BACK)
2851 {
2852 context->stencilBackFunc = func;
2853 context->stencilBackRef = ref;
2854 context->stencilBackMask = mask;
2855 }
2856 }
2857 }
2858 catch(std::bad_alloc&)
2859 {
2860 return error(GL_OUT_OF_MEMORY);
2861 }
2862}
2863
2864void __stdcall glStencilMask(GLuint mask)
2865{
2866 glStencilMaskSeparate(GL_FRONT_AND_BACK, mask);
2867}
2868
2869void __stdcall glStencilMaskSeparate(GLenum face, GLuint mask)
2870{
2871 TRACE("GLenum face = 0x%X, GLuint mask = %d", face, mask);
2872
2873 try
2874 {
2875 switch (face)
2876 {
2877 case GL_FRONT:
2878 case GL_BACK:
2879 case GL_FRONT_AND_BACK:
2880 break;
2881 default:
2882 return error(GL_INVALID_ENUM);
2883 }
2884
2885 gl::Context *context = gl::getContext();
2886
2887 if (context)
2888 {
2889 if (face == GL_FRONT || face == GL_FRONT_AND_BACK)
2890 {
2891 context->stencilWritemask = mask;
2892 }
2893
2894 if (face == GL_BACK || face == GL_FRONT_AND_BACK)
2895 {
2896 context->stencilBackWritemask = mask;
2897 }
2898 }
2899 }
2900 catch(std::bad_alloc&)
2901 {
2902 return error(GL_OUT_OF_MEMORY);
2903 }
2904}
2905
2906void __stdcall glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
2907{
2908 glStencilOpSeparate(GL_FRONT_AND_BACK, fail, zfail, zpass);
2909}
2910
2911void __stdcall glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
2912{
2913 TRACE("GLenum face = 0x%X, GLenum fail = 0x%X, GLenum zfail = 0x%X, GLenum zpas = 0x%Xs", face, fail, zfail, zpass);
2914
2915 try
2916 {
2917 switch (face)
2918 {
2919 case GL_FRONT:
2920 case GL_BACK:
2921 case GL_FRONT_AND_BACK:
2922 break;
2923 default:
2924 return error(GL_INVALID_ENUM);
2925 }
2926
2927 switch (fail)
2928 {
2929 case GL_ZERO:
2930 case GL_KEEP:
2931 case GL_REPLACE:
2932 case GL_INCR:
2933 case GL_DECR:
2934 case GL_INVERT:
2935 case GL_INCR_WRAP:
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]2936 case GL_DECR_WRAP:
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2937 break;
2938 default:
2939 return error(GL_INVALID_ENUM);
2940 }
2941
2942 switch (zfail)
2943 {
2944 case GL_ZERO:
2945 case GL_KEEP:
2946 case GL_REPLACE:
2947 case GL_INCR:
2948 case GL_DECR:
2949 case GL_INVERT:
2950 case GL_INCR_WRAP:
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]2951 case GL_DECR_WRAP:
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2952 break;
2953 default:
2954 return error(GL_INVALID_ENUM);
2955 }
2956
2957 switch (zpass)
2958 {
2959 case GL_ZERO:
2960 case GL_KEEP:
2961 case GL_REPLACE:
2962 case GL_INCR:
2963 case GL_DECR:
2964 case GL_INVERT:
2965 case GL_INCR_WRAP:
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]2966 case GL_DECR_WRAP:
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]2967 break;
2968 default:
2969 return error(GL_INVALID_ENUM);
2970 }
2971
2972 gl::Context *context = gl::getContext();
2973
2974 if (context)
2975 {
2976 if (face == GL_FRONT || face == GL_FRONT_AND_BACK)
2977 {
2978 context->stencilFail = fail;
2979 context->stencilPassDepthFail = zfail;
2980 context->stencilPassDepthPass = zpass;
2981 }
2982
2983 if (face == GL_BACK || face == GL_FRONT_AND_BACK)
2984 {
2985 context->stencilBackFail = fail;
2986 context->stencilBackPassDepthFail = zfail;
2987 context->stencilBackPassDepthPass = zpass;
2988 }
2989 }
2990 }
2991 catch(std::bad_alloc&)
2992 {
2993 return error(GL_OUT_OF_MEMORY);
2994 }
2995}
2996
2997void __stdcall glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
2998{
2999 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);
3000
3001 try
3002 {
3003 if (level < 0 || width < 0 || height < 0)
3004 {
3005 return error(GL_INVALID_VALUE);
3006 }
3007
3008 if (level > 0 && (!gl::isPow2(width) || !gl::isPow2(height)))
3009 {
3010 return error(GL_INVALID_VALUE);
3011 }
daniel@transgaming.comfab5a1a2010-03-11 19:22:30 +0000[diff] [blame]3012
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]3013 switch (target)
3014 {
3015 case GL_TEXTURE_2D:
3016 if (width > (gl::MAX_TEXTURE_SIZE >> level) || height > (gl::MAX_TEXTURE_SIZE >> level))
3017 {
3018 return error(GL_INVALID_VALUE);
3019 }
3020 break;
3021 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
3022 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
3023 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
3024 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
3025 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
3026 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
3027 if (!gl::isPow2(width) || !gl::isPow2(height))
3028 {
3029 return error(GL_INVALID_VALUE);
3030 }
3031
3032 if (width > (gl::MAX_CUBE_MAP_TEXTURE_SIZE >> level) || height > (gl::MAX_CUBE_MAP_TEXTURE_SIZE >> level))
3033 {
3034 return error(GL_INVALID_VALUE);
3035 }
3036 break;
3037 default:
3038 return error(GL_INVALID_ENUM);
3039 }
3040
3041 if (internalformat != format)
3042 {
3043 return error(GL_INVALID_OPERATION);
3044 }
3045
3046 switch (internalformat)
3047 {
3048 case GL_ALPHA:
3049 case GL_LUMINANCE:
3050 case GL_LUMINANCE_ALPHA:
3051 switch (type)
3052 {
3053 case GL_UNSIGNED_BYTE:
3054 break;
3055 default:
3056 return error(GL_INVALID_ENUM);
3057 }
3058 break;
3059 case GL_RGB:
3060 switch (type)
3061 {
3062 case GL_UNSIGNED_BYTE:
3063 case GL_UNSIGNED_SHORT_5_6_5:
3064 break;
3065 default:
3066 return error(GL_INVALID_ENUM);
3067 }
3068 break;
3069 case GL_RGBA:
3070 switch (type)
3071 {
3072 case GL_UNSIGNED_BYTE:
3073 case GL_UNSIGNED_SHORT_4_4_4_4:
3074 case GL_UNSIGNED_SHORT_5_5_5_1:
3075 break;
3076 default:
3077 return error(GL_INVALID_ENUM);
3078 }
3079 break;
3080 default:
3081 return error(GL_INVALID_VALUE);
3082 }
3083
3084 if (border != 0)
3085 {
3086 return error(GL_INVALID_VALUE);
3087 }
3088
3089 gl::Context *context = gl::getContext();
3090
3091 if (context)
3092 {
3093 if (target == GL_TEXTURE_2D)
3094 {
3095 gl::Texture2D *texture = context->getTexture2D();
3096
3097 if (!texture)
3098 {
3099 return error(GL_INVALID_OPERATION);
3100 }
3101
daniel@transgaming.com3489e3a2010-03-21 04:31:11 +0000[diff] [blame]3102 texture->setImage(level, internalformat, width, height, format, type, context->unpackAlignment, pixels);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]3103 }
3104 else
3105 {
3106 gl::TextureCubeMap *texture = context->getTextureCubeMap();
3107
3108 if (!texture)
3109 {
3110 return error(GL_INVALID_OPERATION);
3111 }
3112
3113 switch (target)
3114 {
3115 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
daniel@transgaming.com3489e3a2010-03-21 04:31:11 +0000[diff] [blame]3116 texture->setImagePosX(level, internalformat, width, height, format, type, context->unpackAlignment, pixels);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]3117 break;
3118 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
daniel@transgaming.com3489e3a2010-03-21 04:31:11 +0000[diff] [blame]3119 texture->setImageNegX(level, internalformat, width, height, format, type, context->unpackAlignment, pixels);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]3120 break;
3121 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
daniel@transgaming.com3489e3a2010-03-21 04:31:11 +0000[diff] [blame]3122 texture->setImagePosY(level, internalformat, width, height, format, type, context->unpackAlignment, pixels);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]3123 break;
3124 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
daniel@transgaming.com3489e3a2010-03-21 04:31:11 +0000[diff] [blame]3125 texture->setImageNegY(level, internalformat, width, height, format, type, context->unpackAlignment, pixels);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]3126 break;
3127 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
daniel@transgaming.com3489e3a2010-03-21 04:31:11 +0000[diff] [blame]3128 texture->setImagePosZ(level, internalformat, width, height, format, type, context->unpackAlignment, pixels);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]3129 break;
3130 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
daniel@transgaming.com3489e3a2010-03-21 04:31:11 +0000[diff] [blame]3131 texture->setImageNegZ(level, internalformat, width, height, format, type, context->unpackAlignment, pixels);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]3132 break;
3133 default: UNREACHABLE();
3134 }
3135 }
3136 }
3137 }
3138 catch(std::bad_alloc&)
3139 {
3140 return error(GL_OUT_OF_MEMORY);
3141 }
3142}
3143
3144void __stdcall glTexParameterf(GLenum target, GLenum pname, GLfloat param)
3145{
3146 glTexParameteri(target, pname, (GLint)param);
3147}
3148
3149void __stdcall glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
3150{
3151 glTexParameteri(target, pname, (GLint)*params);
3152}
3153
3154void __stdcall glTexParameteri(GLenum target, GLenum pname, GLint param)
3155{
3156 TRACE("GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat param = %f", target, pname, param);
3157
3158 try
3159 {
3160 gl::Context *context = gl::getContext();
3161
3162 if (context)
3163 {
3164 gl::Texture *texture;
3165
3166 switch (target)
3167 {
3168 case GL_TEXTURE_2D:
3169 texture = context->getTexture2D();
3170 break;
3171 case GL_TEXTURE_CUBE_MAP:
3172 texture = context->getTextureCubeMap();
3173 break;
3174 default:
3175 return error(GL_INVALID_ENUM);
3176 }
3177
3178 switch (pname)
3179 {
3180 case GL_TEXTURE_WRAP_S:
3181 if (!texture->setWrapS((GLenum)param))
3182 {
3183 return error(GL_INVALID_ENUM);
3184 }
3185 break;
3186 case GL_TEXTURE_WRAP_T:
3187 if (!texture->setWrapT((GLenum)param))
3188 {
3189 return error(GL_INVALID_ENUM);
3190 }
3191 break;
3192 case GL_TEXTURE_MIN_FILTER:
3193 if (!texture->setMinFilter((GLenum)param))
3194 {
3195 return error(GL_INVALID_ENUM);
3196 }
3197 break;
3198 case GL_TEXTURE_MAG_FILTER:
3199 if (!texture->setMagFilter((GLenum)param))
3200 {
3201 return error(GL_INVALID_ENUM);
3202 }
3203 break;
3204 default:
3205 return error(GL_INVALID_ENUM);
3206 }
3207 }
3208 }
3209 catch(std::bad_alloc&)
3210 {
3211 return error(GL_OUT_OF_MEMORY);
3212 }
3213}
3214
3215void __stdcall glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
3216{
3217 glTexParameteri(target, pname, *params);
3218}
3219
3220void __stdcall glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
3221{
3222 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",
3223 target, level, xoffset, yoffset, width, height, format, type, pixels);
3224
3225 try
3226 {
daniel@transgaming.com00c75962010-03-11 20:36:15 +0000[diff] [blame]3227 if (target != GL_TEXTURE_2D && !es2dx::IsCubemapTextureTarget(target))
3228 {
3229 return error(GL_INVALID_ENUM);
3230 }
3231
3232 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]3233 {
3234 return error(GL_INVALID_VALUE);
3235 }
3236
daniel@transgaming.com00c75962010-03-11 20:36:15 +0000[diff] [blame]3237 if (std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height)
3238 {
3239 return error(GL_INVALID_VALUE);
3240 }
3241
3242 if (!es2dx::CheckTextureFormatType(format, type))
3243 {
3244 return error(GL_INVALID_ENUM);
3245 }
3246
3247 if (width == 0 || height == 0 || pixels == NULL)
3248 {
3249 return;
3250 }
3251
3252 gl::Context *context = gl::getContext();
3253
3254 if (context)
3255 {
3256 if (target == GL_TEXTURE_2D)
3257 {
3258 gl::Texture2D *texture = context->getTexture2D();
3259
3260 if (!texture)
3261 {
3262 return error(GL_INVALID_OPERATION);
3263 }
3264
daniel@transgaming.com3489e3a2010-03-21 04:31:11 +0000[diff] [blame]3265 texture->subImage(level, xoffset, yoffset, width, height, format, type, context->unpackAlignment, pixels);
daniel@transgaming.com00c75962010-03-11 20:36:15 +0000[diff] [blame]3266 }
3267 else if (es2dx::IsCubemapTextureTarget(target))
3268 {
3269 gl::TextureCubeMap *texture = context->getTextureCubeMap();
3270
3271 if (!texture)
3272 {
3273 return error(GL_INVALID_OPERATION);
3274 }
3275
daniel@transgaming.com3489e3a2010-03-21 04:31:11 +0000[diff] [blame]3276 texture->subImage(target, level, xoffset, yoffset, width, height, format, type, context->unpackAlignment, pixels);
daniel@transgaming.com00c75962010-03-11 20:36:15 +0000[diff] [blame]3277 }
3278 else
3279 {
3280 UNREACHABLE();
3281 }
3282 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]3283 }
3284 catch(std::bad_alloc&)
3285 {
3286 return error(GL_OUT_OF_MEMORY);
3287 }
3288}
3289
3290void __stdcall glUniform1f(GLint location, GLfloat x)
3291{
3292 glUniform1fv(location, 1, &x);
3293}
3294
3295void __stdcall glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
3296{
3297 TRACE("GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p", location, count, v);
3298
3299 try
3300 {
3301 if (location == -1)
3302 {
3303 return;
3304 }
3305
3306 if (count < 0)
3307 {
3308 return error(GL_INVALID_VALUE);
3309 }
3310
3311 gl::Context *context = gl::getContext();
3312
3313 if (context)
3314 {
3315 gl::Program *program = context->getCurrentProgram();
3316
3317 if (!program)
3318 {
3319 return error(GL_INVALID_OPERATION);
3320 }
3321
3322 if (!program->setUniform1fv(location, count, v))
3323 {
3324 return error(GL_INVALID_OPERATION);
3325 }
3326 }
3327 }
3328 catch(std::bad_alloc&)
3329 {
3330 return error(GL_OUT_OF_MEMORY);
3331 }
3332}
3333
3334void __stdcall glUniform1i(GLint location, GLint x)
3335{
3336 glUniform1iv(location, 1, &x);
3337}
3338
3339void __stdcall glUniform1iv(GLint location, GLsizei count, const GLint* v)
3340{
3341 TRACE("GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p", location, count, v);
3342
3343 try
3344 {
3345 if (count < 0)
3346 {
3347 return error(GL_INVALID_VALUE);
3348 }
3349
3350 gl::Context *context = gl::getContext();
3351
3352 if (context)
3353 {
3354 gl::Program *program = context->getCurrentProgram();
3355
3356 if (!program)
3357 {
3358 return error(GL_INVALID_OPERATION);
3359 }
3360
3361 if (!program->setUniform1iv(location, count, v))
3362 {
3363 return error(GL_INVALID_OPERATION);
3364 }
3365 }
3366 }
3367 catch(std::bad_alloc&)
3368 {
3369 return error(GL_OUT_OF_MEMORY);
3370 }
3371}
3372
3373void __stdcall glUniform2f(GLint location, GLfloat x, GLfloat y)
3374{
3375 GLfloat xy[2] = {x, y};
3376
3377 glUniform2fv(location, 1, (GLfloat*)&xy);
3378}
3379
3380void __stdcall glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
3381{
3382 TRACE("GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p", location, count, v);
3383
3384 try
3385 {
3386 if (location == -1)
3387 {
3388 return;
3389 }
3390
3391 if (count < 0)
3392 {
3393 return error(GL_INVALID_VALUE);
3394 }
3395
3396 gl::Context *context = gl::getContext();
3397
3398 if (context)
3399 {
3400 gl::Program *program = context->getCurrentProgram();
3401
3402 if (!program)
3403 {
3404 return error(GL_INVALID_OPERATION);
3405 }
3406
3407 if (!program->setUniform2fv(location, count, v))
3408 {
3409 return error(GL_INVALID_OPERATION);
3410 }
3411 }
3412 }
3413 catch(std::bad_alloc&)
3414 {
3415 return error(GL_OUT_OF_MEMORY);
3416 }
3417}
3418
3419void __stdcall glUniform2i(GLint location, GLint x, GLint y)
3420{
3421 GLint xy[4] = {x, y};
3422
3423 glUniform2iv(location, 1, (GLint*)&xy);
3424}
3425
3426void __stdcall glUniform2iv(GLint location, GLsizei count, const GLint* v)
3427{
3428 TRACE("GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p", location, count, v);
3429
3430 try
3431 {
3432 if (count < 0)
3433 {
3434 return error(GL_INVALID_VALUE);
3435 }
3436
3437 UNIMPLEMENTED(); // FIXME
3438 }
3439 catch(std::bad_alloc&)
3440 {
3441 return error(GL_OUT_OF_MEMORY);
3442 }
3443}
3444
3445void __stdcall glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
3446{
3447 GLfloat xyz[3] = {x, y, z};
3448
3449 glUniform3fv(location, 1, (GLfloat*)&xyz);
3450}
3451
3452void __stdcall glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
3453{
3454 TRACE("GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p", location, count, v);
3455
3456 try
3457 {
3458 if (count < 0)
3459 {
3460 return error(GL_INVALID_VALUE);
3461 }
3462
3463 if (location == -1)
3464 {
3465 return;
3466 }
3467
3468 gl::Context *context = gl::getContext();
3469
3470 if (context)
3471 {
3472 gl::Program *program = context->getCurrentProgram();
3473
3474 if (!program)
3475 {
3476 return error(GL_INVALID_OPERATION);
3477 }
3478
3479 if (!program->setUniform3fv(location, count, v))
3480 {
3481 return error(GL_INVALID_OPERATION);
3482 }
3483 }
3484 }
3485 catch(std::bad_alloc&)
3486 {
3487 return error(GL_OUT_OF_MEMORY);
3488 }
3489}
3490
3491void __stdcall glUniform3i(GLint location, GLint x, GLint y, GLint z)
3492{
3493 GLint xyz[3] = {x, y, z};
3494
3495 glUniform3iv(location, 1, (GLint*)&xyz);
3496}
3497
3498void __stdcall glUniform3iv(GLint location, GLsizei count, const GLint* v)
3499{
3500 TRACE("GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p", location, count, v);
3501
3502 try
3503 {
3504 if (count < 0)
3505 {
3506 return error(GL_INVALID_VALUE);
3507 }
3508
3509 UNIMPLEMENTED(); // FIXME
3510 }
3511 catch(std::bad_alloc&)
3512 {
3513 return error(GL_OUT_OF_MEMORY);
3514 }
3515}
3516
3517void __stdcall glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
3518{
3519 GLfloat xyzw[4] = {x, y, z, w};
3520
3521 glUniform4fv(location, 1, (GLfloat*)&xyzw);
3522}
3523
3524void __stdcall glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
3525{
3526 TRACE("GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p", location, count, v);
3527
3528 try
3529 {
3530 if (count < 0)
3531 {
3532 return error(GL_INVALID_VALUE);
3533 }
3534
3535 if (location == -1)
3536 {
3537 return;
3538 }
3539
3540 gl::Context *context = gl::getContext();
3541
3542 if (context)
3543 {
3544 gl::Program *program = context->getCurrentProgram();
3545
3546 if (!program)
3547 {
3548 return error(GL_INVALID_OPERATION);
3549 }
3550
3551 if (!program->setUniform4fv(location, count, v))
3552 {
3553 return error(GL_INVALID_OPERATION);
3554 }
3555 }
3556 }
3557 catch(std::bad_alloc&)
3558 {
3559 return error(GL_OUT_OF_MEMORY);
3560 }
3561}
3562
3563void __stdcall glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
3564{
3565 GLint xyzw[4] = {x, y, z, w};
3566
3567 glUniform4iv(location, 1, (GLint*)&xyzw);
3568}
3569
3570void __stdcall glUniform4iv(GLint location, GLsizei count, const GLint* v)
3571{
3572 TRACE("GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p", location, count, v);
3573
3574 try
3575 {
3576 if (count < 0)
3577 {
3578 return error(GL_INVALID_VALUE);
3579 }
3580
3581 UNIMPLEMENTED(); // FIXME
3582 }
3583 catch(std::bad_alloc&)
3584 {
3585 return error(GL_OUT_OF_MEMORY);
3586 }
3587}
3588
3589void __stdcall glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
3590{
3591 TRACE("GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = 0x%0.8p", location, count, transpose, value);
3592
3593 try
3594 {
3595 if (count < 0 || transpose != GL_FALSE)
3596 {
3597 return error(GL_INVALID_VALUE);
3598 }
3599
3600 if (location == -1)
3601 {
3602 return;
3603 }
3604
3605 gl::Context *context = gl::getContext();
3606
3607 if (context)
3608 {
3609 gl::Program *program = context->getCurrentProgram();
3610
3611 if (!program)
3612 {
3613 return error(GL_INVALID_OPERATION);
3614 }
3615
3616 if (!program->setUniformMatrix2fv(location, count, value))
3617 {
3618 return error(GL_INVALID_OPERATION);
3619 }
3620 }
3621 }
3622 catch(std::bad_alloc&)
3623 {
3624 return error(GL_OUT_OF_MEMORY);
3625 }
3626}
3627
3628void __stdcall glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
3629{
3630 TRACE("GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = 0x%0.8p", location, count, transpose, value);
3631
3632 try
3633 {
3634 if (count < 0 || transpose != GL_FALSE)
3635 {
3636 return error(GL_INVALID_VALUE);
3637 }
3638
3639 if (location == -1)
3640 {
3641 return;
3642 }
3643
3644 gl::Context *context = gl::getContext();
3645
3646 if (context)
3647 {
3648 gl::Program *program = context->getCurrentProgram();
3649
3650 if (!program)
3651 {
3652 return error(GL_INVALID_OPERATION);
3653 }
3654
3655 if (!program->setUniformMatrix3fv(location, count, value))
3656 {
3657 return error(GL_INVALID_OPERATION);
3658 }
3659 }
3660 }
3661 catch(std::bad_alloc&)
3662 {
3663 return error(GL_OUT_OF_MEMORY);
3664 }
3665}
3666
3667void __stdcall glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
3668{
3669 TRACE("GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = 0x%0.8p", location, count, transpose, value);
3670
3671 try
3672 {
3673 if (count < 0 || transpose != GL_FALSE)
3674 {
3675 return error(GL_INVALID_VALUE);
3676 }
3677
3678 if (location == -1)
3679 {
3680 return;
3681 }
3682
3683 gl::Context *context = gl::getContext();
3684
3685 if (context)
3686 {
3687 gl::Program *program = context->getCurrentProgram();
3688
3689 if (!program)
3690 {
3691 return error(GL_INVALID_OPERATION);
3692 }
3693
3694 if (!program->setUniformMatrix4fv(location, count, value))
3695 {
3696 return error(GL_INVALID_OPERATION);
3697 }
3698 }
3699 }
3700 catch(std::bad_alloc&)
3701 {
3702 return error(GL_OUT_OF_MEMORY);
3703 }
3704}
3705
3706void __stdcall glUseProgram(GLuint program)
3707{
3708 TRACE("GLuint program = %d", program);
3709
3710 try
3711 {
3712 gl::Context *context = gl::getContext();
3713
3714 if (context)
3715 {
3716 gl::Program *programObject = context->getProgram(program);
3717
3718 if (programObject && !programObject->isLinked())
3719 {
3720 return error(GL_INVALID_OPERATION);
3721 }
3722
3723 context->useProgram(program);
3724 }
3725 }
3726 catch(std::bad_alloc&)
3727 {
3728 return error(GL_OUT_OF_MEMORY);
3729 }
3730}
3731
3732void __stdcall glValidateProgram(GLuint program)
3733{
3734 TRACE("GLuint program = %d", program);
3735
3736 try
3737 {
3738 UNIMPLEMENTED(); // FIXME
3739 }
3740 catch(std::bad_alloc&)
3741 {
3742 return error(GL_OUT_OF_MEMORY);
3743 }
3744}
3745
3746void __stdcall glVertexAttrib1f(GLuint index, GLfloat x)
3747{
3748 TRACE("GLuint index = %d, GLfloat x = %f", index, x);
3749
3750 try
3751 {
3752 if (index >= gl::MAX_VERTEX_ATTRIBS)
3753 {
3754 return error(GL_INVALID_VALUE);
3755 }
3756
3757 UNIMPLEMENTED(); // FIXME
3758 }
3759 catch(std::bad_alloc&)
3760 {
3761 return error(GL_OUT_OF_MEMORY);
3762 }
3763}
3764
3765void __stdcall glVertexAttrib1fv(GLuint index, const GLfloat* values)
3766{
3767 TRACE("GLuint index = %d, const GLfloat* values = 0x%0.8p", index, values);
3768
3769 try
3770 {
3771 if (index >= gl::MAX_VERTEX_ATTRIBS)
3772 {
3773 return error(GL_INVALID_VALUE);
3774 }
3775
3776 UNIMPLEMENTED(); // FIXME
3777 }
3778 catch(std::bad_alloc&)
3779 {
3780 return error(GL_OUT_OF_MEMORY);
3781 }
3782}
3783
3784void __stdcall glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
3785{
3786 TRACE("GLuint index = %d, GLfloat x = %f, GLfloat y = %f", index, x, y);
3787
3788 try
3789 {
3790 if (index >= gl::MAX_VERTEX_ATTRIBS)
3791 {
3792 return error(GL_INVALID_VALUE);
3793 }
3794
3795 UNIMPLEMENTED(); // FIXME
3796 }
3797 catch(std::bad_alloc&)
3798 {
3799 return error(GL_OUT_OF_MEMORY);
3800 }
3801}
3802
3803void __stdcall glVertexAttrib2fv(GLuint index, const GLfloat* values)
3804{
3805 TRACE("GLuint index = %d, const GLfloat* values = 0x%0.8p", index, values);
3806
3807 try
3808 {
3809 if (index >= gl::MAX_VERTEX_ATTRIBS)
3810 {
3811 return error(GL_INVALID_VALUE);
3812 }
3813
3814 UNIMPLEMENTED(); // FIXME
3815 }
3816 catch(std::bad_alloc&)
3817 {
3818 return error(GL_OUT_OF_MEMORY);
3819 }
3820}
3821
3822void __stdcall glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
3823{
3824 TRACE("GLuint index = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f", index, x, y, z);
3825
3826 try
3827 {
3828 if (index >= gl::MAX_VERTEX_ATTRIBS)
3829 {
3830 return error(GL_INVALID_VALUE);
3831 }
3832
3833 UNIMPLEMENTED(); // FIXME
3834 }
3835 catch(std::bad_alloc&)
3836 {
3837 return error(GL_OUT_OF_MEMORY);
3838 }
3839}
3840
3841void __stdcall glVertexAttrib3fv(GLuint index, const GLfloat* values)
3842{
3843 TRACE("GLuint index = %d, const GLfloat* values = 0x%0.8p", index, values);
3844
3845 try
3846 {
3847 if (index >= gl::MAX_VERTEX_ATTRIBS)
3848 {
3849 return error(GL_INVALID_VALUE);
3850 }
3851
3852 UNIMPLEMENTED(); // FIXME
3853 }
3854 catch(std::bad_alloc&)
3855 {
3856 return error(GL_OUT_OF_MEMORY);
3857 }
3858}
3859
3860void __stdcall glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
3861{
3862 TRACE("GLuint index = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f, GLfloat w = %f", index, x, y, z, w);
3863
3864 try
3865 {
3866 if (index >= gl::MAX_VERTEX_ATTRIBS)
3867 {
3868 return error(GL_INVALID_VALUE);
3869 }
3870
3871 UNIMPLEMENTED(); // FIXME
3872 }
3873 catch(std::bad_alloc&)
3874 {
3875 return error(GL_OUT_OF_MEMORY);
3876 }
3877}
3878
3879void __stdcall glVertexAttrib4fv(GLuint index, const GLfloat* values)
3880{
3881 TRACE("GLuint index = %d, const GLfloat* values = 0x%0.8p", index, values);
3882
3883 try
3884 {
3885 if (index >= gl::MAX_VERTEX_ATTRIBS)
3886 {
3887 return error(GL_INVALID_VALUE);
3888 }
3889
3890 UNIMPLEMENTED(); // FIXME
3891 }
3892 catch(std::bad_alloc&)
3893 {
3894 return error(GL_OUT_OF_MEMORY);
3895 }
3896}
3897
3898void __stdcall glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
3899{
3900 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);
3901
3902 try
3903 {
3904 if (index >= gl::MAX_VERTEX_ATTRIBS)
3905 {
3906 return error(GL_INVALID_VALUE);
3907 }
3908
3909 if (size < 1 || size > 4)
3910 {
3911 return error(GL_INVALID_VALUE);
3912 }
3913
3914 switch (type)
3915 {
3916 case GL_BYTE:
3917 case GL_UNSIGNED_BYTE:
3918 case GL_SHORT:
3919 case GL_UNSIGNED_SHORT:
3920 case GL_FIXED:
3921 case GL_FLOAT:
3922 break;
3923 default:
3924 return error(GL_INVALID_ENUM);
3925 }
3926
3927 if (stride < 0)
3928 {
3929 return error(GL_INVALID_VALUE);
3930 }
3931
3932 gl::Context *context = gl::getContext();
3933
3934 if (context)
3935 {
daniel@transgaming.com0f7aaf52010-03-11 19:41:38 +0000[diff] [blame]3936 context->vertexAttribute[index].mBoundBuffer = context->arrayBuffer;
3937 context->vertexAttribute[index].mSize = size;
3938 context->vertexAttribute[index].mType = type;
3939 context->vertexAttribute[index].mNormalized = normalized;
3940 context->vertexAttribute[index].mStride = stride;
3941 context->vertexAttribute[index].mPointer = ptr;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000[diff] [blame]3942 }
3943 }
3944 catch(std::bad_alloc&)
3945 {
3946 return error(GL_OUT_OF_MEMORY);
3947 }
3948}
3949
3950void __stdcall glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
3951{
3952 TRACE("GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d", x, y, width, height);
3953
3954 try
3955 {
3956 if (width < 0 || height < 0)
3957 {
3958 return error(GL_INVALID_VALUE);
3959 }
3960
3961 gl::Context *context = gl::getContext();
3962
3963 if (context)
3964 {
3965 context->viewportX = x;
3966 context->viewportY = y;
3967 context->viewportWidth = width;
3968 context->viewportHeight = height;
3969 }
3970 }
3971 catch(std::bad_alloc&)
3972 {
3973 return error(GL_OUT_OF_MEMORY);
3974 }
3975}
3976
3977void __stdcall glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels)
3978{
3979 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",
3980 target, level, internalformat, width, height, depth, border, format, type, pixels);
3981
3982 try
3983 {
3984 UNIMPLEMENTED(); // FIXME
3985 }
3986 catch(std::bad_alloc&)
3987 {
3988 return error(GL_OUT_OF_MEMORY);
3989 }
3990}
3991}