Implement a Radiance prototype.

Bug 18591036

Change-Id: Ic9b58dd38073b32a8507842d5da8af3d8b260f43
Reviewed-on: https://swiftshader-review.googlesource.com/1325
Reviewed-by: Nicolas Capens <nicolascapens@google.com>
Tested-by: Nicolas Capens <nicolascapens@google.com>

diff --git a/src/Main/FrameBufferWin.cpp b/src/Main/FrameBufferWin.cpp
index 19ffb68..928aa55 100644 (file)
--- a/src/Main/FrameBufferWin.cpp
+++ b/src/Main/FrameBufferWin.cpp
@@ -47,32 +47,32 @@ namespace sw
                }\r
        }\r
 }\r
-
-#include "FrameBufferDD.hpp"
-#include "FrameBufferGDI.hpp"
-#include "Common/Configurator.hpp"
-
-extern "C"
-{
-       sw::FrameBufferWin *createFrameBufferWin(HWND windowHandle, int width, int height, bool fullscreen, bool topLeftOrigin)
-       {
-               sw::Configurator ini("SwiftShader.ini");
-               int api = ini.getInteger("Testing", "FrameBufferAPI", 0);
-
-               if(api == 0 && topLeftOrigin)
-               {
-                       return new sw::FrameBufferDD(windowHandle, width, height, fullscreen, topLeftOrigin);
-               }
-               else
-               {
-                       return new sw::FrameBufferGDI(windowHandle, width, height, fullscreen, topLeftOrigin);
-               }
-
-               return 0;
-       }
-
-       sw::FrameBuffer *createFrameBuffer(HDC display, HWND window, int width, int height)
-       {
-               return createFrameBufferWin(window, width, height, false, false);
-       }
-}
+\r
+#include "FrameBufferDD.hpp"\r
+#include "FrameBufferGDI.hpp"\r
+#include "Common/Configurator.hpp"\r
+\r
+extern "C"\r
+{\r
+       sw::FrameBufferWin *createFrameBufferWin(HWND windowHandle, int width, int height, bool fullscreen, bool topLeftOrigin)\r
+       {\r
+               sw::Configurator ini("SwiftShader.ini");\r
+               int api = ini.getInteger("Testing", "FrameBufferAPI", 0);\r
+\r
+               if(api == 0 && topLeftOrigin)\r
+               {\r
+                       return new sw::FrameBufferDD(windowHandle, width, height, fullscreen, topLeftOrigin);\r
+               }\r
+               else\r
+               {\r
+                       return new sw::FrameBufferGDI(windowHandle, width, height, fullscreen, topLeftOrigin);\r
+               }\r
+\r
+               return 0;\r
+       }\r
+\r
+       sw::FrameBuffer *createFrameBuffer(HDC display, HWND window, int width, int height)\r
+       {\r
+               return createFrameBufferWin(window, width, height, false, false);\r
+       }\r
+}\r

diff --git a/src/Radiance/compiler/OutputASM.cpp b/src/Radiance/compiler/OutputASM.cpp
index 1bcfc94..adc8529 100644 (file)
--- a/src/Radiance/compiler/OutputASM.cpp
+++ b/src/Radiance/compiler/OutputASM.cpp
@@ -99,7 +99,7 @@ namespace sh
                this->registerIndex = registerIndex;\r
        }\r
 \r
-       OutputASM::OutputASM(TParseContext &context, rad::Shader *shaderObject) : TIntermTraverser(true, true, true), mContext(context), shaderObject(shaderObject)\r
+       OutputASM::OutputASM(TParseContext &context, es2::Shader *shaderObject) : TIntermTraverser(true, true, true), mContext(context), shaderObject(shaderObject)\r
        {\r
                shader = 0;\r
                pixelShader = 0;\r
@@ -2044,10 +2044,10 @@ namespace sh
                {\r
                        const TType &type = varying->getType();\r
                        const char *name = varying->getAsSymbolNode()->getSymbol().c_str();\r
-                       rad::VaryingList &activeVaryings = shaderObject->varyings;\r
+                       es2::VaryingList &activeVaryings = shaderObject->varyings;\r
                        \r
                        // Check if this varying has been declared before without having a register assigned\r
-                       for(rad::VaryingList::iterator v = activeVaryings.begin(); v != activeVaryings.end(); v++)\r
+                       for(es2::VaryingList::iterator v = activeVaryings.begin(); v != activeVaryings.end(); v++)\r
                        {\r
                                if(v->name == name)\r
                                {\r
@@ -2061,7 +2061,7 @@ namespace sh
                                }\r
                        }\r
                        \r
-                       activeVaryings.push_back(rad::Varying(glVariableType(type), name, varying->getArraySize(), reg, 0));\r
+                       activeVaryings.push_back(es2::Varying(glVariableType(type), name, varying->getArraySize(), reg, 0));\r
                }\r
        }\r
 \r

diff --git a/src/Radiance/compiler/OutputASM.h b/src/Radiance/compiler/OutputASM.h
index d9fb981..0252421 100644 (file)
--- a/src/Radiance/compiler/OutputASM.h
+++ b/src/Radiance/compiler/OutputASM.h
@@ -24,7 +24,7 @@
 #include <set>\r
 #include <map>\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
        class Shader;\r
 }\r
@@ -81,7 +81,7 @@ namespace sh
        class OutputASM : public TIntermTraverser\r
        {\r
        public:\r
-               explicit OutputASM(TParseContext &context, rad::Shader *shaderObject);\r
+               explicit OutputASM(TParseContext &context, es2::Shader *shaderObject);\r
                ~OutputASM();\r
 \r
                void output();\r
@@ -145,7 +145,7 @@ namespace sh
                static unsigned int loopCount(TIntermLoop *node);\r
                static bool isSamplerRegister(TIntermTyped *operand);\r
 \r
-               rad::Shader *const shaderObject;\r
+               es2::Shader *const shaderObject;\r
                sw::Shader *shader;\r
                sw::PixelShader *pixelShader;\r
                sw::VertexShader *vertexShader;\r

diff --git a/src/Radiance/compiler/TranslatorASM.cpp b/src/Radiance/compiler/TranslatorASM.cpp
index b518a6c..8749900 100644 (file)
--- a/src/Radiance/compiler/TranslatorASM.cpp
+++ b/src/Radiance/compiler/TranslatorASM.cpp
@@ -13,7 +13,7 @@
 \r
 #include "InitializeParseContext.h"\r
 \r
-TranslatorASM::TranslatorASM(rad::Shader *shaderObject, ShShaderType type, ShShaderSpec spec) : TCompiler(type, spec), shaderObject(shaderObject)\r
+TranslatorASM::TranslatorASM(es2::Shader *shaderObject, ShShaderType type, ShShaderSpec spec) : TCompiler(type, spec), shaderObject(shaderObject)\r
 {\r
 }\r
 \r

diff --git a/src/Radiance/compiler/TranslatorASM.h b/src/Radiance/compiler/TranslatorASM.h
index 12807cc..0b824a7 100644 (file)
--- a/src/Radiance/compiler/TranslatorASM.h
+++ b/src/Radiance/compiler/TranslatorASM.h
@@ -25,13 +25,13 @@ namespace rad
 class TranslatorASM : public TCompiler\r
 {\r
 public:\r
-    TranslatorASM(rad::Shader *shaderObject, ShShaderType type, ShShaderSpec spec);\r
+    TranslatorASM(es2::Shader *shaderObject, ShShaderType type, ShShaderSpec spec);\r
 \r
 protected:\r
     virtual bool translate(TIntermNode* root);\r
 \r
 private:\r
-       rad::Shader *const shaderObject;\r
+       es2::Shader *const shaderObject;\r
 };\r
 \r
 #endif  // COMPILER_TRANSLATORASM_H_\r

diff --git a/src/Radiance/include/RAD/rad.h b/src/Radiance/include/RAD/rad.h
index 44e6ff4..2557c34 100644 (file)
--- a/src/Radiance/include/RAD/rad.h
+++ b/src/Radiance/include/RAD/rad.h
@@ -137,6 +137,7 @@ typedef enum {
 } RADtextureTarget;\r
 \r
 typedef enum {\r
+       RAD_FORMAT_NONE = 0x000,\r
     RAD_RGBA8 = 0x8058,\r
     RAD_DEPTH24_STENCIL8 = 0x88F0,\r
 } RADinternalFormat;\r
@@ -321,6 +322,7 @@ typedef enum {
 } RADpolygonMode;\r
 \r
 typedef enum {\r
+       RAD_POLYGON_OFFSET_NONE = 0x0000,\r
     RAD_POLYGON_OFFSET_POINT = 0x0001,\r
     RAD_POLYGON_OFFSET_LINE = 0x0002,\r
     RAD_POLYGON_OFFSET_FILL = 0x0004,\r

diff --git a/src/Radiance/libEGL/Display.cpp b/src/Radiance/libEGL/Display.cpp
index bff3741..657a90e 100644 (file)
--- a/src/Radiance/libEGL/Display.cpp
+++ b/src/Radiance/libEGL/Display.cpp
@@ -390,9 +390,9 @@ EGLContext Display::createContext(EGLConfig configHandle, const egl::Context *sh
 \r
        if(clientVersion == 2 && config->mRenderableType & EGL_OPENGL_ES2_BIT)\r
        {\r
-               if(rad::createContext != 0)\r
+               if(es2::createContext != 0)\r
                {\r
-                       context = rad::createContext(config, shareContext);\r
+                       context = es2::createContext(config, shareContext);\r
                }\r
        }\r
        else\r

diff --git a/src/Radiance/libEGL/Display.h b/src/Radiance/libEGL/Display.h
index ff1d7c8..ef3b1a1 100644 (file)
--- a/src/Radiance/libEGL/Display.h
+++ b/src/Radiance/libEGL/Display.h
@@ -58,7 +58,7 @@ namespace egl
                EGLNativeDisplayType getNativeDisplay() const;\r
                const char *getExtensionString() const;\r
 \r
-       private:\r
+       public:\r
                Display(EGLNativeDisplayType displayId);\r
 \r
                DisplayMode getDisplayMode() const;\r

diff --git a/src/Radiance/libEGL/Surface.cpp b/src/Radiance/libEGL/Surface.cpp
index 5703dfe..0af9b13 100644 (file)
--- a/src/Radiance/libEGL/Surface.cpp
+++ b/src/Radiance/libEGL/Surface.cpp
@@ -132,7 +132,7 @@ bool Surface::reset(int backBufferWidth, int backBufferHeight)
 \r
     if(mWindow)\r
     {\r
-               frameBuffer = rad::createFrameBuffer(mDisplay->getNativeDisplay(), mWindow, backBufferWidth, backBufferHeight);\r
+               frameBuffer = es2::createFrameBuffer(mDisplay->getNativeDisplay(), mWindow, backBufferWidth, backBufferHeight);\r
 \r
                if(!frameBuffer)\r
                {\r
@@ -142,7 +142,7 @@ bool Surface::reset(int backBufferWidth, int backBufferHeight)
                }\r
     }\r
 \r
-       backBuffer = rad::createBackBuffer(backBufferWidth, backBufferHeight, mConfig);\r
+       backBuffer = es2::createBackBuffer(backBufferWidth, backBufferHeight, mConfig);\r
 \r
     if(!backBuffer)\r
     {\r
@@ -153,7 +153,7 @@ bool Surface::reset(int backBufferWidth, int backBufferHeight)
 \r
     if(mConfig->mDepthStencilFormat != sw::FORMAT_NULL)\r
     {\r
-        mDepthStencil = rad::createDepthStencil(backBufferWidth, backBufferHeight, mConfig->mDepthStencilFormat, 1, false);\r
+        mDepthStencil = es2::createDepthStencil(backBufferWidth, backBufferHeight, mConfig->mDepthStencilFormat, 1, false);\r
 \r
                if(!mDepthStencil)\r
                {\r

diff --git a/src/Radiance/libEGL/Surface.h b/src/Radiance/libEGL/Surface.h
index fe33be8..71d0cd3 100644 (file)
--- a/src/Radiance/libEGL/Surface.h
+++ b/src/Radiance/libEGL/Surface.h
@@ -61,7 +61,7 @@ public:
 \r
        bool checkForResize();   // Returns true if surface changed due to resize\r
 \r
-private:\r
+public:\r
     void release();\r
     bool reset();\r
 \r

diff --git a/src/Radiance/libEGL/main.cpp b/src/Radiance/libEGL/main.cpp
index 4c84130..a737aea 100644 (file)
--- a/src/Radiance/libEGL/main.cpp
+++ b/src/Radiance/libEGL/main.cpp
@@ -90,11 +90,11 @@ CONSTRUCTOR static bool eglAttachProcess()
        #endif\r
        \r
     libRAD = loadLibrary(libRAD_lib);\r
-    rad::createContext = (egl::Context *(*)(const egl::Config*, const egl::Context*))getProcAddress(libRAD, "glCreateContext");\r
+    es2::createContext = (egl::Context *(*)(const egl::Config*, const egl::Context*))getProcAddress(libRAD, "glCreateContext");\r
     rad::getProcAddress = (__eglMustCastToProperFunctionPointerType (RADAPIENTRY *)(const char*))getProcAddress(libRAD, "radGetProcAddress");\r
-       rad::createBackBuffer = (egl::Image *(*)(int, int, const egl::Config*))getProcAddress(libRAD, "createBackBuffer");\r
-       rad::createDepthStencil = (egl::Image *(*)(unsigned int, unsigned int, sw::Format, int, bool))getProcAddress(libRAD, "createDepthStencil");\r
-    rad::createFrameBuffer = (sw::FrameBuffer *(*)(EGLNativeDisplayType, EGLNativeWindowType, int, int))getProcAddress(libRAD, "createFrameBuffer");\r
+       es2::createBackBuffer = (egl::Image *(*)(int, int, const egl::Config*))getProcAddress(libRAD, "createBackBuffer");\r
+       es2::createDepthStencil = (egl::Image *(*)(unsigned int, unsigned int, sw::Format, int, bool))getProcAddress(libRAD, "createDepthStencil");\r
+    es2::createFrameBuffer = (sw::FrameBuffer *(*)(EGLNativeDisplayType, EGLNativeWindowType, int, int))getProcAddress(libRAD, "createFrameBuffer");\r
 \r
        return libRAD != 0;\r
 }\r
@@ -313,14 +313,18 @@ EGLContext clientGetCurrentDisplay()
 }\r
 }\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
        egl::Context *(*createContext)(const egl::Config *config, const egl::Context *shareContext) = 0;\r
-       __eglMustCastToProperFunctionPointerType (RADAPIENTRY *getProcAddress)(const char *procname) = 0;\r
 \r
        egl::Image *(*createBackBuffer)(int width, int height, const egl::Config *config) = 0;\r
        egl::Image *(*createDepthStencil)(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard) = 0;\r
        sw::FrameBuffer *(*createFrameBuffer)(EGLNativeDisplayType display, EGLNativeWindowType window, int width, int height) = 0;\r
 }\r
 \r
+namespace rad\r
+{\r
+       __eglMustCastToProperFunctionPointerType (RADAPIENTRY *getProcAddress)(const char *procname) = 0;\r
+}\r
+\r
 void *libRAD = 0;   // Handle to the libRAD module\r

diff --git a/src/Radiance/libEGL/main.h b/src/Radiance/libEGL/main.h
index 6fd4344..3b32f23 100644 (file)
--- a/src/Radiance/libEGL/main.h
+++ b/src/Radiance/libEGL/main.h
@@ -84,16 +84,20 @@ namespace sw
 }
 
 // libRAD dependencies
-namespace rad
+namespace es2
 {
        extern egl::Context *(*createContext)(const egl::Config *config, const egl::Context *shareContext);
-       extern __eglMustCastToProperFunctionPointerType (RADAPIENTRY *getProcAddress)(const char *procname);
 
        extern egl::Image *(*createBackBuffer)(int width, int height, const egl::Config *config);
        extern egl::Image *(*createDepthStencil)(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard);
        extern sw::FrameBuffer *(*createFrameBuffer)(EGLNativeDisplayType display, EGLNativeWindowType window, int width, int height);
 }
 
+namespace rad
+{
+       extern __eglMustCastToProperFunctionPointerType (RADAPIENTRY *getProcAddress)(const char *procname);
+}
+
 extern void *libRAD;    // Handle to the libRAD module
 
 #endif  // LIBEGL_MAIN_H_

diff --git a/src/Radiance/libRAD/Buffer.cpp b/src/Radiance/libRAD/Buffer.cpp
index 476b153..78411ac 100644 (file)
--- a/src/Radiance/libRAD/Buffer.cpp
+++ b/src/Radiance/libRAD/Buffer.cpp
@@ -19,7 +19,7 @@
 #include "VertexDataManager.h"
 #include "IndexDataManager.h"
 
-namespace rad
+namespace es2
 {
 
 Buffer::Buffer(GLuint id) : RefCountObject(id)

diff --git a/src/Radiance/libRAD/Buffer.h b/src/Radiance/libRAD/Buffer.h
index 44e4169..a303d66 100644 (file)
--- a/src/Radiance/libRAD/Buffer.h
+++ b/src/Radiance/libRAD/Buffer.h
@@ -25,7 +25,7 @@
 #include <cstddef>\r
 #include <vector>\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 class Buffer : public RefCountObject\r
 {\r
@@ -43,7 +43,7 @@ class Buffer : public RefCountObject
 \r
        sw::Resource *getResource();\r
 \r
-  private:\r
+  public:\r
     sw::Resource *mContents;\r
     size_t mSize;\r
     GLenum mUsage;\r

diff --git a/src/Radiance/libRAD/Context.cpp b/src/Radiance/libRAD/Context.cpp
index 0461129..cb12bae 100644 (file)
--- a/src/Radiance/libRAD/Context.cpp
+++ b/src/Radiance/libRAD/Context.cpp
@@ -9,7 +9,7 @@
 // or implied, including but not limited to any patent rights, are granted to you.\r
 //\r
 \r
-// Context.cpp: Implements the rad::Context class, managing all GL state and performing\r
+// Context.cpp: Implements the es2::Context class, managing all GL state and performing\r
 // rendering operations. It is the GLES2 specific implementation of EGLContext.\r
 \r
 #include "Context.h"\r
@@ -37,7 +37,7 @@
 #undef near\r
 #undef far\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 Device *Context::device = 0;\r
 \r
@@ -1157,7 +1157,8 @@ Buffer *Context::getElementArrayBuffer()
 \r
 Program *Context::getCurrentProgram()\r
 {\r
-    return mResourceManager->getProgram(mState.currentProgram);\r
+       return mState.program;\r
+    //return mResourceManager->getProgram(mState.currentProgram);\r
 }\r
 \r
 Texture2D *Context::getTexture2D()\r
@@ -1678,13 +1679,13 @@ bool Context::applyRenderTarget()
         return error(GL_INVALID_FRAMEBUFFER_OPERATION, false);\r
     }\r
 \r
-    egl::Image *renderTarget = framebuffer->getRenderTarget();\r
+    egl::Image *renderTarget = mState.colorBuffer;//framebuffer->getRenderTarget();\r
        device->setRenderTarget(renderTarget);\r
-       if(renderTarget) renderTarget->release();\r
+       //if(renderTarget) renderTarget->release();\r
 \r
-    egl::Image *depthStencil = framebuffer->getDepthStencil();\r
+    egl::Image *depthStencil = mState.depthBuffer;//framebuffer->getDepthStencil();\r
     device->setDepthStencilSurface(depthStencil);\r
-       if(depthStencil) depthStencil->release();\r
+       //if(depthStencil) depthStencil->release();\r
 \r
     Viewport viewport;\r
     float zNear = clamp01(mState.zNear);\r
@@ -2069,19 +2070,38 @@ void Context::applyTextures(sw::SamplerType samplerType)
 \r
 void Context::applyTexture(sw::SamplerType type, int index, Texture *baseTexture)\r
 {\r
-       Program *program = getCurrentProgram();\r
+       //Program *program = getCurrentProgram();\r
        int sampler = (type == sw::SAMPLER_PIXEL) ? index : 16 + index;\r
-       bool textureUsed = false;\r
+       bool textureUsed = true;\r
+\r
+       //if(type == sw::SAMPLER_PIXEL)\r
+       //{\r
+       //      textureUsed = program->getPixelShader()->usesSampler(index);\r
+       //}\r
+       //else if(type == sw::SAMPLER_VERTEX)\r
+       //{\r
+       //      textureUsed = program->getVertexShader()->usesSampler(index);\r
+       //}\r
+       //else UNREACHABLE();\r
+\r
+//     GLenum wrapS = baseTexture->getWrapS();\r
+//    GLenum wrapT = baseTexture->getWrapT();\r
+//    GLenum texFilter = baseTexture->getMinFilter();\r
+//    GLenum magFilter = baseTexture->getMagFilter();\r
+//     GLenum maxAnisotropy = baseTexture->getMaxAnisotropy();\r
+//\r
+//     device->setAddressingModeU(type, index, rad2sw::ConvertTextureWrap(wrapS));\r
+//    device->setAddressingModeV(type, index, rad2sw::ConvertTextureWrap(wrapT));\r
+//\r
+//     sw::FilterType minFilter;\r
+//     sw::MipmapType mipFilter;\r
+//    rad2sw::ConvertMinFilter(texFilter, &minFilter, &mipFilter, maxAnisotropy);\r
+////   ASSERT(minFilter == rad2sw::ConvertMagFilter(magFilter));\r
 \r
-       if(type == sw::SAMPLER_PIXEL)\r
-       {\r
-               textureUsed = program->getPixelShader()->usesSampler(index);\r
-       }\r
-       else if(type == sw::SAMPLER_VERTEX)\r
-       {\r
-               textureUsed = program->getVertexShader()->usesSampler(index);\r
-       }\r
-       else UNREACHABLE();\r
+       device->setTextureFilter(type, index, sw::FILTER_LINEAR);\r
+//     device->setTextureFilter(type, index, rad2sw::ConvertMagFilter(magFilter));\r
+       device->setMipmapFilter(type, index, sw::MIPMAP_NONE);\r
+       device->setMaxAnisotropy(type, index, 1.0f);   \r
 \r
        sw::Resource *resource = 0;\r
 \r
@@ -2457,7 +2477,7 @@ void Context::drawArrays(GLenum mode, GLint first, GLsizei count)
 \r
 void Context::drawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)\r
 {\r
-    if(!mState.currentProgram)\r
+    if(!mState.currentProgram && !mState.program)\r
     {\r
         return error(GL_INVALID_OPERATION);\r
     }\r
@@ -2500,7 +2520,7 @@ void Context::drawElements(GLenum mode, GLsizei count, GLenum type, const void *
     }\r
 \r
     applyShaders();\r
-    applyTextures();\r
+    //applyTextures();\r
 \r
     if(!getCurrentProgram()->validateSamplers(false))\r
     {\r
@@ -3020,7 +3040,7 @@ void Context::blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1
 \r
 void Context::bindTexImage(egl::Surface *surface)\r
 {\r
-       rad::Texture2D *textureObject = getTexture2D();\r
+       es2::Texture2D *textureObject = getTexture2D();\r
 \r
     if(textureObject)\r
     {\r
@@ -3051,14 +3071,14 @@ EGLenum Context::validateSharedImage(EGLenum target, GLuint name, GLuint texture
         return EGL_BAD_PARAMETER;\r
     }\r
        \r
-    if(textureLevel >= rad::IMPLEMENTATION_MAX_TEXTURE_LEVELS)\r
+    if(textureLevel >= es2::IMPLEMENTATION_MAX_TEXTURE_LEVELS)\r
     {\r
         return EGL_BAD_MATCH;\r
     }\r
 \r
     if(textureTarget != GL_NONE)\r
     {\r
-        rad::Texture *texture = getTexture(name);\r
+        es2::Texture *texture = getTexture(name);\r
 \r
         if(!texture || texture->getTarget() != textureTarget)\r
         {\r
@@ -3082,7 +3102,7 @@ EGLenum Context::validateSharedImage(EGLenum target, GLuint name, GLuint texture
     }\r
     else if(target == EGL_GL_RENDERBUFFER_KHR)\r
     {\r
-        rad::Renderbuffer *renderbuffer = getRenderbuffer(name);\r
+        es2::Renderbuffer *renderbuffer = getRenderbuffer(name);\r
 \r
         if(!renderbuffer)\r
         {\r
@@ -3116,13 +3136,13 @@ egl::Image *Context::createSharedImage(EGLenum target, GLuint name, GLuint textu
 \r
     if(textureTarget != GL_NONE)\r
     {\r
-        rad::Texture *texture = getTexture(name);\r
+        es2::Texture *texture = getTexture(name);\r
 \r
         return texture->createSharedImage(textureTarget, textureLevel);\r
     }\r
     else if(target == EGL_GL_RENDERBUFFER_KHR)\r
     {\r
-        rad::Renderbuffer *renderbuffer = getRenderbuffer(name);\r
+        es2::Renderbuffer *renderbuffer = getRenderbuffer(name);\r
 \r
         return renderbuffer->createSharedImage();\r
     }\r
@@ -3136,7 +3156,7 @@ Device *Context::getDevice()
        if(!device)\r
        {\r
                sw::Context *context = new sw::Context();\r
-               device = new rad::Device(context);\r
+               device = new es2::Device(context);\r
        }\r
 \r
        return device;\r
@@ -3147,8 +3167,8 @@ Device *Context::getDevice()
 // Exported functions for use by EGL\r
 extern "C"\r
 {\r
-       rad::Context *glCreateContext(const egl::Config *config, const rad::Context *shareContext)\r
+       es2::Context *glCreateContext(const egl::Config *config, const es2::Context *shareContext)\r
        {\r
-               return new rad::Context(config, shareContext);\r
+               return new es2::Context(config, shareContext);\r
        }\r
 }\r

diff --git a/src/Radiance/libRAD/Context.h b/src/Radiance/libRAD/Context.h
index 3f18600..52b8715 100644 (file)
--- a/src/Radiance/libRAD/Context.h
+++ b/src/Radiance/libRAD/Context.h
@@ -38,7 +38,7 @@ class Surface;
 class Config;\r
 }\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 struct TranslatedAttribute;\r
 struct TranslatedIndexData;\r
@@ -228,6 +228,10 @@ struct State
     GLuint drawFramebuffer;\r
     BindingPointer<Renderbuffer> renderbuffer;\r
     GLuint currentProgram;\r
+       \r
+       Program *program;\r
+       egl::Image *colorBuffer;\r
+       egl::Image *depthBuffer;\r
 \r
     VertexAttribute vertexAttribute[MAX_VERTEX_ATTRIBS];\r
     BindingPointer<Texture> samplerTexture[TEXTURE_TYPE_COUNT][MAX_COMBINED_TEXTURE_IMAGE_UNITS];\r
@@ -426,7 +430,7 @@ public:
 \r
        Device *getDevice();\r
 \r
-private:\r
+public:\r
        virtual ~Context();\r
 \r
     bool applyRenderTarget();\r

diff --git a/src/Radiance/libRAD/Device.cpp b/src/Radiance/libRAD/Device.cpp
index 4cfc90c..2ff7774 100644 (file)
--- a/src/Radiance/libRAD/Device.cpp
+++ b/src/Radiance/libRAD/Device.cpp
@@ -27,7 +27,7 @@
 \r
 bool localShaderConstants = false;\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
        using namespace sw;\r
 \r

diff --git a/src/Radiance/libRAD/Device.hpp b/src/Radiance/libRAD/Device.hpp
index ef6f69b..92a3a11 100644 (file)
--- a/src/Radiance/libRAD/Device.hpp
+++ b/src/Radiance/libRAD/Device.hpp
@@ -19,7 +19,7 @@ namespace egl
        class Image;\r
 }\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
        class Texture;\r
        class Image;\r

diff --git a/src/Radiance/libRAD/Fence.cpp b/src/Radiance/libRAD/Fence.cpp
index f468244..e79077b 100644 (file)
--- a/src/Radiance/libRAD/Fence.cpp
+++ b/src/Radiance/libRAD/Fence.cpp
@@ -16,7 +16,7 @@
 #include "main.h"\r
 #include "Common/Thread.hpp"\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 \r
 Fence::Fence()\r

diff --git a/src/Radiance/libRAD/Fence.h b/src/Radiance/libRAD/Fence.h
index 7359688..a2b5bab 100644 (file)
--- a/src/Radiance/libRAD/Fence.h
+++ b/src/Radiance/libRAD/Fence.h
@@ -17,7 +17,7 @@
 #define GL_APICALL\r
 #include <GLES2/gl2.h>\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 \r
 class Fence\r

diff --git a/src/Radiance/libRAD/Framebuffer.cpp b/src/Radiance/libRAD/Framebuffer.cpp
index dad609a..c98973c 100644 (file)
--- a/src/Radiance/libRAD/Framebuffer.cpp
+++ b/src/Radiance/libRAD/Framebuffer.cpp
@@ -19,7 +19,7 @@
 #include "Texture.h"
 #include "utilities.h"
 
-namespace rad
+namespace es2
 {
 
 Framebuffer::Framebuffer()
@@ -245,7 +245,7 @@ GLenum Framebuffer::completeness(int &width, int &height, int &samples)
 
                if(mColorbufferType == GL_RENDERBUFFER)
                {
-                       if(!rad::IsColorRenderable(colorbuffer->getFormat()))
+                       if(!es2::IsColorRenderable(colorbuffer->getFormat()))
                        {
                                return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
                        }
@@ -262,7 +262,7 @@ GLenum Framebuffer::completeness(int &width, int &height, int &samples)
                                return GL_FRAMEBUFFER_UNSUPPORTED;
                        }
 
-                       if(rad::IsDepthTexture(format) || rad::IsStencilTexture(format))
+                       if(es2::IsDepthTexture(format) || es2::IsStencilTexture(format))
                        {
                                return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
                        }
@@ -297,14 +297,14 @@ GLenum Framebuffer::completeness(int &width, int &height, int &samples)
 
                if(mDepthbufferType == GL_RENDERBUFFER)
                {
-                       if(!rad::IsDepthRenderable(depthbuffer->getFormat()))
+                       if(!es2::IsDepthRenderable(depthbuffer->getFormat()))
                        {
                                return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
                        }
                }
                else if(IsTextureTarget(mDepthbufferType))
                {
-                       if(!rad::IsDepthTexture(depthbuffer->getFormat()))
+                       if(!es2::IsDepthTexture(depthbuffer->getFormat()))
                        {
                                return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
                        }
@@ -347,7 +347,7 @@ GLenum Framebuffer::completeness(int &width, int &height, int &samples)
 
                if(mStencilbufferType == GL_RENDERBUFFER)
                {
-                       if(!rad::IsStencilRenderable(stencilbuffer->getFormat()))
+                       if(!es2::IsStencilRenderable(stencilbuffer->getFormat()))
                        {
                                return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
                        }
@@ -356,7 +356,7 @@ GLenum Framebuffer::completeness(int &width, int &height, int &samples)
                {
                        GLenum internalformat = stencilbuffer->getFormat();
 
-                       if(!rad::IsStencilTexture(internalformat))
+                       if(!es2::IsStencilTexture(internalformat))
                        {
                                return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
                        }

diff --git a/src/Radiance/libRAD/Framebuffer.h b/src/Radiance/libRAD/Framebuffer.h
index db8688f..df29240 100644 (file)
--- a/src/Radiance/libRAD/Framebuffer.h
+++ b/src/Radiance/libRAD/Framebuffer.h
@@ -21,7 +21,7 @@
 #define GL_APICALL\r
 #include <GLES2/gl2.h>\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 class Renderbuffer;\r
 class Colorbuffer;\r

diff --git a/src/Radiance/libRAD/HandleAllocator.cpp b/src/Radiance/libRAD/HandleAllocator.cpp
index fc81c48..85813f2 100644 (file)
--- a/src/Radiance/libRAD/HandleAllocator.cpp
+++ b/src/Radiance/libRAD/HandleAllocator.cpp
@@ -16,7 +16,7 @@
 
 #include "main.h"
 
-namespace rad
+namespace es2
 {
 
 HandleAllocator::HandleAllocator() : mBaseValue(1), mNextValue(1)

diff --git a/src/Radiance/libRAD/HandleAllocator.h b/src/Radiance/libRAD/HandleAllocator.h
index 3d96d5b..8079d12 100644 (file)
--- a/src/Radiance/libRAD/HandleAllocator.h
+++ b/src/Radiance/libRAD/HandleAllocator.h
@@ -20,7 +20,7 @@
 \r
 #include <vector>\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 \r
 class HandleAllocator\r

diff --git a/src/Radiance/libRAD/Image.cpp b/src/Radiance/libRAD/Image.cpp
index 9b62b4b..86d2342 100644 (file)
--- a/src/Radiance/libRAD/Image.cpp
+++ b/src/Radiance/libRAD/Image.cpp
@@ -18,7 +18,7 @@
 
 #include <GLES2/gl2ext.h>
 
-namespace rad
+namespace es2
 {
        static sw::Resource *getParentResource(Texture *texture)
        {

diff --git a/src/Radiance/libRAD/Image.hpp b/src/Radiance/libRAD/Image.hpp
index a3c4a67..70baa6d 100644 (file)
--- a/src/Radiance/libRAD/Image.hpp
+++ b/src/Radiance/libRAD/Image.hpp
@@ -18,7 +18,7 @@
 #define GL_APICALL
 #include <GLES2/gl2.h>
 
-namespace rad
+namespace es2
 {
        class Texture;
 

diff --git a/src/Radiance/libRAD/IndexDataManager.cpp b/src/Radiance/libRAD/IndexDataManager.cpp
index 3ab88c0..a2b468c 100644 (file)
--- a/src/Radiance/libRAD/IndexDataManager.cpp
+++ b/src/Radiance/libRAD/IndexDataManager.cpp
@@ -25,7 +25,7 @@ namespace
     enum { INITIAL_INDEX_BUFFER_SIZE = 4096 * sizeof(GLuint) };\r
 }\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 \r
 IndexDataManager::IndexDataManager()\r

diff --git a/src/Radiance/libRAD/IndexDataManager.h b/src/Radiance/libRAD/IndexDataManager.h
index c7e5f27..0bab66e 100644 (file)
--- a/src/Radiance/libRAD/IndexDataManager.h
+++ b/src/Radiance/libRAD/IndexDataManager.h
@@ -20,7 +20,7 @@
 #define GL_APICALL\r
 #include <GLES2/gl2.h>\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 \r
 struct TranslatedIndexData\r

diff --git a/src/Radiance/libRAD/Program.cpp b/src/Radiance/libRAD/Program.cpp
index 84faf19..03042fa 100644 (file)
--- a/src/Radiance/libRAD/Program.cpp
+++ b/src/Radiance/libRAD/Program.cpp
@@ -24,7 +24,7 @@
 #include <string>\r
 #include <stdlib.h>\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
        unsigned int Program::currentSerial = 1;\r
 \r

diff --git a/src/Radiance/libRAD/Program.h b/src/Radiance/libRAD/Program.h
index ba47c34..dd87fb2 100644 (file)
--- a/src/Radiance/libRAD/Program.h
+++ b/src/Radiance/libRAD/Program.h
@@ -24,7 +24,7 @@
 #include <vector>\r
 #include <set>\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
        class Device;\r
        class ResourceManager;\r
@@ -163,7 +163,7 @@ namespace rad
                static unsigned int issueSerial();\r
 \r
        private:\r
-               rad::Device *device;\r
+               es2::Device *device;\r
                FragmentShader *fragmentShader;\r
                VertexShader *vertexShader;\r
 \r

diff --git a/src/Radiance/libRAD/Query.cpp b/src/Radiance/libRAD/Query.cpp
index d91bfa6..97c4efd 100644 (file)
--- a/src/Radiance/libRAD/Query.cpp
+++ b/src/Radiance/libRAD/Query.cpp
@@ -9,14 +9,14 @@
 // or implied, including but not limited to any patent rights, are granted to you.\r
 //\r
 \r
-// Query.cpp: Implements the rad::Query class\r
+// Query.cpp: Implements the es2::Query class\r
 \r
 #include "Query.h"\r
 \r
 #include "main.h"\r
 #include "Common/Thread.hpp"\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 \r
 Query::Query(GLuint id, GLenum type) : RefCountObject(id)\r

diff --git a/src/Radiance/libRAD/Query.h b/src/Radiance/libRAD/Query.h
index bc95dda..6811939 100644 (file)
--- a/src/Radiance/libRAD/Query.h
+++ b/src/Radiance/libRAD/Query.h
@@ -9,7 +9,7 @@
 // or implied, including but not limited to any patent rights, are granted to you.\r
 //\r
 \r
-// Query.h: Defines the rad::Query class\r
+// Query.h: Defines the es2::Query class\r
 \r
 #ifndef LIBGLESV2_QUERY_H_\r
 #define LIBGLESV2_QUERY_H_\r
@@ -20,7 +20,7 @@
 #define GL_APICALL\r
 #include <GLES2/gl2.h>\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 \r
 class Query : public RefCountObject\r

diff --git a/src/Radiance/libRAD/RefCountObject.cpp b/src/Radiance/libRAD/RefCountObject.cpp
index b69b0c7..3dfbf03 100644 (file)
--- a/src/Radiance/libRAD/RefCountObject.cpp
+++ b/src/Radiance/libRAD/RefCountObject.cpp
@@ -18,7 +18,7 @@
 
 #include "Common/Thread.hpp"
 
-namespace rad
+namespace es2
 {
 
 RefCountObject::RefCountObject(GLuint id)

diff --git a/src/Radiance/libRAD/RefCountObject.h b/src/Radiance/libRAD/RefCountObject.h
index da19dda..25eae02 100644 (file)
--- a/src/Radiance/libRAD/RefCountObject.h
+++ b/src/Radiance/libRAD/RefCountObject.h
@@ -24,7 +24,7 @@
 
 #include <cstddef>
 
-namespace rad
+namespace es2
 {
 
 class RefCountObject

diff --git a/src/Radiance/libRAD/Renderbuffer.cpp b/src/Radiance/libRAD/Renderbuffer.cpp
index 06c023d..5496158 100644 (file)
--- a/src/Radiance/libRAD/Renderbuffer.cpp
+++ b/src/Radiance/libRAD/Renderbuffer.cpp
@@ -19,7 +19,7 @@
 #include "Texture.h"
 #include "utilities.h"
 
-namespace rad
+namespace es2
 {
 RenderbufferInterface::RenderbufferInterface()
 {

diff --git a/src/Radiance/libRAD/Renderbuffer.h b/src/Radiance/libRAD/Renderbuffer.h
index c3cb53c..53bae78 100644 (file)
--- a/src/Radiance/libRAD/Renderbuffer.h
+++ b/src/Radiance/libRAD/Renderbuffer.h
@@ -23,7 +23,7 @@
 #define GL_APICALL\r
 #include <GLES2/gl2.h>\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 class Texture2D;\r
 class TextureCubeMap;\r

diff --git a/src/Radiance/libRAD/ResourceManager.cpp b/src/Radiance/libRAD/ResourceManager.cpp
index b0da866..e3be9bc 100644 (file)
--- a/src/Radiance/libRAD/ResourceManager.cpp
+++ b/src/Radiance/libRAD/ResourceManager.cpp
@@ -20,7 +20,7 @@
 #include "Shader.h"
 #include "Texture.h"
 
-namespace rad
+namespace es2
 {
 ResourceManager::ResourceManager()
 {

diff --git a/src/Radiance/libRAD/ResourceManager.h b/src/Radiance/libRAD/ResourceManager.h
index ffa57f1..699944f 100644 (file)
--- a/src/Radiance/libRAD/ResourceManager.h
+++ b/src/Radiance/libRAD/ResourceManager.h
@@ -22,7 +22,7 @@
 \r
 #include <map>\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 class Buffer;\r
 class Shader;\r

diff --git a/src/Radiance/libRAD/Shader.cpp b/src/Radiance/libRAD/Shader.cpp
index fd170d1..335427a 100644 (file)
--- a/src/Radiance/libRAD/Shader.cpp
+++ b/src/Radiance/libRAD/Shader.cpp
@@ -22,7 +22,7 @@
 
 #include <string>
 
-namespace rad
+namespace es2
 {
 bool Shader::compilerInitialized = false;
 

diff --git a/src/Radiance/libRAD/Shader.h b/src/Radiance/libRAD/Shader.h
index 409cbd7..009d0dd 100644 (file)
--- a/src/Radiance/libRAD/Shader.h
+++ b/src/Radiance/libRAD/Shader.h
@@ -32,7 +32,7 @@ namespace sh
        class OutputASM;\r
 }\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 struct Varying\r
 {\r
@@ -46,7 +46,7 @@ struct Varying
                return arraySize >= 1;\r
        }\r
 \r
-       int size() const   // Unify with rad::Uniform?\r
+       int size() const   // Unify with es2::Uniform?\r
        {\r
                return arraySize > 0 ? arraySize : 1;\r
        }\r

diff --git a/src/Radiance/libRAD/Texture.cpp b/src/Radiance/libRAD/Texture.cpp
index 2804978..a318dbd 100644 (file)
--- a/src/Radiance/libRAD/Texture.cpp
+++ b/src/Radiance/libRAD/Texture.cpp
@@ -25,7 +25,7 @@
 \r
 #include <algorithm>\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 \r
 Texture::Texture(GLuint id) : RefCountObject(id)\r
@@ -376,7 +376,7 @@ sw::Format Texture2D::getInternalFormat(GLenum target, GLint level) const
 \r
 int Texture2D::getLevelCount() const\r
 {\r
-       ASSERT(isSamplerComplete());\r
+       //ASSERT(isSamplerComplete());\r
        int levels = 0;\r
 \r
        while(levels < MIPMAP_LEVELS && image[levels])\r
@@ -1156,17 +1156,17 @@ void TextureExternal::setImage(Image *sharedImage)
 // Exported functions for use by EGL\r
 extern "C"\r
 {\r
-       rad::Image *createBackBuffer(int width, int height, const egl::Config *config)\r
+       es2::Image *createBackBuffer(int width, int height, const egl::Config *config)\r
        {\r
                if(config)\r
                {\r
-                       return new rad::Image(0, width, height, config->mAlphaSize ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE);\r
+                       return new es2::Image(0, width, height, config->mAlphaSize ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE);\r
                }\r
 \r
                return 0;\r
        }\r
 \r
-       rad::Image *createDepthStencil(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard)\r
+       es2::Image *createDepthStencil(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard)\r
        {\r
                if(width == 0 || height == 0 || height > OUTLINE_RESOLUTION)\r
                {\r
@@ -1199,7 +1199,7 @@ extern "C"
                        UNREACHABLE();\r
                }\r
 \r
-               rad::Image *surface = new rad::Image(0, width, height, format, multiSampleDepth, lockable, true);\r
+               es2::Image *surface = new es2::Image(0, width, height, format, multiSampleDepth, lockable, true);\r
 \r
                if(!surface)\r
                {\r

diff --git a/src/Radiance/libRAD/Texture.h b/src/Radiance/libRAD/Texture.h
index 8411da7..2d1e2fe 100644 (file)
--- a/src/Radiance/libRAD/Texture.h
+++ b/src/Radiance/libRAD/Texture.h
@@ -33,7 +33,7 @@ class Surface;
 class Config;\r
 }\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 class Framebuffer;\r
 \r

diff --git a/src/Radiance/libRAD/VertexDataManager.cpp b/src/Radiance/libRAD/VertexDataManager.cpp
index 47479fe..37875c0 100644 (file)
--- a/src/Radiance/libRAD/VertexDataManager.cpp
+++ b/src/Radiance/libRAD/VertexDataManager.cpp
@@ -24,7 +24,7 @@ namespace
     enum {INITIAL_STREAM_BUFFER_SIZE = 1024 * 1024};\r
 }\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 \r
 VertexDataManager::VertexDataManager(Context *context) : mContext(context)\r

diff --git a/src/Radiance/libRAD/VertexDataManager.h b/src/Radiance/libRAD/VertexDataManager.h
index 503a143..ee32c03 100644 (file)
--- a/src/Radiance/libRAD/VertexDataManager.h
+++ b/src/Radiance/libRAD/VertexDataManager.h
@@ -21,7 +21,7 @@
 #define GL_APICALL\r
 #include <GLES2/gl2.h>\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
 \r
 struct TranslatedAttribute\r

diff --git a/src/Radiance/libRAD/libRAD.cpp b/src/Radiance/libRAD/libRAD.cpp
index 0e6c92a..7d0596d 100644 (file)
--- a/src/Radiance/libRAD/libRAD.cpp
+++ b/src/Radiance/libRAD/libRAD.cpp
@@ -1,6 +1,6 @@
 // SwiftShader Software Renderer\r
 //\r
-// Copyright(c) 2005-2013 TransGaming Inc.\r
+// Copyright(c) 2014 Google Inc.\r
 //\r
 // All rights reserved. No part of this software may be copied, distributed, transmitted,\r
 // transcribed, stored in a retrieval system, translated into any human or computer\r
@@ -8,6325 +8,2310 @@
 // agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express\r
 // or implied, including but not limited to any patent rights, are granted to you.\r
 //\r
-// libRAD.cpp: Implements the exported OpenGL ES 2.0 functions.\r
+// libRAD.cpp: Implements the exported Radiance functions.\r
 \r
 #include "main.h"\r
-#include "mathutil.h"\r
-#include "utilities.h"\r
 #include "Buffer.h"\r
 #include "Context.h"\r
-#include "Fence.h"\r
-#include "Framebuffer.h"\r
 #include "Program.h"\r
-#include "Renderbuffer.h"\r
 #include "Shader.h"\r
 #include "Texture.h"\r
-#include "Query.h"\r
 #include "common/debug.h"\r
 #include "Common/Version.h"\r
 #include "Main/Register.hpp"\r
+#include "../libEGL/Surface.h"\r
 \r
 #define GL_APICALL\r
-#include <GLES2/gl2.h>\r
-#include <GLES2/gl2ext.h>\r
 #include <RAD/rad.h>\r
 \r
-#include <exception>\r
 #include <limits>\r
+#include <deque>\r
+#include <set>\r
 \r
-static bool validImageSize(GLint level, GLsizei width, GLsizei height)\r
+namespace rad\r
 {\r
-    if(level < 0 || level >= rad::IMPLEMENTATION_MAX_TEXTURE_LEVELS || width < 0 || height < 0)\r
-    {\r
-        return false;\r
-    }\r
-\r
-    return true;\r
-}\r
-\r
-static bool validateSubImageParams(bool compressed, GLsizei width, GLsizei height, GLint xoffset, GLint yoffset, GLenum target, GLint level, GLenum format, rad::Texture *texture)\r
-{\r
-    if(!texture)\r
-    {\r
-        return error(GL_INVALID_OPERATION, false);\r
-    }\r
-\r
-    if(compressed != texture->isCompressed(target, level))\r
-    {\r
-        return error(GL_INVALID_OPERATION, false);\r
-    }\r
-\r
-    if(format != GL_NONE && format != texture->getFormat(target, level))\r
-    {\r
-        return error(GL_INVALID_OPERATION, false);\r
-    }\r
-\r
-    if(compressed)\r
-    {\r
-        if((width % 4 != 0 && width != texture->getWidth(target, 0)) || \r
-           (height % 4 != 0 && height != texture->getHeight(target, 0)))\r
-        {\r
-            return error(GL_INVALID_OPERATION, false);\r
-        }\r
-    }\r
-\r
-    if(xoffset + width > texture->getWidth(target, level) ||\r
-       yoffset + height > texture->getHeight(target, level))\r
-    {\r
-        return error(GL_INVALID_VALUE, false);\r
-    }\r
-\r
-    return true;\r
-}\r
-\r
-// Check for combinations of format and type that are valid for ReadPixels\r
-static bool validReadFormatType(GLenum format, GLenum type)\r
-{\r
-    switch(format)\r
-    {\r
-    case GL_RGBA:\r
-        switch (type)\r
-        {\r
-        case GL_UNSIGNED_BYTE:\r
-            break;\r
-        default:\r
-            return false;\r
-        }\r
-        break;\r
-    case GL_BGRA_EXT:\r
-        switch (type)\r
-        {\r
-        case GL_UNSIGNED_BYTE:\r
-        case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT:\r
-        case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT:\r
-            break;\r
-        default:\r
-            return false;\r
-        }\r
-        break;\r
-    case rad::IMPLEMENTATION_COLOR_READ_FORMAT:\r
-        switch (type)\r
-        {\r
-        case rad::IMPLEMENTATION_COLOR_READ_TYPE:\r
-            break;\r
-        default:\r
-            return false;\r
-        }\r
-        break;\r
-    default:\r
-        return false;\r
-    }\r
-\r
-    return true;\r
-}\r
-\r
-extern "C"\r
-{\r
-\r
-void GL_APIENTRY glActiveTexture(GLenum texture)\r
-{\r
-    TRACE("(GLenum texture = 0x%X)", texture);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(texture < GL_TEXTURE0 || texture > GL_TEXTURE0 + rad::MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1)\r
-            {\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-\r
-            context->setActiveSampler(texture - GL_TEXTURE0);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glAttachShader(GLuint program, GLuint shader)\r
-{\r
-    TRACE("(GLuint program = %d, GLuint shader = %d)", program, shader);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Program *programObject = context->getProgram(program);\r
-            rad::Shader *shaderObject = context->getShader(shader);\r
-\r
-            if(!programObject)\r
-            {\r
-                if(context->getShader(program))\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-            }\r
-\r
-            if(!shaderObject)\r
-            {\r
-                if(context->getProgram(shader))\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-            }\r
-\r
-            if(!programObject->attachShader(shaderObject))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glBeginQueryEXT(GLenum target, GLuint id)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLuint %d)", target, id);\r
-\r
-    try\r
-    {\r
-        switch(target)\r
-        {\r
-        case GL_ANY_SAMPLES_PASSED_EXT: \r
-        case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:\r
-            break;\r
-        default: \r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        if(id == 0)\r
-        {\r
-            return error(GL_INVALID_OPERATION);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->beginQuery(target, id);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glBindAttribLocation(GLuint program, GLuint index, const GLchar* name)\r
-{\r
-    TRACE("(GLuint program = %d, GLuint index = %d, const GLchar* name = 0x%0.8p)", program, index, name);\r
-\r
-    try\r
-    {\r
-        if(index >= rad::MAX_VERTEX_ATTRIBS)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Program *programObject = context->getProgram(program);\r
-\r
-            if(!programObject)\r
-            {\r
-                if(context->getShader(program))\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-            }\r
-\r
-            if(strncmp(name, "gl_", 3) == 0)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            programObject->bindAttributeLocation(index, name);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glBindBuffer(GLenum target, GLuint buffer)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLuint buffer = %d)", target, buffer);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            switch(target)\r
-            {\r
-              case GL_ARRAY_BUFFER:\r
-                context->bindArrayBuffer(buffer);\r
-                return;\r
-              case GL_ELEMENT_ARRAY_BUFFER:\r
-                context->bindElementArrayBuffer(buffer);\r
-                return;\r
-              default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glBindFramebuffer(GLenum target, GLuint framebuffer)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLuint framebuffer = %d)", target, framebuffer);\r
-\r
-    try\r
-    {\r
-        if(target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_ANGLE && target != GL_READ_FRAMEBUFFER_ANGLE)\r
-        {\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(target == GL_READ_FRAMEBUFFER_ANGLE || target == GL_FRAMEBUFFER)\r
-            {\r
-                context->bindReadFramebuffer(framebuffer);\r
-            }\r
-            \r
-            if(target == GL_DRAW_FRAMEBUFFER_ANGLE || target == GL_FRAMEBUFFER)\r
-            {\r
-                context->bindDrawFramebuffer(framebuffer);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glBindRenderbuffer(GLenum target, GLuint renderbuffer)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLuint renderbuffer = %d)", target, renderbuffer);\r
-\r
-    try\r
-    {\r
-        if(target != GL_RENDERBUFFER)\r
-        {\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-                       if (renderbuffer != 0 && !context->getRenderbuffer(renderbuffer))
-                       {
-                               // [OpenGL ES 2.0.25] Section 4.4.3 page 112\r
-                               // [OpenGL ES 3.0.2] Section 4.4.2 page 201\r
-                               // 'renderbuffer' must be either zero or the name of an existing renderbuffer object of\r
-                               // type 'renderbuffertarget', otherwise an INVALID_OPERATION error is generated.\r
-                               return error(GL_INVALID_OPERATION);
-                       }\r
-\r
-            context->bindRenderbuffer(renderbuffer);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glBindTexture(GLenum target, GLuint texture)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLuint texture = %d)", target, texture);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Texture *textureObject = context->getTexture(texture);\r
-\r
-            if(textureObject && textureObject->getTarget() != target && texture != 0)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            switch(target)\r
-            {\r
-            case GL_TEXTURE_2D:\r
-                context->bindTexture2D(texture);\r
-                return;\r
-            case GL_TEXTURE_CUBE_MAP:\r
-                context->bindTextureCubeMap(texture);\r
-                return;\r
-            case GL_TEXTURE_EXTERNAL_OES:\r
-                context->bindTextureExternal(texture);\r
-                return;\r
-            default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)\r
-{\r
-    TRACE("(GLclampf red = %f, GLclampf green = %f, GLclampf blue = %f, GLclampf alpha = %f)",\r
-          red, green, blue, alpha);\r
-\r
-    try\r
-    {\r
-        rad::Context* context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->setBlendColor(rad::clamp01(red), rad::clamp01(green), rad::clamp01(blue), rad::clamp01(alpha));\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glBlendEquation(GLenum mode)\r
-{\r
-    glBlendEquationSeparate(mode, mode);\r
-}\r
-\r
-void GL_APIENTRY glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)\r
-{\r
-    TRACE("(GLenum modeRGB = 0x%X, GLenum modeAlpha = 0x%X)", modeRGB, modeAlpha);\r
-\r
-    try\r
-    {\r
-        switch(modeRGB)\r
-        {\r
-        case GL_FUNC_ADD:\r
-        case GL_FUNC_SUBTRACT:\r
-        case GL_FUNC_REVERSE_SUBTRACT:\r
-        case GL_MIN_EXT:\r
-        case GL_MAX_EXT:\r
-            break;\r
-        default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        switch(modeAlpha)\r
-        {\r
-        case GL_FUNC_ADD:\r
-        case GL_FUNC_SUBTRACT:\r
-        case GL_FUNC_REVERSE_SUBTRACT:\r
-        case GL_MIN_EXT:\r
-        case GL_MAX_EXT:\r
-            break;\r
-        default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->setBlendEquation(modeRGB, modeAlpha);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor)\r
-{\r
-    glBlendFuncSeparate(sfactor, dfactor, sfactor, dfactor);\r
-}\r
-\r
-void GL_APIENTRY glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)\r
-{\r
-    TRACE("(GLenum srcRGB = 0x%X, GLenum dstRGB = 0x%X, GLenum srcAlpha = 0x%X, GLenum dstAlpha = 0x%X)",\r
-          srcRGB, dstRGB, srcAlpha, dstAlpha);\r
-\r
-    try\r
-    {\r
-        switch(srcRGB)\r
-        {\r
-          case GL_ZERO:\r
-          case GL_ONE:\r
-          case GL_SRC_COLOR:\r
-          case GL_ONE_MINUS_SRC_COLOR:\r
-          case GL_DST_COLOR:\r
-          case GL_ONE_MINUS_DST_COLOR:\r
-          case GL_SRC_ALPHA:\r
-          case GL_ONE_MINUS_SRC_ALPHA:\r
-          case GL_DST_ALPHA:\r
-          case GL_ONE_MINUS_DST_ALPHA:\r
-          case GL_CONSTANT_COLOR:\r
-          case GL_ONE_MINUS_CONSTANT_COLOR:\r
-          case GL_CONSTANT_ALPHA:\r
-          case GL_ONE_MINUS_CONSTANT_ALPHA:\r
-          case GL_SRC_ALPHA_SATURATE:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        switch(dstRGB)\r
-        {\r
-          case GL_ZERO:\r
-          case GL_ONE:\r
-          case GL_SRC_COLOR:\r
-          case GL_ONE_MINUS_SRC_COLOR:\r
-          case GL_DST_COLOR:\r
-          case GL_ONE_MINUS_DST_COLOR:\r
-          case GL_SRC_ALPHA:\r
-          case GL_ONE_MINUS_SRC_ALPHA:\r
-          case GL_DST_ALPHA:\r
-          case GL_ONE_MINUS_DST_ALPHA:\r
-          case GL_CONSTANT_COLOR:\r
-          case GL_ONE_MINUS_CONSTANT_COLOR:\r
-          case GL_CONSTANT_ALPHA:\r
-          case GL_ONE_MINUS_CONSTANT_ALPHA:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        switch(srcAlpha)\r
-        {\r
-          case GL_ZERO:\r
-          case GL_ONE:\r
-          case GL_SRC_COLOR:\r
-          case GL_ONE_MINUS_SRC_COLOR:\r
-          case GL_DST_COLOR:\r
-          case GL_ONE_MINUS_DST_COLOR:\r
-          case GL_SRC_ALPHA:\r
-          case GL_ONE_MINUS_SRC_ALPHA:\r
-          case GL_DST_ALPHA:\r
-          case GL_ONE_MINUS_DST_ALPHA:\r
-          case GL_CONSTANT_COLOR:\r
-          case GL_ONE_MINUS_CONSTANT_COLOR:\r
-          case GL_CONSTANT_ALPHA:\r
-          case GL_ONE_MINUS_CONSTANT_ALPHA:\r
-          case GL_SRC_ALPHA_SATURATE:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        switch(dstAlpha)\r
-        {\r
-          case GL_ZERO:\r
-          case GL_ONE:\r
-          case GL_SRC_COLOR:\r
-          case GL_ONE_MINUS_SRC_COLOR:\r
-          case GL_DST_COLOR:\r
-          case GL_ONE_MINUS_DST_COLOR:\r
-          case GL_SRC_ALPHA:\r
-          case GL_ONE_MINUS_SRC_ALPHA:\r
-          case GL_DST_ALPHA:\r
-          case GL_ONE_MINUS_DST_ALPHA:\r
-          case GL_CONSTANT_COLOR:\r
-          case GL_ONE_MINUS_CONSTANT_COLOR:\r
-          case GL_CONSTANT_ALPHA:\r
-          case GL_ONE_MINUS_CONSTANT_ALPHA:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->setBlendFactors(srcRGB, dstRGB, srcAlpha, dstAlpha);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLsizeiptr size = %d, const GLvoid* data = 0x%0.8p, GLenum usage = %d)",\r
-          target, size, data, usage);\r
-\r
-    try\r
-    {\r
-        if(size < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        switch(usage)\r
-        {\r
-          case GL_STREAM_DRAW:\r
-          case GL_STATIC_DRAW:\r
-          case GL_DYNAMIC_DRAW:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Buffer *buffer;\r
-\r
-            switch(target)\r
-            {\r
-              case GL_ARRAY_BUFFER:\r
-                buffer = context->getArrayBuffer();\r
-                break;\r
-              case GL_ELEMENT_ARRAY_BUFFER:\r
-                buffer = context->getElementArrayBuffer();\r
-                break;\r
-              default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-\r
-            if(!buffer)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            buffer->bufferData(data, size, usage);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLintptr offset = %d, GLsizeiptr size = %d, const GLvoid* data = 0x%0.8p)",\r
-          target, offset, size, data);\r
-\r
-    try\r
-    {\r
-        if(size < 0 || offset < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        if(data == NULL)\r
-        {\r
-            return;\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Buffer *buffer;\r
-\r
-            switch(target)\r
-            {\r
-              case GL_ARRAY_BUFFER:\r
-                buffer = context->getArrayBuffer();\r
-                break;\r
-              case GL_ELEMENT_ARRAY_BUFFER:\r
-                buffer = context->getElementArrayBuffer();\r
-                break;\r
-              default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-\r
-            if(!buffer)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            if((size_t)size + offset > buffer->size())\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            buffer->bufferSubData(data, size, offset);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-GLenum GL_APIENTRY glCheckFramebufferStatus(GLenum target)\r
-{\r
-    TRACE("(GLenum target = 0x%X)", target);\r
-\r
-    try\r
-    {\r
-        if(target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_ANGLE && target != GL_READ_FRAMEBUFFER_ANGLE)\r
-        {\r
-            return error(GL_INVALID_ENUM, 0);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Framebuffer *framebuffer = NULL;\r
-            if(target == GL_READ_FRAMEBUFFER_ANGLE)\r
-            {\r
-                framebuffer = context->getReadFramebuffer();\r
-            }\r
-            else\r
-            {\r
-                framebuffer = context->getDrawFramebuffer();\r
-            }\r
-\r
-            return framebuffer->completeness();\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY, 0);\r
-    }\r
-\r
-    return 0;\r
-}\r
-\r
-void GL_APIENTRY glClear(GLbitfield mask)\r
-{\r
-    TRACE("(GLbitfield mask = %X)", mask);\r
-\r
-    try\r
-    {\r
-               if((mask & ~(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) != 0)\r
-               {\r
-                       return error(GL_INVALID_VALUE);\r
-               }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->clear(mask);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)\r
-{\r
-    TRACE("(GLclampf red = %f, GLclampf green = %f, GLclampf blue = %f, GLclampf alpha = %f)",\r
-          red, green, blue, alpha);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->setClearColor(red, green, blue, alpha);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glClearDepthf(GLclampf depth)\r
-{\r
-    TRACE("(GLclampf depth = %f)", depth);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->setClearDepth(depth);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glClearStencil(GLint s)\r
-{\r
-    TRACE("(GLint s = %d)", s);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->setClearStencil(s);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)\r
-{\r
-    TRACE("(GLboolean red = %d, GLboolean green = %d, GLboolean blue = %d, GLboolean alpha = %d)",\r
-          red, green, blue, alpha);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->setColorMask(red == GL_TRUE, green == GL_TRUE, blue == GL_TRUE, alpha == GL_TRUE);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glCompileShader(GLuint shader)\r
-{\r
-    TRACE("(GLuint shader = %d)", shader);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Shader *shaderObject = context->getShader(shader);\r
-\r
-            if(!shaderObject)\r
-            {\r
-                if(context->getProgram(shader))\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-            }\r
-\r
-            shaderObject->compile();\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, \r
-                                        GLint border, GLsizei imageSize, const GLvoid* data)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = %d, " \r
-          "GLsizei height = %d, GLint border = %d, GLsizei imageSize = %d, const GLvoid* data = 0x%0.8p)",\r
-          target, level, internalformat, width, height, border, imageSize, data);\r
-\r
-    try\r
-    {\r
-        if(!validImageSize(level, width, height) || border != 0 || imageSize < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        switch(internalformat)\r
-        {\r
-        case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:\r
-        case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:\r
-               case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:\r
-               case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:\r
-                       if(!S3TC_SUPPORT)\r
-            {\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-            break;\r
-               case GL_DEPTH_COMPONENT:\r
-               case GL_DEPTH_COMPONENT16:\r
-               case GL_DEPTH_COMPONENT32_OES:\r
-               case GL_DEPTH_STENCIL_OES:\r
-               case GL_DEPTH24_STENCIL8_OES:\r
-                       return error(GL_INVALID_OPERATION);\r
-        default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        if(border != 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-                       if(level > rad::IMPLEMENTATION_MAX_TEXTURE_LEVELS)\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            switch(target)\r
-            {\r
-              case GL_TEXTURE_2D:\r
-                if(width > (rad::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level) ||\r
-                    height > (rad::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level))\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-                break;\r
-              case GL_TEXTURE_CUBE_MAP_POSITIVE_X:\r
-              case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:\r
-              case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:\r
-              case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:\r
-              case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:\r
-              case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:\r
-                if(width != height)\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-\r
-                if(width > (rad::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level) ||\r
-                   height > (rad::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level))\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-                break;\r
-              default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-\r
-            if(imageSize != rad::ComputeCompressedSize(width, height, internalformat))\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            if(target == GL_TEXTURE_2D)\r
-            {\r
-                rad::Texture2D *texture = context->getTexture2D();\r
-\r
-                if(!texture)\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-\r
-                texture->setCompressedImage(level, internalformat, width, height, imageSize, data);\r
-            }\r
-            else\r
-            {\r
-                rad::TextureCubeMap *texture = context->getTextureCubeMap();\r
-\r
-                if(!texture)\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-\r
-                switch(target)\r
-                {\r
-                  case GL_TEXTURE_CUBE_MAP_POSITIVE_X:\r
-                  case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:\r
-                  case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:\r
-                  case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:\r
-                  case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:\r
-                  case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:\r
-                    texture->setCompressedImage(target, level, internalformat, width, height, imageSize, data);\r
-                    break;\r
-                  default: UNREACHABLE();\r
-                }\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,\r
-                                         GLenum format, GLsizei imageSize, const GLvoid* data)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "\r
-          "GLsizei width = %d, GLsizei height = %d, GLenum format = 0x%X, "\r
-          "GLsizei imageSize = %d, const GLvoid* data = 0x%0.8p)",\r
-          target, level, xoffset, yoffset, width, height, format, imageSize, data);\r
-\r
-    try\r
-    {\r
-        if(!rad::IsTextureTarget(target))\r
-        {\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        if(xoffset < 0 || yoffset < 0 || !validImageSize(level, width, height) || imageSize < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        switch(format)\r
-        {\r
-        case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:\r
-        case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:\r
-               case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:\r
-               case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:\r
-                       if(!S3TC_SUPPORT)\r
-            {\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-            break;\r
-        default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        if(width == 0 || height == 0 || data == NULL)\r
-        {\r
-            return;\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(level > rad::IMPLEMENTATION_MAX_TEXTURE_LEVELS)\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            if(imageSize != rad::ComputeCompressedSize(width, height, format))\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            if(xoffset % 4 != 0 || yoffset % 4 != 0)\r
-            {\r
-                               // We wait to check the offsets until this point, because the multiple-of-four restriction does not exist unless DXT1 textures are supported\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            if(target == GL_TEXTURE_2D)\r
-            {\r
-                rad::Texture2D *texture = context->getTexture2D();\r
-\r
-                if(validateSubImageParams(true, width, height, xoffset, yoffset, target, level, format, texture))\r
-                               {\r
-                                       texture->subImageCompressed(level, xoffset, yoffset, width, height, format, imageSize, data);\r
-                               }\r
-            }\r
-            else if(rad::IsCubemapTextureTarget(target))\r
-            {\r
-                rad::TextureCubeMap *texture = context->getTextureCubeMap();\r
-\r
-                if(validateSubImageParams(true, width, height, xoffset, yoffset, target, level, format, texture))\r
-                               {\r
-                                       texture->subImageCompressed(target, level, xoffset, yoffset, width, height, format, imageSize, data);\r
-                               }\r
-            }\r
-            else\r
-            {\r
-                UNREACHABLE();\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, "\r
-          "GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLint border = %d)",\r
-          target, level, internalformat, x, y, width, height, border);\r
-\r
-    try\r
-    {\r
-        if(!validImageSize(level, width, height))\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        if(border != 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            switch(target)\r
-            {\r
-              case GL_TEXTURE_2D:\r
-                if(width > (rad::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level) ||\r
-                   height > (rad::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level))\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-                break;\r
-              case GL_TEXTURE_CUBE_MAP_POSITIVE_X:\r
-              case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:\r
-              case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:\r
-              case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:\r
-              case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:\r
-              case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:\r
-                if(width != height)\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-\r
-                if(width > (rad::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level) ||\r
-                   height > (rad::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level))\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-                break;\r
-              default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-\r
-            rad::Framebuffer *framebuffer = context->getReadFramebuffer();\r
-\r
-            if(framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)\r
-            {\r
-                return error(GL_INVALID_FRAMEBUFFER_OPERATION);\r
-            }\r
-\r
-            if(context->getReadFramebufferHandle() != 0 && framebuffer->getColorbuffer()->getSamples() > 1)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            rad::Renderbuffer *source = framebuffer->getColorbuffer();\r
-            GLenum colorbufferFormat = source->getFormat();\r
-\r
-            // [OpenGL ES 2.0.24] table 3.9\r
-            switch(internalformat)\r
-            {\r
-            case GL_ALPHA:\r
-                if(colorbufferFormat != GL_ALPHA &&\r
-                   colorbufferFormat != GL_RGBA &&\r
-                   colorbufferFormat != GL_RGBA4 &&\r
-                   colorbufferFormat != GL_RGB5_A1 &&\r
-                   colorbufferFormat != GL_RGBA8_OES)\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                break;\r
-            case GL_LUMINANCE:\r
-            case GL_RGB:\r
-                if(colorbufferFormat != GL_RGB &&\r
-                   colorbufferFormat != GL_RGB565 &&\r
-                   colorbufferFormat != GL_RGB8_OES &&\r
-                   colorbufferFormat != GL_RGBA &&\r
-                   colorbufferFormat != GL_RGBA4 &&\r
-                   colorbufferFormat != GL_RGB5_A1 &&\r
-                   colorbufferFormat != GL_RGBA8_OES)\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                break;\r
-            case GL_LUMINANCE_ALPHA:\r
-            case GL_RGBA:\r
-                if(colorbufferFormat != GL_RGBA &&\r
-                   colorbufferFormat != GL_RGBA4 &&\r
-                   colorbufferFormat != GL_RGB5_A1 &&\r
-                   colorbufferFormat != GL_RGBA8_OES)\r
-                 {\r
-                     return error(GL_INVALID_OPERATION);\r
-                 }\r
-                 break;\r
-            case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:\r
-            case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:\r
-                       case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:\r
-                       case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:\r
-                if(S3TC_SUPPORT)\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_ENUM);\r
-                }\r
-                break;\r
-            default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-\r
-            if(target == GL_TEXTURE_2D)\r
-            {\r
-                rad::Texture2D *texture = context->getTexture2D();\r
-\r
-                if(!texture)\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-\r
-                texture->copyImage(level, internalformat, x, y, width, height, framebuffer);\r
-            }\r
-            else if(rad::IsCubemapTextureTarget(target))\r
-            {\r
-                rad::TextureCubeMap *texture = context->getTextureCubeMap();\r
-\r
-                if(!texture)\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-\r
-                texture->copyImage(target, level, internalformat, x, y, width, height, framebuffer);\r
-            }\r
-            else UNREACHABLE();\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "\r
-          "GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)",\r
-          target, level, xoffset, yoffset, x, y, width, height);\r
-\r
-    try\r
-    {\r
-        if(!rad::IsTextureTarget(target))\r
-        {\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        if(level < 0 || xoffset < 0 || yoffset < 0 || width < 0 || height < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        if(std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        if(width == 0 || height == 0)\r
-        {\r
-            return;\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(level > rad::IMPLEMENTATION_MAX_TEXTURE_LEVELS)\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            rad::Framebuffer *framebuffer = context->getReadFramebuffer();\r
-\r
-            if(framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)\r
-            {\r
-                return error(GL_INVALID_FRAMEBUFFER_OPERATION);\r
-            }\r
-\r
-            if(context->getReadFramebufferHandle() != 0 && framebuffer->getColorbuffer()->getSamples() > 1)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            rad::Renderbuffer *source = framebuffer->getColorbuffer();\r
-            GLenum colorbufferFormat = source->getFormat();\r
-            rad::Texture *texture = NULL;\r
-\r
-            if(target == GL_TEXTURE_2D)\r
-            {\r
-                texture = context->getTexture2D();\r
-            }\r
-            else if(rad::IsCubemapTextureTarget(target))\r
-            {\r
-                texture = context->getTextureCubeMap();\r
-            }\r
-            else UNREACHABLE();\r
-\r
-            if(!validateSubImageParams(false, width, height, xoffset, yoffset, target, level, GL_NONE, texture))\r
-                       {\r
-                               return;\r
-                       }\r
-\r
-            GLenum textureFormat = texture->getFormat(target, level);\r
-\r
-            // [OpenGL ES 2.0.24] table 3.9\r
-            switch(textureFormat)\r
-            {\r
-            case GL_ALPHA:\r
-                if(colorbufferFormat != GL_ALPHA &&\r
-                   colorbufferFormat != GL_RGBA &&\r
-                   colorbufferFormat != GL_RGBA4 &&\r
-                   colorbufferFormat != GL_RGB5_A1 &&\r
-                   colorbufferFormat != GL_RGBA8_OES)\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                break;\r
-            case GL_LUMINANCE:\r
-            case GL_RGB:\r
-                if(colorbufferFormat != GL_RGB &&\r
-                   colorbufferFormat != GL_RGB565 &&\r
-                   colorbufferFormat != GL_RGB8_OES &&\r
-                   colorbufferFormat != GL_RGBA &&\r
-                   colorbufferFormat != GL_RGBA4 &&\r
-                   colorbufferFormat != GL_RGB5_A1 &&\r
-                   colorbufferFormat != GL_RGBA8_OES)\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                break;\r
-            case GL_LUMINANCE_ALPHA:\r
-            case GL_RGBA:\r
-                if(colorbufferFormat != GL_RGBA &&\r
-                   colorbufferFormat != GL_RGBA4 &&\r
-                   colorbufferFormat != GL_RGB5_A1 &&\r
-                   colorbufferFormat != GL_RGBA8_OES)\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                break;\r
-            case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:\r
-            case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:\r
-                       case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:\r
-                       case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:\r
-                return error(GL_INVALID_OPERATION);\r
-                       case GL_DEPTH_COMPONENT:\r
-                       case GL_DEPTH_STENCIL_OES:\r
-                               return error(GL_INVALID_OPERATION);\r
-            default:\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            texture->copySubImage(target, level, xoffset, yoffset, x, y, width, height, framebuffer);\r
-        }\r
-    }\r
-\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-GLuint GL_APIENTRY glCreateProgram(void)\r
-{\r
-    TRACE("()");\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            return context->createProgram();\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY, 0);\r
-    }\r
-\r
-    return 0;\r
-}\r
-\r
-GLuint GL_APIENTRY glCreateShader(GLenum type)\r
-{\r
-    TRACE("(GLenum type = 0x%X)", type);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            switch(type)\r
-            {\r
-              case GL_FRAGMENT_SHADER:\r
-              case GL_VERTEX_SHADER:\r
-                return context->createShader(type);\r
-              default:\r
-                return error(GL_INVALID_ENUM, 0);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY, 0);\r
-    }\r
-\r
-    return 0;\r
-}\r
-\r
-void GL_APIENTRY glCullFace(GLenum mode)\r
-{\r
-    TRACE("(GLenum mode = 0x%X)", mode);\r
-\r
-    try\r
-    {\r
-        switch(mode)\r
-        {\r
-          case GL_FRONT:\r
-          case GL_BACK:\r
-          case GL_FRONT_AND_BACK:\r
-            {\r
-                rad::Context *context = rad::getContext();\r
-\r
-                if(context)\r
-                {\r
-                    context->setCullMode(mode);\r
-                }\r
-            }\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glDeleteBuffers(GLsizei n, const GLuint* buffers)\r
-{\r
-    TRACE("(GLsizei n = %d, const GLuint* buffers = 0x%0.8p)", n, buffers);\r
-\r
-    try\r
-    {\r
-        if(n < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            for(int i = 0; i < n; i++)\r
-            {\r
-                context->deleteBuffer(buffers[i]);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glDeleteFencesNV(GLsizei n, const GLuint* fences)\r
-{\r
-    TRACE("(GLsizei n = %d, const GLuint* fences = 0x%0.8p)", n, fences);\r
-\r
-    try\r
-    {\r
-        if(n < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            for(int i = 0; i < n; i++)\r
-            {\r
-                context->deleteFence(fences[i]);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)\r
-{\r
-    TRACE("(GLsizei n = %d, const GLuint* framebuffers = 0x%0.8p)", n, framebuffers);\r
-\r
-    try\r
-    {\r
-        if(n < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            for(int i = 0; i < n; i++)\r
-            {\r
-                if(framebuffers[i] != 0)\r
-                {\r
-                    context->deleteFramebuffer(framebuffers[i]);\r
-                }\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glDeleteProgram(GLuint program)\r
-{\r
-    TRACE("(GLuint program = %d)", program);\r
-\r
-    try\r
-    {\r
-        if(program == 0)\r
-        {\r
-            return;\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(!context->getProgram(program))\r
-            {\r
-                if(context->getShader(program))\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-            }\r
-\r
-            context->deleteProgram(program);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glDeleteQueriesEXT(GLsizei n, const GLuint *ids)\r
-{\r
-    TRACE("(GLsizei n = %d, const GLuint *ids = 0x%0.8p)", n, ids);\r
-\r
-    try\r
-    {\r
-        if(n < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            for(int i = 0; i < n; i++)\r
-            {\r
-                context->deleteQuery(ids[i]);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)\r
-{\r
-    TRACE("(GLsizei n = %d, const GLuint* renderbuffers = 0x%0.8p)", n, renderbuffers);\r
-\r
-    try\r
-    {\r
-        if(n < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            for(int i = 0; i < n; i++)\r
-            {\r
-                context->deleteRenderbuffer(renderbuffers[i]);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glDeleteShader(GLuint shader)\r
-{\r
-    TRACE("(GLuint shader = %d)", shader);\r
-\r
-    try\r
-    {\r
-        if(shader == 0)\r
-        {\r
-            return;\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(!context->getShader(shader))\r
-            {\r
-                if(context->getProgram(shader))\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-            }\r
-\r
-            context->deleteShader(shader);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glDeleteTextures(GLsizei n, const GLuint* textures)\r
-{\r
-    TRACE("(GLsizei n = %d, const GLuint* textures = 0x%0.8p)", n, textures);\r
-\r
-    try\r
-    {\r
-        if(n < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            for(int i = 0; i < n; i++)\r
-            {\r
-                if(textures[i] != 0)\r
-                {\r
-                    context->deleteTexture(textures[i]);\r
-                }\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glDepthFunc(GLenum func)\r
-{\r
-    TRACE("(GLenum func = 0x%X)", func);\r
-\r
-    try\r
-    {\r
-        switch(func)\r
-        {\r
-          case GL_NEVER:\r
-          case GL_ALWAYS:\r
-          case GL_LESS:\r
-          case GL_LEQUAL:\r
-          case GL_EQUAL:\r
-          case GL_GREATER:\r
-          case GL_GEQUAL:\r
-          case GL_NOTEQUAL:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->setDepthFunc(func);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glDepthMask(GLboolean flag)\r
-{\r
-    TRACE("(GLboolean flag = %d)", flag);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->setDepthMask(flag != GL_FALSE);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glDepthRangef(GLclampf zNear, GLclampf zFar)\r
-{\r
-    TRACE("(GLclampf zNear = %f, GLclampf zFar = %f)", zNear, zFar);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->setDepthRange(zNear, zFar);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glDetachShader(GLuint program, GLuint shader)\r
-{\r
-    TRACE("(GLuint program = %d, GLuint shader = %d)", program, shader);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-\r
-            rad::Program *programObject = context->getProgram(program);\r
-            rad::Shader *shaderObject = context->getShader(shader);\r
-            \r
-            if(!programObject)\r
-            {\r
-                rad::Shader *shaderByProgramHandle;\r
-                shaderByProgramHandle = context->getShader(program);\r
-                if(!shaderByProgramHandle)\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-            }\r
-\r
-            if(!shaderObject)\r
-            {\r
-                rad::Program *programByShaderHandle = context->getProgram(shader);\r
-                if(!programByShaderHandle)\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-            }\r
-\r
-            if(!programObject->detachShader(shaderObject))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glDisable(GLenum cap)\r
-{\r
-    TRACE("(GLenum cap = 0x%X)", cap);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            switch(cap)\r
-            {\r
-              case GL_CULL_FACE:                context->setCullFace(false);              break;\r
-              case GL_POLYGON_OFFSET_FILL:      context->setPolygonOffsetFill(false);     break;\r
-              case GL_SAMPLE_ALPHA_TO_COVERAGE: context->setSampleAlphaToCoverage(false); break;\r
-              case GL_SAMPLE_COVERAGE:          context->setSampleCoverage(false);        break;\r
-              case GL_SCISSOR_TEST:             context->setScissorTest(false);           break;\r
-              case GL_STENCIL_TEST:             context->setStencilTest(false);           break;\r
-              case GL_DEPTH_TEST:               context->setDepthTest(false);             break;\r
-              case GL_BLEND:                    context->setBlend(false);                 break;\r
-              case GL_DITHER:                   context->setDither(false);                break;\r
-              default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glDisableVertexAttribArray(GLuint index)\r
-{\r
-    TRACE("(GLuint index = %d)", index);\r
-\r
-    try\r
-    {\r
-        if(index >= rad::MAX_VERTEX_ATTRIBS)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->setEnableVertexAttribArray(index, false);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glDrawArrays(GLenum mode, GLint first, GLsizei count)\r
-{\r
-    TRACE("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d)", mode, first, count);\r
-\r
-    try\r
-    {\r
-        if(count < 0 || first < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->drawArrays(mode, first, count);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)\r
-{\r
-    TRACE("(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const GLvoid* indices = 0x%0.8p)",\r
-          mode, count, type, indices);\r
-\r
-    try\r
-    {\r
-        if(count < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            switch(type)\r
-            {\r
-              case GL_UNSIGNED_BYTE:\r
-              case GL_UNSIGNED_SHORT:\r
-              case GL_UNSIGNED_INT:\r
-                break;\r
-              default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-        \r
-            context->drawElements(mode, count, type, indices);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glEnable(GLenum cap)\r
-{\r
-    TRACE("(GLenum cap = 0x%X)", cap);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            switch(cap)\r
-            {\r
-              case GL_CULL_FACE:                context->setCullFace(true);              break;\r
-              case GL_POLYGON_OFFSET_FILL:      context->setPolygonOffsetFill(true);     break;\r
-              case GL_SAMPLE_ALPHA_TO_COVERAGE: context->setSampleAlphaToCoverage(true); break;\r
-              case GL_SAMPLE_COVERAGE:          context->setSampleCoverage(true);        break;\r
-              case GL_SCISSOR_TEST:             context->setScissorTest(true);           break;\r
-              case GL_STENCIL_TEST:             context->setStencilTest(true);           break;\r
-              case GL_DEPTH_TEST:               context->setDepthTest(true);             break;\r
-              case GL_BLEND:                    context->setBlend(true);                 break;\r
-              case GL_DITHER:                   context->setDither(true);                break;\r
-              default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glEnableVertexAttribArray(GLuint index)\r
-{\r
-    TRACE("(GLuint index = %d)", index);\r
-\r
-    try\r
-    {\r
-        if(index >= rad::MAX_VERTEX_ATTRIBS)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->setEnableVertexAttribArray(index, true);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glEndQueryEXT(GLenum target)\r
-{\r
-    TRACE("GLenum target = 0x%X)", target);\r
-\r
-    try\r
-    {\r
-        switch(target)\r
-        {\r
-        case GL_ANY_SAMPLES_PASSED_EXT: \r
-        case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:\r
-            break;\r
-        default: \r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->endQuery(target);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glFinishFenceNV(GLuint fence)\r
-{\r
-    TRACE("(GLuint fence = %d)", fence);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Fence* fenceObject = context->getFence(fence);\r
-\r
-            if(fenceObject == NULL)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            fenceObject->finishFence();\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glFinish(void)\r
-{\r
-    TRACE("()");\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->finish();\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glFlush(void)\r
-{\r
-    TRACE("()");\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->flush();\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum renderbuffertarget = 0x%X, "\r
-          "GLuint renderbuffer = %d)", target, attachment, renderbuffertarget, renderbuffer);\r
-\r
-    try\r
-    {\r
-        if((target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_ANGLE && target != GL_READ_FRAMEBUFFER_ANGLE)\r
-            || (renderbuffertarget != GL_RENDERBUFFER && renderbuffer != 0))\r
-        {\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Framebuffer *framebuffer = NULL;\r
-            GLuint framebufferHandle = 0;\r
-            if(target == GL_READ_FRAMEBUFFER_ANGLE)\r
-            {\r
-                framebuffer = context->getReadFramebuffer();\r
-                framebufferHandle = context->getReadFramebufferHandle();\r
-            }\r
-            else\r
-            {\r
-                framebuffer = context->getDrawFramebuffer();\r
-                framebufferHandle = context->getDrawFramebufferHandle();\r
-            }\r
-\r
-            if(!framebuffer || (framebufferHandle == 0 && renderbuffer != 0))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            switch(attachment)\r
-            {\r
-              case GL_COLOR_ATTACHMENT0:\r
-                framebuffer->setColorbuffer(GL_RENDERBUFFER, renderbuffer);\r
-                break;\r
-              case GL_DEPTH_ATTACHMENT:\r
-                framebuffer->setDepthbuffer(GL_RENDERBUFFER, renderbuffer);\r
-                break;\r
-              case GL_STENCIL_ATTACHMENT:\r
-                framebuffer->setStencilbuffer(GL_RENDERBUFFER, renderbuffer);\r
-                break;\r
-              default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum textarget = 0x%X, "\r
-          "GLuint texture = %d, GLint level = %d)", target, attachment, textarget, texture, level);\r
-\r
-    try\r
-    {\r
-        if(target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_ANGLE && target != GL_READ_FRAMEBUFFER_ANGLE)\r
-        {\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        switch(attachment)\r
-        {\r
-          case GL_COLOR_ATTACHMENT0:\r
-          case GL_DEPTH_ATTACHMENT:\r
-          case GL_STENCIL_ATTACHMENT:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(texture == 0)\r
-            {\r
-                textarget = GL_NONE;\r
-            }\r
-            else\r
-            {\r
-                rad::Texture *tex = context->getTexture(texture);\r
-\r
-                if(tex == NULL)\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-\r
-                if(tex->isCompressed(textarget, level))\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-\r
-                switch(textarget)\r
-                {\r
-                  case GL_TEXTURE_2D:\r
-                    if(tex->getTarget() != GL_TEXTURE_2D)\r
-                    {\r
-                        return error(GL_INVALID_OPERATION);\r
-                    }\r
-                    break;\r
-\r
-                  case GL_TEXTURE_CUBE_MAP_POSITIVE_X:\r
-                  case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:\r
-                  case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:\r
-                  case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:\r
-                  case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:\r
-                  case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:\r
-                    if(tex->getTarget() != GL_TEXTURE_CUBE_MAP)\r
-                    {\r
-                        return error(GL_INVALID_OPERATION);\r
-                    }\r
-                    break;\r
-\r
-                  default:\r
-                    return error(GL_INVALID_ENUM);\r
-                }\r
-\r
-                if(level != 0)\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-            }\r
-\r
-            rad::Framebuffer *framebuffer = NULL;\r
-            GLuint framebufferHandle = 0;\r
-            if(target == GL_READ_FRAMEBUFFER_ANGLE)\r
-            {\r
-                framebuffer = context->getReadFramebuffer();\r
-                framebufferHandle = context->getReadFramebufferHandle();\r
-            }\r
-            else\r
-            {\r
-                framebuffer = context->getDrawFramebuffer();\r
-                framebufferHandle = context->getDrawFramebufferHandle();\r
-            }\r
-\r
-            if(framebufferHandle == 0 || !framebuffer)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            switch(attachment)\r
-            {\r
-              case GL_COLOR_ATTACHMENT0:  framebuffer->setColorbuffer(textarget, texture);   break;\r
-              case GL_DEPTH_ATTACHMENT:   framebuffer->setDepthbuffer(textarget, texture);   break;\r
-              case GL_STENCIL_ATTACHMENT: framebuffer->setStencilbuffer(textarget, texture); break;\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glFrontFace(GLenum mode)\r
-{\r
-    TRACE("(GLenum mode = 0x%X)", mode);\r
-\r
-    try\r
-    {\r
-        switch(mode)\r
-        {\r
-          case GL_CW:\r
-          case GL_CCW:\r
-            {\r
-                rad::Context *context = rad::getContext();\r
-\r
-                if(context)\r
-                {\r
-                    context->setFrontFace(mode);\r
-                }\r
-            }\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGenBuffers(GLsizei n, GLuint* buffers)\r
-{\r
-    TRACE("(GLsizei n = %d, GLuint* buffers = 0x%0.8p)", n, buffers);\r
-\r
-    try\r
-    {\r
-        if(n < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            for(int i = 0; i < n; i++)\r
-            {\r
-                buffers[i] = context->createBuffer();\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGenerateMipmap(GLenum target)\r
-{\r
-    TRACE("(GLenum target = 0x%X)", target);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Texture *texture;\r
-\r
-            switch(target)\r
-            {\r
-              case GL_TEXTURE_2D:\r
-                texture = context->getTexture2D();\r
-                break;\r
-              case GL_TEXTURE_CUBE_MAP:\r
-                texture = context->getTextureCubeMap();\r
-                break;\r
-              default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-\r
-            if(texture->isCompressed(target, 0) || texture->isDepth(target, 0))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            texture->generateMipmaps();\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGenFencesNV(GLsizei n, GLuint* fences)\r
-{\r
-    TRACE("(GLsizei n = %d, GLuint* fences = 0x%0.8p)", n, fences);\r
-\r
-    try\r
-    {\r
-        if(n < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            for(int i = 0; i < n; i++)\r
-            {\r
-                fences[i] = context->createFence();\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGenFramebuffers(GLsizei n, GLuint* framebuffers)\r
-{\r
-    TRACE("(GLsizei n = %d, GLuint* framebuffers = 0x%0.8p)", n, framebuffers);\r
-\r
-    try\r
-    {\r
-        if(n < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            for(int i = 0; i < n; i++)\r
-            {\r
-                framebuffers[i] = context->createFramebuffer();\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGenQueriesEXT(GLsizei n, GLuint* ids)\r
-{\r
-    TRACE("(GLsizei n = %d, GLuint* ids = 0x%0.8p)", n, ids);\r
-\r
-    try\r
-    {\r
-        if(n < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            for(int i = 0; i < n; i++)\r
-            {\r
-                ids[i] = context->createQuery();\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)\r
-{\r
-    TRACE("(GLsizei n = %d, GLuint* renderbuffers = 0x%0.8p)", n, renderbuffers);\r
-\r
-    try\r
-    {\r
-        if(n < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            for(int i = 0; i < n; i++)\r
-            {\r
-                renderbuffers[i] = context->createRenderbuffer();\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGenTextures(GLsizei n, GLuint* textures)\r
-{\r
-    TRACE("(GLsizei n = %d, GLuint* textures =  0x%0.8p)", n, textures);\r
-\r
-    try\r
-    {\r
-        if(n < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            for(int i = 0; i < n; i++)\r
-            {\r
-                textures[i] = context->createTexture();\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)\r
-{\r
-    TRACE("(GLuint program = %d, GLuint index = %d, GLsizei bufsize = %d, GLsizei *length = 0x%0.8p, "\r
-          "GLint *size = 0x%0.8p, GLenum *type = %0.8p, GLchar *name = %0.8p)",\r
-          program, index, bufsize, length, size, type, name);\r
-\r
-    try\r
-    {\r
-        if(bufsize < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Program *programObject = context->getProgram(program);\r
-\r
-            if(!programObject)\r
-            {\r
-                if(context->getShader(program))\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-            }\r
-\r
-            if(index >= (GLuint)programObject->getActiveAttributeCount())\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            programObject->getActiveAttribute(index, bufsize, length, size, type, name);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)\r
-{\r
-    TRACE("(GLuint program = %d, GLuint index = %d, GLsizei bufsize = %d, "\r
-          "GLsizei* length = 0x%0.8p, GLint* size = 0x%0.8p, GLenum* type = 0x%0.8p, GLchar* name = 0x%0.8p)",\r
-          program, index, bufsize, length, size, type, name);\r
-\r
-    try\r
-    {\r
-        if(bufsize < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Program *programObject = context->getProgram(program);\r
-\r
-            if(!programObject)\r
-            {\r
-                if(context->getShader(program))\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-            }\r
-\r
-            if(index >= (GLuint)programObject->getActiveUniformCount())\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            programObject->getActiveUniform(index, bufsize, length, size, type, name);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)\r
-{\r
-    TRACE("(GLuint program = %d, GLsizei maxcount = %d, GLsizei* count = 0x%0.8p, GLuint* shaders = 0x%0.8p)",\r
-          program, maxcount, count, shaders);\r
-\r
-    try\r
-    {\r
-        if(maxcount < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Program *programObject = context->getProgram(program);\r
-\r
-            if(!programObject)\r
-            {\r
-                if(context->getShader(program))\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-            }\r
-\r
-            return programObject->getAttachedShaders(maxcount, count, shaders);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-int GL_APIENTRY glGetAttribLocation(GLuint program, const GLchar* name)\r
-{\r
-    TRACE("(GLuint program = %d, const GLchar* name = %s)", program, name);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-\r
-            rad::Program *programObject = context->getProgram(program);\r
-\r
-            if(!programObject)\r
-            {\r
-                if(context->getShader(program))\r
-                {\r
-                    return error(GL_INVALID_OPERATION, -1);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_VALUE, -1);\r
-                }\r
-            }\r
-\r
-            if(!programObject->isLinked())\r
-            {\r
-                return error(GL_INVALID_OPERATION, -1);\r
-            }\r
-\r
-            return programObject->getAttributeLocation(name);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY, -1);\r
-    }\r
-\r
-    return -1;\r
-}\r
-\r
-void GL_APIENTRY glGetBooleanv(GLenum pname, GLboolean* params)\r
-{\r
-    TRACE("(GLenum pname = 0x%X, GLboolean* params = 0x%0.8p)",  pname, params);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(!(context->getBooleanv(pname, params)))\r
-            {\r
-                GLenum nativeType;\r
-                unsigned int numParams = 0;\r
-                if(!context->getQueryParameterInfo(pname, &nativeType, &numParams))\r
-                    return error(GL_INVALID_ENUM);\r
-\r
-                if(numParams == 0)\r
-                    return; // it is known that the pname is valid, but there are no parameters to return\r
-\r
-                if(nativeType == GL_FLOAT)\r
-                {\r
-                    GLfloat *floatParams = NULL;\r
-                    floatParams = new GLfloat[numParams];\r
-\r
-                    context->getFloatv(pname, floatParams);\r
-\r
-                    for(unsigned int i = 0; i < numParams; ++i)\r
-                    {\r
-                        if(floatParams[i] == 0.0f)\r
-                            params[i] = GL_FALSE;\r
-                        else\r
-                            params[i] = GL_TRUE;\r
-                    }\r
-\r
-                    delete [] floatParams;\r
-                }\r
-                else if(nativeType == GL_INT)\r
-                {\r
-                    GLint *intParams = NULL;\r
-                    intParams = new GLint[numParams];\r
-\r
-                    context->getIntegerv(pname, intParams);\r
-\r
-                    for(unsigned int i = 0; i < numParams; ++i)\r
-                    {\r
-                        if(intParams[i] == 0)\r
-                            params[i] = GL_FALSE;\r
-                        else\r
-                            params[i] = GL_TRUE;\r
-                    }\r
-\r
-                    delete [] intParams;\r
-                }\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", target, pname, params);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Buffer *buffer;\r
-\r
-            switch(target)\r
-            {\r
-              case GL_ARRAY_BUFFER:\r
-                buffer = context->getArrayBuffer();\r
-                break;\r
-              case GL_ELEMENT_ARRAY_BUFFER:\r
-                buffer = context->getElementArrayBuffer();\r
-                break;\r
-              default: return error(GL_INVALID_ENUM);\r
-            }\r
-\r
-            if(!buffer)\r
-            {\r
-                // A null buffer means that "0" is bound to the requested buffer target\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            switch(pname)\r
-            {\r
-              case GL_BUFFER_USAGE:\r
-                *params = buffer->usage();\r
-                break;\r
-              case GL_BUFFER_SIZE:\r
-                *params = buffer->size();\r
-                break;\r
-              default: return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-GLenum GL_APIENTRY glGetError(void)\r
-{\r
-    TRACE("()");\r
-\r
-    rad::Context *context = rad::getContext();\r
-\r
-    if(context)\r
-    {\r
-        return context->getError();\r
-    }\r
-\r
-    return GL_NO_ERROR;\r
-}\r
-\r
-void GL_APIENTRY glGetFenceivNV(GLuint fence, GLenum pname, GLint *params)\r
-{\r
-    TRACE("(GLuint fence = %d, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", fence, pname, params);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Fence *fenceObject = context->getFence(fence);\r
-\r
-            if(fenceObject == NULL)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            fenceObject->getFenceiv(pname, params);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetFloatv(GLenum pname, GLfloat* params)\r
-{\r
-    TRACE("(GLenum pname = 0x%X, GLfloat* params = 0x%0.8p)", pname, params);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(!(context->getFloatv(pname, params)))\r
-            {\r
-                GLenum nativeType;\r
-                unsigned int numParams = 0;\r
-                if(!context->getQueryParameterInfo(pname, &nativeType, &numParams))\r
-                    return error(GL_INVALID_ENUM);\r
-\r
-                if(numParams == 0)\r
-                    return; // it is known that the pname is valid, but that there are no parameters to return.\r
-\r
-                if(nativeType == GL_BOOL)\r
-                {\r
-                    GLboolean *boolParams = NULL;\r
-                    boolParams = new GLboolean[numParams];\r
-\r
-                    context->getBooleanv(pname, boolParams);\r
-\r
-                    for(unsigned int i = 0; i < numParams; ++i)\r
-                    {\r
-                        if(boolParams[i] == GL_FALSE)\r
-                            params[i] = 0.0f;\r
-                        else\r
-                            params[i] = 1.0f;\r
-                    }\r
-\r
-                    delete [] boolParams;\r
-                }\r
-                else if(nativeType == GL_INT)\r
-                {\r
-                    GLint *intParams = NULL;\r
-                    intParams = new GLint[numParams];\r
-\r
-                    context->getIntegerv(pname, intParams);\r
-\r
-                    for(unsigned int i = 0; i < numParams; ++i)\r
-                    {\r
-                        params[i] = (GLfloat)intParams[i];\r
-                    }\r
-\r
-                    delete [] intParams;\r
-                }\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p)",\r
-          target, attachment, pname, params);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_ANGLE && target != GL_READ_FRAMEBUFFER_ANGLE)\r
-            {\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-\r
-            rad::Framebuffer *framebuffer = NULL;\r
-            if(target == GL_READ_FRAMEBUFFER_ANGLE)\r
-            {\r
-                if(context->getReadFramebufferHandle() == 0)\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-\r
-                framebuffer = context->getReadFramebuffer();\r
-            }\r
-            else \r
-            {\r
-                if(context->getDrawFramebufferHandle() == 0)\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-\r
-                framebuffer = context->getDrawFramebuffer();\r
-            }\r
-\r
-            GLenum attachmentType;\r
-            GLuint attachmentHandle;\r
-            switch(attachment)\r
-            {\r
-              case GL_COLOR_ATTACHMENT0:    \r
-                attachmentType = framebuffer->getColorbufferType();\r
-                attachmentHandle = framebuffer->getColorbufferHandle(); \r
-                break;\r
-              case GL_DEPTH_ATTACHMENT:     \r
-                attachmentType = framebuffer->getDepthbufferType();\r
-                attachmentHandle = framebuffer->getDepthbufferHandle();\r
-                break;\r
-              case GL_STENCIL_ATTACHMENT:   \r
-                attachmentType = framebuffer->getStencilbufferType();\r
-                attachmentHandle = framebuffer->getStencilbufferHandle();\r
-                break;\r
-              default: return error(GL_INVALID_ENUM);\r
-            }\r
-\r
-            GLenum attachmentObjectType;   // Type category\r
-            if(attachmentType == GL_NONE || attachmentType == GL_RENDERBUFFER)\r
-            {\r
-                attachmentObjectType = attachmentType;\r
-            }\r
-            else if(rad::IsTextureTarget(attachmentType))\r
-            {\r
-                attachmentObjectType = GL_TEXTURE;\r
-            }\r
-            else UNREACHABLE();\r
-\r
-            switch(pname)\r
-            {\r
-              case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:\r
-                *params = attachmentObjectType;\r
-                break;\r
-              case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:\r
-                if(attachmentObjectType == GL_RENDERBUFFER || attachmentObjectType == GL_TEXTURE)\r
-                {\r
-                    *params = attachmentHandle;\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_ENUM);\r
-                }\r
-                break;\r
-              case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:\r
-                if(attachmentObjectType == GL_TEXTURE)\r
-                {\r
-                    *params = 0; // FramebufferTexture2D will not allow level to be set to anything else in GL ES 2.0\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_ENUM);\r
-                }\r
-                break;\r
-              case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:\r
-                if(attachmentObjectType == GL_TEXTURE)\r
-                {\r
-                    if(rad::IsCubemapTextureTarget(attachmentType))\r
-                    {\r
-                        *params = attachmentType;\r
-                    }\r
-                    else\r
-                    {\r
-                        *params = 0;\r
-                    }\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_ENUM);\r
-                }\r
-                break;\r
-              default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-GLenum GL_APIENTRY glGetGraphicsResetStatusEXT(void)\r
-{\r
-    TRACE("()");\r
-\r
-    return GL_NO_ERROR;\r
-}\r
-\r
-void GL_APIENTRY glGetIntegerv(GLenum pname, GLint* params)\r
-{\r
-    TRACE("(GLenum pname = 0x%X, GLint* params = 0x%0.8p)", pname, params);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(!(context->getIntegerv(pname, params)))\r
-            {\r
-                GLenum nativeType;\r
-                unsigned int numParams = 0;\r
-                if(!context->getQueryParameterInfo(pname, &nativeType, &numParams))\r
-                    return error(GL_INVALID_ENUM);\r
-\r
-                if(numParams == 0)\r
-                    return; // it is known that pname is valid, but there are no parameters to return\r
-\r
-                if(nativeType == GL_BOOL)\r
-                {\r
-                    GLboolean *boolParams = NULL;\r
-                    boolParams = new GLboolean[numParams];\r
-\r
-                    context->getBooleanv(pname, boolParams);\r
-\r
-                    for(unsigned int i = 0; i < numParams; ++i)\r
-                    {\r
-                        if(boolParams[i] == GL_FALSE)\r
-                            params[i] = 0;\r
-                        else\r
-                            params[i] = 1;\r
-                    }\r
-\r
-                    delete [] boolParams;\r
-                }\r
-                else if(nativeType == GL_FLOAT)\r
-                {\r
-                    GLfloat *floatParams = NULL;\r
-                    floatParams = new GLfloat[numParams];\r
-\r
-                    context->getFloatv(pname, floatParams);\r
-\r
-                    for(unsigned int i = 0; i < numParams; ++i)\r
-                    {\r
-                        if(pname == GL_DEPTH_RANGE || pname == GL_COLOR_CLEAR_VALUE || pname == GL_DEPTH_CLEAR_VALUE || pname == GL_BLEND_COLOR)\r
-                        {\r
-                            params[i] = (GLint)(((GLfloat)(0xFFFFFFFF) * floatParams[i] - 1.0f) / 2.0f);\r
-                        }\r
-                        else\r
-                            params[i] = (GLint)(floatParams[i] > 0.0f ? floor(floatParams[i] + 0.5) : ceil(floatParams[i] - 0.5));\r
-                    }\r
-\r
-                    delete [] floatParams;\r
-                }\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetProgramiv(GLuint program, GLenum pname, GLint* params)\r
-{\r
-    TRACE("(GLuint program = %d, GLenum pname = %d, GLint* params = 0x%0.8p)", program, pname, params);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Program *programObject = context->getProgram(program);\r
-\r
-            if(!programObject)\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            switch(pname)\r
-            {\r
-              case GL_DELETE_STATUS:\r
-                *params = programObject->isFlaggedForDeletion();\r
-                return;\r
-              case GL_LINK_STATUS:\r
-                *params = programObject->isLinked();\r
-                return;\r
-              case GL_VALIDATE_STATUS:\r
-                *params = programObject->isValidated();\r
-                return;\r
-              case GL_INFO_LOG_LENGTH:\r
-                *params = programObject->getInfoLogLength();\r
-                return;\r
-              case GL_ATTACHED_SHADERS:\r
-                *params = programObject->getAttachedShadersCount();\r
-                return;\r
-              case GL_ACTIVE_ATTRIBUTES:\r
-                *params = programObject->getActiveAttributeCount();\r
-                return;\r
-              case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:\r
-                *params = programObject->getActiveAttributeMaxLength();\r
-                return;\r
-              case GL_ACTIVE_UNIFORMS:\r
-                *params = programObject->getActiveUniformCount();\r
-                return;\r
-              case GL_ACTIVE_UNIFORM_MAX_LENGTH:\r
-                *params = programObject->getActiveUniformMaxLength();\r
-                return;\r
-              default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog)\r
-{\r
-    TRACE("(GLuint program = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLchar* infolog = 0x%0.8p)",\r
-          program, bufsize, length, infolog);\r
-\r
-    try\r
-    {\r
-        if(bufsize < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Program *programObject = context->getProgram(program);\r
-\r
-            if(!programObject)\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            programObject->getInfoLog(bufsize, length, infolog);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetQueryivEXT(GLenum target, GLenum pname, GLint *params)\r
-{\r
-    TRACE("GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", target, pname, params);\r
-\r
-    try\r
-    {\r
-        switch(pname)\r
-        {\r
-        case GL_CURRENT_QUERY_EXT:\r
-            break;\r
-        default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            params[0] = context->getActiveQuery(target);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params)\r
-{\r
-    TRACE("(GLuint id = %d, GLenum pname = 0x%X, GLuint *params = 0x%0.8p)", id, pname, params);\r
-\r
-    try\r
-    {\r
-        switch(pname)\r
-        {\r
-        case GL_QUERY_RESULT_EXT:\r
-        case GL_QUERY_RESULT_AVAILABLE_EXT:\r
-            break;\r
-        default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Query *queryObject = context->getQuery(id, false, GL_NONE);\r
-\r
-            if(!queryObject)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            if(context->getActiveQuery(queryObject->getType()) == id)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            switch(pname)\r
-            {\r
-            case GL_QUERY_RESULT_EXT:\r
-                params[0] = queryObject->getResult();\r
-                break;\r
-            case GL_QUERY_RESULT_AVAILABLE_EXT:\r
-                params[0] = queryObject->isResultAvailable();\r
-                break;\r
-            default:\r
-                ASSERT(false);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", target, pname, params);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(target != GL_RENDERBUFFER)\r
-            {\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-\r
-            if(context->getRenderbufferHandle() == 0)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            rad::Renderbuffer *renderbuffer = context->getRenderbuffer(context->getRenderbufferHandle());\r
-\r
-            switch(pname)\r
-            {\r
-            case GL_RENDERBUFFER_WIDTH:           *params = renderbuffer->getWidth();       break;\r
-            case GL_RENDERBUFFER_HEIGHT:          *params = renderbuffer->getHeight();      break;\r
-            case GL_RENDERBUFFER_INTERNAL_FORMAT: *params = renderbuffer->getFormat();      break;\r
-            case GL_RENDERBUFFER_RED_SIZE:        *params = renderbuffer->getRedSize();     break;\r
-            case GL_RENDERBUFFER_GREEN_SIZE:      *params = renderbuffer->getGreenSize();   break;\r
-            case GL_RENDERBUFFER_BLUE_SIZE:       *params = renderbuffer->getBlueSize();    break;\r
-            case GL_RENDERBUFFER_ALPHA_SIZE:      *params = renderbuffer->getAlphaSize();   break;\r
-            case GL_RENDERBUFFER_DEPTH_SIZE:      *params = renderbuffer->getDepthSize();   break;\r
-            case GL_RENDERBUFFER_STENCIL_SIZE:    *params = renderbuffer->getStencilSize(); break;\r
-            case GL_RENDERBUFFER_SAMPLES_ANGLE:   *params = renderbuffer->getSamples();     break;\r
-            default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetShaderiv(GLuint shader, GLenum pname, GLint* params)\r
-{\r
-    TRACE("(GLuint shader = %d, GLenum pname = %d, GLint* params = 0x%0.8p)", shader, pname, params);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Shader *shaderObject = context->getShader(shader);\r
-\r
-            if(!shaderObject)\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            switch(pname)\r
-            {\r
-              case GL_SHADER_TYPE:\r
-                *params = shaderObject->getType();\r
-                return;\r
-              case GL_DELETE_STATUS:\r
-                *params = shaderObject->isFlaggedForDeletion();\r
-                return;\r
-              case GL_COMPILE_STATUS:\r
-                *params = shaderObject->isCompiled() ? GL_TRUE : GL_FALSE;\r
-                return;\r
-              case GL_INFO_LOG_LENGTH:\r
-                *params = shaderObject->getInfoLogLength();\r
-                return;\r
-              case GL_SHADER_SOURCE_LENGTH:\r
-                *params = shaderObject->getSourceLength();\r
-                return;\r
-              default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog)\r
-{\r
-    TRACE("(GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLchar* infolog = 0x%0.8p)",\r
-          shader, bufsize, length, infolog);\r
-\r
-    try\r
-    {\r
-        if(bufsize < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Shader *shaderObject = context->getShader(shader);\r
-\r
-            if(!shaderObject)\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            shaderObject->getInfoLog(bufsize, length, infolog);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)\r
-{\r
-    TRACE("(GLenum shadertype = 0x%X, GLenum precisiontype = 0x%X, GLint* range = 0x%0.8p, GLint* precision = 0x%0.8p)",\r
-          shadertype, precisiontype, range, precision);\r
-\r
-    try\r
-    {\r
-        switch(shadertype)\r
-        {\r
-          case GL_VERTEX_SHADER:\r
-          case GL_FRAGMENT_SHADER:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-\r
-        switch(precisiontype)\r
-        {\r
-          case GL_LOW_FLOAT:\r
-          case GL_MEDIUM_FLOAT:\r
-          case GL_HIGH_FLOAT:\r
-            // IEEE 754 single-precision\r
-            range[0] = 127;\r
-            range[1] = 127;\r
-            *precision = 23;\r
-            break;\r
-          case GL_LOW_INT:\r
-          case GL_MEDIUM_INT:\r
-          case GL_HIGH_INT:\r
-            // Single-precision floating-point numbers can accurately represent integers up to +/-16777216\r
-            range[0] = 24;\r
-            range[1] = 24;\r
-            *precision = 0;\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source)\r
-{\r
-    TRACE("(GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLchar* source = 0x%0.8p)",\r
-          shader, bufsize, length, source);\r
-\r
-    try\r
-    {\r
-        if(bufsize < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Shader *shaderObject = context->getShader(shader);\r
-\r
-            if(!shaderObject)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            shaderObject->getSource(bufsize, length, source);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-const GLubyte* GL_APIENTRY glGetString(GLenum name)\r
-{\r
-    TRACE("(GLenum name = 0x%X)", name);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        switch(name)\r
-        {\r
-        case GL_VENDOR:\r
-            return (GLubyte*)"TransGaming Inc.";\r
-        case GL_RENDERER:\r
-            return (GLubyte*)"SwiftShader";\r
-        case GL_VERSION:\r
-            return (GLubyte*)"OpenGL ES 2.0 SwiftShader "VERSION_STRING;\r
-        case GL_SHADING_LANGUAGE_VERSION:\r
-            return (GLubyte*)"OpenGL ES GLSL ES 1.00 SwiftShader "VERSION_STRING;\r
-        case GL_EXTENSIONS:\r
-            // Keep list sorted in following order:\r
-               // OES extensions\r
-               // EXT extensions\r
-               // Vendor extensions\r
-            return (GLubyte*)\r
-                "GL_OES_depth_texture "\r
-                "GL_OES_depth_texture_cube_map "\r
-                "GL_OES_EGL_image "\r
-                "GL_OES_EGL_image_external "\r
-                "GL_OES_element_index_uint "\r
-                "GL_OES_packed_depth_stencil "\r
-                "GL_OES_rgb8_rgba8 "\r
-                "GL_OES_standard_derivatives "\r
-                "GL_OES_texture_float "\r
-                "GL_OES_texture_float_linear "\r
-                "GL_OES_texture_half_float "\r
-                "GL_OES_texture_half_float_linear "\r
-                "GL_OES_texture_npot "\r
-                "GL_EXT_blend_minmax "\r
-                "GL_EXT_occlusion_query_boolean "\r
-                "GL_EXT_read_format_bgra "\r
-                   #if (S3TC_SUPPORT)\r
-                "GL_EXT_texture_compression_dxt1 "\r
-                "GL_ANGLE_texture_compression_dxt3 "\r
-                "GL_ANGLE_texture_compression_dxt5 "\r
-                   #endif\r
-                "GL_EXT_texture_filter_anisotropic "\r
-                "GL_EXT_texture_format_BGRA8888 "\r
-                "GL_ANGLE_framebuffer_blit "\r
-                "GL_ANGLE_framebuffer_multisample "\r
-                "GL_NV_fence";\r
-        default:\r
-            return error(GL_INVALID_ENUM, (GLubyte*)NULL);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY, (GLubyte*)NULL);\r
-    }\r
-\r
-    return NULL;\r
-}\r
-\r
-void GL_APIENTRY glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat* params = 0x%0.8p)", target, pname, params);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Texture *texture;\r
-\r
-            switch(target)\r
-            {\r
-            case GL_TEXTURE_2D:\r
-                texture = context->getTexture2D();\r
-                break;\r
-            case GL_TEXTURE_CUBE_MAP:\r
-                texture = context->getTextureCubeMap();\r
-                break;\r
-            case GL_TEXTURE_EXTERNAL_OES:\r
-                texture = context->getTextureExternal();\r
-                break;\r
-            default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-\r
-            switch(pname)\r
-            {\r
-            case GL_TEXTURE_MAG_FILTER:\r
-                *params = (GLfloat)texture->getMagFilter();\r
-                break;\r
-            case GL_TEXTURE_MIN_FILTER:\r
-                *params = (GLfloat)texture->getMinFilter();\r
-                break;\r
-            case GL_TEXTURE_WRAP_S:\r
-                *params = (GLfloat)texture->getWrapS();\r
-                break;\r
-            case GL_TEXTURE_WRAP_T:\r
-                *params = (GLfloat)texture->getWrapT();\r
-                break;\r
-                       case GL_TEXTURE_MAX_ANISOTROPY_EXT:\r
-                *params = texture->getMaxAnisotropy();\r
-                break;\r
-            case GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES:\r
-                *params = (GLfloat)1;\r
-                break;\r
-            default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", target, pname, params);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Texture *texture;\r
-\r
-            switch(target)\r
-            {\r
-            case GL_TEXTURE_2D:\r
-                texture = context->getTexture2D();\r
-                break;\r
-            case GL_TEXTURE_CUBE_MAP:\r
-                texture = context->getTextureCubeMap();\r
-                break;\r
-            case GL_TEXTURE_EXTERNAL_OES:\r
-                texture = context->getTextureExternal();\r
-                break;\r
-            default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-\r
-            switch(pname)\r
-            {\r
-            case GL_TEXTURE_MAG_FILTER:\r
-                *params = texture->getMagFilter();\r
-                break;\r
-            case GL_TEXTURE_MIN_FILTER:\r
-                *params = texture->getMinFilter();\r
-                break;\r
-            case GL_TEXTURE_WRAP_S:\r
-                *params = texture->getWrapS();\r
-                break;\r
-            case GL_TEXTURE_WRAP_T:\r
-                *params = texture->getWrapT();\r
-                break;\r
-                   case GL_TEXTURE_MAX_ANISOTROPY_EXT:\r
-                *params = (GLint)texture->getMaxAnisotropy();\r
-                break;\r
-            case GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES:\r
-                *params = 1;\r
-                break;\r
-            default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetnUniformfvEXT(GLuint program, GLint location, GLsizei bufSize, GLfloat* params)\r
-{\r
-    TRACE("(GLuint program = %d, GLint location = %d, GLsizei bufSize = %d, GLfloat* params = 0x%0.8p)",\r
-          program, location, bufSize, params);\r
-\r
-    try\r
-    {\r
-        if(bufSize < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(program == 0)\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            rad::Program *programObject = context->getProgram(program);\r
-\r
-            if(!programObject || !programObject->isLinked())\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            if(!programObject->getUniformfv(location, &bufSize, params))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetUniformfv(GLuint program, GLint location, GLfloat* params)\r
-{\r
-    TRACE("(GLuint program = %d, GLint location = %d, GLfloat* params = 0x%0.8p)", program, location, params);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(program == 0)\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            rad::Program *programObject = context->getProgram(program);\r
-\r
-            if(!programObject || !programObject->isLinked())\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            if(!programObject->getUniformfv(location, NULL, params))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint* params)\r
-{\r
-    TRACE("(GLuint program = %d, GLint location = %d, GLsizei bufSize = %d, GLint* params = 0x%0.8p)", \r
-          program, location, bufSize, params);\r
-\r
-    try\r
-    {\r
-        if(bufSize < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(program == 0)\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            rad::Program *programObject = context->getProgram(program);\r
-\r
-            if(!programObject || !programObject->isLinked())\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            if(!programObject)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            if(!programObject->getUniformiv(location, &bufSize, params))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetUniformiv(GLuint program, GLint location, GLint* params)\r
-{\r
-    TRACE("(GLuint program = %d, GLint location = %d, GLint* params = 0x%0.8p)", program, location, params);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(program == 0)\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            rad::Program *programObject = context->getProgram(program);\r
-\r
-            if(!programObject || !programObject->isLinked())\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            if(!programObject)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            if(!programObject->getUniformiv(location, NULL, params))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-int GL_APIENTRY glGetUniformLocation(GLuint program, const GLchar* name)\r
-{\r
-    TRACE("(GLuint program = %d, const GLchar* name = 0x%0.8p)", program, name);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(strstr(name, "gl_") == name)\r
-        {\r
-            return -1;\r
-        }\r
-\r
-        if(context)\r
-        {\r
-            rad::Program *programObject = context->getProgram(program);\r
-\r
-            if(!programObject)\r
-            {\r
-                if(context->getShader(program))\r
-                {\r
-                    return error(GL_INVALID_OPERATION, -1);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_VALUE, -1);\r
-                }\r
-            }\r
-\r
-            if(!programObject->isLinked())\r
-            {\r
-                return error(GL_INVALID_OPERATION, -1);\r
-            }\r
-\r
-            return programObject->getUniformLocation(name);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY, -1);\r
-    }\r
-\r
-    return -1;\r
-}\r
-\r
-void GL_APIENTRY glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)\r
-{\r
-    TRACE("(GLuint index = %d, GLenum pname = 0x%X, GLfloat* params = 0x%0.8p)", index, pname, params);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(index >= rad::MAX_VERTEX_ATTRIBS)\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            const rad::VertexAttribute &attribState = context->getVertexAttribState(index);\r
-\r
-            switch(pname)\r
-            {\r
-              case GL_VERTEX_ATTRIB_ARRAY_ENABLED:\r
-                *params = (GLfloat)(attribState.mArrayEnabled ? GL_TRUE : GL_FALSE);\r
-                break;\r
-              case GL_VERTEX_ATTRIB_ARRAY_SIZE:\r
-                *params = (GLfloat)attribState.mSize;\r
-                break;\r
-              case GL_VERTEX_ATTRIB_ARRAY_STRIDE:\r
-                *params = (GLfloat)attribState.mStride;\r
-                break;\r
-              case GL_VERTEX_ATTRIB_ARRAY_TYPE:\r
-                *params = (GLfloat)attribState.mType;\r
-                break;\r
-              case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:\r
-                *params = (GLfloat)(attribState.mNormalized ? GL_TRUE : GL_FALSE);\r
-                break;\r
-              case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:\r
-                *params = (GLfloat)attribState.mBoundBuffer.id();\r
-                break;\r
-              case GL_CURRENT_VERTEX_ATTRIB:\r
-                for(int i = 0; i < 4; ++i)\r
-                {\r
-                    params[i] = attribState.mCurrentValue[i];\r
-                }\r
-                break;\r
-              default: return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)\r
-{\r
-    TRACE("(GLuint index = %d, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", index, pname, params);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(index >= rad::MAX_VERTEX_ATTRIBS)\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            const rad::VertexAttribute &attribState = context->getVertexAttribState(index);\r
-\r
-            switch(pname)\r
-            {\r
-              case GL_VERTEX_ATTRIB_ARRAY_ENABLED:\r
-                *params = (attribState.mArrayEnabled ? GL_TRUE : GL_FALSE);\r
-                break;\r
-              case GL_VERTEX_ATTRIB_ARRAY_SIZE:\r
-                *params = attribState.mSize;\r
-                break;\r
-              case GL_VERTEX_ATTRIB_ARRAY_STRIDE:\r
-                *params = attribState.mStride;\r
-                break;\r
-              case GL_VERTEX_ATTRIB_ARRAY_TYPE:\r
-                *params = attribState.mType;\r
-                break;\r
-              case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:\r
-                *params = (attribState.mNormalized ? GL_TRUE : GL_FALSE);\r
-                break;\r
-              case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:\r
-                *params = attribState.mBoundBuffer.id();\r
-                break;\r
-              case GL_CURRENT_VERTEX_ATTRIB:\r
-                for(int i = 0; i < 4; ++i)\r
-                {\r
-                    float currentValue = attribState.mCurrentValue[i];\r
-                    params[i] = (GLint)(currentValue > 0.0f ? floor(currentValue + 0.5f) : ceil(currentValue - 0.5f));\r
-                }\r
-                break;\r
-              default: return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer)\r
-{\r
-    TRACE("(GLuint index = %d, GLenum pname = 0x%X, GLvoid** pointer = 0x%0.8p)", index, pname, pointer);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            if(index >= rad::MAX_VERTEX_ATTRIBS)\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            if(pname != GL_VERTEX_ATTRIB_ARRAY_POINTER)\r
-            {\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-\r
-            *pointer = const_cast<GLvoid*>(context->getVertexAttribPointer(index));\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-void GL_APIENTRY glHint(GLenum target, GLenum mode)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLenum mode = 0x%X)", target, mode);\r
-\r
-    try\r
-    {\r
-        switch(mode)\r
-        {\r
-          case GL_FASTEST:\r
-          case GL_NICEST:\r
-          case GL_DONT_CARE:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM); \r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-        switch(target)\r
-        {\r
-          case GL_GENERATE_MIPMAP_HINT:\r
-            if(context) context->setGenerateMipmapHint(mode);\r
-            break;\r
-          case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:\r
-            if(context) context->setFragmentShaderDerivativeHint(mode);\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
-\r
-GLboolean GL_APIENTRY glIsBuffer(GLuint buffer)\r
-{\r
-    TRACE("(GLuint buffer = %d)", buffer);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context && buffer)\r
-        {\r
-            rad::Buffer *bufferObject = context->getBuffer(buffer);\r
-\r
-            if(bufferObject)\r
-            {\r
-                return GL_TRUE;\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY, GL_FALSE);\r
-    }\r
-\r
-    return GL_FALSE;\r
-}\r
-\r
-GLboolean GL_APIENTRY glIsEnabled(GLenum cap)\r
-{\r
-    TRACE("(GLenum cap = 0x%X)", cap);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            switch(cap)\r
-            {\r
-              case GL_CULL_FACE:                return context->isCullFaceEnabled();\r
-              case GL_POLYGON_OFFSET_FILL:      return context->isPolygonOffsetFillEnabled();\r
-              case GL_SAMPLE_ALPHA_TO_COVERAGE: return context->isSampleAlphaToCoverageEnabled();\r
-              case GL_SAMPLE_COVERAGE:          return context->isSampleCoverageEnabled();\r
-              case GL_SCISSOR_TEST:             return context->isScissorTestEnabled();\r
-              case GL_STENCIL_TEST:             return context->isStencilTestEnabled();\r
-              case GL_DEPTH_TEST:               return context->isDepthTestEnabled();\r
-              case GL_BLEND:                    return context->isBlendEnabled();\r
-              case GL_DITHER:                   return context->isDitherEnabled();\r
-              default:\r
-                return error(GL_INVALID_ENUM, false);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY, false);\r
-    }\r
-\r
-    return false;\r
-}\r
-\r
-GLboolean GL_APIENTRY glIsFenceNV(GLuint fence)\r
-{\r
-    TRACE("(GLuint fence = %d)", fence);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Fence *fenceObject = context->getFence(fence);\r
-\r
-            if(fenceObject == NULL)\r
-            {\r
-                return GL_FALSE;\r
-            }\r
-\r
-            return fenceObject->isFence();\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY, GL_FALSE);\r
-    }\r
-\r
-    return GL_FALSE;\r
-}\r
-\r
-GLboolean GL_APIENTRY glIsFramebuffer(GLuint framebuffer)\r
-{\r
-    TRACE("(GLuint framebuffer = %d)", framebuffer);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context && framebuffer)\r
-        {\r
-            rad::Framebuffer *framebufferObject = context->getFramebuffer(framebuffer);\r
-\r
-            if(framebufferObject)\r
-            {\r
-                return GL_TRUE;\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY, GL_FALSE);\r
-    }\r
-\r
-    return GL_FALSE;\r
-}\r
-\r
-GLboolean GL_APIENTRY glIsProgram(GLuint program)\r
-{\r
-    TRACE("(GLuint program = %d)", program);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context && program)\r
-        {\r
-            rad::Program *programObject = context->getProgram(program);\r
-\r
-            if(programObject)\r
-            {\r
-                return GL_TRUE;\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY, GL_FALSE);\r
-    }\r
-\r
-    return GL_FALSE;\r
-}\r
-\r
-GLboolean GL_APIENTRY glIsQueryEXT(GLuint id)\r
-{\r
-    TRACE("(GLuint id = %d)", id);\r
-\r
-    try\r
-    {\r
-        if(id == 0)\r
-        {\r
-            return GL_FALSE;\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Query *queryObject = context->getQuery(id, false, GL_NONE);\r
-\r
-            if(queryObject)\r
-            {\r
-                return GL_TRUE;\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY, GL_FALSE);\r
-    }\r
-\r
-    return GL_FALSE;\r
-}\r
-\r
-GLboolean GL_APIENTRY glIsRenderbuffer(GLuint renderbuffer)\r
-{\r
-    TRACE("(GLuint renderbuffer = %d)", renderbuffer);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context && renderbuffer)\r
-        {\r
-            rad::Renderbuffer *renderbufferObject = context->getRenderbuffer(renderbuffer);\r
-\r
-            if(renderbufferObject)\r
-            {\r
-                return GL_TRUE;\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY, GL_FALSE);\r
-    }\r
-\r
-    return GL_FALSE;\r
-}\r
-\r
-GLboolean GL_APIENTRY glIsShader(GLuint shader)\r
-{\r
-    TRACE("(GLuint shader = %d)", shader);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context && shader)\r
-        {\r
-            rad::Shader *shaderObject = context->getShader(shader);\r
-\r
-            if(shaderObject)\r
-            {\r
-                return GL_TRUE;\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY, GL_FALSE);\r
-    }\r
-\r
-    return GL_FALSE;\r
-}\r
-\r
-GLboolean GL_APIENTRY glIsTexture(GLuint texture)\r
-{\r
-    TRACE("(GLuint texture = %d)", texture);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context && texture)\r
-        {\r
-            rad::Texture *textureObject = context->getTexture(texture);\r
-\r
-            if(textureObject)\r
-            {\r
-                return GL_TRUE;\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY, GL_FALSE);\r
-    }\r
-\r
-    return GL_FALSE;\r
-}\r
+class Object;\r
+typedef std::set<const Object*> ObjectPool;\r
 \r
-void GL_APIENTRY glLineWidth(GLfloat width)\r
+class Device\r
 {\r
-    TRACE("(GLfloat width = %f)", width);\r
-\r
-    try\r
-    {\r
-        if(width <= 0.0f)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+public:\r
+       Device()\r
+       {\r
+               referenceCount = 1;\r
+       }\r
 \r
-        rad::Context *context = rad::getContext();\r
+       void reference()\r
+       {\r
+               sw::atomicIncrement(&referenceCount);\r
+       }\r
 \r
-        if(context)\r
-        {\r
-            context->setLineWidth(width);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
+       void release()\r
+       {\r
+               ASSERT(referenceCount > 0);\r
 \r
-void GL_APIENTRY glLinkProgram(GLuint program)\r
-{\r
-    TRACE("(GLuint program = %d)", program);\r
+               if(referenceCount > 0)\r
+               {\r
+                       sw::atomicDecrement(&referenceCount);\r
+               }\r
 \r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
+               if(referenceCount == 0)\r
+               {\r
+                       delete this;\r
+               }\r
+       }\r
 \r
-        if(context)\r
-        {\r
-            rad::Program *programObject = context->getProgram(program);\r
-\r
-            if(!programObject)\r
-            {\r
-                if(context->getShader(program))\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-            }\r
-\r
-            programObject->link();\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
+       void addObject(const Object *object)\r
+       {\r
+               pool.insert(object);\r
+       }\r
 \r
-void GL_APIENTRY glPixelStorei(GLenum pname, GLint param)\r
-{\r
-    TRACE("(GLenum pname = 0x%X, GLint param = %d)", pname, param);\r
+       void removeObject(const Object *object)\r
+       {\r
+               pool.erase(object);\r
+       }\r
 \r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
+private:\r
+       virtual ~Device()\r
+       {\r
+               ASSERT(referenceCount == 0);\r
 \r
-        if(context)\r
-        {\r
-            switch(pname)\r
-            {\r
-              case GL_UNPACK_ALIGNMENT:\r
-                if(param != 1 && param != 2 && param != 4 && param != 8)\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-\r
-                context->setUnpackAlignment(param);\r
-                break;\r
-\r
-              case GL_PACK_ALIGNMENT:\r
-                if(param != 1 && param != 2 && param != 4 && param != 8)\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-\r
-                context->setPackAlignment(param);\r
-                break;\r
-\r
-              default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
+               size_t leakedObjectCount = pool.size();\r
 \r
-void GL_APIENTRY glPolygonOffset(GLfloat factor, GLfloat units)\r
-{\r
-    TRACE("(GLfloat factor = %f, GLfloat units = %f)", factor, units);\r
+               if(leakedObjectCount != 0)\r
+               {\r
+                       const Object *leakedObject = *pool.begin();\r
+                       ASSERT(!leakedObject);\r
+               }\r
+       }\r
 \r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
+       volatile int referenceCount;\r
 \r
-        if(context)\r
-        {\r
-            context->setPolygonOffsetParams(factor, units);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
+       ObjectPool pool;\r
+};\r
 \r
-void GL_APIENTRY glReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height,\r
-                                GLenum format, GLenum type, GLsizei bufSize,\r
-                                GLvoid *data)\r
+class Object\r
 {\r
-    TRACE("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "\r
-          "GLenum format = 0x%X, GLenum type = 0x%X, GLsizei bufSize = 0x%d, GLvoid *data = 0x%0.8p)",\r
-          x, y, width, height, format, type, bufSize, data);\r
+public:\r
+       Object(Device *device) : device(device)\r
+       {\r
+               referenceCount = 1;\r
 \r
-    try\r
-    {\r
-        if(width < 0 || height < 0 || bufSize < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+               device->addObject(this);\r
+       }\r
 \r
-        if(!validReadFormatType(format, type))\r
-        {\r
-            return error(GL_INVALID_OPERATION);\r
-        }\r
+       void reference()\r
+       {\r
+               sw::atomicIncrement(&referenceCount);\r
+       }\r
 \r
-        rad::Context *context = rad::getContext();\r
+       void release()\r
+       {\r
+               ASSERT(referenceCount > 0);\r
 \r
-        if(context)\r
-        {\r
-            context->readPixels(x, y, width, height, format, type, &bufSize, data);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
+               if(referenceCount > 0)\r
+               {\r
+                       sw::atomicDecrement(&referenceCount);\r
+               }\r
 \r
-void GL_APIENTRY glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)\r
-{\r
-    TRACE("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "\r
-          "GLenum format = 0x%X, GLenum type = 0x%X, GLvoid* pixels = 0x%0.8p)",\r
-          x, y, width, height, format, type,  pixels);\r
+               if(referenceCount == 0)\r
+               {\r
+                       device->removeObject(this);\r
 \r
-    try\r
-    {\r
-        if(width < 0 || height < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+                       delete this;\r
+               }\r
+       }\r
 \r
-        if(!validReadFormatType(format, type))\r
-        {\r
-            return error(GL_INVALID_OPERATION);\r
-        }\r
+protected:\r
+       virtual ~Object()\r
+       {\r
+               ASSERT(referenceCount == 0);\r
+       }\r
 \r
-        rad::Context *context = rad::getContext();\r
+       Device *const device;\r
 \r
-        if(context)\r
-        {\r
-            context->readPixels(x, y, width, height, format, type, NULL, pixels);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
+private:\r
+       volatile int referenceCount;\r
+};\r
 \r
-void GL_APIENTRY glReleaseShaderCompiler(void)\r
+static void Release(Object *object)\r
 {\r
-    TRACE("()");\r
-\r
-    try\r
-    {\r
-        rad::Shader::releaseCompiler();\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+       if(object)\r
+       {\r
+               object->release();\r
+       }\r
 }\r
 \r
-void GL_APIENTRY glRenderbufferStorageMultisampleANGLE(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)\r
+class Buffer : public Object\r
 {\r
-    TRACE("(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = %d)",\r
-          target, samples, internalformat, width, height);\r
+public:\r
+       Buffer(Device *device) : Object(device)\r
+       {\r
+               buffer = nullptr;\r
+               access = 0;      // FIXME: default?\r
+               mapAccess = 0;   // FIXME: default?\r
+       }\r
 \r
-    try\r
-    {\r
-        switch(target)\r
-        {\r
-          case GL_RENDERBUFFER:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
+       virtual ~Buffer()\r
+       {\r
+               if(buffer)\r
+               {\r
+                       buffer->release();\r
+               }\r
+       }\r
+\r
+       void storage(RADsizei size)\r
+       {\r
+               ASSERT(!buffer);\r
+               buffer = new es2::Buffer(0);\r
+               buffer->addRef();\r
+               buffer->mContents = new sw::Resource(size);\r
+               buffer->mSize = size;\r
+       }\r
+\r
+       void *map()\r
+       {\r
+               ASSERT(buffer);\r
+               return const_cast<void*>(buffer->data());\r
+       }\r
+\r
+       es2::Buffer *buffer;\r
+\r
+       RADbitfield access;\r
+       RADbitfield mapAccess;\r
+};\r
+\r
+class Sampler : public Object\r
+{\r
+public:\r
+       Sampler(Device *device) : Object(device)\r
+       {\r
+               default();\r
+       }\r
+\r
+       virtual ~Sampler()\r
+       {\r
+       }\r
+\r
+       void default()\r
+       {\r
+               minFilter = RAD_MIN_FILTER_NEAREST_MIPMAP_LINEAR;   // FIXME: default?\r
+               magFilter = RAD_MAG_FILTER_LINEAR;                  // FIXME: default?\r
+\r
+               wrapModeS = RAD_WRAP_MODE_REPEAT;   // FIXME: default?\r
+               wrapModeT = RAD_WRAP_MODE_REPEAT;   // FIXME: default?\r
+               wrapModeR = RAD_WRAP_MODE_REPEAT;   // FIXME: default?\r
+\r
+               minLod = -1000.0f;   // FIXME: default?\r
+               maxLod = 1000.0f;   // FIXME: default?\r
+               lodBias = 0.0f;\r
+               compareMode = RAD_COMPARE_MODE_NONE;\r
+               compareFunc = RAD_COMPARE_FUNC_LEQUAL;   // FIXME: default?\r
+               borderColor[0] = 0.0f;   // FIXME: default?\r
+               borderColor[1] = 0.0f;   // FIXME: default?\r
+               borderColor[2] = 0.0f;   // FIXME: default?\r
+               borderColor[3] = 0.0f;   // FIXME: default?\r
+               borderColorInt[0] = 0;   // FIXME: default?\r
+               borderColorInt[1] = 0;   // FIXME: default?\r
+               borderColorInt[2] = 0;   // FIXME: default?\r
+               borderColorInt[3] = 0;   // FIXME: default?\r
+       }\r
+\r
+       RADminFilter minFilter;\r
+       RADmagFilter magFilter;\r
+\r
+       RADwrapMode wrapModeS;\r
+       RADwrapMode wrapModeT;\r
+       RADwrapMode wrapModeR;\r
+\r
+       RADfloat minLod;\r
+       RADfloat maxLod;\r
+       RADfloat lodBias;\r
+       RADcompareMode compareMode;\r
+       RADcompareFunc compareFunc;\r
+       RADfloat borderColor[4];\r
+       RADuint borderColorInt[4];\r
+};\r
+\r
+class Texture;\r
+\r
+struct TextureSampler\r
+{\r
+       TextureSampler(Texture *texture, Sampler *sampler, RADtextureTarget target, RADinternalFormat internalFormat, RADuint minLevel, RADuint numLevels, RADuint minLayer, RADuint numLayers);\r
+\r
+       virtual TextureSampler::~TextureSampler();\r
+\r
+       Texture *texture;\r
+       Sampler *sampler;\r
+       RADtextureTarget target;\r
+       RADinternalFormat internalFormat;\r
+       RADuint minLevel;\r
+       RADuint numLevels;\r
+       RADuint minLayer;\r
+       RADuint numLayers;\r
+};\r
+\r
+class Texture : public Object\r
+{\r
+public:\r
+       Texture(Device *device) : Object(device)\r
+       {\r
+               texture = nullptr;\r
+               access = 0;   // FIXME: default?\r
+               //target = 0;\r
+               //levels = 0;\r
+               //internalFormat = 0;\r
+               //width = 0;\r
+               //height = 0;\r
+               //depth = 0;\r
+               //samples = 0;\r
+       }\r
+\r
+       virtual ~Texture()\r
+       {\r
+               if(texture)\r
+               {\r
+                       texture->release();\r
+               }\r
 \r
-        if(!rad::IsColorRenderable(internalformat) && !rad::IsDepthRenderable(internalformat) && !rad::IsStencilRenderable(internalformat))\r
-        {\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
+               for(size_t i = 0; i < textureSamplers.size(); i++)\r
+               {\r
+                       delete textureSamplers[i];\r
+               }\r
+       }\r
 \r
-        if(width < 0 || height < 0 || samples < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+       es2::Texture *texture;\r
 \r
-        rad::Context *context = rad::getContext();\r
+       RADbitfield access;\r
 \r
-        if(context)\r
-        {\r
-            if(width > rad::IMPLEMENTATION_MAX_RENDERBUFFER_SIZE || \r
-               height > rad::IMPLEMENTATION_MAX_RENDERBUFFER_SIZE ||\r
-               samples > rad::IMPLEMENTATION_MAX_SAMPLES)\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            GLuint handle = context->getRenderbufferHandle();\r
-            if(handle == 0)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            switch(internalformat)\r
-            {\r
-              case GL_DEPTH_COMPONENT16:\r
-                context->setRenderbufferStorage(new rad::Depthbuffer(width, height, samples));\r
-                break;\r
-              case GL_RGBA4:\r
-              case GL_RGB5_A1:\r
-              case GL_RGB565:\r
-              case GL_RGB8_OES:\r
-              case GL_RGBA8_OES:\r
-                context->setRenderbufferStorage(new rad::Colorbuffer(width, height, internalformat, samples));\r
-                break;\r
-              case GL_STENCIL_INDEX8:\r
-                context->setRenderbufferStorage(new rad::Stencilbuffer(width, height, samples));\r
-                break;\r
-              case GL_DEPTH24_STENCIL8_OES:\r
-                context->setRenderbufferStorage(new rad::DepthStencilbuffer(width, height, samples));\r
-                break;\r
-              default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
+       RADtextureTarget target;\r
+       RADsizei levels;\r
+       RADinternalFormat internalFormat;\r
+       RADsizei width;\r
+       RADsizei height;\r
+       RADsizei depth;\r
+       RADsizei samples;\r
 \r
-void GL_APIENTRY glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)\r
-{\r
-    glRenderbufferStorageMultisampleANGLE(target, 0, internalformat, width, height);\r
-}\r
+       std::vector<TextureSampler*> textureSamplers;\r
+};\r
 \r
-void GL_APIENTRY glSampleCoverage(GLclampf value, GLboolean invert)\r
+TextureSampler::TextureSampler(Texture *texture, Sampler *sampler, RADtextureTarget target, RADinternalFormat internalFormat, RADuint minLevel, RADuint numLevels, RADuint minLayer, RADuint numLayers)\r
 {\r
-    TRACE("(GLclampf value = %f, GLboolean invert = %d)", value, invert);\r
-\r
-    try\r
-    {\r
-        rad::Context* context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            context->setSampleCoverageParams(rad::clamp01(value), invert == GL_TRUE);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+       ASSERT(texture);\r
+       ASSERT(sampler);\r
+       //texture->reference();\r
+       this->texture = texture;\r
+       //sampler->reference();\r
+       this->sampler = sampler;\r
+       this->target = target;\r
+       this->internalFormat = internalFormat;\r
+       this->minLevel = minLevel;\r
+       this->numLevels = numLevels;\r
+       this->minLayer = minLayer;\r
+       this->numLayers = numLayers;\r
 }\r
 \r
-void GL_APIENTRY glSetFenceNV(GLuint fence, GLenum condition)\r
+TextureSampler::~TextureSampler()\r
 {\r
-    TRACE("(GLuint fence = %d, GLenum condition = 0x%X)", fence, condition);\r
+       //texture->release();\r
+       //sampler->release();\r
+}\r
 \r
-    try\r
-    {\r
-        if(condition != GL_ALL_COMPLETED_NV)\r
-        {\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
+class Pass;\r
 \r
-        rad::Context *context = rad::getContext();\r
+class Program : public Object\r
+{\r
+public:\r
+       Program(Device *device) : Object(device)\r
+       {\r
+               program = new es2::Program(nullptr, 0);\r
+       }\r
 \r
-        if(context)\r
-        {\r
-            rad::Fence *fenceObject = context->getFence(fence);\r
+       virtual ~Program()\r
+       {\r
+               program->release();\r
+       }\r
 \r
-            if(fenceObject == NULL)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
+       es2::Program *program;\r
+};\r
 \r
-            fenceObject->setFence(condition);    \r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+template<typename T, size_t n>\r
+inline size_t arraySize(T(&)[n])\r
+{\r
+       return n;\r
 }\r
 \r
-void GL_APIENTRY glScissor(GLint x, GLint y, GLsizei width, GLsizei height)\r
-{\r
-    TRACE("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)", x, y, width, height);\r
+const int RAD_MAX_COLOR_TARGETS = 1;\r
 \r
-    try\r
-    {\r
-        if(width < 0 || height < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+struct ColorState : public Object\r
+{\r
+       ColorState(Device *device) : Object(device)\r
+       {\r
+               default();\r
+       }\r
 \r
-        rad::Context* context = rad::getContext();\r
+       void default()\r
+       {\r
+               enable = RAD_FALSE;\r
 \r
-        if(context)\r
-        {\r
-            context->setScissorParams(x, y, width, height);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
+               for(size_t i = 0; i < arraySize(blend); i++)\r
+               {\r
+                       blend[i].default();\r
+               }\r
 \r
-void GL_APIENTRY glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length)\r
-{\r
-    TRACE("(GLsizei n = %d, const GLuint* shaders = 0x%0.8p, GLenum binaryformat = 0x%X, "\r
-          "const GLvoid* binary = 0x%0.8p, GLsizei length = %d)",\r
-          n, shaders, binaryformat, binary, length);\r
+               numTargets = 1;\r
+               logicOpEnable = RAD_FALSE;\r
+               logicOp = RAD_LOGIC_OP_COPY;\r
+               alphaToCoverageEnable = RAD_FALSE;\r
+               blendColor[0] = 0.0f;\r
+               blendColor[1] = 0.0f;\r
+               blendColor[2] = 0.0f;\r
+               blendColor[3] = 0.0f;\r
+       }\r
+\r
+       RADboolean enable;\r
+       \r
+       struct Blend\r
+       {\r
+               Blend()\r
+               {\r
+                       default();\r
+               }\r
 \r
-    try\r
-    {\r
-        // No binary shader formats are supported.\r
-        return error(GL_INVALID_ENUM);\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
+               void default()\r
+               {\r
+                       enable = RAD_FALSE;\r
+                       srcFunc = RAD_BLEND_FUNC_ONE;\r
+                       dstFunc = RAD_BLEND_FUNC_ZERO;\r
+                       srcFuncAlpha = RAD_BLEND_FUNC_ONE;\r
+                       dstFuncAlpha = RAD_BLEND_FUNC_ZERO;\r
+                       modeRGB = RAD_BLEND_EQUATION_ADD;\r
+                       modeAlpha = RAD_BLEND_EQUATION_ADD;\r
+                       maskRGBA[0] = RAD_TRUE;\r
+                       maskRGBA[1] = RAD_TRUE;\r
+                       maskRGBA[2] = RAD_TRUE;\r
+                       maskRGBA[3] = RAD_TRUE;\r
+               }\r
 \r
-void GL_APIENTRY glShaderSource(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length)\r
-{\r
-    TRACE("(GLuint shader = %d, GLsizei count = %d, const GLchar** string = 0x%0.8p, const GLint* length = 0x%0.8p)",\r
-          shader, count, string, length);\r
+               RADboolean enable;\r
+               RADblendFunc srcFunc;\r
+               RADblendFunc dstFunc;\r
+               RADblendFunc srcFuncAlpha;\r
+               RADblendFunc dstFuncAlpha;\r
+               RADblendEquation modeRGB;\r
+               RADblendEquation modeAlpha;\r
+               RADboolean maskRGBA[4];\r
+       };\r
+\r
+       Blend blend[RAD_MAX_COLOR_TARGETS];\r
+\r
+       RADuint numTargets;\r
+       RADboolean logicOpEnable;\r
+       RADlogicOp logicOp;\r
+       RADboolean alphaToCoverageEnable;\r
+       RADfloat blendColor[4];\r
+};\r
+\r
+struct RasterState : public Object\r
+{\r
+       RasterState(Device *device) : Object(device)\r
+       {\r
+               default();\r
+       }\r
+\r
+       void default()\r
+       {\r
+               pointSize = 1.0f;\r
+               lineWidth = 1.0f;\r
+               cullFace = RAD_FACE_NONE;\r
+               frontFace = RAD_FRONT_FACE_CW;\r
+               polygonMode = RAD_POLYGON_MODE_FILL;\r
+       \r
+               offsetFactor = 0.0f;\r
+               offsetUnits = 0.0f;\r
+               offsetClamp = 0.0f;\r
+\r
+               polygonOffsetEnables = RAD_POLYGON_OFFSET_NONE;\r
+               discardEnable = RAD_FALSE;\r
+               multisampleEnable = RAD_TRUE;\r
+\r
+               samples = 0;\r
+               sampleMask = ~0;\r
+       }\r
+\r
+       RADfloat pointSize;\r
+       RADfloat lineWidth;\r
+       RADfaceBitfield cullFace;\r
+       RADfrontFace frontFace;\r
+       RADpolygonMode polygonMode;\r
+       \r
+       RADfloat offsetFactor;\r
+       RADfloat offsetUnits;\r
+       RADfloat offsetClamp;\r
+\r
+       RADpolygonOffsetEnables polygonOffsetEnables;\r
+       RADboolean discardEnable;\r
+       RADboolean multisampleEnable;\r
+\r
+       RADuint samples;\r
+       RADuint sampleMask;\r
+};\r
+\r
+struct DepthStencilState : public Object\r
+{\r
+       DepthStencilState(Device *device) : Object(device)\r
+       {\r
+               default();\r
+       }\r
+\r
+       void default()\r
+       {\r
+               depthTestEnable = RAD_FALSE;\r
+               depthWriteEnable = RAD_FALSE;\r
+               depthFunc = RAD_DEPTH_FUNC_LESS;\r
+               stencilTestEnable = RAD_FALSE;\r
+\r
+               stencilFuncFront = RAD_STENCIL_FUNC_ALWAYS;\r
+               stencilRefFront = 0;\r
+               stencilMaskFront = ~0;\r
+\r
+               stencilFuncBack = RAD_STENCIL_FUNC_ALWAYS;\r
+               stencilRefBack = 0;\r
+               stencilMaskBack = ~0;\r
+\r
+               stencilFailOpFront = RAD_STENCIL_OP_KEEP;\r
+               depthFailOpFront = RAD_STENCIL_OP_KEEP;\r
+               depthPassOpFront = RAD_STENCIL_OP_KEEP;\r
+\r
+               stencilFailOpBack = RAD_STENCIL_OP_KEEP;\r
+               depthFailOpBack = RAD_STENCIL_OP_KEEP;\r
+               depthPassOpBack = RAD_STENCIL_OP_KEEP;\r
+\r
+               stencilWriteMaskFront = ~0;\r
+               stencilWriteMaskBack = ~0;\r
+       }\r
+\r
+       RADboolean depthTestEnable;\r
+       RADboolean depthWriteEnable;\r
+       RADdepthFunc depthFunc;\r
+       RADboolean stencilTestEnable;\r
+       \r
+       RADstencilFunc stencilFuncFront;\r
+       RADint stencilRefFront;\r
+       RADuint stencilMaskFront;\r
+\r
+       RADstencilFunc stencilFuncBack;\r
+       RADint stencilRefBack;\r
+       RADuint stencilMaskBack;\r
+\r
+       RADstencilOp stencilFailOpFront;\r
+       RADstencilOp depthFailOpFront;\r
+       RADstencilOp depthPassOpFront;\r
+\r
+       RADstencilOp stencilFailOpBack;\r
+       RADstencilOp depthFailOpBack;\r
+       RADstencilOp depthPassOpBack;\r
+\r
+       RADuint stencilWriteMaskFront;\r
+       RADuint stencilWriteMaskBack;\r
+};\r
+\r
+const int RAD_MAX_VERTEX_ATTRIB = 16;\r
+const int RAD_MAX_VERTEX_BINDING = 16;\r
+\r
+struct VertexState : public Object\r
+{\r
+       VertexState(Device *device) : Object(device)\r
+       {\r
+               default();\r
+       }\r
+\r
+       void default()\r
+       {\r
+               for(size_t i = 0; i < arraySize(attrib); i++)\r
+               {\r
+                       attrib[i].default();\r
+               }\r
 \r
-    try\r
-    {\r
-        if(count < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+               for(size_t i = 0; i < arraySize(binding); i++)\r
+               {\r
+                       binding[i].default();\r
+               }\r
+       }\r
 \r
-        rad::Context *context = rad::getContext();\r
+       struct Attribute\r
+       {\r
+               Attribute()\r
+               {\r
+                       default();\r
+               }\r
 \r
-        if(context)\r
-        {\r
-            rad::Shader *shaderObject = context->getShader(shader);\r
-\r
-            if(!shaderObject)\r
-            {\r
-                if(context->getProgram(shader))\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-            }\r
-\r
-            shaderObject->setSource(count, string, length);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
+               void default()\r
+               {\r
+                       enable = RAD_FALSE;\r
+                       bindingIndex = 0;\r
+                       numComponents = 0;\r
+                       bytesPerComponent = 0;\r
+                       type = RAD_ATTRIB_TYPE_SNORM;\r
+                       relativeOffset = 0;\r
+               }\r
 \r
-void GL_APIENTRY glStencilFunc(GLenum func, GLint ref, GLuint mask)\r
-{\r
-    glStencilFuncSeparate(GL_FRONT_AND_BACK, func, ref, mask);\r
-}\r
+               RADboolean enable;\r
+               \r
+               RADint bindingIndex;\r
+               \r
+               RADint numComponents;\r
+               RADint bytesPerComponent;\r
+               RADattribType type;\r
+               RADuint relativeOffset;\r
+       };\r
 \r
-void GL_APIENTRY glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)\r
-{\r
-    TRACE("(GLenum face = 0x%X, GLenum func = 0x%X, GLint ref = %d, GLuint mask = %d)", face, func, ref, mask);\r
+       Attribute attrib[RAD_MAX_VERTEX_ATTRIB];\r
 \r
-    try\r
-    {\r
-        switch(face)\r
-        {\r
-          case GL_FRONT:\r
-          case GL_BACK:\r
-          case GL_FRONT_AND_BACK:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
+       struct Binding\r
+       {\r
+               Binding()\r
+               {\r
+                       default();\r
+               }\r
 \r
-        switch(func)\r
-        {\r
-          case GL_NEVER:\r
-          case GL_ALWAYS:\r
-          case GL_LESS:\r
-          case GL_LEQUAL:\r
-          case GL_EQUAL:\r
-          case GL_GEQUAL:\r
-          case GL_GREATER:\r
-          case GL_NOTEQUAL:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
+               void default()\r
+               {\r
+                       group = 0;\r
+                       index = 0;\r
+                       stride = 0;\r
+               }\r
 \r
-        rad::Context *context = rad::getContext();\r
+               RADint group;\r
+               RADint index;\r
 \r
-        if(context)\r
-        {\r
-            if(face == GL_FRONT || face == GL_FRONT_AND_BACK)\r
-            {\r
-                context->setStencilParams(func, ref, mask);\r
-            }\r
-\r
-            if(face == GL_BACK || face == GL_FRONT_AND_BACK)\r
-            {\r
-                context->setStencilBackParams(func, ref, mask);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
+               RADuint stride;\r
+       };\r
 \r
-void GL_APIENTRY glStencilMask(GLuint mask)\r
-{\r
-    glStencilMaskSeparate(GL_FRONT_AND_BACK, mask);\r
-}\r
+       Binding binding[RAD_MAX_VERTEX_BINDING];\r
+};\r
 \r
-void GL_APIENTRY glStencilMaskSeparate(GLenum face, GLuint mask)\r
+struct FormatState : public Object\r
 {\r
-    TRACE("(GLenum face = 0x%X, GLuint mask = %d)", face, mask);\r
+       FormatState(Device *device) : Object(device)\r
+       {\r
+               default();\r
+       }\r
 \r
-    try\r
-    {\r
-        switch(face)\r
-        {\r
-          case GL_FRONT:\r
-          case GL_BACK:\r
-          case GL_FRONT_AND_BACK:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
+       void default()\r
+       {\r
+               for(size_t i = 0; i < arraySize(colorFormat); i++)\r
+               {\r
+                       colorFormat[i] = RAD_FORMAT_NONE;\r
+               }\r
 \r
-        rad::Context *context = rad::getContext();\r
+               depthFormat = RAD_FORMAT_NONE;\r
+               stencilFormat = RAD_FORMAT_NONE;\r
+               colorSamples = 0;\r
+               depthStencilSamples = 0;\r
+       }\r
+\r
+       RADinternalFormat colorFormat[RAD_MAX_COLOR_TARGETS];\r
+       RADinternalFormat depthFormat;\r
+       RADinternalFormat stencilFormat;\r
+       RADuint colorSamples;\r
+       RADuint depthStencilSamples;\r
+};\r
+\r
+class Pipeline : public Object\r
+{\r
+public:\r
+       Pipeline(Device *device) : Object(device)\r
+       {\r
+               vertexProgram = nullptr;\r
+               fragmentProgram = nullptr;\r
+               vertexState = nullptr;\r
+               colorState = nullptr;\r
+               rasterState = nullptr;\r
+               depthStencilState = nullptr;\r
+               formatState = nullptr;\r
+               primitiveType = RAD_TRIANGLES;\r
+       }\r
+\r
+       virtual ~Pipeline()\r
+       {\r
+               Release(vertexProgram);\r
+               Release(fragmentProgram);\r
+               Release(vertexState);\r
+               Release(colorState);\r
+               Release(rasterState);\r
+               Release(depthStencilState);\r
+               Release(formatState);\r
+       }\r
+\r
+       Program *vertexProgram;\r
+       Program *fragmentProgram;\r
+       VertexState *vertexState;\r
+       ColorState *colorState;\r
+       RasterState *rasterState;\r
+       DepthStencilState *depthStencilState;\r
+       FormatState *formatState;\r
+       RADprimitiveType primitiveType;\r
+};\r
+\r
+const int RAD_MAX_ATTACHMENTS = 1 /*depth*/ + 1 /*stencil*/ + RAD_MAX_COLOR_TARGETS;\r
+\r
+class Pass : public Object\r
+{\r
+public:\r
+       Pass(Device *device) : Object(device)\r
+       {\r
+               default();\r
+       }\r
+\r
+       virtual ~Pass()\r
+       {\r
+               for(size_t i = 0; i < arraySize(colorTarget); i++)\r
+               {\r
+                       if(colorTarget[i])\r
+                       {\r
+                               colorTarget[i]->release();\r
+                       }\r
+               }\r
 \r
-        if(context)\r
-        {\r
-            if(face == GL_FRONT || face == GL_FRONT_AND_BACK)\r
-            {\r
-                context->setStencilWritemask(mask);\r
-            }\r
-\r
-            if(face == GL_BACK || face == GL_FRONT_AND_BACK)\r
-            {\r
-                context->setStencilBackWritemask(mask);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
+               if(depthTarget)\r
+               {\r
+                       depthTarget->release();\r
+               }\r
 \r
-void GL_APIENTRY glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)\r
-{\r
-    glStencilOpSeparate(GL_FRONT_AND_BACK, fail, zfail, zpass);\r
-}\r
+               if(stencilTarget)\r
+               {\r
+                       stencilTarget->release();\r
+               }\r
+       }\r
 \r
-void GL_APIENTRY glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)\r
-{\r
-    TRACE("(GLenum face = 0x%X, GLenum fail = 0x%X, GLenum zfail = 0x%X, GLenum zpas = 0x%Xs)",\r
-          face, fail, zfail, zpass);\r
+       void default()\r
+       {\r
+               numColors = 0;\r
 \r
-    try\r
-    {\r
-        switch(face)\r
-        {\r
-          case GL_FRONT:\r
-          case GL_BACK:\r
-          case GL_FRONT_AND_BACK:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
+               for(size_t i = 0; i < arraySize(colorTarget); i++)\r
+               {\r
+                       colorTarget[i] = nullptr;\r
+               }\r
 \r
-        switch(fail)\r
-        {\r
-          case GL_ZERO:\r
-          case GL_KEEP:\r
-          case GL_REPLACE:\r
-          case GL_INCR:\r
-          case GL_DECR:\r
-          case GL_INVERT:\r
-          case GL_INCR_WRAP:\r
-          case GL_DECR_WRAP:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
+               depthTarget = nullptr;\r
+               stencilTarget = nullptr;\r
 \r
-        switch(zfail)\r
-        {\r
-          case GL_ZERO:\r
-          case GL_KEEP:\r
-          case GL_REPLACE:\r
-          case GL_INCR:\r
-          case GL_DECR:\r
-          case GL_INVERT:\r
-          case GL_INCR_WRAP:\r
-          case GL_DECR_WRAP:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
+               for(size_t i = 0; i < arraySize(preserveEnable); i++)\r
+               {\r
+                       preserveEnable[i] = RAD_TRUE;\r
+               }\r
+       }\r
+\r
+       RADuint numColors;\r
+       es2::Image *colorTarget[RAD_MAX_COLOR_TARGETS];\r
+       es2::Image *depthTarget;\r
+       es2::Image *stencilTarget;\r
+\r
+       RADboolean preserveEnable[RAD_MAX_ATTACHMENTS];\r
+\r
+       //RADuint numDiscardTextures;\r
+       //const RADtexture *discardTextures;\r
+       //const RADoffset2D *discardOffsets;\r
+       //\r
+       //RADtexture resolveTexture[RAD_MAX_ATTACHMENTS];\r
+\r
+       //RADuint numStoreTextures;\r
+       //const RADtexture *storeTextures;\r
+       //const RADoffset2D *storeOffsets;\r
+       //\r
+       //const RADrect2D *clipRect;\r
+\r
+       //RADuint numDependencies;\r
+       //const RADpass *dependentPasses;\r
+       //const RADbitfield *srcMask;\r
+       //const RADbitfield *dstMask;\r
+       //const RADbitfield *flushMask;\r
+       //const RADbitfield *invalidateMask;\r
+\r
+       //RADboolean tilingBoundary;\r
+\r
+       //RADuint tileFilterWidth;\r
+       //RADuint tileTilterHeight;\r
+\r
+       //RADuint bytesPerPixel;\r
+       //RADuint footprintFilterWidth;\r
+       //RADuint footprintFilterHeight;\r
+};\r
+\r
+class Command\r
+{\r
+public:\r
+       Command()\r
+       {\r
+               //pipeline = nullptr;\r
+               //pass = nullptr;\r
+       }\r
+\r
+       virtual ~Command()\r
+       {\r
+               //Release(pipeline);\r
+               //Release(pass);\r
+       }\r
+\r
+       virtual void execute(Pipeline *pipeline, Pass *pass) = 0;   // FIXME: Just queue as parameter?\r
+\r
+       virtual bool isPresent() const\r
+       {\r
+               return false;\r
+       }\r
+\r
+       //void setPipeline(Pipeline *pipeline)\r
+       //{\r
+       //      if(pipeline)\r
+       //      {\r
+       //              pipeline->reference();\r
+       //              this->pipeline = pipeline;\r
+       //      }\r
+       //}\r
+\r
+       //void setPass(Pass *pass)\r
+       //{\r
+       //      if(pass)\r
+       //      {\r
+       //              pass->reference();\r
+       //              this->pass = pass;\r
+       //      }\r
+       //}\r
+\r
+protected:\r
+       //Pipeline *pipeline;   // FIXME: Command-specific state captured in their constructor?\r
+       //Pass *pass;\r
+};\r
+\r
+class CopyBufferToImage : public Command\r
+{\r
+public:\r
+       CopyBufferToImage(Buffer *buffer, RADintptr bufferOffset, Texture *texture, RADint level, RADuint xoffset, RADuint yoffset, RADuint zoffset, RADsizei width, RADsizei height, RADsizei depth)\r
+       {\r
+               ASSERT(buffer);\r
+               ASSERT(texture);\r
+               buffer->reference();\r
+               this->buffer = buffer;\r
+               this->bufferOffset = bufferOffset;\r
+               texture->reference();\r
+               this->texture = texture;\r
+               this->level = level;\r
+               this->xoffset = xoffset;\r
+               this->yoffset = yoffset;\r
+               this->zoffset = zoffset;\r
+               this->width = width;\r
+               this->height = height;\r
+               this->depth = depth;\r
+       }\r
+\r
+       virtual ~CopyBufferToImage()\r
+       {\r
+               buffer->release();\r
+               texture->release();\r
+       }\r
+\r
+       virtual void execute(Pipeline *pipeline, Pass *pass)\r
+       {\r
+               ASSERT(depth == 1);   // FIXME: Unimplemented\r
+               egl::Image *image = texture->texture->getRenderTarget(GL_TEXTURE_2D, level);\r
+               uint8_t *output = static_cast<uint8_t*>(image->lock(xoffset, yoffset, sw::LOCK_WRITEONLY));   // FIXME: Discard if whole image\r
+               unsigned int pitch = image->getPitch();\r
+               const uint8_t *input = static_cast<const uint8_t*>(buffer->map()) + bufferOffset;   // FIXME: Necessary to lock?\r
+\r
+               ASSERT(texture->internalFormat == RAD_RGBA8);   // FIXME: Unimplemented\r
+               int bytesPerTexel = 4;\r
+\r
+               for(int y = 0; y < height; y++)\r
+               {\r
+                       const uint8_t *source = input + y * (width * bytesPerTexel);\r
+                       uint8_t *dest = output + y * pitch;\r
 \r
-        switch(zpass)\r
-        {\r
-          case GL_ZERO:\r
-          case GL_KEEP:\r
-          case GL_REPLACE:\r
-          case GL_INCR:\r
-          case GL_DECR:\r
-          case GL_INVERT:\r
-          case GL_INCR_WRAP:\r
-          case GL_DECR_WRAP:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
+                       memcpy(dest, source, width * bytesPerTexel);\r
+               }\r
 \r
-        rad::Context *context = rad::getContext();\r
+               image->unlock();\r
+       }\r
+\r
+       Buffer *buffer;\r
+       RADintptr bufferOffset;\r
+       Texture *texture;\r
+       RADint level;\r
+       RADuint xoffset;\r
+       RADuint yoffset;\r
+       RADuint zoffset;\r
+       RADsizei width;\r
+       RADsizei height;\r
+       RADsizei depth;\r
+};\r
+\r
+class Scissor : public Command\r
+{\r
+public:\r
+       Scissor(RADint x, RADint y, RADint w, RADint h)\r
+       {\r
+               this->x = x;\r
+               this->y = y;\r
+               this->w = w;\r
+               this->h = h;\r
+       }\r
+\r
+       virtual ~Scissor()\r
+       {\r
+       }\r
+\r
+       virtual void execute(Pipeline *pipeline, Pass *pass)\r
+       {\r
+               es2::Context *context = es2::getContext();\r
+               context->setScissorParams(x, y, w, h);\r
+       }\r
+\r
+       RADint x;\r
+       RADint y;\r
+       RADint w;\r
+       RADint h;\r
+};\r
+\r
+class Viewport : public Command\r
+{\r
+public:\r
+       Viewport(RADint x, RADint y, RADint w, RADint h)\r
+       {\r
+               this->x = x;\r
+               this->y = y;\r
+               this->w = w;\r
+               this->h = h;\r
+       }\r
+\r
+       virtual ~Viewport()\r
+       {\r
+       }\r
+\r
+       virtual void execute(Pipeline *pipeline, Pass *pass)\r
+       {\r
+               es2::Context *context = es2::getContext();\r
+               context->setViewportParams(x, y, w, h);\r
+       }\r
+\r
+       RADint x;\r
+       RADint y;\r
+       RADint w;\r
+       RADint h;\r
+};\r
+\r
+class ClearColor : public Command\r
+{\r
+public:\r
+       ClearColor(RADuint index, const RADfloat *color)\r
+       {\r
+               this->index = index;\r
+               this->color[0] = color[0];\r
+               this->color[1] = color[1];\r
+               this->color[2] = color[2];\r
+               this->color[3] = color[3];\r
+       }\r
+\r
+       virtual ~ClearColor()\r
+       {\r
+       }\r
+\r
+       virtual void execute(Pipeline *pipeline, Pass *pass)\r
+       {\r
+               ASSERT(pass);   // FIXME: Error if no beginPass\r
+               ASSERT(index < pass->numColors);\r
+               es2::Image *image = pass->colorTarget[index];\r
+\r
+               GLenum format = image->getFormat();\r
+               GLenum type = image->getType();\r
+               ASSERT(format == GL_RGBA);   // FIXME\r
+               ASSERT(type == GL_UNSIGNED_BYTE);   //  FIXME\r
+\r
+               es2::Context *context = es2::getContext();\r
+               int x0 = context->mState.scissorX;\r
+               int y0 = context->mState.scissorY;\r
+               int width = context->mState.scissorWidth;\r
+               int height = context->mState.scissorHeight;\r
+\r
+               image->clearColorBuffer(sw::Color<float>(color[0], color[1], color[2], color[3]), 0xF, x0, y0, width, height);\r
+       }\r
+\r
+       RADuint index;\r
+       RADfloat color[4];\r
+};\r
+\r
+class ClearDepth : public Command\r
+{\r
+public:\r
+       ClearDepth(RADfloat depth)\r
+       {\r
+               this->depth = depth;\r
+       }\r
+\r
+       virtual ~ClearDepth()\r
+       {\r
+       }\r
+\r
+       virtual void execute(Pipeline *pipeline, Pass *pass)\r
+       {\r
+               ASSERT(pass);   // FIXME: Error if no beginPass\r
+               es2::Image *image = pass->depthTarget;\r
+               \r
+               es2::Context *context = es2::getContext();\r
+               int x0 = context->mState.scissorX;\r
+               int y0 = context->mState.scissorY;\r
+               int width = context->mState.scissorWidth;\r
+               int height = context->mState.scissorHeight;\r
+\r
+               image->clearDepthBuffer(depth, x0, y0, width, height);\r
+       }\r
+\r
+       RADfloat depth;\r
+};\r
+\r
+class Present : public Command\r
+{\r
+public:\r
+       Present(Texture *texture)\r
+       {\r
+               texture->reference();\r
+               this->texture = texture;\r
+       }\r
+\r
+       virtual ~Present()\r
+       {\r
+               Release(texture);\r
+       }\r
+\r
+       virtual void execute(Pipeline *pipeline, Pass *pass)\r
+       {\r
+               es2::Context *context = es2::getContext();\r
+               sw::FrameBuffer *frameBuffer = (*es2::getDisplay()->mSurfaceSet.begin())->frameBuffer;\r
+\r
+               egl::Image *image = texture->texture->getRenderTarget(GL_TEXTURE_2D, 0);\r
+               void *source = image->lockInternal(0, 0, 0, sw::LOCK_READONLY, sw::PUBLIC);\r
+               frameBuffer->flip(source, image->getInternalFormat());\r
+               image->unlockInternal();\r
+               image->release();\r
+       }\r
+\r
+       virtual bool isPresent() const\r
+       {\r
+               return true;\r
+       }\r
+\r
+       Texture *texture;\r
+};\r
+\r
+class DrawElements : public Command\r
+{\r
+public:\r
+       DrawElements(RADprimitiveType mode, RADindexType type, RADsizei count, es2::Buffer *indexBuffer, RADuint offset)\r
+       {\r
+               this->mode = mode;\r
+               this->type = type;\r
+               this->count = count;\r
+               this->indexBuffer = indexBuffer;\r
+               this->offset = offset;\r
+       }\r
+\r
+       ~DrawElements()\r
+       {\r
+       }\r
+\r
+       virtual void execute(Pipeline *pipeline, Pass *pass)\r
+       {\r
+               es2::Context *context = es2::getContext();\r
+\r
+               ASSERT(pipeline->vertexProgram == pipeline->fragmentProgram);   // FIXME\r
+               context->mState.program = pipeline->vertexProgram->program;\r
+\r
+               GLenum glType = GL_UNSIGNED_SHORT;\r
+               switch(type)\r
+               {\r
+               case RAD_INDEX_UNSIGNED_BYTE:  glType = GL_UNSIGNED_BYTE;  break;\r
+               case RAD_INDEX_UNSIGNED_SHORT: glType = GL_UNSIGNED_SHORT; break;\r
+               case RAD_INDEX_UNSIGNED_INT:   glType = GL_UNSIGNED_INT;   break;\r
+               default: UNREACHABLE();\r
+               }\r
 \r
-        if(context)\r
-        {\r
-            if(face == GL_FRONT || face == GL_FRONT_AND_BACK)\r
-            {\r
-                context->setStencilOperations(fail, zfail, zpass);\r
-            }\r
-\r
-            if(face == GL_BACK || face == GL_FRONT_AND_BACK)\r
-            {\r
-                context->setStencilBackOperations(fail, zfail, zpass);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
-}\r
+               GLenum glMode = GL_TRIANGLES;\r
+               switch(mode)\r
+               {\r
+               case RAD_TRIANGLES: glMode = GL_TRIANGLES; break;\r
+               default: UNREACHABLE();\r
+               }\r
 \r
-GLboolean GL_APIENTRY glTestFenceNV(GLuint fence)\r
-{\r
-    TRACE("(GLuint fence = %d)", fence);\r
+               context->mState.colorBuffer = pass->colorTarget[0];\r
+               context->mState.depthBuffer = pass->depthTarget;\r
 \r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
+               context->mState.depthTest = pipeline->depthStencilState->depthTestEnable;\r
 \r
-        if(context)\r
-        {\r
-            rad::Fence *fenceObject = context->getFence(fence);\r
+               GLenum glDepth = GL_LESS;\r
+               switch(pipeline->depthStencilState->depthFunc)\r
+               {\r
+               case RAD_DEPTH_FUNC_NEVER:    glDepth = GL_NEVER;    break;\r
+               case RAD_DEPTH_FUNC_LESS:     glDepth = GL_LESS;     break;\r
+               case RAD_DEPTH_FUNC_EQUAL:    glDepth = GL_EQUAL;    break;\r
+               case RAD_DEPTH_FUNC_LEQUAL:   glDepth = GL_LEQUAL;   break;\r
+               case RAD_DEPTH_FUNC_GREATER:  glDepth = GL_GREATER;  break;\r
+               case RAD_DEPTH_FUNC_NOTEQUAL: glDepth = GL_NOTEQUAL; break;\r
+               case RAD_DEPTH_FUNC_GEQUAL:   glDepth = GL_GEQUAL;   break;\r
+               case RAD_DEPTH_FUNC_ALWAYS:   glDepth = GL_ALWAYS;   break;\r
+               default: UNREACHABLE();\r
+               }\r
 \r
-            if(fenceObject == NULL)\r
-            {\r
-                return error(GL_INVALID_OPERATION, GL_TRUE);\r
-            }\r
+               context->mState.elementArrayBuffer.set(indexBuffer);\r
+               context->drawElements(glMode, count, glType, 0);\r
+       }\r
+\r
+       RADprimitiveType mode;\r
+       RADindexType type;\r
+       RADsizei count;\r
+       es2::Buffer *indexBuffer;\r
+       RADuint offset;\r
+};\r
+\r
+class BindGroup : public Command\r
+{\r
+public:\r
+       BindGroup(RADbitfield stages, RADuint group, RADuint count, es2::Buffer *buffer, RADuint offset)\r
+       {\r
+               this->stages = stages;\r
+               this->group = group;\r
+               this->count = count;\r
+               this->buffer = buffer;\r
+               this->offset = offset;\r
+       }\r
+\r
+       virtual ~BindGroup()\r
+       {\r
+       }\r
+\r
+       virtual void execute(Pipeline *pipeline, Pass *pass)\r
+       {\r
+               es2::Context *context = es2::getContext();\r
+\r
+               const RADbindGroupElement *groupElements = static_cast<const RADbindGroupElement*>(buffer->data());\r
+\r
+               // FIXME: Should parse the layout out of the shaders\r
+               es2::Program *program = pipeline->vertexProgram->program;\r
+\r
+               es2::Buffer *element0 = reinterpret_cast<es2::Buffer*>(groupElements[0].handle);\r
+               void *offset0 = reinterpret_cast<void*>(static_cast<uintptr_t>(groupElements[0].offset));\r
+               int position = program->getAttributeLocation("position");\r
+               context->setVertexAttribState(position, element0, 3, GL_FLOAT, GL_TRUE, 0, offset0);\r
+               context->setEnableVertexAttribArray(position, true);\r
+\r
+               es2::Buffer *element1 = reinterpret_cast<es2::Buffer*>(groupElements[1].handle);\r
+               void *offset1 = reinterpret_cast<void*>(static_cast<uintptr_t>(groupElements[1].offset));\r
+               int tc = program->getAttributeLocation("tc");\r
+               context->setVertexAttribState(tc, element1, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, offset1);\r
+               context->setEnableVertexAttribArray(tc, true);\r
+\r
+               es2::Buffer *element2 = reinterpret_cast<es2::Buffer*>(groupElements[2].handle);\r
+               const void *uniform = static_cast<const uint8_t*>(element2->data()) + groupElements[2].offset;\r
+               int scale = program->getUniformLocation("scale");\r
+               program->setUniform4fv(scale, 1, (const GLfloat*)uniform);\r
+\r
+               rad::TextureSampler *element3 = reinterpret_cast<rad::TextureSampler*>(groupElements[3].handle);\r
+               int tex = program->getUniformLocation("tex");\r
+               int sampler = 0;\r
+               program->setUniform1iv(tex, 1, &sampler);\r
+               context->applyTexture(sw::SAMPLER_PIXEL, sampler, element3->texture->texture);\r
+       }\r
+\r
+       RADbitfield stages;\r
+       RADuint group;\r
+       RADuint count;\r
+       es2::Buffer *buffer;\r
+       RADuint offset;\r
+};\r
+\r
+class Queue : public Object\r
+{\r
+public:\r
+       Queue(Device *device) : Object(device)\r
+       {\r
+               graphicsPipeline = nullptr;\r
+               pass = nullptr;\r
+       }\r
+\r
+       virtual ~Queue()\r
+       {\r
+               for(size_t i = 0; i < commands.size(); i++)\r
+               {\r
+                       delete commands[i];\r
+               }\r
 \r
-            return fenceObject->testFence();\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        error(GL_OUT_OF_MEMORY);\r
-    }\r
-    \r
-    return GL_TRUE;\r
-}\r
+               Release(graphicsPipeline);\r
 \r
-void GL_APIENTRY glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,\r
-                              GLint border, GLenum format, GLenum type, const GLvoid* pixels)\r
-{\r
-    TRACE("(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, GLsizei height = %d, "\r
-          "GLint border = %d, GLenum format = 0x%X, GLenum type = 0x%X, const GLvoid* pixels =  0x%0.8p)",\r
-          target, level, internalformat, width, height, border, format, type, pixels);\r
+               ASSERT(!pass);   // FIXME: No matching endPass\r
+               Release(pass);\r
+       }\r
 \r
-    try\r
-    {\r
-        if(!validImageSize(level, width, height))\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+       void submit(Command *command)\r
+       {\r
+               // FIXME: Make BeginPass/EndPass/BindPipeline commands too?\r
+               //command->setPipeline(graphicsPipeline);\r
+               //command->setPass(pass);\r
 \r
-        if(internalformat != format)\r
-        {\r
-            return error(GL_INVALID_OPERATION);\r
-        }\r
+               if(false)   // Queued execution\r
+               {\r
+                       commands.push_back(command);\r
 \r
-        switch(format)\r
-        {\r
-        case GL_ALPHA:\r
-        case GL_LUMINANCE:\r
-        case GL_LUMINANCE_ALPHA:\r
-            switch(type)\r
-            {\r
-            case GL_UNSIGNED_BYTE:\r
-            case GL_FLOAT:\r
-            case GL_HALF_FLOAT_OES:\r
-                break;\r
-            default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-            break;\r
-        case GL_RGB:\r
-            switch(type)\r
-            {\r
-            case GL_UNSIGNED_BYTE:\r
-            case GL_UNSIGNED_SHORT_5_6_5:\r
-            case GL_FLOAT:\r
-            case GL_HALF_FLOAT_OES:\r
-                break;\r
-            default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-            break;\r
-        case GL_RGBA:\r
-            switch(type)\r
-            {\r
-            case GL_UNSIGNED_BYTE:\r
-            case GL_UNSIGNED_SHORT_4_4_4_4:\r
-            case GL_UNSIGNED_SHORT_5_5_5_1:\r
-            case GL_FLOAT:\r
-            case GL_HALF_FLOAT_OES:\r
-                break;\r
-            default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-            break;\r
-        case GL_BGRA_EXT:\r
-            switch(type)\r
-            {\r
-            case GL_UNSIGNED_BYTE:\r
-                break;\r
-            default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-            break;\r
-        case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:  // error cases for compressed textures are handled below\r
-        case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:\r
-               case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:\r
-               case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:\r
-            break;\r
-               case GL_DEPTH_COMPONENT:\r
-                       switch(type)\r
+                       if(command->isPresent())\r
                        {\r
-                       case GL_UNSIGNED_SHORT:\r
-                       case GL_UNSIGNED_INT:\r
-                               break;\r
-                       default:\r
-                               return error(GL_INVALID_ENUM);\r
+                               // FIXME: Flush\r
                        }\r
-                       break;\r
-               case GL_DEPTH_STENCIL_OES:\r
-                       switch(type)\r
+               }\r
+               else   // Immediate execution\r
+               {\r
+                       command->execute(graphicsPipeline, pass);\r
+\r
+                       delete command;\r
+               }\r
+       }\r
+\r
+       void bindPipeline(RADpipelineType pipelineType, Pipeline *pipeline)\r
+       {\r
+               if(pipelineType == RAD_PIPELINE_TYPE_GRAPHICS)\r
+               {\r
+                       pipeline->reference();\r
+\r
+                       if(graphicsPipeline)\r
                        {\r
-                       case GL_UNSIGNED_INT_24_8_OES:\r
-                               break;\r
-                       default:\r
-                               return error(GL_INVALID_ENUM);\r
+                               graphicsPipeline->release();\r
                        }\r
-                       break;\r
-        default:\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
 \r
-        if(border != 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
+                       graphicsPipeline = pipeline;\r
+               }\r
+               else UNREACHABLE();\r
+       }\r
+\r
+       void beginPass(rad::Pass *pass)\r
+       {\r
+               ASSERT(!this->pass);   // FIXME: Can be nested?\r
+               pass->reference();\r
+               this->pass = pass;\r
+       }\r
+\r
+       void endPass(rad::Pass *pass)\r
+       {\r
+               ASSERT(this->pass == pass);   // FIXME: Can be nested?\r
+               this->pass->release();\r
+               this->pass = nullptr;\r
+       }\r
+\r
+private:\r
+       std::deque<Command*> commands;\r
+       Pipeline *graphicsPipeline;\r
+       Pass *pass;\r
+};\r
+}\r
 \r
-        if(context)\r
-        {\r
-            switch(target)\r
-            {\r
-              case GL_TEXTURE_2D:\r
-                if(width > (rad::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level) ||\r
-                   height > (rad::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level))\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-                break;\r
-              case GL_TEXTURE_CUBE_MAP_POSITIVE_X:\r
-              case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:\r
-              case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:\r
-              case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:\r
-              case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:\r
-              case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:\r
-                if(width != height)\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-\r
-                if(width > (rad::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level) ||\r
-                   height > (rad::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level))\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-                break;\r
-              default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-\r
-            if(format == GL_COMPRESSED_RGB_S3TC_DXT1_EXT ||\r
-               format == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ||\r
-                          format == GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE ||\r
-                          format == GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE)\r
-            {\r
-                if(S3TC_SUPPORT)\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_ENUM);\r
-                }\r
-            }\r
-                       \r
-            if(target == GL_TEXTURE_2D)\r
-            {\r
-                rad::Texture2D *texture = context->getTexture2D();\r
-\r
-                if(!texture)\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-\r
-                texture->setImage(level, width, height, format, type, context->getUnpackAlignment(), pixels);\r
-            }\r
-            else\r
-            {\r
-                rad::TextureCubeMap *texture = context->getTextureCubeMap();\r
-\r
-                if(!texture)\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-\r
-                               texture->setImage(target, level, width, height, format, type, context->getUnpackAlignment(), pixels);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+extern "C"\r
+{\r
+RADdevice RADAPIENTRY radCreateDevice(void)\r
+{\r
+       static rad::Device *device = new rad::Device();\r
+       return reinterpret_cast<RADdevice>(device);\r
 }\r
 \r
-void GL_APIENTRY glTexParameterf(GLenum target, GLenum pname, GLfloat param)\r
+void RADAPIENTRY radReferenceDevice(RADdevice device)\r
+{\r
+       rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
+       return radDevice->reference();\r
+}\r
+void RADAPIENTRY radReleaseDevice(RADdevice device)\r
 {\r
-    TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat param = %f)", target, pname, param);\r
+       rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
+       return radDevice->release();\r
+}\r
 \r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
+RADuint RADAPIENTRY radGetTokenHeader(RADdevice device, RADtokenName name) {UNIMPLEMENTED(); return 0;}\r
 \r
-        if(context)\r
-        {\r
-            rad::Texture *texture;\r
-\r
-            switch(target)\r
-            {\r
-            case GL_TEXTURE_2D:\r
-                texture = context->getTexture2D();\r
-                break;\r
-            case GL_TEXTURE_CUBE_MAP:\r
-                texture = context->getTextureCubeMap();\r
-                break;\r
-            case GL_TEXTURE_EXTERNAL_OES:\r
-                texture = context->getTextureExternal();\r
-                break;\r
-            default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-\r
-            switch(pname)\r
-            {\r
-            case GL_TEXTURE_WRAP_S:\r
-                if(!texture->setWrapS((GLenum)param))\r
-                {\r
-                    return error(GL_INVALID_ENUM);\r
-                }\r
-                break;\r
-            case GL_TEXTURE_WRAP_T:\r
-                if(!texture->setWrapT((GLenum)param))\r
-                {\r
-                    return error(GL_INVALID_ENUM);\r
-                }\r
-                break;\r
-            case GL_TEXTURE_MIN_FILTER:\r
-                if(!texture->setMinFilter((GLenum)param))\r
-                {\r
-                    return error(GL_INVALID_ENUM);\r
-                }\r
-                break;\r
-            case GL_TEXTURE_MAG_FILTER:\r
-                if(!texture->setMagFilter((GLenum)param))\r
-                {\r
-                    return error(GL_INVALID_ENUM);\r
-                }\r
-                break;\r
-            case GL_TEXTURE_MAX_ANISOTROPY_EXT:\r
-                if(!texture->setMaxAnisotropy(param))\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-                break;\r
-            default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+RADqueue RADAPIENTRY radCreateQueue(RADdevice device, RADqueueType queuetype)\r
+{\r
+       rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
+       rad::Queue *queue = new rad::Queue(radDevice);\r
+       return reinterpret_cast<RADqueue>(queue);\r
 }\r
 \r
-void GL_APIENTRY glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)\r
+void RADAPIENTRY radReferenceQueue(RADqueue queue)\r
 {\r
-    glTexParameterf(target, pname, *params);\r
+       rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
+       return radQueue->reference();\r
 }\r
 \r
-void GL_APIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param)\r
+void RADAPIENTRY radReleaseQueue(RADqueue queue)\r
 {\r
-    TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint param = %d)", target, pname, param);\r
+       rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
+       return radQueue->release();\r
+}\r
 \r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radQueueTagBuffer(RADqueue queue, RADbuffer buffer) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radQueueTagTexture(RADqueue queue, RADtexture texture) {UNIMPLEMENTED();}\r
 \r
-        if(context)\r
-        {\r
-            rad::Texture *texture;\r
-\r
-            switch(target)\r
-            {\r
-            case GL_TEXTURE_2D:\r
-                texture = context->getTexture2D();\r
-                break;\r
-            case GL_TEXTURE_CUBE_MAP:\r
-                texture = context->getTextureCubeMap();\r
-                break;\r
-            case GL_TEXTURE_EXTERNAL_OES:\r
-                  texture = context->getTextureExternal();\r
-                  break;\r
-            default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-\r
-            switch(pname)\r
-            {\r
-            case GL_TEXTURE_WRAP_S:\r
-                if(!texture->setWrapS((GLenum)param))\r
-                {\r
-                    return error(GL_INVALID_ENUM);\r
-                }\r
-                break;\r
-            case GL_TEXTURE_WRAP_T:\r
-                if(!texture->setWrapT((GLenum)param))\r
-                {\r
-                    return error(GL_INVALID_ENUM);\r
-                }\r
-                break;\r
-            case GL_TEXTURE_MIN_FILTER:\r
-                if(!texture->setMinFilter((GLenum)param))\r
-                {\r
-                    return error(GL_INVALID_ENUM);\r
-                }\r
-                break;\r
-            case GL_TEXTURE_MAG_FILTER:\r
-                if(!texture->setMagFilter((GLenum)param))\r
-                {\r
-                    return error(GL_INVALID_ENUM);\r
-                }\r
-                break;\r
-                       case GL_TEXTURE_MAX_ANISOTROPY_EXT:\r
-                if(!texture->setMaxAnisotropy((GLfloat)param))\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-                break;\r
-            default:\r
-                return error(GL_INVALID_ENUM);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radQueueSubmitCommands(RADqueue queue, RADuint numCommands, const RADcommandHandle *handles)\r
+{\r
+       return;\r
 }\r
 \r
-void GL_APIENTRY glTexParameteriv(GLenum target, GLenum pname, const GLint* params)\r
+void RADAPIENTRY radFlushQueue(RADqueue queue) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radFinishQueue(RADqueue queue) {UNIMPLEMENTED();}\r
+\r
+void RADAPIENTRY radQueueViewport(RADqueue queue, RADint x, RADint y, RADint w, RADint h)\r
 {\r
-    glTexParameteri(target, pname, *params);\r
+       rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
+       rad::Viewport *command = new rad::Viewport(x, y, w, h);\r
+       radQueue->submit(command);\r
 }\r
 \r
-void GL_APIENTRY glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,\r
-                               GLenum format, GLenum type, const GLvoid* pixels)\r
+void RADAPIENTRY radQueueScissor(RADqueue queue, RADint x, RADint y, RADint w, RADint h)\r
 {\r
-    TRACE("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "\r
-          "GLsizei width = %d, GLsizei height = %d, GLenum format = 0x%X, GLenum type = 0x%X, "\r
-          "const GLvoid* pixels = 0x%0.8p)",\r
-           target, level, xoffset, yoffset, width, height, format, type, pixels);\r
+       rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
+       rad::Scissor *command = new rad::Scissor(x, y, w, h);\r
+       radQueue->submit(command);\r
+}\r
 \r
-    try\r
-    {\r
-        if(!rad::IsTextureTarget(target))\r
-        {\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
+void RADAPIENTRY radQueueCopyBufferToImage(RADqueue queue, RADbuffer buffer, RADintptr bufferOffset, RADtexture texture, RADint level, RADuint xoffset, RADuint yoffset, RADuint zoffset, RADsizei width, RADsizei height, RADsizei depth)\r
+{\r
+       rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
+       rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
+       rad::Texture *radTexture = reinterpret_cast<rad::Texture*>(texture);\r
+       rad::CopyBufferToImage *command = new rad::CopyBufferToImage(radBuffer, bufferOffset, radTexture, level, xoffset, yoffset, zoffset, width, height, depth);\r
+       radQueue->submit(command);\r
+}\r
 \r
-        if(level < 0 || xoffset < 0 || yoffset < 0 || width < 0 || height < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+void RADAPIENTRY radQueueCopyImageToBuffer(RADqueue queue, RADbuffer buffer, RADintptr bufferOffset, RADtexture texture, RADint level, RADuint xoffset, RADuint yoffset, RADuint zoffset, RADsizei width, RADsizei height, RADsizei depth) {UNIMPLEMENTED();}\r
 \r
-        if(std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+void RADAPIENTRY radQueueCopyBuffer(RADqueue queue, RADbuffer srcBuffer, RADintptr srcOffset, RADbuffer dstBuffer, RADintptr dstOffset, RADsizei size)\r
+{\r
+       return;\r
+}\r
 \r
-        if(!rad::CheckTextureFormatType(format, type))\r
-        {\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
+void RADAPIENTRY radQueueClearColor(RADqueue queue, RADuint index, const RADfloat *color)\r
+{\r
+       rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
+       rad::ClearColor *command = new rad::ClearColor(index, color);\r
+       radQueue->submit(command);\r
+}\r
 \r
-        if(width == 0 || height == 0 || pixels == NULL)\r
-        {\r
-            return;\r
-        }\r
+void RADAPIENTRY radQueueClearDepth(RADqueue queue, RADfloat depth)\r
+{\r
+       rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
+       rad::ClearDepth *command = new rad::ClearDepth(depth);\r
+       radQueue->submit(command);\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radQueueClearStencil(RADqueue queue, RADuint stencil) {UNIMPLEMENTED();}\r
 \r
-        if(context)\r
-        {\r
-            if(level > rad::IMPLEMENTATION_MAX_TEXTURE_LEVELS)\r
-            {\r
-                return error(GL_INVALID_VALUE);\r
-            }\r
-\r
-            if(target == GL_TEXTURE_2D)\r
-            {\r
-                rad::Texture2D *texture = context->getTexture2D();\r
-\r
-                if(validateSubImageParams(false, width, height, xoffset, yoffset, target, level, format, texture))\r
-                               {\r
-                                       texture->subImage(level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);\r
-                               }\r
-            }\r
-            else if(rad::IsCubemapTextureTarget(target))\r
-            {\r
-                rad::TextureCubeMap *texture = context->getTextureCubeMap();\r
-                               \r
-                               if(validateSubImageParams(false, width, height, xoffset, yoffset, target, level, format, texture))\r
-                               {\r
-                                       texture->subImage(target, level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);\r
-                               }\r
-            }\r
-            else\r
-            {\r
-                UNREACHABLE();\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radQueuePresent(RADqueue queue, RADtexture texture)\r
+{\r
+       rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
+       rad::Texture *radTexture = reinterpret_cast<rad::Texture*>(texture);\r
+       rad::Present *command = new rad::Present(radTexture);\r
+       radQueue->submit(command);\r
 }\r
 \r
-void GL_APIENTRY glUniform1f(GLint location, GLfloat x)\r
+void RADAPIENTRY radQueueDrawArrays(RADqueue queue, RADprimitiveType mode, RADint first, RADsizei count) {UNIMPLEMENTED();}\r
+\r
+void RADAPIENTRY radQueueDrawElements(RADqueue queue, RADprimitiveType mode, RADindexType type, RADsizei count, RADindexHandle indexHandle, RADuint offset)\r
 {\r
-    glUniform1fv(location, 1, &x);\r
+       rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
+       es2::Buffer *indexBuffer = reinterpret_cast<es2::Buffer*>(indexHandle);\r
+       rad::DrawElements *command = new rad::DrawElements(mode, type, count, indexBuffer, offset);\r
+       radQueue->submit(command);\r
 }\r
 \r
-void GL_APIENTRY glUniform1fv(GLint location, GLsizei count, const GLfloat* v)\r
+void RADAPIENTRY radQueueBindPipeline(RADqueue queue, RADpipelineType pipelineType, RADpipelineHandle pipelineHandle)\r
 {\r
-    TRACE("(GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p)", location, count, v);\r
+       rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
+       rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipelineHandle);\r
+       radQueue->bindPipeline(pipelineType, radPipeline);\r
+}\r
 \r
-    try\r
-    {\r
-        if(count < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+void RADAPIENTRY radQueueBindGroup(RADqueue queue, RADbitfield stages, RADuint group, RADuint count, RADbindGroupHandle groupHandle, RADuint offset)\r
+{\r
+       rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
+       es2::Buffer *groupBuffer = reinterpret_cast<es2::Buffer*>(groupHandle);\r
+       rad::BindGroup *command = new rad::BindGroup(stages, group, count, groupBuffer, offset);\r
+       radQueue->submit(command);\r
+}\r
 \r
-        if(location == -1)\r
-        {\r
-            return;\r
-        }\r
+void RADAPIENTRY radQueueBeginPass(RADqueue queue, RADpass pass)\r
+{\r
+       rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
+       rad::Pass *radPass = reinterpret_cast<rad::Pass*>(pass);\r
+       radQueue->beginPass(radPass);\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radQueueEndPass(RADqueue queue, RADpass pass)\r
+{\r
+       rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
+       rad::Pass *radPass = reinterpret_cast<rad::Pass*>(pass);\r
+       radQueue->endPass(radPass);\r
+}\r
 \r
-        if(context)\r
-        {\r
-            rad::Program *program = context->getCurrentProgram();\r
+void RADAPIENTRY radQueueSubmitDynamic(RADqueue queue, const void *dynamic, RADsizei length) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radQueueStencilValueMask(RADqueue queue, RADfaceBitfield faces, RADuint mask) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radQueueStencilMask(RADqueue queue, RADfaceBitfield faces, RADuint mask) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radQueueStencilRef(RADqueue queue, RADfaceBitfield faces, RADint ref) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radQueueBlendColor(RADqueue queue, const RADfloat *blendColor) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radQueuePointSize(RADqueue queue, RADfloat pointSize) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radQueueLineWidth(RADqueue queue, RADfloat lineWidth) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radQueuePolygonOffsetClamp(RADqueue queue, RADfloat factor, RADfloat units, RADfloat clamp) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radQueueSampleMask(RADqueue queue, RADuint mask) {UNIMPLEMENTED();}\r
 \r
-            if(!program)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
+RADprogram RADAPIENTRY radCreateProgram(RADdevice device)\r
+{\r
+       rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
+       rad::Program *program = new rad::Program(radDevice);\r
+       return reinterpret_cast<RADprogram>(program);\r
+}\r
 \r
-            if(!program->setUniform1fv(location, count, v))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radReferenceProgram(RADprogram program)\r
+{\r
+       rad::Program *radProgram = reinterpret_cast<rad::Program*>(program);\r
+       radProgram->reference();\r
 }\r
 \r
-void GL_APIENTRY glUniform1i(GLint location, GLint x)\r
+void RADAPIENTRY radReleaseProgram(RADprogram program)\r
 {\r
-    glUniform1iv(location, 1, &x);\r
+       rad::Program *radProgram = reinterpret_cast<rad::Program*>(program);\r
+       radProgram->release();\r
 }\r
 \r
-void GL_APIENTRY glUniform1iv(GLint location, GLsizei count, const GLint* v)\r
+void RADAPIENTRY radProgramSource(RADprogram program, RADprogramFormat format, RADsizei length, const void *source)\r
 {\r
-    TRACE("(GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p)", location, count, v);\r
+       rad::Program *radProgram = reinterpret_cast<rad::Program*>(program);\r
 \r
-    try\r
-    {\r
-        if(count < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+       // FIXME: Assumes first source is vertex shader, second is fragment shader\r
+       ASSERT(length == 2);\r
+       const char *vertexSource = static_cast<const char* const*>(source)[0];\r
+       const char *fragmentSource = static_cast<const char* const*>(source)[1];\r
+       GLint vertexLength = strlen(vertexSource);\r
+       GLint fragmentLength = strlen(fragmentSource);\r
 \r
-        if(location == -1)\r
-        {\r
-            return;\r
-        }\r
+       es2::VertexShader *vertexShader = new es2::VertexShader(nullptr, 0);\r
+       es2::FragmentShader *fragmentShader = new es2::FragmentShader(nullptr, 0);\r
 \r
-        rad::Context *context = rad::getContext();\r
+       vertexShader->setSource(1, &vertexSource, &vertexLength);\r
+       fragmentShader->setSource(1, &fragmentSource, &fragmentLength);\r
 \r
-        if(context)\r
-        {\r
-            rad::Program *program = context->getCurrentProgram();\r
+       vertexShader->compile();\r
+       fragmentShader->compile();\r
 \r
-            if(!program)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
+       radProgram->program->attachShader(vertexShader);\r
+       radProgram->program->attachShader(fragmentShader);\r
+       radProgram->program->link();\r
 \r
-            if(!program->setUniform1iv(location, count, v))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+       vertexShader->release();     // Still referenced by program\r
+       fragmentShader->release();   // Still referenced by program\r
 }\r
 \r
-void GL_APIENTRY glUniform2f(GLint location, GLfloat x, GLfloat y)\r
+RADbuffer RADAPIENTRY radCreateBuffer(RADdevice device)\r
 {\r
-    GLfloat xy[2] = {x, y};\r
-\r
-    glUniform2fv(location, 1, (GLfloat*)&xy);\r
+       rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
+       rad::Buffer *buffer = new rad::Buffer(radDevice);\r
+       return reinterpret_cast<RADbuffer>(buffer);\r
 }\r
 \r
-void GL_APIENTRY glUniform2fv(GLint location, GLsizei count, const GLfloat* v)\r
+void RADAPIENTRY radReferenceBuffer(RADbuffer buffer)\r
 {\r
-    TRACE("(GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p)", location, count, v);\r
-\r
-    try\r
-    {\r
-        if(count < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
-        \r
-        if(location == -1)\r
-        {\r
-            return;\r
-        }\r
-\r
-        rad::Context *context = rad::getContext();\r
-\r
-        if(context)\r
-        {\r
-            rad::Program *program = context->getCurrentProgram();\r
+       rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
+       radBuffer->reference();\r
+}\r
 \r
-            if(!program)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
+void RADAPIENTRY radReleaseBuffer(RADbuffer buffer, RADtagMode tagMode)\r
+{\r
+       rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
+       radBuffer->release();\r
+}\r
 \r
-            if(!program->setUniform2fv(location, count, v))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radBufferAccess(RADbuffer buffer, RADbitfield access)\r
+{\r
+       rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
+       radBuffer->access = access;\r
 }\r
 \r
-void GL_APIENTRY glUniform2i(GLint location, GLint x, GLint y)\r
+void RADAPIENTRY radBufferMapAccess(RADbuffer buffer, RADbitfield mapAccess)\r
 {\r
-    GLint xy[4] = {x, y};\r
+       rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
+       radBuffer->mapAccess = mapAccess;\r
+}\r
 \r
-    glUniform2iv(location, 1, (GLint*)&xy);\r
+void RADAPIENTRY radBufferStorage(RADbuffer buffer, RADsizei size)\r
+{\r
+       rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
+       radBuffer->storage(size);\r
 }\r
 \r
-void GL_APIENTRY glUniform2iv(GLint location, GLsizei count, const GLint* v)\r
+void* RADAPIENTRY radMapBuffer(RADbuffer buffer)\r
 {\r
-    TRACE("(GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p)", location, count, v);\r
+       rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
+       return radBuffer->map();\r
+}\r
 \r
-    try\r
-    {\r
-        if(count < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+RADvertexHandle RADAPIENTRY radGetVertexHandle(RADbuffer buffer)\r
+{\r
+       rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
+       return reinterpret_cast<RADvertexHandle>(radBuffer->buffer);\r
+}\r
 \r
-        if(location == -1)\r
-        {\r
-            return;\r
-        }\r
+RADindexHandle RADAPIENTRY radGetIndexHandle(RADbuffer buffer)\r
+{\r
+       rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
+       return reinterpret_cast<RADvertexHandle>(radBuffer->buffer);\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+RADuniformHandle RADAPIENTRY radGetUniformHandle(RADbuffer buffer)\r
+{\r
+       rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
+       return reinterpret_cast<RADuniformHandle>(radBuffer->buffer);\r
+}\r
 \r
-        if(context)\r
-        {\r
-            rad::Program *program = context->getCurrentProgram();\r
+RADbindGroupHandle RADAPIENTRY radGetBindGroupHandle(RADbuffer buffer)\r
+{\r
+       rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
+       return reinterpret_cast<RADbindGroupHandle>(radBuffer->buffer);\r
+}\r
 \r
-            if(!program)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
+RADtexture RADAPIENTRY radCreateTexture(RADdevice device)\r
+{\r
+       rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
+       rad::Texture *colorState = new rad::Texture(radDevice);\r
+       return reinterpret_cast<RADtexture>(colorState);\r
+}\r
 \r
-            if(!program->setUniform2iv(location, count, v))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radReferenceTexture(RADtexture texture)\r
+{\r
+       rad::Texture *radTexture = reinterpret_cast<rad::Texture*>(texture);\r
+       radTexture->reference();\r
 }\r
 \r
-void GL_APIENTRY glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)\r
+void RADAPIENTRY radReleaseTexture(RADtexture texture, RADtagMode tagMode)\r
 {\r
-    GLfloat xyz[3] = {x, y, z};\r
+       rad::Texture *radTexture = reinterpret_cast<rad::Texture*>(texture);\r
+       radTexture->release();\r
+}\r
 \r
-    glUniform3fv(location, 1, (GLfloat*)&xyz);\r
+void RADAPIENTRY radTextureAccess(RADtexture texture, RADbitfield access)\r
+{\r
+       rad::Texture *radTexture = reinterpret_cast<rad::Texture*>(texture);\r
+       radTexture->access = access;\r
 }\r
 \r
-void GL_APIENTRY glUniform3fv(GLint location, GLsizei count, const GLfloat* v)\r
+void RADAPIENTRY radTextureStorage(RADtexture texture, RADtextureTarget target, RADsizei levels, RADinternalFormat internalFormat, RADsizei width, RADsizei height, RADsizei depth, RADsizei samples)\r
 {\r
-    TRACE("(GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p)", location, count, v);\r
+       rad::Texture *radTexture = reinterpret_cast<rad::Texture*>(texture);\r
+       ASSERT(!radTexture->texture);\r
 \r
-    try\r
-    {\r
-        if(count < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+       radTexture->target = target;\r
+       radTexture->levels = levels;\r
+       radTexture->internalFormat = internalFormat;\r
+       radTexture->width = width;\r
+       radTexture->height = height;\r
+       radTexture->depth = depth;\r
+       radTexture->samples = samples;\r
 \r
-        if(location == -1)\r
-        {\r
-            return;\r
-        }\r
+       GLenum format = GL_NONE;\r
+       GLenum type = GL_NONE;\r
+       switch(internalFormat)\r
+       {\r
+       case RAD_RGBA8:\r
+               format = GL_RGBA;\r
+               type = GL_UNSIGNED_BYTE;\r
+               break;\r
+       case RAD_DEPTH24_STENCIL8:\r
+               format = GL_DEPTH_STENCIL_OES;\r
+               type = GL_UNSIGNED_INT_24_8_OES;\r
+               break;\r
+       default:\r
+               UNIMPLEMENTED();   // FIXME\r
+       }\r
 \r
-        rad::Context *context = rad::getContext();\r
+       switch(target)\r
+       {\r
+       case RAD_TEXTURE_2D:\r
+               {\r
+                       es2::Texture2D *tex = new es2::Texture2D(0);\r
+                       for(int level = 0; level < levels; level++)\r
+                       {\r
+                               tex->setImage(level, width >> level, height >> level, format, type, 1, nullptr);\r
+                       }\r
+                       tex->addRef();\r
+                       radTexture->texture = tex;\r
+               }\r
+               break;\r
+       default:\r
+               UNIMPLEMENTED();   // FIXME\r
+       }\r
+}\r
 \r
-        if(context)\r
-        {\r
-            rad::Program *program = context->getCurrentProgram();\r
+RADtextureHandle RADAPIENTRY radGetTextureSamplerHandle(RADtexture texture, RADsampler sampler, RADtextureTarget target, RADinternalFormat internalFormat, RADuint minLevel, RADuint numLevels, RADuint minLayer, RADuint numLayers)\r
+{\r
+       rad::Texture *radTexture = reinterpret_cast<rad::Texture*>(texture);\r
+       rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
+       rad::TextureSampler *textureSampler = new rad::TextureSampler(radTexture, radSampler, target, internalFormat, minLevel, numLevels, minLayer, numLayers);\r
+       radTexture->textureSamplers.push_back(textureSampler);   // FIXME: Check for matching existing textureSampler\r
+       return reinterpret_cast<RADtextureHandle>(textureSampler);\r
+}\r
 \r
-            if(!program)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
+RADrenderTargetHandle RADAPIENTRY radGetTextureRenderTargetHandle(RADtexture texture, RADtextureTarget target, RADinternalFormat internalFormat, RADuint level, RADuint minLayer, RADuint numLayers)\r
+{\r
+       rad::Texture *radTexture = reinterpret_cast<rad::Texture*>(texture);\r
+       ASSERT(radTexture->texture);\r
+       ASSERT(radTexture->internalFormat == internalFormat);\r
+       ASSERT(minLayer == 0);\r
+       ASSERT(numLayers == 1);\r
+       GLenum glTarget = GL_NONE;\r
+       switch(target)\r
+       {\r
+       case RAD_TEXTURE_2D:\r
+               glTarget = GL_TEXTURE_2D;\r
+               break;\r
+       default:\r
+               UNREACHABLE();\r
+       }\r
+       return reinterpret_cast<RADrenderTargetHandle>(radTexture->texture->getRenderTarget(glTarget, level));\r
+}\r
 \r
-            if(!program->setUniform3fv(location, count, v))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+RADsampler RADAPIENTRY radCreateSampler(RADdevice device)\r
+{\r
+       rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
+       rad::Sampler *sampler = new rad::Sampler(radDevice);\r
+       return reinterpret_cast<RADsampler>(sampler);\r
 }\r
 \r
-void GL_APIENTRY glUniform3i(GLint location, GLint x, GLint y, GLint z)\r
+void RADAPIENTRY radReferenceSampler(RADsampler sampler)\r
 {\r
-    GLint xyz[3] = {x, y, z};\r
+       rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
+       radSampler->reference();\r
+}\r
 \r
-    glUniform3iv(location, 1, (GLint*)&xyz);\r
+void RADAPIENTRY radReleaseSampler(RADsampler sampler)\r
+{\r
+       rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
+       radSampler->release();\r
 }\r
 \r
-void GL_APIENTRY glUniform3iv(GLint location, GLsizei count, const GLint* v)\r
+void RADAPIENTRY radSamplerDefault(RADsampler sampler)\r
 {\r
-    TRACE("(GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p)", location, count, v);\r
+       rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
+       radSampler->default();\r
+}\r
 \r
-    try\r
-    {\r
-        if(count < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+void RADAPIENTRY radSamplerMinMagFilter(RADsampler sampler, RADminFilter min, RADmagFilter mag)\r
+{\r
+       rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
+       radSampler->minFilter = min;\r
+       radSampler->magFilter = mag;\r
+}\r
 \r
-        if(location == -1)\r
-        {\r
-            return;\r
-        }\r
+void RADAPIENTRY radSamplerWrapMode(RADsampler sampler, RADwrapMode s, RADwrapMode t, RADwrapMode r)\r
+{\r
+       rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
+       radSampler->wrapModeS = s;\r
+       radSampler->wrapModeT = t;\r
+       radSampler->wrapModeR = r;\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radSamplerLodClamp(RADsampler sampler, RADfloat min, RADfloat max)\r
+{\r
+       rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
+       radSampler->minLod = min;\r
+       radSampler->maxLod = max;\r
+}\r
 \r
-        if(context)\r
-        {\r
-            rad::Program *program = context->getCurrentProgram();\r
+void RADAPIENTRY radSamplerLodBias(RADsampler sampler, RADfloat bias)\r
+{\r
+       rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
+       radSampler->lodBias = bias;\r
+}\r
 \r
-            if(!program)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
+void RADAPIENTRY radSamplerCompare(RADsampler sampler, RADcompareMode mode, RADcompareFunc func)\r
+{\r
+       rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
+       radSampler->compareMode = mode;\r
+       radSampler->compareFunc = func;\r
+}\r
 \r
-            if(!program->setUniform3iv(location, count, v))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radSamplerBorderColorFloat(RADsampler sampler, const RADfloat *borderColor)\r
+{\r
+       rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
+       radSampler->borderColor[0] = borderColor[0];\r
+       radSampler->borderColor[1] = borderColor[1];\r
+       radSampler->borderColor[2] = borderColor[2];\r
+       radSampler->borderColor[3] = borderColor[3];\r
 }\r
 \r
-void GL_APIENTRY glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)\r
+void RADAPIENTRY radSamplerBorderColorInt(RADsampler sampler, const RADuint *borderColor)\r
 {\r
-    GLfloat xyzw[4] = {x, y, z, w};\r
+       rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
+       radSampler->borderColorInt[0] = borderColor[0];\r
+       radSampler->borderColorInt[1] = borderColor[1];\r
+       radSampler->borderColorInt[2] = borderColor[2];\r
+       radSampler->borderColorInt[3] = borderColor[3];\r
+}\r
 \r
-    glUniform4fv(location, 1, (GLfloat*)&xyzw);\r
+RADcolorState RADAPIENTRY radCreateColorState(RADdevice device)\r
+{\r
+       rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
+       rad::ColorState *colorState = new rad::ColorState(radDevice);\r
+       return reinterpret_cast<RADcolorState>(colorState);\r
 }\r
 \r
-void GL_APIENTRY glUniform4fv(GLint location, GLsizei count, const GLfloat* v)\r
+void RADAPIENTRY radReferenceColorState(RADcolorState color)\r
 {\r
-    TRACE("(GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p)", location, count, v);\r
+       rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
+       colorState->reference();\r
+}\r
 \r
-    try\r
-    {\r
-        if(count < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+void RADAPIENTRY radReleaseColorState(RADcolorState color)\r
+{\r
+       rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
+       colorState->release();\r
+}\r
 \r
-        if(location == -1)\r
-        {\r
-            return;\r
-        }\r
+void RADAPIENTRY radColorDefault(RADcolorState color)\r
+{\r
+       rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
+       colorState->default();\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radColorBlendEnable(RADcolorState color, RADuint index, RADboolean enable)\r
+{\r
+       rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
+       colorState->blend[index].enable = enable;\r
+}\r
 \r
-        if(context)\r
-        {\r
-            rad::Program *program = context->getCurrentProgram();\r
+void RADAPIENTRY radColorBlendFunc(RADcolorState color, RADuint index, RADblendFunc srcFunc, RADblendFunc dstFunc, RADblendFunc srcFuncAlpha, RADblendFunc dstFuncAlpha)\r
+{\r
+       rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
+       colorState->blend[index].srcFunc = srcFunc;\r
+       colorState->blend[index].dstFunc = dstFunc;\r
+       colorState->blend[index].srcFuncAlpha = srcFuncAlpha;\r
+       colorState->blend[index].dstFuncAlpha = dstFuncAlpha;\r
+}\r
 \r
-            if(!program)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
+void RADAPIENTRY radColorBlendEquation(RADcolorState color, RADuint index, RADblendEquation modeRGB, RADblendEquation modeAlpha)\r
+{\r
+       rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
+       colorState->blend[index].modeRGB = modeRGB;\r
+       colorState->blend[index].modeAlpha = modeAlpha;\r
+}\r
 \r
-            if(!program->setUniform4fv(location, count, v))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radColorMask(RADcolorState color, RADuint index, RADboolean r, RADboolean g, RADboolean b, RADboolean a)\r
+{\r
+       rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
+       colorState->blend[index].maskRGBA[0] = r;\r
+       colorState->blend[index].maskRGBA[1] = g;\r
+       colorState->blend[index].maskRGBA[2] = b;\r
+       colorState->blend[index].maskRGBA[3] = a;\r
 }\r
 \r
-void GL_APIENTRY glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)\r
+void RADAPIENTRY radColorNumTargets(RADcolorState color, RADuint numTargets)\r
 {\r
-    GLint xyzw[4] = {x, y, z, w};\r
+       rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
+       colorState->numTargets = numTargets;\r
+}\r
 \r
-    glUniform4iv(location, 1, (GLint*)&xyzw);\r
+void RADAPIENTRY radColorLogicOpEnable(RADcolorState color, RADboolean enable)\r
+{\r
+       rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
+       colorState->logicOpEnable = enable;\r
 }\r
 \r
-void GL_APIENTRY glUniform4iv(GLint location, GLsizei count, const GLint* v)\r
+void RADAPIENTRY radColorLogicOp(RADcolorState color, RADlogicOp logicOp)\r
 {\r
-    TRACE("(GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p)", location, count, v);\r
+       rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
+       colorState->logicOp = logicOp;\r
+}\r
 \r
-    try\r
-    {\r
-        if(count < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+void RADAPIENTRY radColorAlphaToCoverageEnable(RADcolorState color, RADboolean enable)\r
+{\r
+       rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
+       colorState->alphaToCoverageEnable = enable;\r
+}\r
 \r
-        if(location == -1)\r
-        {\r
-            return;\r
-        }\r
+void RADAPIENTRY radColorBlendColor(RADcolorState color, const RADfloat *blendColor)\r
+{\r
+       rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
+       colorState->blendColor[0] = blendColor[0];\r
+       colorState->blendColor[1] = blendColor[1];\r
+       colorState->blendColor[2] = blendColor[2];\r
+       colorState->blendColor[3] = blendColor[3];\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radColorDynamic(RADcolorState color, RADcolorDynamic dynamic, RADboolean enable) {UNIMPLEMENTED();}\r
 \r
-        if(context)\r
-        {\r
-            rad::Program *program = context->getCurrentProgram();\r
+RADrasterState RADAPIENTRY radCreateRasterState(RADdevice device)\r
+{\r
+       rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
+       rad::RasterState *rasterState = new rad::RasterState(radDevice);\r
+       return reinterpret_cast<RADrasterState>(rasterState);\r
+}\r
 \r
-            if(!program)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
+void RADAPIENTRY radReferenceRasterState(RADrasterState raster)\r
+{\r
+       rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
+       rasterState->reference();\r
+}\r
 \r
-            if(!program->setUniform4iv(location, count, v))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radReleaseRasterState(RADrasterState raster)\r
+{\r
+       rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
+       rasterState->release();\r
 }\r
 \r
-void GL_APIENTRY glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)\r
+void RADAPIENTRY radRasterDefault(RADrasterState raster)\r
 {\r
-    TRACE("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = 0x%0.8p)",\r
-          location, count, transpose, value);\r
+       rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
+       rasterState->default();\r
+}\r
 \r
-    try\r
-    {\r
-        if(count < 0 || transpose != GL_FALSE)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+void RADAPIENTRY radRasterPointSize(RADrasterState raster, RADfloat pointSize)\r
+{\r
+       rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
+       rasterState->pointSize = pointSize;\r
+}\r
 \r
-        if(location == -1)\r
-        {\r
-            return;\r
-        }\r
+void RADAPIENTRY radRasterLineWidth(RADrasterState raster, RADfloat lineWidth)\r
+{\r
+       rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
+       rasterState->lineWidth = lineWidth;\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radRasterCullFace(RADrasterState raster, RADfaceBitfield face)\r
+{\r
+       rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
+       rasterState->cullFace = face;\r
+}\r
 \r
-        if(context)\r
-        {\r
-            rad::Program *program = context->getCurrentProgram();\r
+void RADAPIENTRY radRasterFrontFace(RADrasterState raster, RADfrontFace face)\r
+{\r
+       rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
+       rasterState->frontFace = face;\r
+}\r
 \r
-            if(!program)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
+void RADAPIENTRY radRasterPolygonMode(RADrasterState raster, RADpolygonMode polygonMode)\r
+{\r
+       rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
+       rasterState->polygonMode = polygonMode;\r
+}\r
 \r
-            if(!program->setUniformMatrix2fv(location, count, value))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radRasterPolygonOffsetClamp(RADrasterState raster, RADfloat factor, RADfloat units, RADfloat clamp)\r
+{\r
+       rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
+       rasterState->offsetFactor = factor;\r
+       rasterState->offsetUnits = units;\r
+       rasterState->offsetClamp = clamp;\r
 }\r
 \r
-void GL_APIENTRY glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)\r
+void RADAPIENTRY radRasterPolygonOffsetEnables(RADrasterState raster, RADpolygonOffsetEnables enables)\r
 {\r
-    TRACE("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = 0x%0.8p)",\r
-          location, count, transpose, value);\r
+       rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
+       rasterState->polygonOffsetEnables = enables;\r
+}\r
 \r
-    try\r
-    {\r
-        if(count < 0 || transpose != GL_FALSE)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+void RADAPIENTRY radRasterDiscardEnable(RADrasterState raster, RADboolean enable)\r
+{\r
+       rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
+       rasterState->discardEnable = enable;\r
+}\r
 \r
-        if(location == -1)\r
-        {\r
-            return;\r
-        }\r
+void RADAPIENTRY radRasterMultisampleEnable(RADrasterState raster, RADboolean enable)\r
+{\r
+       rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
+       rasterState->multisampleEnable = enable;\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radRasterSamples(RADrasterState raster, RADuint samples)\r
+{\r
+       rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
+       rasterState->samples = samples;\r
+}\r
 \r
-        if(context)\r
-        {\r
-            rad::Program *program = context->getCurrentProgram();\r
+void RADAPIENTRY radRasterSampleMask(RADrasterState raster, RADuint mask)\r
+{\r
+       rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
+       rasterState->sampleMask = mask;\r
+}\r
 \r
-            if(!program)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
+void RADAPIENTRY radRasterDynamic(RADrasterState raster, RADrasterDynamic dynamic, RADboolean enable)\r
+{\r
+       UNIMPLEMENTED();\r
+}\r
 \r
-            if(!program->setUniformMatrix3fv(location, count, value))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+RADdepthStencilState RADAPIENTRY radCreateDepthStencilState(RADdevice device)\r
+{\r
+       rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
+       rad::DepthStencilState *depthStencilState = new rad::DepthStencilState(radDevice);\r
+       return reinterpret_cast<RADdepthStencilState>(depthStencilState);\r
 }\r
 \r
-void GL_APIENTRY glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)\r
+void RADAPIENTRY radReferenceDepthStencilState(RADdepthStencilState depthStencil)\r
 {\r
-    TRACE("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = 0x%0.8p)",\r
-          location, count, transpose, value);\r
+       rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
+       depthStencilState->reference();\r
+}\r
 \r
-    try\r
-    {\r
-        if(count < 0 || transpose != GL_FALSE)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+void RADAPIENTRY radReleaseDepthStencilState(RADdepthStencilState depthStencil)\r
+{\r
+       rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
+       depthStencilState->release();\r
+}\r
 \r
-        if(location == -1)\r
-        {\r
-            return;\r
-        }\r
+void RADAPIENTRY radDepthStencilDefault(RADdepthStencilState depthStencil)\r
+{\r
+       rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
+       depthStencilState->default();\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radDepthStencilDepthTestEnable(RADdepthStencilState depthStencil, RADboolean enable)\r
+{\r
+       rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
+       depthStencilState->depthTestEnable = enable;\r
+}\r
 \r
-        if(context)\r
-        {\r
-            rad::Program *program = context->getCurrentProgram();\r
+void RADAPIENTRY radDepthStencilDepthWriteEnable(RADdepthStencilState depthStencil, RADboolean enable)\r
+{\r
+       rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
+       depthStencilState->depthWriteEnable = enable;\r
+}\r
 \r
-            if(!program)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
+void RADAPIENTRY radDepthStencilDepthFunc(RADdepthStencilState depthStencil, RADdepthFunc func)\r
+{\r
+       rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
+       depthStencilState->depthFunc = func;\r
+}\r
 \r
-            if(!program->setUniformMatrix4fv(location, count, value))\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radDepthStencilStencilTestEnable(RADdepthStencilState depthStencil, RADboolean enable)\r
+{\r
+       rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
+       depthStencilState->stencilTestEnable = enable;\r
 }\r
 \r
-void GL_APIENTRY glUseProgram(GLuint program)\r
+void RADAPIENTRY radDepthStencilStencilFunc(RADdepthStencilState depthStencil, RADfaceBitfield faces, RADstencilFunc func, RADint ref, RADuint mask)\r
 {\r
-    TRACE("(GLuint program = %d)", program);\r
+       rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
 \r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
+       if(faces & RAD_FACE_FRONT)\r
+       {\r
+               depthStencilState->stencilFuncFront = func;\r
+               depthStencilState->stencilRefFront = ref;\r
+               depthStencilState->stencilMaskFront = mask;\r
+       }\r
 \r
-        if(context)\r
-        {\r
-            rad::Program *programObject = context->getProgram(program);\r
-\r
-            if(!programObject && program != 0)\r
-            {\r
-                if(context->getShader(program))\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-            }\r
-\r
-            if(program != 0 && !programObject->isLinked())\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
-\r
-            context->useProgram(program);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+       if(faces & RAD_FACE_BACK)\r
+       {\r
+               depthStencilState->stencilFuncBack = func;\r
+               depthStencilState->stencilRefBack = ref;\r
+               depthStencilState->stencilMaskBack = mask;\r
+       }\r
 }\r
 \r
-void GL_APIENTRY glValidateProgram(GLuint program)\r
+void RADAPIENTRY radDepthStencilStencilOp(RADdepthStencilState depthStencil, RADfaceBitfield faces, RADstencilOp fail, RADstencilOp depthFail, RADstencilOp depthPass)\r
 {\r
-    TRACE("(GLuint program = %d)", program);\r
-\r
-    try\r
-    {\r
-        rad::Context *context = rad::getContext();\r
+       rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
+       \r
+       if(faces & RAD_FACE_FRONT)\r
+       {\r
+               depthStencilState->stencilFailOpFront = fail;\r
+               depthStencilState->depthFailOpFront = depthFail;\r
+               depthStencilState->depthPassOpFront = depthPass;\r
+       }\r
 \r
-        if(context)\r
-        {\r
-            rad::Program *programObject = context->getProgram(program);\r
-\r
-            if(!programObject)\r
-            {\r
-                if(context->getShader(program))\r
-                {\r
-                    return error(GL_INVALID_OPERATION);\r
-                }\r
-                else\r
-                {\r
-                    return error(GL_INVALID_VALUE);\r
-                }\r
-            }\r
-\r
-            programObject->validate();\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+       if(faces & RAD_FACE_BACK)\r
+       {\r
+               depthStencilState->stencilFailOpBack = fail;\r
+               depthStencilState->depthFailOpBack = depthFail;\r
+               depthStencilState->depthPassOpBack = depthPass;\r
+       }\r
 }\r
 \r
-void GL_APIENTRY glVertexAttrib1f(GLuint index, GLfloat x)\r
+void RADAPIENTRY radDepthStencilStencilMask(RADdepthStencilState depthStencil, RADfaceBitfield faces, RADuint mask)\r
 {\r
-    TRACE("(GLuint index = %d, GLfloat x = %f)", index, x);\r
+       rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
+       \r
+       if(faces & RAD_FACE_FRONT)\r
+       {\r
+               depthStencilState->stencilMaskFront = mask;\r
+               \r
+       }\r
 \r
-    try\r
-    {\r
-        if(index >= rad::MAX_VERTEX_ATTRIBS)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+       if(faces & RAD_FACE_BACK)\r
+       {\r
+               depthStencilState->stencilMaskBack = mask;\r
+       }\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radDepthStencilDynamic(RADdepthStencilState depthStencil, RADdepthStencilDynamic dynamic, RADboolean enable)\r
+{\r
+       UNIMPLEMENTED();\r
+}\r
 \r
-        if(context)\r
-        {\r
-            GLfloat vals[4] = { x, 0, 0, 1 };\r
-            context->setVertexAttrib(index, vals);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+RADvertexState RADAPIENTRY radCreateVertexState(RADdevice device)\r
+{\r
+       rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
+       rad::VertexState *vertexState = new rad::VertexState(radDevice);\r
+       return reinterpret_cast<RADvertexState>(vertexState);\r
 }\r
 \r
-void GL_APIENTRY glVertexAttrib1fv(GLuint index, const GLfloat* values)\r
+void RADAPIENTRY radReferenceVertexState(RADvertexState vertex)\r
 {\r
-    TRACE("(GLuint index = %d, const GLfloat* values = 0x%0.8p)", index, values);\r
+       rad::VertexState *vertexState = reinterpret_cast<rad::VertexState*>(vertex);\r
+       vertexState->reference();\r
+}\r
 \r
-    try\r
-    {\r
-        if(index >= rad::MAX_VERTEX_ATTRIBS)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+void RADAPIENTRY radReleaseVertexState(RADvertexState vertex)\r
+{\r
+       rad::VertexState *vertexState = reinterpret_cast<rad::VertexState*>(vertex);\r
+       vertexState->release();\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radVertexDefault(RADvertexState vertex) {UNIMPLEMENTED();}\r
 \r
-        if(context)\r
-        {\r
-            GLfloat vals[4] = { values[0], 0, 0, 1 };\r
-            context->setVertexAttrib(index, vals);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radVertexAttribFormat(RADvertexState vertex, RADint attribIndex, RADint numComponents, RADint bytesPerComponent, RADattribType type, RADuint relativeOffset)\r
+{\r
+       ASSERT(attribIndex >= 0 && attribIndex < GL_MAX_VERTEX_ATTRIBS);\r
+       rad::VertexState *vertexState = reinterpret_cast<rad::VertexState*>(vertex);\r
+       vertexState->attrib[attribIndex].numComponents = numComponents;\r
+       vertexState->attrib[attribIndex].bytesPerComponent = bytesPerComponent;\r
+       vertexState->attrib[attribIndex].type = type;\r
+       vertexState->attrib[attribIndex].relativeOffset = relativeOffset;\r
 }\r
 \r
-void GL_APIENTRY glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)\r
+void RADAPIENTRY radVertexAttribBinding(RADvertexState vertex, RADint attribIndex, RADint bindingIndex)\r
 {\r
-    TRACE("(GLuint index = %d, GLfloat x = %f, GLfloat y = %f)", index, x, y);\r
+       ASSERT(attribIndex >= 0 && attribIndex < GL_MAX_VERTEX_ATTRIBS);\r
+       rad::VertexState *vertexState = reinterpret_cast<rad::VertexState*>(vertex);\r
+       vertexState->attrib[attribIndex].bindingIndex = bindingIndex;\r
+}\r
 \r
-    try\r
-    {\r
-        if(index >= rad::MAX_VERTEX_ATTRIBS)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+void RADAPIENTRY radVertexBindingGroup(RADvertexState vertex, RADint bindingIndex, RADint group, RADint index)\r
+{\r
+       ASSERT(bindingIndex >= 0 && bindingIndex < GL_MAX_VERTEX_ATTRIBS);\r
+       rad::VertexState *vertexState = reinterpret_cast<rad::VertexState*>(vertex);\r
+       vertexState->binding[bindingIndex].group = group;\r
+       vertexState->binding[bindingIndex].index = index;\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radVertexAttribEnable(RADvertexState vertex, RADint attribIndex, RADboolean enable)\r
+{\r
+       ASSERT(attribIndex >= 0 && attribIndex < GL_MAX_VERTEX_ATTRIBS);\r
+       rad::VertexState *vertexState = reinterpret_cast<rad::VertexState*>(vertex);\r
+       vertexState->attrib[attribIndex].bindingIndex = enable;\r
+}\r
 \r
-        if(context)\r
-        {\r
-            GLfloat vals[4] = { x, y, 0, 1 };\r
-            context->setVertexAttrib(index, vals);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radVertexBindingStride(RADvertexState vertex, RADint bindingIndex, RADuint stride)\r
+{\r
+       ASSERT(bindingIndex >= 0 && bindingIndex < GL_MAX_VERTEX_ATTRIBS);\r
+       rad::VertexState *vertexState = reinterpret_cast<rad::VertexState*>(vertex);\r
+       vertexState->binding[bindingIndex].stride = stride;\r
 }\r
 \r
-void GL_APIENTRY glVertexAttrib2fv(GLuint index, const GLfloat* values)\r
+RADrtFormatState RADAPIENTRY radCreateRtFormatState(RADdevice device)\r
 {\r
-    TRACE("(GLuint index = %d, const GLfloat* values = 0x%0.8p)", index, values);\r
+       rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
+       rad::FormatState *formatState = new rad::FormatState(radDevice);\r
+       return reinterpret_cast<RADrtFormatState>(formatState);\r
+}\r
 \r
-    try\r
-    {\r
-        if(index >= rad::MAX_VERTEX_ATTRIBS)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+void RADAPIENTRY radReferenceRtFormatState(RADrtFormatState rtFormat)\r
+{\r
+       rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
+       formatState->reference();\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radReleaseRtFormatState(RADrtFormatState rtFormat)\r
+{\r
+       rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
+       formatState->release();\r
+}\r
 \r
-        if(context)\r
-        {\r
-            GLfloat vals[4] = { values[0], values[1], 0, 1 };\r
-            context->setVertexAttrib(index, vals);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radRtFormatDefault(RADrtFormatState rtFormat)\r
+{\r
+       rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
+       formatState->default();\r
 }\r
 \r
-void GL_APIENTRY glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)\r
+void RADAPIENTRY radRtFormatColorFormat(RADrtFormatState rtFormat, RADuint index, RADinternalFormat format)\r
 {\r
-    TRACE("(GLuint index = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", index, x, y, z);\r
+       rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
+       formatState->colorFormat[index] = format;\r
+}\r
 \r
-    try\r
-    {\r
-        if(index >= rad::MAX_VERTEX_ATTRIBS)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+void RADAPIENTRY radRtFormatDepthFormat(RADrtFormatState rtFormat, RADinternalFormat format)\r
+{\r
+       rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
+       formatState->depthFormat = format;\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radRtFormatStencilFormat(RADrtFormatState rtFormat, RADinternalFormat format)\r
+{\r
+       rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
+       formatState->stencilFormat = format;\r
+}\r
 \r
-        if(context)\r
-        {\r
-            GLfloat vals[4] = { x, y, z, 1 };\r
-            context->setVertexAttrib(index, vals);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radRtFormatColorSamples(RADrtFormatState rtFormat, RADuint samples)\r
+{\r
+       rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
+       formatState->colorSamples = samples;\r
 }\r
 \r
-void GL_APIENTRY glVertexAttrib3fv(GLuint index, const GLfloat* values)\r
+void RADAPIENTRY radRtFormatDepthStencilSamples(RADrtFormatState rtFormat, RADuint samples)\r
 {\r
-    TRACE("(GLuint index = %d, const GLfloat* values = 0x%0.8p)", index, values);\r
+       rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
+       formatState->depthStencilSamples = samples;\r
+}\r
 \r
-    try\r
-    {\r
-        if(index >= rad::MAX_VERTEX_ATTRIBS)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+RADpipeline RADAPIENTRY radCreatePipeline(RADdevice device, RADpipelineType pipelineType)\r
+{\r
+       rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
+       rad::Pipeline *pipeline = new rad::Pipeline(radDevice);\r
+       return reinterpret_cast<RADpipeline>(pipeline);\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radReferencePipeline(RADpipeline pipeline)\r
+{\r
+       rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
+       radPipeline->reference();\r
+}\r
 \r
-        if(context)\r
-        {\r
-            GLfloat vals[4] = { values[0], values[1], values[2], 1 };\r
-            context->setVertexAttrib(index, vals);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radReleasePipeline(RADpipeline pipeline)\r
+{\r
+       rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
+       radPipeline->release();\r
 }\r
 \r
-void GL_APIENTRY glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)\r
+void RADAPIENTRY radPipelineProgramStages(RADpipeline pipeline, RADbitfield stages, RADprogram program)\r
 {\r
-    TRACE("(GLuint index = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f, GLfloat w = %f)", index, x, y, z, w);\r
+       rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
+       rad::Program *radProgram = reinterpret_cast<rad::Program*>(program);\r
 \r
-    try\r
-    {\r
-        if(index >= rad::MAX_VERTEX_ATTRIBS)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+       if(stages & RAD_VERTEX_SHADER_BIT)\r
+       {\r
+               ASSERT(!radPipeline->vertexProgram);\r
+               radProgram->reference();   // FIXME: here or at compile?\r
+               radPipeline->vertexProgram = radProgram;\r
+       }\r
 \r
-        rad::Context *context = rad::getContext();\r
+       if(stages & RAD_FRAGMENT_SHADER_BIT)\r
+       {\r
+               ASSERT(!radPipeline->fragmentProgram);\r
+               radProgram->reference();   // FIXME: here or at compile?\r
+               radPipeline->fragmentProgram = radProgram;\r
+       }\r
+}\r
 \r
-        if(context)\r
-        {\r
-            GLfloat vals[4] = { x, y, z, w };\r
-            context->setVertexAttrib(index, vals);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radPipelineVertexState(RADpipeline pipeline, RADvertexState vertex)\r
+{\r
+       rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
+       rad::VertexState *vertexState = reinterpret_cast<rad::VertexState*>(vertex);\r
+       ASSERT(!radPipeline->vertexState);\r
+       vertexState->reference();   // FIXME: here or at compile?\r
+       radPipeline->vertexState = vertexState;\r
 }\r
 \r
-void GL_APIENTRY glVertexAttrib4fv(GLuint index, const GLfloat* values)\r
+void RADAPIENTRY radPipelineColorState(RADpipeline pipeline, RADcolorState color)\r
 {\r
-    TRACE("(GLuint index = %d, const GLfloat* values = 0x%0.8p)", index, values);\r
+       rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
+       rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
+       ASSERT(!radPipeline->colorState);\r
+       colorState->reference();   // FIXME: here or at compile?\r
+       radPipeline->colorState = colorState;\r
+}\r
 \r
-    try\r
-    {\r
-        if(index >= rad::MAX_VERTEX_ATTRIBS)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+void RADAPIENTRY radPipelineRasterState(RADpipeline pipeline, RADrasterState raster)\r
+{\r
+       rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
+       rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
+       ASSERT(!radPipeline->rasterState);\r
+       rasterState->reference();   // FIXME: here or at compile?\r
+       radPipeline->rasterState = rasterState;\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radPipelineDepthStencilState(RADpipeline pipeline, RADdepthStencilState depthStencil)\r
+{\r
+       rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
+       rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
+       ASSERT(!radPipeline->depthStencilState);\r
+       depthStencilState->reference();   // FIXME: here or at compile?\r
+       radPipeline->depthStencilState = depthStencilState;\r
+}\r
 \r
-        if(context)\r
-        {\r
-            context->setVertexAttrib(index, values);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radPipelineRtFormatState(RADpipeline pipeline, RADrtFormatState rtFormat)\r
+{\r
+       rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
+       rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
+       ASSERT(!radPipeline->formatState);\r
+       formatState->reference();   // FIXME: here or at compile?\r
+       radPipeline->formatState = formatState;\r
 }\r
 \r
-void GL_APIENTRY glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr)\r
+void RADAPIENTRY radPipelinePrimitiveType(RADpipeline pipeline, RADprimitiveType mode)\r
 {\r
-    TRACE("(GLuint index = %d, GLint size = %d, GLenum type = 0x%X, "\r
-          "GLboolean normalized = %d, GLsizei stride = %d, const GLvoid* ptr = 0x%0.8p)",\r
-          index, size, type, normalized, stride, ptr);\r
+       rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
+       radPipeline->primitiveType = mode;\r
+}\r
 \r
-    try\r
-    {\r
-        if(index >= rad::MAX_VERTEX_ATTRIBS)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+void RADAPIENTRY radCompilePipeline(RADpipeline pipeline)\r
+{\r
+       // FIXME: Reference state objects here or when set?\r
+       return;\r
+}\r
 \r
-        if(size < 1 || size > 4)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+RADpipelineHandle RADAPIENTRY radGetPipelineHandle(RADpipeline pipeline)\r
+{\r
+       return reinterpret_cast<RADpipelineHandle>(pipeline);\r
+}\r
 \r
-        switch(type)\r
-        {\r
-          case GL_BYTE:\r
-          case GL_UNSIGNED_BYTE:\r
-          case GL_SHORT:\r
-          case GL_UNSIGNED_SHORT:\r
-          case GL_FIXED:\r
-          case GL_FLOAT:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
+RADcommandBuffer RADAPIENTRY radCreateCommandBuffer(RADdevice device, RADqueueType queueType)\r
+{\r
+       return 0;\r
+}\r
 \r
-        if(stride < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+void RADAPIENTRY radReferenceCommandBuffer(RADcommandBuffer cmdBuf) {UNIMPLEMENTED();}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radReleaseCommandBuffer(RADcommandBuffer cmdBuf)\r
+{\r
+       return;\r
+}\r
 \r
-        if(context)\r
-        {\r
-            context->setVertexAttribState(index, context->getArrayBuffer(), size, type, (normalized == GL_TRUE), stride, ptr);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radCmdBindPipeline(RADcommandBuffer cmdBuf, RADpipelineType pipelineType, RADpipelineHandle pipelineHandle)\r
+{\r
+       return;\r
 }\r
 \r
-void GL_APIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height)\r
+void RADAPIENTRY radCmdBindGroup(RADcommandBuffer cmdBuf, RADbitfield stages, RADuint group, RADuint count, RADbindGroupHandle groupHandle, RADuint offset)\r
 {\r
-    TRACE("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)", x, y, width, height);\r
+       \r
+}\r
 \r
-    try\r
-    {\r
-        if(width < 0 || height < 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+void RADAPIENTRY radCmdDrawArrays(RADcommandBuffer cmdBuf, RADprimitiveType mode, RADint first, RADsizei count) {UNIMPLEMENTED();}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radCmdDrawElements(RADcommandBuffer cmdBuf, RADprimitiveType mode, RADindexType type, RADsizei count, RADindexHandle indexHandle, RADuint offset)\r
+{\r
+       return;\r
+}\r
 \r
-        if(context)\r
-        {\r
-            context->setViewportParams(x, y, width, height);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+RADboolean RADAPIENTRY radCompileCommandBuffer(RADcommandBuffer cmdBuf)\r
+{\r
+       return false;\r
 }\r
 \r
-void GL_APIENTRY glBlitFramebufferANGLE(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,\r
-                                      GLbitfield mask, GLenum filter)\r
+RADcommandHandle RADAPIENTRY radGetCommandHandle(RADcommandBuffer cmdBuf)\r
 {\r
-    TRACE("(GLint srcX0 = %d, GLint srcY0 = %d, GLint srcX1 = %d, GLint srcY1 = %d, "\r
-          "GLint dstX0 = %d, GLint dstY0 = %d, GLint dstX1 = %d, GLint dstY1 = %d, "\r
-          "GLbitfield mask = 0x%X, GLenum filter = 0x%X)",\r
-          srcX0, srcY0, srcX1, srcX1, dstX0, dstY0, dstX1, dstY1, mask, filter);\r
+       return 0;\r
+}\r
 \r
-    try\r
-    {\r
-        switch(filter)\r
-        {\r
-          case GL_NEAREST:\r
-            break;\r
-          default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
+void RADAPIENTRY radCmdStencilValueMask(RADcommandBuffer cmdBuf, RADfaceBitfield faces, RADuint mask) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radCmdStencilMask(RADcommandBuffer cmdBuf, RADfaceBitfield faces, RADuint mask) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radCmdStencilRef(RADcommandBuffer cmdBuf, RADfaceBitfield faces, RADint ref) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radCmdBlendColor(RADcommandBuffer cmdBuf, const RADfloat *blendColor) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radCmdPointSize(RADcommandBuffer cmdBuf, RADfloat pointSize) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radCmdLineWidth(RADcommandBuffer cmdBuf, RADfloat lineWidth) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radCmdPolygonOffsetClamp(RADcommandBuffer cmdBuf, RADfloat factor, RADfloat units, RADfloat clamp) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radCmdSampleMask(RADcommandBuffer cmdBuf, RADuint mask) {UNIMPLEMENTED();}\r
 \r
-        if((mask & ~(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)) != 0)\r
-        {\r
-            return error(GL_INVALID_VALUE);\r
-        }\r
+RADpass RADAPIENTRY radCreatePass(RADdevice device)\r
+{\r
+       rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
+       rad::Pass *pass = new rad::Pass(radDevice);\r
+       return reinterpret_cast<RADpass>(pass);\r
+}\r
 \r
-        if(srcX1 - srcX0 != dstX1 - dstX0 || srcY1 - srcY0 != dstY1 - dstY0)\r
-        {\r
-            ERR("Scaling and flipping in BlitFramebufferANGLE not supported by this implementation");\r
-            return error(GL_INVALID_OPERATION);\r
-        }\r
+void RADAPIENTRY radReferencePass(RADpass pass)\r
+{\r
+       rad::Pass *radPass = reinterpret_cast<rad::Pass*>(pass);\r
+       radPass->reference();\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radReleasePass(RADpass pass)\r
+{\r
+       rad::Pass *radPass = reinterpret_cast<rad::Pass*>(pass);\r
+       radPass->release();\r
+}\r
 \r
-        if(context)\r
-        {\r
-            if(context->getReadFramebufferHandle() == context->getDrawFramebufferHandle())\r
-            {\r
-                ERR("Blits with the same source and destination framebuffer are not supported by this implementation.");\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
+void RADAPIENTRY radPassDefault(RADpass pass)\r
+{\r
+       rad::Pass *radPass = reinterpret_cast<rad::Pass*>(pass);\r
+       radPass->default();\r
+}\r
 \r
-            context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+void RADAPIENTRY radCompilePass(RADpass pass)\r
+{\r
+       return;\r
 }\r
 \r
-void GL_APIENTRY glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,\r
-                               GLint border, GLenum format, GLenum type, const GLvoid* pixels)\r
+void RADAPIENTRY radPassRenderTargets(RADpass pass, RADuint numColors, const RADrenderTargetHandle *colors, RADrenderTargetHandle depth, RADrenderTargetHandle stencil)\r
 {\r
-    TRACE("(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, "\r
-          "GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, "\r
-          "GLenum format = 0x%X, GLenum type = 0x%x, const GLvoid* pixels = 0x%0.8p)",\r
-          target, level, internalformat, width, height, depth, border, format, type, pixels);\r
+       rad::Pass *radPass = reinterpret_cast<rad::Pass*>(pass);\r
+       radPass->numColors = numColors;\r
+       for(unsigned int i = 0; i < numColors; i++)\r
+       {\r
+               ASSERT(colors[i]);\r
+               es2::Image *colorTarget = reinterpret_cast<es2::Image*>(colors[i]);\r
+               colorTarget->addRef();   // FIXME: here or at compile?\r
+               radPass->colorTarget[i] = colorTarget;\r
+       }\r
 \r
-    try\r
-    {\r
-               UNIMPLEMENTED();   // FIXME\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+       if(depth)\r
+       {\r
+               es2::Image *depthTarget = reinterpret_cast<es2::Image*>(depth);\r
+               depthTarget->addRef();   // FIXME: here or at compile?\r
+               radPass->depthTarget = depthTarget;\r
+       }\r
+\r
+       if(stencil)\r
+       {\r
+               es2::Image *stencilTarget = reinterpret_cast<es2::Image*>(stencil);\r
+               stencilTarget->addRef();   // FIXME: here or at compile?\r
+               radPass->stencilTarget = stencilTarget;\r
+       }\r
 }\r
 \r
-void GL_APIENTRY glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)\r
+void RADAPIENTRY radPassPreserveEnable(RADpass pass, RADrtAttachment attachment, RADboolean enable) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radPassDiscard(RADpass pass, RADuint numTextures, const RADtexture *textures, const RADoffset2D *offsets) {UNIMPLEMENTED();}\r
+\r
+void RADAPIENTRY radPassResolve(RADpass pass, RADrtAttachment attachment, RADtexture texture)\r
 {\r
-    TRACE("(GLenum target = 0x%X, GLeglImageOES image = 0x%0.8p)", target, image);\r
+       return;\r
+}\r
 \r
-    try\r
-    {\r
-        switch(target)\r
-        {\r
-        case GL_TEXTURE_EXTERNAL_OES:\r
-            break;\r
-        default:\r
-            return error(GL_INVALID_ENUM);\r
-        }\r
+void RADAPIENTRY radPassStore(RADpass pass, RADuint numTextures, const RADtexture *textures, const RADoffset2D *offsets) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radPassClip(RADpass pass, const RADrect2D *rect) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radPassDependencies(RADpass pass, RADuint numPasses, const RADpass *otherPasses, const RADbitfield *srcMask, const RADbitfield *dstMask, const RADbitfield *flushMask, const RADbitfield *invalidateMask) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radPassTilingBoundary(RADpass pass, RADboolean boundary) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radPassTileFilterWidth(RADpass pass, RADuint filterWidth, RADuint filterHeight) {UNIMPLEMENTED();}\r
+void RADAPIENTRY radPassTileFootprint(RADpass pass, RADuint bytesPerPixel, RADuint maxFilterWidth, RADuint maxFilterHeight) {UNIMPLEMENTED();}\r
 \r
-        if(!image)\r
-        {\r
-            return error(GL_INVALID_OPERATION);\r
-        }\r
+RADsync RADAPIENTRY radCreateSync(RADdevice device)\r
+{\r
+       return 0;\r
+}\r
 \r
-        rad::Context *context = rad::getContext();\r
+void RADAPIENTRY radReferenceSync(RADsync sync) {UNIMPLEMENTED();}\r
 \r
-        if(context)\r
-        {\r
-            rad::TextureExternal *texture = context->getTextureExternal();\r
+void RADAPIENTRY radReleaseSync(RADsync sync)\r
+{\r
+       return;\r
+}\r
 \r
-            if(!texture)\r
-            {\r
-                return error(GL_INVALID_OPERATION);\r
-            }\r
+void RADAPIENTRY radQueueFenceSync(RADqueue queue, RADsync sync, RADsyncCondition condition, RADbitfield flags)\r
+{\r
+       return;\r
+}\r
 \r
-            rad::Image *glImage = static_cast<rad::Image*>(image);\r
+RADwaitSyncResult RADAPIENTRY radWaitSync(RADsync sync, RADuint64 timeout) {UNIMPLEMENTED(); return RAD_WAIT_SYNC_FAILED;}\r
 \r
-            texture->setImage(glImage);\r
-        }\r
-    }\r
-    catch(std::bad_alloc&)\r
-    {\r
-        return error(GL_OUT_OF_MEMORY);\r
-    }\r
+RADboolean RADAPIENTRY radQueueWaitSync(RADqueue queue, RADsync sync)\r
+{\r
+       return 0;\r
 }\r
 \r
-RADdevice RADAPIENTRY radCreateDevice (void) {UNIMPLEMENTED(); return 0;}\r
-void RADAPIENTRY radReferenceDevice (RADdevice device) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radReleaseDevice (RADdevice device) {UNIMPLEMENTED();}\r
-RADuint RADAPIENTRY radGetTokenHeader (RADdevice device, RADtokenName name) {UNIMPLEMENTED(); return 0;}\r
-RADqueue RADAPIENTRY radCreateQueue (RADdevice device, RADqueueType queuetype) {UNIMPLEMENTED(); return 0;}\r
-void RADAPIENTRY radReferenceQueue (RADqueue queue) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radReleaseQueue (RADqueue queue) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueTagBuffer (RADqueue queue, RADbuffer buffer) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueTagTexture (RADqueue queue, RADtexture texture) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueSubmitCommands (RADqueue queue, RADuint numCommands, const RADcommandHandle *handles) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radFlushQueue (RADqueue queue) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radFinishQueue (RADqueue queue) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueViewport (RADqueue queue, RADint x, RADint y, RADint w, RADint h) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueScissor (RADqueue queue, RADint x, RADint y, RADint w, RADint h) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueCopyBufferToImage (RADqueue queue, RADbuffer buffer, RADintptr bufferOffset, RADtexture texture, RADint level, RADuint xoffset, RADuint yoffset, RADuint zoffset, RADsizei width, RADsizei height, RADsizei depth) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueCopyImageToBuffer (RADqueue queue, RADbuffer buffer, RADintptr bufferOffset, RADtexture texture, RADint level, RADuint xoffset, RADuint yoffset, RADuint zoffset, RADsizei width, RADsizei height, RADsizei depth) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueCopyBuffer (RADqueue queue, RADbuffer srcBuffer, RADintptr srcOffset, RADbuffer dstBuffer, RADintptr dstOffset, RADsizei size) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueClearColor (RADqueue queue, RADuint index, const RADfloat *color) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueClearDepth (RADqueue queue, RADfloat depth) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueClearStencil (RADqueue queue, RADuint stencil) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueuePresent (RADqueue queue, RADtexture texture) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueDrawArrays (RADqueue queue, RADprimitiveType mode, RADint first, RADsizei count) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueDrawElements (RADqueue queue, RADprimitiveType mode, RADindexType type, RADsizei count, RADindexHandle indexHandle, RADuint offset) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueBindPipeline (RADqueue queue, RADpipelineType pipelineType, RADpipelineHandle pipelineHandle) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueBindGroup (RADqueue queue, RADbitfield stages, RADuint group, RADuint count, RADbindGroupHandle groupHandle, RADuint offset) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueBeginPass (RADqueue queue, RADpass pass) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueEndPass (RADqueue queue, RADpass pass) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueSubmitDynamic (RADqueue queue, const void *dynamic, RADsizei length) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueStencilValueMask (RADqueue queue, RADfaceBitfield faces, RADuint mask) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueStencilMask (RADqueue queue, RADfaceBitfield faces, RADuint mask) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueStencilRef (RADqueue queue, RADfaceBitfield faces, RADint ref) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueBlendColor (RADqueue queue, const RADfloat *blendColor) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueuePointSize (RADqueue queue, RADfloat pointSize) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueLineWidth (RADqueue queue, RADfloat lineWidth) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueuePolygonOffsetClamp (RADqueue queue, RADfloat factor, RADfloat units, RADfloat clamp) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueSampleMask (RADqueue queue, RADuint mask) {UNIMPLEMENTED();}\r
-RADprogram RADAPIENTRY radCreateProgram (RADdevice device) {UNIMPLEMENTED(); return 0;}\r
-void RADAPIENTRY radReferenceProgram (RADprogram program) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radReleaseProgram (RADprogram program) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radProgramSource (RADprogram program, RADprogramFormat format, RADsizei length, const void *source) {UNIMPLEMENTED();}\r
-RADbuffer RADAPIENTRY radCreateBuffer (RADdevice device) {UNIMPLEMENTED(); return 0;}\r
-void RADAPIENTRY radReferenceBuffer (RADbuffer buffer) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radReleaseBuffer (RADbuffer buffer, RADtagMode tagMode) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radBufferAccess (RADbuffer buffer, RADbitfield access) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radBufferMapAccess (RADbuffer buffer, RADbitfield mapAccess) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radBufferStorage (RADbuffer buffer, RADsizei size) {UNIMPLEMENTED();}\r
-void* RADAPIENTRY radMapBuffer (RADbuffer buffer) {UNIMPLEMENTED(); return 0;}\r
-RADvertexHandle RADAPIENTRY radGetVertexHandle (RADbuffer buffer) {UNIMPLEMENTED(); return 0;}\r
-RADindexHandle RADAPIENTRY radGetIndexHandle (RADbuffer buffer) {UNIMPLEMENTED(); return 0;}\r
-RADuniformHandle RADAPIENTRY radGetUniformHandle (RADbuffer buffer) {UNIMPLEMENTED(); return 0;}\r
-RADbindGroupHandle RADAPIENTRY radGetBindGroupHandle (RADbuffer buffer) {UNIMPLEMENTED(); return 0;}\r
-RADtexture RADAPIENTRY radCreateTexture (RADdevice device) {UNIMPLEMENTED(); return 0;}\r
-void RADAPIENTRY radReferenceTexture (RADtexture texture) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radReleaseTexture (RADtexture texture, RADtagMode tagMode) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radTextureAccess (RADtexture texture, RADbitfield access) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radTextureStorage (RADtexture texture, RADtextureTarget target, RADsizei levels, RADinternalFormat internalFormat, RADsizei width, RADsizei height, RADsizei depth, RADsizei samples) {UNIMPLEMENTED();}\r
-RADtextureHandle RADAPIENTRY radGetTextureSamplerHandle (RADtexture texture, RADsampler sampler, RADtextureTarget target, RADinternalFormat internalFormat, RADuint minLevel, RADuint numLevels, RADuint minLayer, RADuint numLayers) {UNIMPLEMENTED(); return 0;}\r
-RADrenderTargetHandle RADAPIENTRY radGetTextureRenderTargetHandle (RADtexture texture, RADtextureTarget target, RADinternalFormat internalFormat, RADuint level, RADuint minLayer, RADuint numLayers) {UNIMPLEMENTED(); return 0;}\r
-RADsampler RADAPIENTRY radCreateSampler (RADdevice device) {UNIMPLEMENTED(); return 0;}\r
-void RADAPIENTRY radReferenceSampler (RADsampler sampler) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radReleaseSampler (RADsampler sampler) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radSamplerDefault (RADsampler sampler) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radSamplerMinMagFilter (RADsampler sampler, RADminFilter min, RADmagFilter mag) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radSamplerWrapMode (RADsampler sampler, RADwrapMode s, RADwrapMode t, RADwrapMode r) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radSamplerLodClamp (RADsampler sampler, RADfloat min, RADfloat max) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radSamplerLodBias (RADsampler sampler, RADfloat bias) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radSamplerCompare (RADsampler sampler, RADcompareMode mode, RADcompareFunc func) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radSamplerBorderColorFloat (RADsampler sampler, const RADfloat *borderColor) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radSamplerBorderColorInt (RADsampler sampler, const RADuint *borderColor) {UNIMPLEMENTED();}\r
-RADcolorState RADAPIENTRY radCreateColorState (RADdevice device) {UNIMPLEMENTED(); return 0;}\r
-void RADAPIENTRY radReferenceColorState (RADcolorState color) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radReleaseColorState (RADcolorState color) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radColorDefault (RADcolorState color) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radColorBlendEnable (RADcolorState color, RADuint index, RADboolean enable) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radColorBlendFunc (RADcolorState color, RADuint index, RADblendFunc srcFunc, RADblendFunc dstFunc, RADblendFunc srcFuncAlpha, RADblendFunc dstFuncAlpha) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radColorBlendEquation (RADcolorState color, RADuint index, RADblendEquation modeRGB, RADblendEquation modeAlpha) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radColorMask (RADcolorState color, RADuint index, RADboolean r, RADboolean g, RADboolean b, RADboolean a) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radColorNumTargets (RADcolorState color, RADuint numTargets) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radColorLogicOpEnable (RADcolorState color, RADboolean enable) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radColorLogicOp (RADcolorState color, RADlogicOp logicOp) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radColorAlphaToCoverageEnable (RADcolorState color, RADboolean enable) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radColorBlendColor (RADcolorState color, const RADfloat *blendColor) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radColorDynamic (RADcolorState color, RADcolorDynamic dynamic, RADboolean enable) {UNIMPLEMENTED();}\r
-RADrasterState RADAPIENTRY radCreateRasterState (RADdevice device) {UNIMPLEMENTED(); return 0;}\r
-void RADAPIENTRY radReferenceRasterState (RADrasterState raster) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radReleaseRasterState (RADrasterState raster) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRasterDefault (RADrasterState raster) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRasterPointSize (RADrasterState raster, RADfloat pointSize) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRasterLineWidth (RADrasterState raster, RADfloat lineWidth) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRasterCullFace (RADrasterState raster, RADfaceBitfield face) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRasterFrontFace (RADrasterState raster, RADfrontFace face) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRasterPolygonMode (RADrasterState raster, RADpolygonMode polygonMode) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRasterPolygonOffsetClamp (RADrasterState raster, RADfloat factor, RADfloat units, RADfloat clamp) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRasterPolygonOffsetEnables (RADrasterState raster, RADpolygonOffsetEnables enables) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRasterDiscardEnable (RADrasterState raster, RADboolean enable) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRasterMultisampleEnable (RADrasterState raster, RADboolean enable) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRasterSamples (RADrasterState raster, RADuint samples) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRasterSampleMask (RADrasterState raster, RADuint mask) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRasterDynamic (RADrasterState raster, RADrasterDynamic dynamic, RADboolean enable) {UNIMPLEMENTED();}\r
-RADdepthStencilState RADAPIENTRY radCreateDepthStencilState (RADdevice device) {UNIMPLEMENTED(); return 0;}\r
-void RADAPIENTRY radReferenceDepthStencilState (RADdepthStencilState depthStencil) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radReleaseDepthStencilState (RADdepthStencilState depthStencil) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radDepthStencilDefault (RADdepthStencilState depthStencil) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radDepthStencilDepthTestEnable (RADdepthStencilState depthStencil, RADboolean enable) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radDepthStencilDepthWriteEnable (RADdepthStencilState depthStencil, RADboolean enable) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radDepthStencilDepthFunc (RADdepthStencilState depthStencil, RADdepthFunc func) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radDepthStencilStencilTestEnable (RADdepthStencilState depthStencil, RADboolean enable) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radDepthStencilStencilFunc (RADdepthStencilState depthStencil, RADfaceBitfield faces, RADstencilFunc func, RADint ref, RADuint mask) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radDepthStencilStencilOp (RADdepthStencilState depthStencil, RADfaceBitfield faces, RADstencilOp fail, RADstencilOp depthFail, RADstencilOp depthPass) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radDepthStencilStencilMask (RADdepthStencilState depthStencil, RADfaceBitfield faces, RADuint mask) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radDepthStencilDynamic (RADdepthStencilState depthStencil, RADdepthStencilDynamic dynamic, RADboolean enable) {UNIMPLEMENTED();}\r
-RADvertexState RADAPIENTRY radCreateVertexState (RADdevice device) {UNIMPLEMENTED(); return 0;}\r
-void RADAPIENTRY radReferenceVertexState (RADvertexState vertex) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radReleaseVertexState (RADvertexState vertex) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radVertexDefault (RADvertexState vertex) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radVertexAttribFormat (RADvertexState vertex, RADint attribIndex, RADint numComponents, RADint bytesPerComponent, RADattribType type, RADuint relativeOffset) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radVertexAttribBinding (RADvertexState vertex, RADint attribIndex, RADint bindingIndex) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radVertexBindingGroup (RADvertexState vertex, RADint bindingIndex, RADint group, RADint index) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radVertexAttribEnable (RADvertexState vertex, RADint attribIndex, RADboolean enable) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radVertexBindingStride (RADvertexState vertex, RADint bindingIndex, RADuint stride) {UNIMPLEMENTED();}\r
-RADrtFormatState RADAPIENTRY radCreateRtFormatState (RADdevice device) {UNIMPLEMENTED(); return 0;}\r
-void RADAPIENTRY radReferenceRtFormatState (RADrtFormatState rtFormat) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radReleaseRtFormatState (RADrtFormatState rtFormat) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRtFormatDefault (RADrtFormatState rtFormat) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRtFormatColorFormat (RADrtFormatState rtFormat, RADuint index, RADinternalFormat format) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRtFormatDepthFormat (RADrtFormatState rtFormat, RADinternalFormat format) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRtFormatStencilFormat (RADrtFormatState rtFormat, RADinternalFormat format) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRtFormatColorSamples (RADrtFormatState rtFormat, RADuint samples) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radRtFormatDepthStencilSamples (RADrtFormatState rtFormat, RADuint samples) {UNIMPLEMENTED();}\r
-RADpipeline RADAPIENTRY radCreatePipeline (RADdevice device, RADpipelineType pipelineType) {UNIMPLEMENTED(); return 0;}\r
-void RADAPIENTRY radReferencePipeline (RADpipeline pipeline) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radReleasePipeline (RADpipeline pipeline) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPipelineProgramStages (RADpipeline pipeline, RADbitfield stages, RADprogram program) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPipelineVertexState (RADpipeline pipeline, RADvertexState vertex) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPipelineColorState (RADpipeline pipeline, RADcolorState color) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPipelineRasterState (RADpipeline pipeline, RADrasterState raster) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPipelineDepthStencilState (RADpipeline pipeline, RADdepthStencilState depthStencil) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPipelineRtFormatState (RADpipeline pipeline, RADrtFormatState rtFormat) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPipelinePrimitiveType (RADpipeline pipeline, RADprimitiveType mode) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radCompilePipeline (RADpipeline pipeline) {UNIMPLEMENTED();}\r
-RADpipelineHandle RADAPIENTRY radGetPipelineHandle (RADpipeline pipeline) {UNIMPLEMENTED(); return 0;}\r
-RADcommandBuffer RADAPIENTRY radCreateCommandBuffer (RADdevice device, RADqueueType queueType) {UNIMPLEMENTED(); return 0;}\r
-void RADAPIENTRY radReferenceCommandBuffer (RADcommandBuffer cmdBuf) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radReleaseCommandBuffer (RADcommandBuffer cmdBuf) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radCmdBindPipeline (RADcommandBuffer cmdBuf, RADpipelineType pipelineType, RADpipelineHandle pipelineHandle) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radCmdBindGroup (RADcommandBuffer cmdBuf, RADbitfield stages, RADuint group, RADuint count, RADbindGroupHandle groupHandle, RADuint offset) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radCmdDrawArrays (RADcommandBuffer cmdBuf, RADprimitiveType mode, RADint first, RADsizei count) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radCmdDrawElements (RADcommandBuffer cmdBuf, RADprimitiveType mode, RADindexType type, RADsizei count, RADindexHandle indexHandle, RADuint offset) {UNIMPLEMENTED();}\r
-RADboolean RADAPIENTRY radCompileCommandBuffer (RADcommandBuffer cmdBuf) {UNIMPLEMENTED(); return 0;}\r
-RADcommandHandle RADAPIENTRY radGetCommandHandle (RADcommandBuffer cmdBuf) {UNIMPLEMENTED(); return 0;}\r
-void RADAPIENTRY radCmdStencilValueMask (RADcommandBuffer cmdBuf, RADfaceBitfield faces, RADuint mask) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radCmdStencilMask (RADcommandBuffer cmdBuf, RADfaceBitfield faces, RADuint mask) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radCmdStencilRef (RADcommandBuffer cmdBuf, RADfaceBitfield faces, RADint ref) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radCmdBlendColor (RADcommandBuffer cmdBuf, const RADfloat *blendColor) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radCmdPointSize (RADcommandBuffer cmdBuf, RADfloat pointSize) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radCmdLineWidth (RADcommandBuffer cmdBuf, RADfloat lineWidth) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radCmdPolygonOffsetClamp (RADcommandBuffer cmdBuf, RADfloat factor, RADfloat units, RADfloat clamp) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radCmdSampleMask (RADcommandBuffer cmdBuf, RADuint mask) {UNIMPLEMENTED();}\r
-RADpass RADAPIENTRY radCreatePass (RADdevice device) {UNIMPLEMENTED(); return 0;}\r
-void RADAPIENTRY radReferencePass (RADpass pass) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radReleasePass (RADpass pass) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPassDefault (RADpass pass) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radCompilePass (RADpass pass) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPassRenderTargets (RADpass pass, RADuint numColors, const RADrenderTargetHandle *colors, RADrenderTargetHandle depth, RADrenderTargetHandle stencil) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPassPreserveEnable (RADpass pass, RADrtAttachment attachment, RADboolean enable) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPassDiscard (RADpass pass, RADuint numTextures, const RADtexture *textures, const RADoffset2D *offsets) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPassResolve (RADpass pass, RADrtAttachment attachment, RADtexture texture) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPassStore (RADpass pass, RADuint numTextures, const RADtexture *textures, const RADoffset2D *offsets) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPassClip (RADpass pass, const RADrect2D *rect) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPassDependencies (RADpass pass, RADuint numPasses, const RADpass *otherPasses, const RADbitfield *srcMask, const RADbitfield *dstMask, const RADbitfield *flushMask, const RADbitfield *invalidateMask) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPassTilingBoundary (RADpass pass, RADboolean boundary) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPassTileFilterWidth (RADpass pass, RADuint filterWidth, RADuint filterHeight) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radPassTileFootprint (RADpass pass, RADuint bytesPerPixel, RADuint maxFilterWidth, RADuint maxFilterHeight) {UNIMPLEMENTED();}\r
-RADsync RADAPIENTRY radCreateSync (RADdevice device) {UNIMPLEMENTED(); return 0;}\r
-void RADAPIENTRY radReferenceSync (RADsync sync) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radReleaseSync (RADsync sync) {UNIMPLEMENTED();}\r
-void RADAPIENTRY radQueueFenceSync (RADqueue queue, RADsync sync, RADsyncCondition condition, RADbitfield flags) {UNIMPLEMENTED();}\r
-RADwaitSyncResult RADAPIENTRY radWaitSync (RADsync sync, RADuint64 timeout) {UNIMPLEMENTED(); return RAD_WAIT_SYNC_FAILED;}\r
-RADboolean RADAPIENTRY radQueueWaitSync (RADqueue queue, RADsync sync) {UNIMPLEMENTED(); return 0;}\r
-\r
 RADPROC RADAPIENTRY radGetProcAddress(const RADchar *procname)\r
 {\r
        struct Extension\r
@@ -6534,57 +2519,6 @@ RADPROC RADAPIENTRY radGetProcAddress(const RADchar *procname)
     return NULL;\r
 }\r
 \r
-__eglMustCastToProperFunctionPointerType glGetProcAddress(const char *procname)\r
-{\r
-    struct Extension\r
-    {\r
-        const char *name;\r
-        __eglMustCastToProperFunctionPointerType address;\r
-    };\r
-\r
-    static const Extension glExtensions[] =\r
-    {\r
-               #define EXTENSION(name) {#name, (__eglMustCastToProperFunctionPointerType)name}\r
-\r
-        EXTENSION(glTexImage3DOES),\r
-        EXTENSION(glBlitFramebufferANGLE),\r
-        EXTENSION(glRenderbufferStorageMultisampleANGLE),\r
-        EXTENSION(glDeleteFencesNV),\r
-        EXTENSION(glGenFencesNV),\r
-        EXTENSION(glIsFenceNV),\r
-        EXTENSION(glTestFenceNV),\r
-        EXTENSION(glGetFenceivNV),\r
-        EXTENSION(glFinishFenceNV),\r
-        EXTENSION(glSetFenceNV),\r
-               EXTENSION(glGetGraphicsResetStatusEXT),\r
-        EXTENSION(glReadnPixelsEXT),\r
-        EXTENSION(glGetnUniformfvEXT),\r
-        EXTENSION(glGetnUniformivEXT),\r
-               EXTENSION(glGenQueriesEXT),\r
-        EXTENSION(glDeleteQueriesEXT),\r
-        EXTENSION(glIsQueryEXT),\r
-        EXTENSION(glBeginQueryEXT),\r
-        EXTENSION(glEndQueryEXT),\r
-        EXTENSION(glGetQueryivEXT),\r
-        EXTENSION(glGetQueryObjectuivEXT),\r
-        EXTENSION(glEGLImageTargetTexture2DOES),\r
-\r
-               EXTENSION(radGetProcAddress),\r
-\r
-               #undef EXTENSION\r
-    };\r
-\r
-    for(int ext = 0; ext < sizeof(glExtensions) / sizeof(Extension); ext++)\r
-    {\r
-        if(strcmp(procname, glExtensions[ext].name) == 0)\r
-        {\r
-            return (__eglMustCastToProperFunctionPointerType)glExtensions[ext].address;\r
-        }\r
-    }\r
-\r
-    return NULL;\r
-}\r
-\r
 void GL_APIENTRY Register(const char *licenseKey)\r
 {\r
        RegisterLicenseKey(licenseKey);\r

diff --git a/src/Radiance/libRAD/libRAD.def b/src/Radiance/libRAD/libRAD.def
index 6145f39..0b301d2 100644 (file)
--- a/src/Radiance/libRAD/libRAD.def
+++ b/src/Radiance/libRAD/libRAD.def
@@ -1,178 +1,9 @@
 LIBRARY libRAD\r
 EXPORTS\r
-    glActiveTexture                 @1\r
-    glAttachShader                  @2\r
-    glBindAttribLocation            @3\r
-    glBindBuffer                    @4\r
-    glBindFramebuffer               @5\r
-    glBindRenderbuffer              @6\r
-    glBindTexture                   @7\r
-    glBlendColor                    @8\r
-    glBlendEquation                 @9\r
-    glBlendEquationSeparate         @10\r
-    glBlendFunc                     @11\r
-    glBlendFuncSeparate             @12\r
-    glBufferData                    @13\r
-    glBufferSubData                 @14\r
-    glCheckFramebufferStatus        @15\r
-    glClear                         @16\r
-    glClearColor                    @17\r
-    glClearDepthf                   @18\r
-    glClearStencil                  @19\r
-    glColorMask                     @20\r
-    glCompileShader                 @21\r
-    glCompressedTexImage2D          @22\r
-    glCompressedTexSubImage2D       @23\r
-    glCopyTexImage2D                @24\r
-    glCopyTexSubImage2D             @25\r
-    glCreateProgram                 @26\r
-    glCreateShader                  @27\r
-    glCullFace                      @28\r
-    glDeleteBuffers                 @29\r
-    glDeleteFramebuffers            @30\r
-    glDeleteProgram                 @32\r
-    glDeleteRenderbuffers           @33\r
-    glDeleteShader                  @34\r
-    glDeleteTextures                @31\r
-    glDepthFunc                     @36\r
-    glDepthMask                     @37\r
-    glDepthRangef                   @38\r
-    glDetachShader                  @35\r
-    glDisable                       @39\r
-    glDisableVertexAttribArray      @40\r
-    glDrawArrays                    @41\r
-    glDrawElements                  @42\r
-    glEnable                        @43\r
-    glEnableVertexAttribArray       @44\r
-    glFinish                        @45\r
-    glFlush                         @46\r
-    glFramebufferRenderbuffer       @47\r
-    glFramebufferTexture2D          @48\r
-    glFrontFace                     @49\r
-    glGenBuffers                    @50\r
-    glGenFramebuffers               @52\r
-    glGenRenderbuffers              @53\r
-    glGenTextures                   @54\r
-    glGenerateMipmap                @51\r
-    glGetActiveAttrib               @55\r
-    glGetActiveUniform              @56\r
-    glGetAttachedShaders            @57\r
-    glGetAttribLocation             @58\r
-    glGetBooleanv                   @59\r
-    glGetBufferParameteriv          @60\r
-    glGetError                      @61\r
-    glGetFloatv                     @62\r
-    glGetFramebufferAttachmentParameteriv   @63\r
-    glGetIntegerv                   @64\r
-    glGetProgramInfoLog             @66\r
-    glGetProgramiv                  @65\r
-    glGetRenderbufferParameteriv    @67\r
-    glGetShaderInfoLog              @69\r
-    glGetShaderPrecisionFormat      @70\r
-    glGetShaderSource               @71\r
-    glGetShaderiv                   @68\r
-    glGetString                     @72\r
-    glGetTexParameterfv             @73\r
-    glGetTexParameteriv             @74\r
-    glGetUniformLocation            @77\r
-    glGetUniformfv                  @75\r
-    glGetUniformiv                  @76\r
-    glGetVertexAttribPointerv       @80\r
-    glGetVertexAttribfv             @78\r
-    glGetVertexAttribiv             @79\r
-    glHint                          @81\r
-    glIsBuffer                      @82\r
-    glIsEnabled                     @83\r
-    glIsFramebuffer                 @84\r
-    glIsProgram                     @85\r
-    glIsRenderbuffer                @86\r
-    glIsShader                      @87\r
-    glIsTexture                     @88\r
-    glLineWidth                     @89\r
-    glLinkProgram                   @90\r
-    glPixelStorei                   @91\r
-    glPolygonOffset                 @92\r
-    glReadPixels                    @93\r
-    glReleaseShaderCompiler         @94\r
-    glRenderbufferStorage           @95\r
-    glSampleCoverage                @96\r
-    glScissor                       @97\r
-    glShaderBinary                  @98\r
-    glShaderSource                  @99\r
-    glStencilFunc                   @100\r
-    glStencilFuncSeparate           @101\r
-    glStencilMask                   @102\r
-    glStencilMaskSeparate           @103\r
-    glStencilOp                     @104\r
-    glStencilOpSeparate             @105\r
-    glTexImage2D                    @106\r
-    glTexParameterf                 @107\r
-    glTexParameterfv                @108\r
-    glTexParameteri                 @109\r
-    glTexParameteriv                @110\r
-    glTexSubImage2D                 @111\r
-    glUniform1f                     @112\r
-    glUniform1fv                    @113\r
-    glUniform1i                     @114\r
-    glUniform1iv                    @115\r
-    glUniform2f                     @116\r
-    glUniform2fv                    @117\r
-    glUniform2i                     @118\r
-    glUniform2iv                    @119\r
-    glUniform3f                     @120\r
-    glUniform3fv                    @121\r
-    glUniform3i                     @122\r
-    glUniform3iv                    @123\r
-    glUniform4f                     @124\r
-    glUniform4fv                    @125\r
-    glUniform4i                     @126\r
-    glUniform4iv                    @127\r
-    glUniformMatrix2fv              @128\r
-    glUniformMatrix3fv              @129\r
-    glUniformMatrix4fv              @130\r
-    glUseProgram                    @131\r
-    glValidateProgram               @132\r
-    glVertexAttrib1f                @133\r
-    glVertexAttrib1fv               @134\r
-    glVertexAttrib2f                @135\r
-    glVertexAttrib2fv               @136\r
-    glVertexAttrib3f                @137\r
-    glVertexAttrib3fv               @138\r
-    glVertexAttrib4f                @139\r
-    glVertexAttrib4fv               @140\r
-    glVertexAttribPointer           @141\r
-    glViewport                      @142\r
-\r
-    ; Extensions\r
-    glTexImage3DOES                 @143\r
-    glBlitFramebufferANGLE          @149\r
-    glRenderbufferStorageMultisampleANGLE @150\r
-    glDeleteFencesNV                @151\r
-    glFinishFenceNV                 @152\r
-    glGenFencesNV                   @153\r
-    glGetFenceivNV                  @154\r
-    glIsFenceNV                     @155\r
-    glSetFenceNV                    @156\r
-    glTestFenceNV                   @157\r
-    ;glGetTranslatedShaderSourceANGLE @159\r
-    ;glTexStorage2DEXT               @160\r
-    glGetGraphicsResetStatusEXT     @161\r
-    glReadnPixelsEXT                @162\r
-    glGetnUniformfvEXT              @163\r
-    glGetnUniformivEXT              @164\r
-       glGenQueriesEXT                 @165\r
-    glDeleteQueriesEXT              @166\r
-    glIsQueryEXT                    @167\r
-    glBeginQueryEXT                 @168\r
-    glEndQueryEXT                   @169\r
-    glGetQueryivEXT                 @170\r
-    glGetQueryObjectuivEXT          @171\r
-\r
        radGetProcAddress\r
 \r
     ; EGL dependencies\r
     glCreateContext\r
-    glGetProcAddress\r
 \r
        createFrameBuffer\r
        createBackBuffer\r

diff --git a/src/Radiance/libRAD/libRAD.vcxproj b/src/Radiance/libRAD/libRAD.vcxproj
index d91162e..f22cca6 100644 (file)
--- a/src/Radiance/libRAD/libRAD.vcxproj
+++ b/src/Radiance/libRAD/libRAD.vcxproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>\r
+<?xml version="1.0" encoding="utf-8"?>\r
 <Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
   <ItemGroup Label="ProjectConfigurations">\r
     <ProjectConfiguration Include="Debug|Win32">\r
@@ -196,6 +196,7 @@ copy "$(OutDir)libRAD.dll" "$(ProjectDir)..\..\..\lib\$(Configuration)\"</Comman
     <ClInclude Include="IndexDataManager.h" />\r
     <ClInclude Include="main.h" />\r
     <ClInclude Include="mathutil.h" />\r
+    <ClInclude Include="Object.hpp" />\r
     <ClInclude Include="Program.h" />\r
     <ClInclude Include="Query.h" />\r
     <ClInclude Include="RefCountObject.h" />\r
@@ -229,4 +230,4 @@ copy "$(OutDir)libRAD.dll" "$(ProjectDir)..\..\..\lib\$(Configuration)\"</Comman
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
   <ImportGroup Label="ExtensionTargets">\r
   </ImportGroup>\r
-</Project>\r
+</Project>
\ No newline at end of file

diff --git a/src/Radiance/libRAD/libRAD.vcxproj.filters b/src/Radiance/libRAD/libRAD.vcxproj.filters
index 60d6272..088df80 100644 (file)
--- a/src/Radiance/libRAD/libRAD.vcxproj.filters
+++ b/src/Radiance/libRAD/libRAD.vcxproj.filters
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>\r
+<?xml version="1.0" encoding="utf-8"?>\r
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
   <ItemGroup>\r
     <Filter Include="Source Files">\r
@@ -145,6 +145,9 @@
     <ClInclude Include="..\common\debug.h">\r
       <Filter>Header Files</Filter>\r
     </ClInclude>\r
+    <ClInclude Include="Object.hpp">\r
+      <Filter>Header Files</Filter>\r
+    </ClInclude>\r
   </ItemGroup>\r
   <ItemGroup>\r
     <ResourceCompile Include="libRAD.rc" />\r
@@ -152,4 +155,4 @@
   <ItemGroup>\r
     <None Include="libRAD.def" />\r
   </ItemGroup>\r
-</Project>\r
+</Project>
\ No newline at end of file

diff --git a/src/Radiance/libRAD/main.cpp b/src/Radiance/libRAD/main.cpp
index 0a9fff7..f1dcaf2 100644 (file)
--- a/src/Radiance/libRAD/main.cpp
+++ b/src/Radiance/libRAD/main.cpp
@@ -89,15 +89,15 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved
 }\r
 #endif\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
-rad::Context *getContext()\r
+es2::Context *getContext()\r
 {\r
        egl::Context *context = egl::getCurrentContext();\r
        \r
        if(context && context->getClientVersion() == 2)\r
        {\r
-               return static_cast<rad::Context*>(context);\r
+               return static_cast<es2::Context*>(context);\r
        }\r
        \r
        return 0;\r
@@ -129,7 +129,7 @@ GLint getClientVersion()
 // Records an error code\r
 void error(GLenum errorCode)\r
 {\r
-    rad::Context *context = rad::getContext();\r
+    es2::Context *context = es2::getContext();\r
 \r
     if(context)\r
     {\r

diff --git a/src/Radiance/libRAD/main.h b/src/Radiance/libRAD/main.h
index 6af6222..ef95881 100644 (file)
--- a/src/Radiance/libRAD/main.h
+++ b/src/Radiance/libRAD/main.h
@@ -23,7 +23,7 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 
-namespace rad
+namespace es2
 {
        Context *getContext();
        egl::Display *getDisplay();

diff --git a/src/Radiance/libRAD/mathutil.h b/src/Radiance/libRAD/mathutil.h
index 1197155..6ac1f37 100644 (file)
--- a/src/Radiance/libRAD/mathutil.h
+++ b/src/Radiance/libRAD/mathutil.h
@@ -18,7 +18,7 @@
 
 #include <math.h>
 
-namespace rad
+namespace es2
 {
 inline bool isPow2(int x)
 {

diff --git a/src/Radiance/libRAD/utilities.cpp b/src/Radiance/libRAD/utilities.cpp
index bef4a46..d6ca530 100644 (file)
--- a/src/Radiance/libRAD/utilities.cpp
+++ b/src/Radiance/libRAD/utilities.cpp
@@ -20,7 +20,7 @@
 #include <limits>\r
 #include <stdio.h>\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
        int UniformComponentCount(GLenum type)\r
        {\r
@@ -478,7 +478,7 @@ namespace rad2sw
                return sw::STENCIL_ALWAYS;\r
        }\r
 \r
-       sw::Color<float> ConvertColor(rad::Color color)\r
+       sw::Color<float> ConvertColor(es2::Color color)\r
        {\r
                return sw::Color<float>(color.red, color.green, color.blue, color.alpha);\r
        }\r
@@ -630,36 +630,36 @@ namespace rad2sw
                }\r
        }\r
 \r
-       bool ConvertPrimitiveType(GLenum primitiveType, GLsizei elementCount,  rad::PrimitiveType &swPrimitiveType, int &primitiveCount)\r
+       bool ConvertPrimitiveType(GLenum primitiveType, GLsizei elementCount,  es2::PrimitiveType &swPrimitiveType, int &primitiveCount)\r
        {\r
                switch(primitiveType)\r
                {\r
                case GL_POINTS:\r
-                       swPrimitiveType = rad::DRAW_POINTLIST;\r
+                       swPrimitiveType = es2::DRAW_POINTLIST;\r
                        primitiveCount = elementCount;\r
                        break;\r
                case GL_LINES:\r
-                       swPrimitiveType = rad::DRAW_LINELIST;\r
+                       swPrimitiveType = es2::DRAW_LINELIST;\r
                        primitiveCount = elementCount / 2;\r
                        break;\r
                case GL_LINE_LOOP:\r
-                       swPrimitiveType = rad::DRAW_LINELOOP;\r
+                       swPrimitiveType = es2::DRAW_LINELOOP;\r
                        primitiveCount = elementCount;\r
                        break;\r
                case GL_LINE_STRIP:\r
-                       swPrimitiveType = rad::DRAW_LINESTRIP;\r
+                       swPrimitiveType = es2::DRAW_LINESTRIP;\r
                        primitiveCount = elementCount - 1;\r
                        break;\r
                case GL_TRIANGLES:\r
-                       swPrimitiveType = rad::DRAW_TRIANGLELIST;\r
+                       swPrimitiveType = es2::DRAW_TRIANGLELIST;\r
                        primitiveCount = elementCount / 3;\r
                        break;\r
                case GL_TRIANGLE_STRIP:\r
-                       swPrimitiveType = rad::DRAW_TRIANGLESTRIP;\r
+                       swPrimitiveType = es2::DRAW_TRIANGLESTRIP;\r
                        primitiveCount = elementCount - 2;\r
                        break;\r
                case GL_TRIANGLE_FAN:\r
-                       swPrimitiveType = rad::DRAW_TRIANGLEFAN;\r
+                       swPrimitiveType = es2::DRAW_TRIANGLEFAN;\r
                        primitiveCount = elementCount - 2;\r
                        break;\r
                default:\r

diff --git a/src/Radiance/libRAD/utilities.h b/src/Radiance/libRAD/utilities.h
index 51ec56c..3121dd4 100644 (file)
--- a/src/Radiance/libRAD/utilities.h
+++ b/src/Radiance/libRAD/utilities.h
@@ -24,7 +24,7 @@
 \r
 #include <string>\r
 \r
-namespace rad\r
+namespace es2\r
 {\r
        struct Color;\r
 \r
@@ -57,7 +57,7 @@ namespace rad2sw
 {\r
        sw::DepthCompareMode ConvertDepthComparison(GLenum comparison);\r
        sw::StencilCompareMode ConvertStencilComparison(GLenum comparison);\r
-       sw::Color<float> ConvertColor(rad::Color color);\r
+       sw::Color<float> ConvertColor(es2::Color color);\r
        sw::BlendFactor ConvertBlendFunc(GLenum blend);\r
        sw::BlendOperation ConvertBlendOp(GLenum blendOp);\r
        sw::StencilOperation ConvertStencilOp(GLenum stencilOp);\r
@@ -66,7 +66,7 @@ namespace rad2sw
        unsigned int ConvertColorMask(bool red, bool green, bool blue, bool alpha);\r
        sw::FilterType ConvertMagFilter(GLenum magFilter);\r
        void ConvertMinFilter(GLenum texFilter, sw::FilterType *minFilter, sw::MipmapType *mipFilter, float maxAnisotropy);\r
-       bool ConvertPrimitiveType(GLenum primitiveType, GLsizei elementCount,  rad::PrimitiveType &swPrimitiveType, int &primitiveCount);\r
+       bool ConvertPrimitiveType(GLenum primitiveType, GLsizei elementCount,  es2::PrimitiveType &swPrimitiveType, int &primitiveCount);\r
        sw::Format ConvertRenderbufferFormat(GLenum format);\r
 }\r
 \r

diff --git a/tests/HelloRAD/src/app/rad.cpp b/tests/HelloRAD/src/app/rad.cpp
index 71cf281..7a71eef 100644 (file)
--- a/tests/HelloRAD/src/app/rad.cpp
+++ b/tests/HelloRAD/src/app/rad.cpp
@@ -28,8 +28,8 @@
 #define        WINDOW_CLASS _T("PVRShellClass")\r
 \r
 // Width and height of the window\r
-#define WINDOW_WIDTH   640\r
-#define WINDOW_HEIGHT  480\r
+#define WINDOW_WIDTH   500\r
+#define WINDOW_HEIGHT  500\r
 \r
 // Index to bind the attributes to vertex shaders\r
 #define VERTEX_ARRAY   0\r
@@ -158,10 +158,10 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, TCHAR *lpCmdLin
 \r
        // Create the eglWindow\r
        RECT    sRect;\r
-       SetRect(&sRect, 0, 0, nWidth, nHeight);\r
-       AdjustWindowRectEx(&sRect, WS_CAPTION | WS_SYSMENU, false, 0);\r
-       hWnd = CreateWindow( WINDOW_CLASS, _T("HelloAPI"), WS_VISIBLE | WS_SYSMENU,\r
-                                                0, 0, nWidth, nHeight, NULL, NULL, hInstance, NULL);\r
+       SetRect(&sRect, 100, 100, 100 + nWidth, 100 + nHeight);\r
+       AdjustWindowRect(&sRect, WS_CAPTION | WS_SYSMENU, false);\r
+       hWnd = CreateWindow( WINDOW_CLASS, _T("RAD Test App"), WS_VISIBLE | WS_CAPTION | WS_SYSMENU,\r
+                                                sRect.left, sRect.top, sRect.right - sRect.left, sRect.bottom - sRect.top, NULL, NULL, hInstance, NULL);\r
        eglWindow = hWnd;\r
 \r
        // Get the associated device context\r
@@ -311,11 +311,11 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, TCHAR *lpCmdLin
                        Swap Buffers.\r
                        Brings to the native display the current render surface.\r
                */\r
-               eglSwapBuffers(eglDisplay, eglSurface);\r
-               if (!TestEGLError(hWnd, "eglSwapBuffers"))\r
-               {\r
-                       goto cleanup;\r
-               }\r
+               //eglSwapBuffers(eglDisplay, eglSurface);\r
+               //if (!TestEGLError(hWnd, "eglSwapBuffers"))\r
+               //{\r
+               //      goto cleanup;\r
+               //}\r
 \r
                // Managing the window messages\r
                MSG msg;\r
@@ -327,6 +327,9 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, TCHAR *lpCmdLin
 \r
        \r
 cleanup:\r
+       void CleanRAD();\r
+       CleanRAD();\r
+\r
        eglMakeCurrent(eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);\r
        eglTerminate(eglDisplay);\r
 \r

diff --git a/tests/HelloRAD/src/app/radexample.cpp b/tests/HelloRAD/src/app/radexample.cpp
index 8e2dde9..660697e 100644 (file)
--- a/tests/HelloRAD/src/app/radexample.cpp
+++ b/tests/HelloRAD/src/app/radexample.cpp
@@ -16,30 +16,41 @@
 \r
 RADdevice device;\r
 RADqueue queue;\r
-bool useCopyQueue = true;\r
+bool useCopyQueue = false /*true*/;\r
 RADqueue copyQueue;\r
+ \r
+#define SHADER_SOURCE(source) #source\r
 \r
 static const char *vsstring = \r
-    "#version 440 core\n"\r
-    "#define BINDGROUP(GROUP,INDEX) layout(binding = ((INDEX) | ((GROUP) << 4)))\n"\r
-    "layout(location = 1) in vec4 tc;\n"\r
-    "layout(location = 0) in vec4 position;\n"\r
-    "BINDGROUP(0, 2) uniform Block {\n"\r
-    "    vec4 scale;\n"\r
-    "};\n"\r
-    "out vec4 ftc;\n"\r
-    "void main() {\n"\r
-    "  gl_Position = position*scale;\n"\r
-    // This line exists to trick the compiler into putting a value in the compiler\r
-    // constant bank, so we can exercise binding that bank\r
-    "  if (scale.z != 1.0 + 1.0/65536.0) {\n"\r
-    "      gl_Position = vec4(0,0,0,0);\n"\r
-    "  }\n"\r
-    "  ftc = tc;\n"\r
-    "}\n";\r
+    //"#version 440 core\n"\r
+    //"#define BINDGROUP(GROUP,INDEX) layout(binding = ((INDEX) | ((GROUP) << 4)))\n"\r
+    //"layout(location = 1) in vec4 tc;\n"\r
+    //"layout(location = 0) in vec4 position;\n"\r
+    //"BINDGROUP(0, 2) uniform Block {\n"\r
+    //"    vec4 scale;\n"\r
+    //"};\n"\r
+    //"out vec4 ftc;\n"\r
+    //"void main() {\n"\r
+    //"  gl_Position = position*scale;\n"\r
+    //// This line exists to trick the compiler into putting a value in the compiler\r
+    //// constant bank, so we can exercise binding that bank\r
+    //"  if (scale.z != 1.0 + 1.0/65536.0) {\n"\r
+    //"      gl_Position = vec4(0,0,0,0);\n"\r
+    //"  }\n"\r
+    //"  ftc = tc;\n"\r
+    //"}\n";\r
+SHADER_SOURCE(attribute highp vec4     position;\r
+              attribute highp vec4     tc;\r
+              varying highp vec4 ftc;\r
+              uniform highp vec4 scale;\r
+              void main(void)\r
+              {\r
+                               gl_Position = position * scale;\r
+                               ftc = tc;\r
+              });\r
 \r
 static const char *fsstring = \r
-    "#version 440 core\n"\r
+   /* "#version 440 core\n"\r
     "#define BINDGROUP(GROUP,INDEX) layout(binding = ((INDEX) | ((GROUP) << 4)))\n"\r
     "BINDGROUP(0, 3) uniform sampler2D tex;\n"\r
     "BINDGROUP(0, 2) uniform Block {\n"\r
@@ -52,7 +63,14 @@ static const char *fsstring =
     "  if (scale.z != 1.0 + 1.0/65536.0) {\n"\r
     "      color = vec4(0,0,0,0);\n"\r
     "  }\n"\r
-    "}\n";\r
+    "}\n";*/\r
+               SHADER_SOURCE(\r
+                       varying highp vec4 ftc;\r
+                       uniform sampler2D tex;\r
+                       void main (void)\r
+                       {\r
+                               gl_FragColor = texture2D(tex, ftc.xy);\n\r
+                       });\r
 \r
 \r
 // Two triangles that intersect\r
@@ -74,7 +92,7 @@ static RADubyte texcoordData[] = {0, 0, 0xFF, 0xFF,
                                   0, 0xFF, 0, 0xFF};\r
 \r
 int windowWidth = 500, windowHeight = 500;\r
-int offscreenWidth = 100, offscreenHeight = 100;\r
+int offscreenWidth = 500, offscreenHeight = 500;\r
 \r
 typedef enum {\r
     QUEUE,\r
@@ -82,7 +100,7 @@ typedef enum {
     COMMAND,\r
 } DrawMode;\r
 \r
-DrawMode drawMode = COMMAND;\r
+DrawMode drawMode = QUEUE /* COMMAND */;\r
 bool benchmark = false;\r
 \r
 void InitRAD()\r
@@ -99,7 +117,16 @@ void InitRAD()
     }\r
 }\r
 \r
-#define USE_MULTISAMPLE 1\r
+void CleanRAD()\r
+{\r
+    if (useCopyQueue) {\r
+               radReleaseQueue(copyQueue);\r
+    }\r
+       radReleaseQueue(queue);\r
+       radReleaseDevice(device);\r
+}\r
+\r
+#define USE_MULTISAMPLE 0\r
 \r
 RADbuffer AllocAndFillBuffer(RADdevice device, void *data, int sizeofdata, RADbitfield access, bool useCopy)\r
 {\r
@@ -211,7 +238,7 @@ void TestRAD()
 \r
     // Create an index buffer and fill it with data\r
     unsigned short indexData[6] = {0, 1, 2, 3, 4, 5};\r
-    RADbuffer ibo = AllocAndFillBuffer(device, indexData, sizeof(indexData), RAD_INDEX_ACCESS_BIT, true);\r
+    RADbuffer ibo = AllocAndFillBuffer(device, indexData, sizeof(indexData), RAD_INDEX_ACCESS_BIT, false /*true*/);\r
 \r
     // Get a handle to be used for setting the buffer as an index buffer\r
     RADvertexHandle iboHandle = radGetVertexHandle(ibo);\r