diff --git a/src/libGLESv2/Texture.cpp b/src/libGLESv2/Texture.cpp
index 9632727..909c3bb 100644
--- a/src/libGLESv2/Texture.cpp
+++ b/src/libGLESv2/Texture.cpp
@@ -416,9 +416,8 @@
 void Texture2D::redefineImage(GLint level, GLint internalformat, GLsizei width, GLsizei height)
 {
     releaseTexImage();
-    assert(dynamic_cast<rx::Renderer9*>(mRenderer) != NULL);                // D3D9_REPLACE
-    rx::Renderer9 *renderer9 = static_cast<rx::Renderer9*>(mRenderer);      // D3D9_REPLACE
-    bool redefined = mImageArray[level]->redefine(renderer9, internalformat, width, height, false);
+   
+    bool redefined = mImageArray[level]->redefine(mRenderer, internalformat, width, height, false);
 
     if (mTexStorage && redefined)
     {
@@ -447,13 +446,11 @@
 
     GLint internalformat = surface->getFormat();
 
-    assert(dynamic_cast<rx::Renderer9*>(mRenderer) != NULL);                // D3D9_REPLACE
-    rx::Renderer9 *renderer9 = static_cast<rx::Renderer9*>(mRenderer);      // D3D9_REPLACE
-    mImageArray[0]->redefine(renderer9, internalformat, surface->getWidth(), surface->getHeight(), true);
+    mImageArray[0]->redefine(mRenderer, internalformat, surface->getWidth(), surface->getHeight(), true);
 
     delete mTexStorage;
     rx::SwapChain9 *swapchain = static_cast<rx::SwapChain9*>(surface->getSwapChain());  // D3D9_REPLACE
-    mTexStorage = new rx::TextureStorage2D(renderer9, swapchain);
+    mTexStorage = new rx::TextureStorage2D(mRenderer, swapchain);
 
     mDirtyImages = true;
     mSurface = surface;
@@ -473,11 +470,9 @@
             mTexStorage = NULL;
         }
 
-        assert(dynamic_cast<rx::Renderer9*>(mRenderer) != NULL);                // D3D9_REPLACE
-        rx::Renderer9 *renderer9 = static_cast<rx::Renderer9*>(mRenderer);      // D3D9_REPLACE
         for (int i = 0; i < IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
         {
-            mImageArray[i]->redefine(renderer9, GL_RGBA8_OES, 0, 0, true);
+            mImageArray[i]->redefine(mRenderer, GL_RGBA8_OES, 0, 0, true);
         }
     }
 }
@@ -592,21 +587,19 @@
 void Texture2D::storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
 {
     delete mTexStorage;
-    assert(dynamic_cast<rx::Renderer9*>(mRenderer) != NULL);                // D3D9_REPLACE
-    rx::Renderer9 *renderer9 = static_cast<rx::Renderer9*>(mRenderer);      // D3D9_REPLACE
-    mTexStorage = new rx::TextureStorage2D(renderer9, levels, internalformat, mUsage, false, width, height);
+    mTexStorage = new rx::TextureStorage2D(mRenderer, levels, internalformat, mUsage, false, width, height);
     mImmutable = true;
 
     for (int level = 0; level < levels; level++)
     {
-        mImageArray[level]->redefine(renderer9, internalformat, width, height, true);
+        mImageArray[level]->redefine(mRenderer, internalformat, width, height, true);
         width = std::max(1, width >> 1);
         height = std::max(1, height >> 1);
     }
 
     for (int level = levels; level < IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
     {
-        mImageArray[level]->redefine(renderer9, GL_NONE, 0, 0, true);
+        mImageArray[level]->redefine(mRenderer, GL_NONE, 0, 0, true);
     }
 
     if (mTexStorage->isManaged())
@@ -736,9 +729,7 @@
     GLenum internalformat = mImageArray[0]->getInternalFormat();
 
     delete mTexStorage;
-    assert(dynamic_cast<rx::Renderer9*>(mRenderer) != NULL);                // D3D9_REPLACE
-    rx::Renderer9 *renderer9 = static_cast<rx::Renderer9*>(mRenderer);      // D3D9_REPLACE
-    mTexStorage = new rx::TextureStorage2D(renderer9, levels, internalformat, mUsage, false, width, height);
+    mTexStorage = new rx::TextureStorage2D(mRenderer, levels, internalformat, mUsage, false, width, height);
     
     if (mTexStorage->isManaged())
     {
@@ -781,9 +772,7 @@
         GLint levels = creationLevels(width, height);
         GLenum internalformat = mImageArray[0]->getInternalFormat();
 
-        assert(dynamic_cast<rx::Renderer9*>(mRenderer) != NULL);                // D3D9_REPLACE
-        rx::Renderer9 *renderer9 = static_cast<rx::Renderer9*>(mRenderer);      // D3D9_REPLACE
-        newTexStorage = new rx::TextureStorage2D(renderer9, levels, internalformat, GL_FRAMEBUFFER_ATTACHMENT_ANGLE, true, width, height);
+        newTexStorage = new rx::TextureStorage2D(mRenderer, levels, internalformat, GL_FRAMEBUFFER_ATTACHMENT_ANGLE, true, width, height);
 
         if (mTexStorage != NULL)
         {
@@ -1195,9 +1184,7 @@
     GLenum internalformat = mImageArray[0][0]->getInternalFormat();
 
     delete mTexStorage;
-    assert(dynamic_cast<rx::Renderer9*>(mRenderer) != NULL);                // D3D9_REPLACE
-    rx::Renderer9 *renderer9 = static_cast<rx::Renderer9*>(mRenderer);      // D3D9_REPLACE
-    mTexStorage = new rx::TextureStorageCubeMap(renderer9, levels, internalformat, mUsage, false, size);
+    mTexStorage = new rx::TextureStorageCubeMap(mRenderer, levels, internalformat, mUsage, false, size);
 
     if (mTexStorage->isManaged())
     {
@@ -1245,9 +1232,7 @@
         GLint levels = creationLevels(size);
         GLenum internalformat = mImageArray[0][0]->getInternalFormat();
 
-        assert(dynamic_cast<rx::Renderer9*>(mRenderer) != NULL);                // D3D9_REPLACE
-        rx::Renderer9 *renderer9 = static_cast<rx::Renderer9*>(mRenderer);      // D3D9_REPLACE
-        newTexStorage = new rx::TextureStorageCubeMap(renderer9, levels, internalformat, GL_FRAMEBUFFER_ATTACHMENT_ANGLE, true, size);
+        newTexStorage = new rx::TextureStorageCubeMap(mRenderer, levels, internalformat, GL_FRAMEBUFFER_ATTACHMENT_ANGLE, true, size);
 
         if (mTexStorage != NULL)
         {
@@ -1286,9 +1271,7 @@
 
 void TextureCubeMap::redefineImage(int face, GLint level, GLint internalformat, GLsizei width, GLsizei height)
 {
-    assert(dynamic_cast<rx::Renderer9*>(mRenderer) != NULL);                // D3D9_REPLACE
-    rx::Renderer9 *renderer9 = static_cast<rx::Renderer9*>(mRenderer);      // D3D9_REPLACE
-    bool redefined = mImageArray[face][level]->redefine(renderer9, internalformat, width, height, false);
+    bool redefined = mImageArray[face][level]->redefine(mRenderer, internalformat, width, height, false);
 
     if (mTexStorage && redefined)
     {
@@ -1386,16 +1369,14 @@
 void TextureCubeMap::storage(GLsizei levels, GLenum internalformat, GLsizei size)
 {
     delete mTexStorage;
-    assert(dynamic_cast<rx::Renderer9*>(mRenderer) != NULL);                // D3D9_REPLACE
-    rx::Renderer9 *renderer9 = static_cast<rx::Renderer9*>(mRenderer);      // D3D9_REPLACE
-    mTexStorage = new rx::TextureStorageCubeMap(renderer9, levels, internalformat, mUsage, false, size);
+    mTexStorage = new rx::TextureStorageCubeMap(mRenderer, levels, internalformat, mUsage, false, size);
     mImmutable = true;
 
     for (int level = 0; level < levels; level++)
     {
         for (int face = 0; face < 6; face++)
         {
-            mImageArray[face][level]->redefine(renderer9, internalformat, size, size, true);
+            mImageArray[face][level]->redefine(mRenderer, internalformat, size, size, true);
             size = std::max(1, size >> 1);
         }
     }
@@ -1404,7 +1385,7 @@
     {
         for (int face = 0; face < 6; face++)
         {
-            mImageArray[face][level]->redefine(renderer9, GL_NONE, 0, 0, true);
+            mImageArray[face][level]->redefine(mRenderer, GL_NONE, 0, 0, true);
         }
     }
 
diff --git a/src/libGLESv2/renderer/Image.cpp b/src/libGLESv2/renderer/Image.cpp
index e263a7a..428c0c5 100644
--- a/src/libGLESv2/renderer/Image.cpp
+++ b/src/libGLESv2/renderer/Image.cpp
@@ -266,22 +266,22 @@
     else UNREACHABLE();
 }
 
-bool Image::redefine(rx::Renderer9 *renderer, GLint internalformat, GLsizei width, GLsizei height, bool forceRelease)
+bool Image::redefine(rx::Renderer *renderer, GLint internalformat, GLsizei width, GLsizei height, bool forceRelease)
 {
     if (mWidth != width ||
         mHeight != height ||
         mInternalFormat != internalformat ||
         forceRelease)
     {
+        mRenderer = Renderer9::makeRenderer9(renderer);
+
         mWidth = width;
         mHeight = height;
         mInternalFormat = internalformat;
         // compute the d3d format that will be used
-        mD3DFormat = renderer->ConvertTextureInternalFormat(internalformat);
+        mD3DFormat = mRenderer->ConvertTextureInternalFormat(internalformat);
         mActualFormat = d3d9_gl::GetEquivalentFormat(mD3DFormat);
 
-        mRenderer = Renderer9::makeRenderer9(renderer); // D3D9_REPLACE
-
         if (mSurface)
         {
             mSurface->Release();
diff --git a/src/libGLESv2/renderer/Image.h b/src/libGLESv2/renderer/Image.h
index 15f58ab..d0c6d17 100644
--- a/src/libGLESv2/renderer/Image.h
+++ b/src/libGLESv2/renderer/Image.h
@@ -23,6 +23,7 @@
 
 namespace rx
 {
+class Renderer;
 class Renderer9;
 class TextureStorage2D;
 class TextureStorageCubeMap;
@@ -36,7 +37,7 @@
     static void GenerateMipmap(Image *dest, Image *source);
     static void Image::CopyLockableSurfaces(IDirect3DSurface9 *dest, IDirect3DSurface9 *source);
 
-    bool redefine(Renderer9 *renderer, GLint internalformat, GLsizei width, GLsizei height, bool forceRelease);
+    bool redefine(Renderer *renderer, GLint internalformat, GLsizei width, GLsizei height, bool forceRelease);
     void markDirty() {mDirty = true;}
     void markClean() {mDirty = false;}
 
diff --git a/src/libGLESv2/renderer/TextureStorage.cpp b/src/libGLESv2/renderer/TextureStorage.cpp
index e236cc6..a641989 100644
--- a/src/libGLESv2/renderer/TextureStorage.cpp
+++ b/src/libGLESv2/renderer/TextureStorage.cpp
@@ -21,11 +21,11 @@
 {
 unsigned int TextureStorage::mCurrentTextureSerial = 1;
 
-TextureStorage::TextureStorage(Renderer9 *renderer, DWORD usage)
+TextureStorage::TextureStorage(Renderer *renderer, DWORD usage)
     : mLodOffset(0),
-      mRenderer(renderer),
+      mRenderer(Renderer9::makeRenderer9(renderer)),
       mD3DUsage(usage),
-      mD3DPool(renderer->getTexturePool(usage)),
+      mD3DPool(mRenderer->getTexturePool(usage)),
       mTextureSerial(issueTextureSerial())
 {
 }
@@ -115,7 +115,7 @@
     return getBaseTexture() ? getBaseTexture()->GetLevelCount() - getLodOffset() : 0;
 }
 
-TextureStorage2D::TextureStorage2D(Renderer9 *renderer, rx::SwapChain9 *swapchain) : TextureStorage(renderer, D3DUSAGE_RENDERTARGET), mRenderTargetSerial(gl::RenderbufferStorage::issueSerial())
+TextureStorage2D::TextureStorage2D(Renderer *renderer, rx::SwapChain9 *swapchain) : TextureStorage(renderer, D3DUSAGE_RENDERTARGET), mRenderTargetSerial(gl::RenderbufferStorage::issueSerial())
 {
     IDirect3DTexture9 *surfaceTexture = swapchain->getOffscreenTexture();
     mTexture = surfaceTexture;
@@ -123,8 +123,8 @@
     initializeRenderTarget();
 }
 
-TextureStorage2D::TextureStorage2D(Renderer9 *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, GLsizei width, GLsizei height)
-    : TextureStorage(renderer, GetTextureUsage(renderer->ConvertTextureInternalFormat(internalformat), usage, forceRenderable)),
+TextureStorage2D::TextureStorage2D(Renderer *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, GLsizei width, GLsizei height)
+    : TextureStorage(renderer, GetTextureUsage(Renderer9::makeRenderer9(renderer)->ConvertTextureInternalFormat(internalformat), usage, forceRenderable)),
       mRenderTargetSerial(gl::RenderbufferStorage::issueSerial())
 {
     mTexture = NULL;
@@ -132,10 +132,10 @@
     // we handle that here by skipping the d3d texture creation
     if (width > 0 && height > 0)
     {
-        IDirect3DDevice9 *device = renderer->getDevice(); // D3D9_REPLACE
+        IDirect3DDevice9 *device = mRenderer->getDevice(); // D3D9_REPLACE
         gl::MakeValidSize(false, gl::IsCompressed(internalformat), &width, &height, &mLodOffset);
         HRESULT result = device->CreateTexture(width, height, levels ? levels + mLodOffset : 0, getUsage(),
-                                               renderer->ConvertTextureInternalFormat(internalformat), getPool(), &mTexture, NULL);
+                                               mRenderer->ConvertTextureInternalFormat(internalformat), getPool(), &mTexture, NULL);
 
         if (FAILED(result))
         {
@@ -221,8 +221,8 @@
     }
 }
 
-TextureStorageCubeMap::TextureStorageCubeMap(Renderer9 *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, int size)
-    : TextureStorage(renderer, GetTextureUsage(renderer->ConvertTextureInternalFormat(internalformat), usage, forceRenderable)),
+TextureStorageCubeMap::TextureStorageCubeMap(Renderer *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, int size)
+    : TextureStorage(renderer, GetTextureUsage(Renderer9::makeRenderer9(renderer)->ConvertTextureInternalFormat(internalformat), usage, forceRenderable)),
       mFirstRenderTargetSerial(gl::RenderbufferStorage::issueCubeSerials())
 {
     mTexture = NULL;
@@ -230,11 +230,11 @@
     // we handle that here by skipping the d3d texture creation
     if (size > 0)
     {
-        IDirect3DDevice9 *device = renderer->getDevice();
+        IDirect3DDevice9 *device = mRenderer->getDevice();
         int height = size;
         gl::MakeValidSize(false, gl::IsCompressed(internalformat), &size, &height, &mLodOffset);
         HRESULT result = device->CreateCubeTexture(size, levels ? levels + mLodOffset : 0, getUsage(),
-                                                   renderer->ConvertTextureInternalFormat(internalformat), getPool(), &mTexture, NULL);
+                                                   mRenderer->ConvertTextureInternalFormat(internalformat), getPool(), &mTexture, NULL);
 
         if (FAILED(result))
         {
diff --git a/src/libGLESv2/renderer/TextureStorage.h b/src/libGLESv2/renderer/TextureStorage.h
index a19878c..a347b81 100644
--- a/src/libGLESv2/renderer/TextureStorage.h
+++ b/src/libGLESv2/renderer/TextureStorage.h
@@ -28,7 +28,7 @@
 class TextureStorage
 {
   public:
-    TextureStorage(rx::Renderer9 *renderer, DWORD usage);
+    TextureStorage(rx::Renderer *renderer, DWORD usage);
 
     virtual ~TextureStorage();
 
@@ -64,8 +64,8 @@
 class TextureStorage2D : public TextureStorage
 {
   public:
-    explicit TextureStorage2D(rx::Renderer9 *renderer, rx::SwapChain9 *swapchain);
-    TextureStorage2D(rx::Renderer9 *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, GLsizei width, GLsizei height);
+    explicit TextureStorage2D(rx::Renderer *renderer, rx::SwapChain9 *swapchain);
+    TextureStorage2D(rx::Renderer *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, GLsizei width, GLsizei height);
 
     virtual ~TextureStorage2D();
 
@@ -89,7 +89,7 @@
 class TextureStorageCubeMap : public TextureStorage
 {
   public:
-    TextureStorageCubeMap(rx::Renderer9 *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, int size);
+    TextureStorageCubeMap(rx::Renderer *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, int size);
 
     virtual ~TextureStorageCubeMap();