Rename renderer namespace to rx

src/libEGL/Config.cpp

@@ -22,7 +22,7 @@ using namespace std;
 
 namespace egl
 {
-Config::Config(renderer::ConfigDesc desc, EGLint minInterval, EGLint maxInterval, EGLint texWidth, EGLint texHeight)
+Config::Config(rx::ConfigDesc desc, EGLint minInterval, EGLint maxInterval, EGLint texWidth, EGLint texHeight)
     : mRenderTargetFormat(desc.renderTargetFormat), mDepthStencilFormat(desc.depthStencilFormat), mMultiSample(desc.multiSample)
 {
     mBindToTextureRGB = EGL_FALSE;
@@ -222,7 +222,7 @@ ConfigSet::ConfigSet()
 {
 }
 
-void ConfigSet::add(renderer::ConfigDesc desc, EGLint minSwapInterval, EGLint maxSwapInterval, EGLint texWidth, EGLint texHeight)
+void ConfigSet::add(rx::ConfigDesc desc, EGLint minSwapInterval, EGLint maxSwapInterval, EGLint texWidth, EGLint texHeight)
 {
     Config config(desc, minSwapInterval, maxSwapInterval, texWidth, texHeight);
     mSet.insert(config);

src/libEGL/Config.h

@@ -26,7 +26,7 @@ class Display;
 class Config
 {
   public:
-    Config(renderer::ConfigDesc desc, EGLint minSwapInterval, EGLint maxSwapInterval, EGLint texWidth, EGLint texHeight);
+    Config(rx::ConfigDesc desc, EGLint minSwapInterval, EGLint maxSwapInterval, EGLint texWidth, EGLint texHeight);
 
     EGLConfig getHandle() const;
 
@@ -96,7 +96,7 @@ class ConfigSet
   public:
     ConfigSet();
 
-    void add(renderer::ConfigDesc desc, EGLint minSwapInterval, EGLint maxSwapInterval, EGLint texWidth, EGLint texHeight);
+    void add(rx::ConfigDesc desc, EGLint minSwapInterval, EGLint maxSwapInterval, EGLint texWidth, EGLint texHeight);
     size_t size() const;
     bool getConfigs(EGLConfig *configs, const EGLint *attribList, EGLint configSize, EGLint *numConfig);
     const egl::Config *get(EGLConfig configHandle);

src/libEGL/Display.cpp

@@ -98,7 +98,7 @@ bool Display::initialize()
     EGLint maxTextureWidth = mRenderer->getMaxTextureWidth();
     EGLint maxTextureHeight = mRenderer->getMaxTextureHeight();
 
-    renderer::ConfigDesc *descList;
+    rx::ConfigDesc *descList;
     int numConfigs = mRenderer->generateConfigs(&descList);
     ConfigSet configSet;
 

src/libEGL/Display.h

@@ -54,8 +54,8 @@ class Display
     bool isValidSurface(egl::Surface *surface);
     bool hasExistingWindowSurface(HWND window);
 
-    renderer::Renderer *getRenderer() { return mRenderer; };
-    renderer::Renderer9 *getRenderer9() { assert(dynamic_cast<renderer::Renderer9*>(mRenderer) != NULL); return static_cast<renderer::Renderer9*>(mRenderer); };   // D3D9_REPLACE
+    rx::Renderer *getRenderer() { return mRenderer; };
+    rx::Renderer9 *getRenderer9() { assert(dynamic_cast<rx::Renderer9*>(mRenderer) != NULL); return static_cast<rx::Renderer9*>(mRenderer); };   // D3D9_REPLACE
 
     virtual void notifyDeviceLost();
 
@@ -81,7 +81,7 @@ class Display
     typedef std::set<gl::Context*> ContextSet;
     ContextSet mContextSet;
 
-    renderer::Renderer *mRenderer;
+    rx::Renderer *mRenderer;
 
     void initExtensionString();
     std::string mExtensionString;

src/libEGL/Surface.cpp

@@ -347,7 +347,7 @@ EGLint Surface::isPostSubBufferSupported() const
     return mPostSubBufferSupported;
 }
 
-renderer::SwapChain *Surface::getSwapChain() const
+rx::SwapChain *Surface::getSwapChain() const
 {
     return mSwapChain;
 }

src/libEGL/Surface.h

@@ -20,7 +20,7 @@ namespace gl
 {
 class Texture2D;
 }
-namespace renderer
+namespace rx
 {
 class Renderer9;
 class SwapChain;
@@ -52,7 +52,7 @@ class Surface
 
     virtual EGLint isPostSubBufferSupported() const;
 
-    virtual renderer::SwapChain *getSwapChain() const;
+    virtual rx::SwapChain *getSwapChain() const;
 
     void setSwapInterval(EGLint interval);
     bool checkForOutOfDateSwapChain();   // Returns true if swapchain changed due to resize or interval update
@@ -68,10 +68,10 @@ private:
     DISALLOW_COPY_AND_ASSIGN(Surface);
 
     Display *const mDisplay;
-    renderer::Renderer9 *mRenderer;   // D3D9_REPLACE
+    rx::Renderer9 *mRenderer;   // D3D9_REPLACE
 
     HANDLE mShareHandle;
-    renderer::SwapChain *mSwapChain;
+    rx::SwapChain *mSwapChain;
 
     void subclassWindow();
     void unsubclassWindow();

src/libEGL/libEGL.cpp

@@ -505,7 +505,7 @@ EGLBoolean __stdcall eglQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surf
         {
           case EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE:
             {
-                renderer::SwapChain *swapchain = eglSurface->getSwapChain();
+                rx::SwapChain *swapchain = eglSurface->getSwapChain();
                 *value = (void*) (swapchain ? swapchain->getShareHandle() : NULL);
             }
             break;
@@ -886,7 +886,7 @@ EGLBoolean __stdcall eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface
             return EGL_FALSE;
         }
 
-        renderer::Renderer *renderer = display->getRenderer();
+        rx::Renderer *renderer = display->getRenderer();
         if (renderer->testDeviceLost(true))
         {
             return EGL_FALSE;

src/libGLESv2/Blit.cpp

@@ -44,7 +44,7 @@ const size_t g_shaderSize[] =
 
 namespace gl
 {
-Blit::Blit(renderer::Renderer9 *renderer)
+Blit::Blit(rx::Renderer9 *renderer)
   : mRenderer(renderer), mQuadVertexBuffer(NULL), mQuadVertexDeclaration(NULL), mSavedRenderTarget(NULL), mSavedDepthStencil(NULL), mSavedStateBlock(NULL)
 {
     initGeometry();
@@ -116,7 +116,7 @@ void Blit::initGeometry()
 
 template <class D3DShaderType>
 bool Blit::setShader(ShaderId source, const char *profile,
-                     D3DShaderType *(renderer::Renderer9::*createShader)(const DWORD *, size_t length),
+                     D3DShaderType *(rx::Renderer9::*createShader)(const DWORD *, size_t length),
                      HRESULT (WINAPI IDirect3DDevice9::*setShader)(D3DShaderType*))
 {
     IDirect3DDevice9 *device = mRenderer->getDevice(); // D3D9_REPLACE
@@ -155,12 +155,12 @@ bool Blit::setShader(ShaderId source, const char *profile,
 
 bool Blit::setVertexShader(ShaderId shader)
 {
-    return setShader<IDirect3DVertexShader9>(shader, "vs_2_0", &renderer::Renderer9::createVertexShader, &IDirect3DDevice9::SetVertexShader);
+    return setShader<IDirect3DVertexShader9>(shader, "vs_2_0", &rx::Renderer9::createVertexShader, &IDirect3DDevice9::SetVertexShader);
 }
 
 bool Blit::setPixelShader(ShaderId shader)
 {
-    return setShader<IDirect3DPixelShader9>(shader, "ps_2_0", &renderer::Renderer9::createPixelShader, &IDirect3DDevice9::SetPixelShader);
+    return setShader<IDirect3DPixelShader9>(shader, "ps_2_0", &rx::Renderer9::createPixelShader, &IDirect3DDevice9::SetPixelShader);
 }
 
 RECT Blit::getSurfaceRect(IDirect3DSurface9 *surface) const

src/libGLESv2/Blit.h

@@ -27,7 +27,7 @@ class Context;
 class Blit
 {
   public:
-    explicit Blit(renderer::Renderer9 *renderer);
+    explicit Blit(rx::Renderer9 *renderer);
     ~Blit();
 
     // Copy from source surface to dest surface.
@@ -45,7 +45,7 @@ class Blit
     bool boxFilter(IDirect3DSurface9 *source, IDirect3DSurface9 *dest);
 
   private:
-    renderer::Renderer9 *mRenderer;
+    rx::Renderer9 *mRenderer;
 
     IDirect3DVertexBuffer9 *mQuadVertexBuffer;
     IDirect3DVertexDeclaration9 *mQuadVertexDeclaration;
@@ -76,7 +76,7 @@ class Blit
 
     template <class D3DShaderType>
     bool setShader(ShaderId source, const char *profile,
-                   D3DShaderType *(renderer::Renderer9::*createShader)(const DWORD *, size_t length),
+                   D3DShaderType *(rx::Renderer9::*createShader)(const DWORD *, size_t length),
                    HRESULT (WINAPI IDirect3DDevice9::*setShader)(D3DShaderType*));
 
     bool setVertexShader(ShaderId shader);

src/libGLESv2/Buffer.h

@@ -48,7 +48,7 @@ class Buffer : public RefCountObject
   private:
     DISALLOW_COPY_AND_ASSIGN(Buffer);
 
-    renderer::Renderer9 *mRenderer;  // D3D9_REPLACE
+    rx::Renderer9 *mRenderer;  // D3D9_REPLACE
     GLubyte *mContents;
     GLsizeiptr mSize;
     GLenum mUsage;

src/libGLESv2/Context.cpp

@@ -318,7 +318,7 @@ void Context::makeCurrent(egl::Display *display, egl::Surface *surface)
     }
 
     // Wrap the existing swapchain resources into GL objects and assign them to the '0' names
-    renderer::SwapChain *swapchain = surface->getSwapChain();
+    rx::SwapChain *swapchain = surface->getSwapChain();
 
     Colorbuffer *colorbufferZero = new Colorbuffer(swapchain);
     DepthStencilbuffer *depthStencilbufferZero = new DepthStencilbuffer(swapchain);
@@ -4398,23 +4398,23 @@ gl::Context *glGetCurrentContext()
     return gl::getContext();
 }
 
-renderer::Renderer *glCreateRenderer(egl::Display *display, HDC hDc, bool softwareDevice)
+rx::Renderer *glCreateRenderer(egl::Display *display, HDC hDc, bool softwareDevice)
 {
-    return new renderer::Renderer9(display, hDc, softwareDevice);  // D3D9_REPLACE
+    return new rx::Renderer9(display, hDc, softwareDevice);  // D3D9_REPLACE
 }
 
-void glDestroyRenderer(renderer::Renderer *renderer)
+void glDestroyRenderer(rx::Renderer *renderer)
 {
     delete renderer;
 }
 
-renderer::SwapChain *glCreateSwapChain(renderer::Renderer9 *renderer, HWND window, HANDLE shareHandle,
+rx::SwapChain *glCreateSwapChain(rx::Renderer9 *renderer, HWND window, HANDLE shareHandle,
                                        GLenum backBufferFormat, GLenum depthBufferFormat)
 {
-    return new renderer::SwapChain(renderer, window, shareHandle, backBufferFormat, depthBufferFormat);
+    return new rx::SwapChain(renderer, window, shareHandle, backBufferFormat, depthBufferFormat);
 }
 
-void glDestroySwapChain(renderer::SwapChain *swapChain)
+void glDestroySwapChain(rx::SwapChain *swapChain)
 {
     delete swapChain;
 }

src/libGLESv2/Context.h

@@ -541,7 +541,7 @@ class Context
 
     egl::Display *mDisplay;
     IDirect3DDevice9 *mDevice;
-    renderer::Renderer9 *mRenderer;  // D3D9_REPLACE
+    rx::Renderer9 *mRenderer;  // D3D9_REPLACE
 
     State mState;
 
@@ -667,11 +667,11 @@ gl::Context *glCreateContext(const gl::Context *shareContext, bool notifyResets,
 void glDestroyContext(gl::Context *context);
 void glMakeCurrent(gl::Context *context, egl::Display *display, egl::Surface *surface);
 gl::Context *glGetCurrentContext();
-renderer::Renderer *glCreateRenderer(egl::Display *display, HDC hDc, bool softwareDevice);
-void glDestroyRenderer(renderer::Renderer *renderer);
-renderer::SwapChain *glCreateSwapChain(renderer::Renderer9 *renderer, HWND window, HANDLE shareHandle,
+rx::Renderer *glCreateRenderer(egl::Display *display, HDC hDc, bool softwareDevice);
+void glDestroyRenderer(rx::Renderer *renderer);
+rx::SwapChain *glCreateSwapChain(rx::Renderer9 *renderer, HWND window, HANDLE shareHandle,
                                        GLenum backBufferFormat, GLenum depthBufferFormat);  // D3D9_REPLACE
-void glDestroySwapChain(renderer::SwapChain *swapChain);
+void glDestroySwapChain(rx::SwapChain *swapChain);
 
 __eglMustCastToProperFunctionPointerType __stdcall glGetProcAddress(const char *procname);
 bool __stdcall glBindTexImage(egl::Surface *surface);

src/libGLESv2/Fence.cpp

@@ -13,7 +13,7 @@
 namespace gl
 {
 
-Fence::Fence(renderer::Renderer9 *renderer)
+Fence::Fence(rx::Renderer9 *renderer)
 {
     mRenderer = renderer;
     mQuery = NULL;

src/libGLESv2/Fence.h

@@ -22,7 +22,7 @@ namespace gl
 class Fence
 {
   public:
-    explicit Fence(renderer::Renderer9 *renderer);
+    explicit Fence(rx::Renderer9 *renderer);
     virtual ~Fence();
 
     GLboolean isFence();
@@ -34,7 +34,7 @@ class Fence
   private:
     DISALLOW_COPY_AND_ASSIGN(Fence);
 
-    renderer::Renderer9 *mRenderer;  // D3D9_REPLACE
+    rx::Renderer9 *mRenderer;  // D3D9_REPLACE
     IDirect3DQuery9* mQuery;  // D3D9_REPLACE
     GLenum mCondition;
     GLboolean mStatus;

src/libGLESv2/IndexDataManager.cpp

@@ -19,7 +19,7 @@ namespace gl
 {
 unsigned int IndexBuffer::mCurrentSerial = 1;
 
-IndexDataManager::IndexDataManager(renderer::Renderer9 *renderer) : mRenderer(renderer)
+IndexDataManager::IndexDataManager(rx::Renderer9 *renderer) : mRenderer(renderer)
 {
     mStreamingBufferShort = new StreamingIndexBuffer(mRenderer, INITIAL_INDEX_BUFFER_SIZE, D3DFMT_INDEX16);
 
@@ -281,7 +281,7 @@ StaticIndexBuffer *IndexDataManager::getCountingIndices(GLsizei count)
     return mCountingBuffer;
 }
 
-IndexBuffer::IndexBuffer(renderer::Renderer9 *renderer, UINT size, D3DFORMAT format) : mRenderer(renderer), mBufferSize(size), mIndexBuffer(NULL)
+IndexBuffer::IndexBuffer(rx::Renderer9 *renderer, UINT size, D3DFORMAT format) : mRenderer(renderer), mBufferSize(size), mIndexBuffer(NULL)
 {
     if (size > 0)
     {
@@ -327,7 +327,7 @@ void IndexBuffer::unmap()
     }
 }
 
-StreamingIndexBuffer::StreamingIndexBuffer(renderer::Renderer9 *renderer, UINT initialSize, D3DFORMAT format) : IndexBuffer(renderer, initialSize, format)
+StreamingIndexBuffer::StreamingIndexBuffer(rx::Renderer9 *renderer, UINT initialSize, D3DFORMAT format) : IndexBuffer(renderer, initialSize, format)
 {
     mWritePosition = 0;
 }
@@ -390,7 +390,7 @@ void StreamingIndexBuffer::reserveSpace(UINT requiredSpace, GLenum type)
     }
 }
 
-StaticIndexBuffer::StaticIndexBuffer(renderer::Renderer9 *renderer) : IndexBuffer(renderer, 0, D3DFMT_UNKNOWN)
+StaticIndexBuffer::StaticIndexBuffer(rx::Renderer9 *renderer) : IndexBuffer(renderer, 0, D3DFMT_UNKNOWN)
 {
     mCacheType = GL_NONE;
 }

src/libGLESv2/IndexDataManager.h

@@ -39,7 +39,7 @@ struct TranslatedIndexData
 class IndexBuffer
 {
   public:
-    IndexBuffer(renderer::Renderer9 *renderer, UINT size, D3DFORMAT format);
+    IndexBuffer(rx::Renderer9 *renderer, UINT size, D3DFORMAT format);
     virtual ~IndexBuffer();
 
     UINT size() const { return mBufferSize; }
@@ -51,7 +51,7 @@ class IndexBuffer
     unsigned int getSerial() const;
 
   protected:
-    renderer::Renderer9 *const mRenderer;   // D3D9_REPLACE
+    rx::Renderer9 *const mRenderer;   // D3D9_REPLACE
 
     IDirect3DIndexBuffer9 *mIndexBuffer;
     UINT mBufferSize;
@@ -67,7 +67,7 @@ class IndexBuffer
 class StreamingIndexBuffer : public IndexBuffer
 {
   public:
-    StreamingIndexBuffer(renderer::Renderer9 *renderer, UINT initialSize, D3DFORMAT format);
+    StreamingIndexBuffer(rx::Renderer9 *renderer, UINT initialSize, D3DFORMAT format);
     ~StreamingIndexBuffer();
 
     virtual void *map(UINT requiredSpace, UINT *offset);
@@ -80,7 +80,7 @@ class StreamingIndexBuffer : public IndexBuffer
 class StaticIndexBuffer : public IndexBuffer
 {
   public:
-    explicit StaticIndexBuffer(renderer::Renderer9 *renderer);
+    explicit StaticIndexBuffer(rx::Renderer9 *renderer);
     ~StaticIndexBuffer();
 
     virtual void *map(UINT requiredSpace, UINT *offset);
@@ -125,7 +125,7 @@ class StaticIndexBuffer : public IndexBuffer
 class IndexDataManager
 {
   public:
-    IndexDataManager(renderer::Renderer9 *renderer);
+    IndexDataManager(rx::Renderer9 *renderer);
     virtual ~IndexDataManager();
 
     GLenum prepareIndexData(GLenum type, GLsizei count, Buffer *arrayElementBuffer, const GLvoid *indices, TranslatedIndexData *translated);
@@ -137,7 +137,7 @@ class IndexDataManager
     std::size_t typeSize(GLenum type) const;
     std::size_t indexSize(D3DFORMAT format) const;
 
-    renderer::Renderer9 *const mRenderer;   // D3D9_REPLACE
+    rx::Renderer9 *const mRenderer;   // D3D9_REPLACE
 
     StreamingIndexBuffer *mStreamingBufferShort;
     StreamingIndexBuffer *mStreamingBufferInt;

src/libGLESv2/ProgramBinary.h

@@ -184,7 +184,7 @@ class ProgramBinary : public RefCountObject
     void applyUniformniv(Uniform *targetUniform, GLsizei count, const Vector4 *vector);
     void applyUniformnbv(Uniform *targetUniform, GLsizei count, int width, const GLboolean *v);
 
-    renderer::Renderer9 *mRenderer;   // D3D9_REPLACE
+    rx::Renderer9 *mRenderer;   // D3D9_REPLACE
     IDirect3DDevice9 *mDevice; // D3D9_REPLACE
 
     IDirect3DPixelShader9 *mPixelExecutable; // D3D9_REPLACE

src/libGLESv2/Query.cpp

@@ -13,7 +13,7 @@
 namespace gl
 {
 
-Query::Query(renderer::Renderer9 *renderer, GLuint id, GLenum type) : RefCountObject(id)
+Query::Query(rx::Renderer9 *renderer, GLuint id, GLenum type) : RefCountObject(id)
 { 
     mRenderer = renderer;
     mQuery = NULL;

src/libGLESv2/Query.h

@@ -23,7 +23,7 @@ namespace gl
 class Query : public RefCountObject
 {
   public:
-    Query(renderer::Renderer9 *renderer, GLuint id, GLenum type);
+    Query(rx::Renderer9 *renderer, GLuint id, GLenum type);
     virtual ~Query();
 
     void begin();
@@ -36,7 +36,7 @@ class Query : public RefCountObject
   private:
     DISALLOW_COPY_AND_ASSIGN(Query);
 
-    renderer::Renderer9 *mRenderer;   // D3D9_REPLACE
+    rx::Renderer9 *mRenderer;   // D3D9_REPLACE
 
     GLboolean testQuery();
 

src/libGLESv2/Renderbuffer.cpp

@@ -382,7 +382,7 @@ unsigned int RenderbufferStorage::issueCubeSerials()
     return firstSerial;
 }
 
-Colorbuffer::Colorbuffer(renderer::SwapChain *swapChain)
+Colorbuffer::Colorbuffer(rx::SwapChain *swapChain)
 {
     mRenderTarget = swapChain->getRenderTarget();
     if (mRenderTarget)
@@ -401,7 +401,7 @@ Colorbuffer::Colorbuffer(renderer::SwapChain *swapChain)
 
 Colorbuffer::Colorbuffer(int width, int height, GLenum format, GLsizei samples) : mRenderTarget(NULL)
 {
-    renderer::Renderer9 *renderer = getDisplay()->getRenderer9();
+    rx::Renderer9 *renderer = getDisplay()->getRenderer9();
     IDirect3DDevice9 *device = renderer->getDevice(); // D3D9_REPLACE
 
     D3DFORMAT requestedFormat = es2dx::ConvertRenderbufferFormat(format);
@@ -457,7 +457,7 @@ IDirect3DSurface9 *Colorbuffer::getRenderTarget()
     return mRenderTarget;
 }
 
-DepthStencilbuffer::DepthStencilbuffer(renderer::SwapChain *swapChain)
+DepthStencilbuffer::DepthStencilbuffer(rx::SwapChain *swapChain)
 {
     mDepthStencil = swapChain->getDepthStencil();
     if (mDepthStencil)
@@ -476,7 +476,7 @@ DepthStencilbuffer::DepthStencilbuffer(renderer::SwapChain *swapChain)
 
 DepthStencilbuffer::DepthStencilbuffer(int width, int height, GLsizei samples)
 {
-    renderer::Renderer9 *renderer = getDisplay()->getRenderer9();
+    rx::Renderer9 *renderer = getDisplay()->getRenderer9();
     IDirect3DDevice9 *device = renderer->getDevice(); // D3D9_REPLACE
 
     mDepthStencil = NULL;

src/libGLESv2/Renderbuffer.h

@@ -202,7 +202,7 @@ class Renderbuffer : public RefCountObject
 class Colorbuffer : public RenderbufferStorage
 {
   public:
-    explicit Colorbuffer(renderer::SwapChain *swapChain);
+    explicit Colorbuffer(rx::SwapChain *swapChain);
     Colorbuffer(GLsizei width, GLsizei height, GLenum format, GLsizei samples);
 
     virtual ~Colorbuffer();
@@ -218,7 +218,7 @@ class Colorbuffer : public RenderbufferStorage
 class DepthStencilbuffer : public RenderbufferStorage
 {
   public:
-    explicit DepthStencilbuffer(renderer::SwapChain *swapChain);
+    explicit DepthStencilbuffer(rx::SwapChain *swapChain);
     DepthStencilbuffer(GLsizei width, GLsizei height, GLsizei samples);
 
     ~DepthStencilbuffer();

src/libGLESv2/Texture.cpp

@@ -442,7 +442,7 @@ void Texture2D::bindTexImage(egl::Surface *surface)
     mImageArray[0].redefine(internalformat, surface->getWidth(), surface->getHeight(), true);
 
     delete mTexStorage;
-    renderer::SwapChain *swapchain = surface->getSwapChain();  // D3D9_REPLACE
+    rx::SwapChain *swapchain = surface->getSwapChain();  // D3D9_REPLACE
     mTexStorage = new TextureStorage2D(swapchain);
 
     mDirtyImages = true;

src/libGLESv2/VertexDataManager.cpp

@@ -37,7 +37,7 @@ int elementsInBuffer(const VertexAttribute &attribute, int size)
     return (size - attribute.mOffset % stride + (stride - attribute.typeSize())) / stride;
 }
 
-VertexDataManager::VertexDataManager(renderer::Renderer9 *renderer) : mRenderer(renderer)
+VertexDataManager::VertexDataManager(rx::Renderer9 *renderer) : mRenderer(renderer)
 {
     for (int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
     {
@@ -569,7 +569,7 @@ unsigned int VertexDataManager::typeIndex(GLenum type) const
     }
 }
 
-VertexBuffer::VertexBuffer(renderer::Renderer9 *renderer, std::size_t size, DWORD usageFlags) : mRenderer(renderer), mVertexBuffer(NULL)
+VertexBuffer::VertexBuffer(rx::Renderer9 *renderer, std::size_t size, DWORD usageFlags) : mRenderer(renderer), mVertexBuffer(NULL)
 {
     if (size > 0)
     {
@@ -615,7 +615,7 @@ unsigned int VertexBuffer::issueSerial()
     return mCurrentSerial++;
 }
 
-ArrayVertexBuffer::ArrayVertexBuffer(renderer::Renderer9 *renderer, std::size_t size, DWORD usageFlags) : VertexBuffer(renderer, size, usageFlags)
+ArrayVertexBuffer::ArrayVertexBuffer(rx::Renderer9 *renderer, std::size_t size, DWORD usageFlags) : VertexBuffer(renderer, size, usageFlags)
 {
     mBufferSize = size;
     mWritePosition = 0;
@@ -631,7 +631,7 @@ void ArrayVertexBuffer::addRequiredSpace(UINT requiredSpace)
     mRequiredSpace += requiredSpace;
 }
 
-StreamingVertexBuffer::StreamingVertexBuffer(renderer::Renderer9 *renderer, std::size_t initialSize) : ArrayVertexBuffer(renderer, initialSize, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY)
+StreamingVertexBuffer::StreamingVertexBuffer(rx::Renderer9 *renderer, std::size_t initialSize) : ArrayVertexBuffer(renderer, initialSize, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY)
 {
 }
 
@@ -698,7 +698,7 @@ void StreamingVertexBuffer::reserveRequiredSpace()
     mRequiredSpace = 0;
 }
 
-StaticVertexBuffer::StaticVertexBuffer(renderer::Renderer9 *renderer) : ArrayVertexBuffer(renderer, 0, D3DUSAGE_WRITEONLY)
+StaticVertexBuffer::StaticVertexBuffer(rx::Renderer9 *renderer) : ArrayVertexBuffer(renderer, 0, D3DUSAGE_WRITEONLY)
 {
 }
 

src/libGLESv2/VertexDataManager.h

@@ -37,7 +37,7 @@ struct TranslatedAttribute
 class VertexBuffer
 {
   public:
-    VertexBuffer(renderer::Renderer9 *renderer, std::size_t size, DWORD usageFlags);
+    VertexBuffer(rx::Renderer9 *renderer, std::size_t size, DWORD usageFlags);
     virtual ~VertexBuffer();
 
     void unmap();
@@ -46,7 +46,7 @@ class VertexBuffer
     unsigned int getSerial() const;
 
   protected:
-    renderer::Renderer9 *const mRenderer;   // D3D9_REPLACE
+    rx::Renderer9 *const mRenderer;   // D3D9_REPLACE
     IDirect3DVertexBuffer9 *mVertexBuffer;
 
     unsigned int mSerial;
@@ -60,7 +60,7 @@ class VertexBuffer
 class ArrayVertexBuffer : public VertexBuffer
 {
   public:
-    ArrayVertexBuffer(renderer::Renderer9 *renderer, std::size_t size, DWORD usageFlags);
+    ArrayVertexBuffer(rx::Renderer9 *renderer, std::size_t size, DWORD usageFlags);
     ~ArrayVertexBuffer();
 
     std::size_t size() const { return mBufferSize; }
@@ -77,7 +77,7 @@ class ArrayVertexBuffer : public VertexBuffer
 class StreamingVertexBuffer : public ArrayVertexBuffer
 {
   public:
-    StreamingVertexBuffer(renderer::Renderer9 *renderer, std::size_t initialSize);
+    StreamingVertexBuffer(rx::Renderer9 *renderer, std::size_t initialSize);
     ~StreamingVertexBuffer();
 
     void *map(const VertexAttribute &attribute, std::size_t requiredSpace, std::size_t *streamOffset);
@@ -87,7 +87,7 @@ class StreamingVertexBuffer : public ArrayVertexBuffer
 class StaticVertexBuffer : public ArrayVertexBuffer
 {
   public:
-    explicit StaticVertexBuffer(renderer::Renderer9 *renderer);
+    explicit StaticVertexBuffer(rx::Renderer9 *renderer);
     ~StaticVertexBuffer();
 
     void *map(const VertexAttribute &attribute, std::size_t requiredSpace, std::size_t *streamOffset);
@@ -113,7 +113,7 @@ class StaticVertexBuffer : public ArrayVertexBuffer
 class VertexDataManager
 {
   public:
-    VertexDataManager(renderer::Renderer9 *renderer);
+    VertexDataManager(rx::Renderer9 *renderer);
     virtual ~VertexDataManager();
 
     void dirtyCurrentValue(int index) { mDirtyCurrentValue[index] = true; }
@@ -126,7 +126,7 @@ class VertexDataManager
     std::size_t spaceRequired(const VertexAttribute &attrib, std::size_t count, GLsizei instances) const;
     std::size_t writeAttributeData(ArrayVertexBuffer *vertexBuffer, GLint start, GLsizei count, const VertexAttribute &attribute, GLsizei instances);
 
-    renderer::Renderer9 *const mRenderer;   // D3D9_REPLACE
+    rx::Renderer9 *const mRenderer;   // D3D9_REPLACE
 
     StreamingVertexBuffer *mStreamingBuffer;
 

src/libGLESv2/renderer/Renderer.h

@@ -37,7 +37,7 @@ namespace egl
 class Display;
 }
 
-namespace renderer
+namespace rx
 {
 
 struct ConfigDesc

src/libGLESv2/renderer/Renderer9.cpp

@@ -27,7 +27,7 @@
 #define ANGLE_ENABLE_D3D9EX 1
 #endif // !defined(ANGLE_ENABLE_D3D9EX)
 
-namespace renderer
+namespace rx
 {
 const D3DFORMAT Renderer9::mRenderTargetFormats[] =
     {

src/libGLESv2/renderer/Renderer9.h

@@ -26,7 +26,7 @@
 #include "libGLESv2/renderer/ShaderCache.h"
 #include "libGLESv2/renderer/Renderer.h"
 
-namespace renderer
+namespace rx
 {
 
 class Renderer9 : public Renderer

src/libGLESv2/renderer/ShaderCache.h

@@ -4,7 +4,7 @@
 // found in the LICENSE file.
 //
 
-// ShaderCache: Defines renderer::ShaderCache, a cache of Direct3D shader objects
+// ShaderCache: Defines rx::ShaderCache, a cache of Direct3D shader objects
 // keyed by their byte code.
 
 #ifndef LIBGLESV2_RENDERER_SHADER_CACHE_H_
@@ -20,7 +20,7 @@
 
 #include "common/debug.h"
 
-namespace renderer
+namespace rx
 {
 template <typename ShaderObject>
 class ShaderCache

src/libGLESv2/renderer/SwapChain.cpp

@@ -15,7 +15,7 @@
 #include "libGLESv2/renderer/Renderer9.h"   // D3D9_REPLACE
 #include "libGLESv2/Context.h"
 
-namespace renderer
+namespace rx
 {
 
 SwapChain::SwapChain(Renderer9 *renderer, HWND window, HANDLE shareHandle,

src/libGLESv2/renderer/SwapChain.h

@@ -16,18 +16,18 @@
 #define EGLAPI
 #include <EGL/egl.h>
 
-#include <d3d9.h>  // D3D9_REPLACE
+#include <d3d9.h>  // D3D9_REPLACE
 
-#include "common/angleutils.h"
+#include "common/angleutils.h"
 
-namespace renderer
+namespace rx
 {
-class Renderer9;   // D3D9_REPLACE
+class Renderer9;   // D3D9_REPLACE
 
 class SwapChain
 {
   public:
-    SwapChain(Renderer9 *renderer, HWND window, HANDLE shareHandle,
+    SwapChain(Renderer9 *renderer, HWND window, HANDLE shareHandle,
               GLenum backBufferFormat, GLenum depthBufferFormat);
     virtual ~SwapChain();
 
@@ -45,7 +45,7 @@ class SwapChain
 
     void release();
 
-    Renderer9 *mRenderer;   // D3D9_REPLACE
+    Renderer9 *mRenderer;   // D3D9_REPLACE
     EGLint mHeight;
     EGLint mWidth;
 

src/libGLESv2/renderer/TextureStorage.cpp

@@ -172,7 +172,7 @@ bool TextureStorage::copyToRenderTarget(IDirect3DSurface9 *dest, IDirect3DSurfac
     if (source && dest)
     {
         HRESULT result = D3DERR_OUTOFVIDEOMEMORY;
-        renderer::Renderer9 *renderer = getDisplay()->getRenderer9();
+        rx::Renderer9 *renderer = getDisplay()->getRenderer9();
         IDirect3DDevice9 *device = renderer->getDevice(); // D3D9_REPLACE
 
         if (fromManaged)
@@ -206,7 +206,7 @@ bool TextureStorage::copyToRenderTarget(IDirect3DSurface9 *dest, IDirect3DSurfac
     return true;
 } 
 
-TextureStorage2D::TextureStorage2D(renderer::SwapChain *swapchain) : TextureStorage(D3DUSAGE_RENDERTARGET), mRenderTargetSerial(RenderbufferStorage::issueSerial())
+TextureStorage2D::TextureStorage2D(rx::SwapChain *swapchain) : TextureStorage(D3DUSAGE_RENDERTARGET), mRenderTargetSerial(RenderbufferStorage::issueSerial())
 {
     IDirect3DTexture9 *surfaceTexture = swapchain->getOffscreenTexture();
     mTexture = surfaceTexture;

src/libGLESv2/renderer/TextureStorage.h

@@ -17,7 +17,7 @@
 
 #include "common/debug.h"
 
-namespace renderer
+namespace rx
 {
 class SwapChain;
 }
@@ -68,7 +68,7 @@ class TextureStorage
 class TextureStorage2D : public TextureStorage
 {
   public:
-    explicit TextureStorage2D(renderer::SwapChain *swapchain);
+    explicit TextureStorage2D(rx::SwapChain *swapchain);
     TextureStorage2D(int levels, GLenum internalformat, GLenum usage, bool forceRenderable, GLsizei width, GLsizei height);
 
     virtual ~TextureStorage2D();