Adds RenderTarget wrapper class for surfaces and views.

src/build_angle.gypi

@@ -264,6 +264,9 @@
             'libGLESv2/renderer/Renderer9.h',
             'libGLESv2/renderer/renderer9_utils.cpp',
             'libGLESv2/renderer/renderer9_utils.h',
+            'libGLESv2/renderer/RenderTarget.h',
+            'libGLESv2/renderer/RenderTarget9.h',
+            'libGLESv2/renderer/RenderTarget9.cpp',
             'libGLESv2/renderer/ShaderCache.h',
             'libGLESv2/renderer/SwapChain.cpp',
             'libGLESv2/renderer/SwapChain.h',

src/libGLESv2/Renderbuffer.cpp

@@ -14,6 +14,7 @@
 #include "libGLESv2/Texture.h"
 #include "libGLESv2/utilities.h"
 
+#include "libGLESv2/renderer/RenderTarget9.h" // D3D9_REPLACE
 #include "libGLESv2/renderer/renderer9_utils.h" // D3D9_REPLACE
 
 namespace gl
@@ -317,7 +318,6 @@ RenderbufferStorage::RenderbufferStorage() : mSerial(issueSerial())
     mWidth = 0;
     mHeight = 0;
     mInternalFormat = GL_RGBA4;
-    mD3DFormat = D3DFMT_A8R8G8B8;
     mActualFormat = GL_RGBA8_OES;
     mSamples = 0;
 }
@@ -384,65 +384,37 @@ unsigned int RenderbufferStorage::issueCubeSerials()
 
 Colorbuffer::Colorbuffer(rx::Renderer *renderer, rx::SwapChain *swapChain)
 {
-    mRenderTarget = swapChain->getRenderTarget();
+    mRenderTarget = new rx::RenderTarget9(renderer, swapChain->getRenderTarget());
     if (mRenderTarget)
     {
-        D3DSURFACE_DESC description;
-        mRenderTarget->GetDesc(&description);
-
-        mWidth = description.Width;
-        mHeight = description.Height;
-        mInternalFormat = d3d9_gl::ConvertBackBufferFormat(description.Format);
-        mD3DFormat = description.Format;
-        mActualFormat = d3d9_gl::GetEquivalentFormat(mD3DFormat);
-        mSamples = d3d9_gl::GetSamplesFromMultisampleType(description.MultiSampleType);
+        mWidth = mRenderTarget->getWidth();
+        mHeight = mRenderTarget->getHeight();
+        mInternalFormat = mRenderTarget->getInternalFormat();
+        mActualFormat = mRenderTarget->getActualFormat();
+        mSamples = mRenderTarget->getSamples();
     }
 }
 
 Colorbuffer::Colorbuffer(rx::Renderer *renderer, int width, int height, GLenum format, GLsizei samples) : mRenderTarget(NULL)
 {
-    ASSERT(dynamic_cast<rx::Renderer9*>(renderer) != NULL); // D3D9_REPLACE
-    rx::Renderer9 *renderer9 = static_cast<rx::Renderer9*>(renderer); // D3D9_REPLACE
-    IDirect3DDevice9 *device = renderer9->getDevice(); // D3D9_REPLACE
 
-    D3DFORMAT requestedFormat = gl_d3d9::ConvertRenderbufferFormat(format);
-    int supportedSamples = renderer9->getNearestSupportedSamples(requestedFormat, samples);
+    mRenderTarget = new rx::RenderTarget9(renderer, width, height, format, samples);
 
-    if (supportedSamples == -1)
+    if (mRenderTarget)
     {
-        error(GL_OUT_OF_MEMORY);
-
-        return;
+        mWidth = width;
+        mHeight = height;
+        mInternalFormat = format;
+        mActualFormat = mRenderTarget->getActualFormat();
+        mSamples = mRenderTarget->getSamples();
     }
-
-    if (width > 0 && height > 0)
-    {
-        HRESULT result = device->CreateRenderTarget(width, height, requestedFormat, 
-                                                    gl_d3d9::GetMultisampleTypeFromSamples(supportedSamples), 0, FALSE, &mRenderTarget, NULL);
-
-        if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
-        {
-            error(GL_OUT_OF_MEMORY);
-
-            return;
-        }
-
-        ASSERT(SUCCEEDED(result));
-    }
-
-    mWidth = width;
-    mHeight = height;
-    mInternalFormat = format;
-    mD3DFormat = requestedFormat;
-    mActualFormat = d3d9_gl::GetEquivalentFormat(mD3DFormat);
-    mSamples = supportedSamples;
 }
 
 Colorbuffer::~Colorbuffer()
 {
     if (mRenderTarget)
     {
-        mRenderTarget->Release();
+        delete mRenderTarget;
     }
 }
 
@@ -452,74 +424,42 @@ IDirect3DSurface9 *Colorbuffer::getRenderTarget()
 {
     if (mRenderTarget)
     {
-        mRenderTarget->AddRef();
+        return mRenderTarget->getSurface();
     }
 
-    return mRenderTarget;
+    return NULL;
 }
 
 DepthStencilbuffer::DepthStencilbuffer(rx::Renderer *renderer, rx::SwapChain *swapChain)
 {
-    mDepthStencil = swapChain->getDepthStencil();
+    mDepthStencil = new rx::RenderTarget9(renderer, swapChain->getDepthStencil());
     if (mDepthStencil)
     {
-        D3DSURFACE_DESC description;
-        mDepthStencil->GetDesc(&description);
-
-        mWidth = description.Width;
-        mHeight = description.Height;
-        mInternalFormat = d3d9_gl::ConvertDepthStencilFormat(description.Format);
-        mSamples = d3d9_gl::GetSamplesFromMultisampleType(description.MultiSampleType); 
-        mD3DFormat = description.Format;
-        mActualFormat = d3d9_gl::GetEquivalentFormat(mD3DFormat);
+        mWidth = mDepthStencil->getWidth();
+        mHeight = mDepthStencil->getHeight();
+        mInternalFormat = mDepthStencil->getInternalFormat();
+        mSamples = mDepthStencil->getSamples();
+        mActualFormat = mDepthStencil->getActualFormat();
     }
 }
 
 DepthStencilbuffer::DepthStencilbuffer(rx::Renderer *renderer, int width, int height, GLsizei samples)
 {
-    ASSERT(dynamic_cast<rx::Renderer9*>(renderer) != NULL); // D3D9_REPLACE
-    rx::Renderer9 *renderer9 = static_cast<rx::Renderer9*>(renderer); // D3D9_REPLACE
-    IDirect3DDevice9 *device = renderer9->getDevice(); // D3D9_REPLACE
 
-    mDepthStencil = NULL;
-    
-    int supportedSamples = renderer9->getNearestSupportedSamples(D3DFMT_D24S8, samples);
+    mDepthStencil = new rx::RenderTarget9(renderer, width, height, GL_DEPTH24_STENCIL8_OES, samples);
 
-    if (supportedSamples == -1)
-    {
-        error(GL_OUT_OF_MEMORY);
-
-        return;
-    }
-
-    if (width > 0 && height > 0)
-    {
-        HRESULT result = device->CreateDepthStencilSurface(width, height, D3DFMT_D24S8, gl_d3d9::GetMultisampleTypeFromSamples(supportedSamples),
-                                                           0, FALSE, &mDepthStencil, 0);
-
-        if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
-        {
-            error(GL_OUT_OF_MEMORY);
-
-            return;
-        }
-
-        ASSERT(SUCCEEDED(result));
-    }
-
-    mWidth = width;
-    mHeight = height;
+    mWidth = mDepthStencil->getWidth();
+    mHeight = mDepthStencil->getHeight();
     mInternalFormat = GL_DEPTH24_STENCIL8_OES;
-    mD3DFormat = D3DFMT_D24S8;
-    mActualFormat = GL_DEPTH24_STENCIL8_OES;
-    mSamples = supportedSamples;
+    mActualFormat = mDepthStencil->getActualFormat();
+    mSamples = mDepthStencil->getSamples();
 }
 
 DepthStencilbuffer::~DepthStencilbuffer()
 {
     if (mDepthStencil)
     {
-        mDepthStencil->Release();
+        delete mDepthStencil;
     }
 }
 
@@ -529,10 +469,10 @@ IDirect3DSurface9 *DepthStencilbuffer::getDepthStencil()
 {
     if (mDepthStencil)
     {
-        mDepthStencil->AddRef();
+        return mDepthStencil->getSurface();
     }
 
-    return mDepthStencil;
+    return NULL;
 }
 
 Depthbuffer::Depthbuffer(rx::Renderer *renderer, int width, int height, GLsizei samples) : DepthStencilbuffer(renderer, width, height, samples)

src/libGLESv2/Renderbuffer.h

@@ -20,6 +20,7 @@
 #include "common/RefCountObject.h"
 
 #include "renderer/SwapChain.h"
+#include "renderer/RenderTarget.h"
 
 namespace rx
 {
@@ -151,7 +152,6 @@ class RenderbufferStorage : public RenderbufferInterface
     GLsizei mHeight;
     GLenum mInternalFormat;
     GLenum mActualFormat;
-    D3DFORMAT mD3DFormat;
     GLsizei mSamples;
 
   private:
@@ -217,7 +217,7 @@ class Colorbuffer : public RenderbufferStorage
   private:
     DISALLOW_COPY_AND_ASSIGN(Colorbuffer);
 
-    IDirect3DSurface9 *mRenderTarget;
+    rx::RenderTarget *mRenderTarget;
 };
 
 class DepthStencilbuffer : public RenderbufferStorage
@@ -231,7 +231,7 @@ class DepthStencilbuffer : public RenderbufferStorage
     virtual IDirect3DSurface9 *getDepthStencil();
 
   protected:
-    IDirect3DSurface9 *mDepthStencil;
+    rx::RenderTarget  *mDepthStencil;
 
   private:
     DISALLOW_COPY_AND_ASSIGN(DepthStencilbuffer);

src/libGLESv2/libGLESv2.vcxproj

@@ -251,6 +251,7 @@ copy "$(OutDir)libGLESv2.lib" "$(ProjectDir)..\..\lib\$(Configuration)\"
     <ClCompile Include="renderer\Renderer9.cpp" />
     <ClCompile Include="renderer\Image.cpp" />
     <ClCompile Include="renderer\renderer9_utils.cpp" />
+    <ClCompile Include="renderer\RenderTarget9.cpp" />
     <ClCompile Include="renderer\SwapChain.cpp" />
     <ClCompile Include="renderer\TextureStorage.cpp" />
     <ClCompile Include="ResourceManager.cpp" />
@@ -287,6 +288,8 @@ copy "$(OutDir)libGLESv2.lib" "$(ProjectDir)..\..\lib\$(Configuration)\"
     <ClInclude Include="renderer\renderer11_utils.h" />
     <ClInclude Include="renderer\Renderer9.h" />
     <ClInclude Include="renderer\renderer9_utils.h" />
+    <ClInclude Include="renderer\RenderTarget.h" />
+    <ClInclude Include="renderer\RenderTarget9.h" />
     <ClInclude Include="renderer\ShaderCache.h" />
     <ClInclude Include="renderer\SwapChain.h" />
     <ClInclude Include="renderer\TextureStorage.h" />

src/libGLESv2/libGLESv2.vcxproj.filters

@@ -107,6 +107,9 @@
     <ClCompile Include="renderer\Blit.cpp">
       <Filter>Renderer</Filter>
     </ClCompile>
+    <ClCompile Include="renderer\RenderTarget9.cpp">
+      <Filter>Renderer</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="BinaryStream.h">
@@ -220,6 +223,12 @@
     <ClInclude Include="angletypes.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="renderer\RenderTarget.h">
+      <Filter>Renderer</Filter>
+    </ClInclude>
+    <ClInclude Include="renderer\RenderTarget9.h">
+      <Filter>Renderer</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="libGLESv2.def">

src/libGLESv2/renderer/RenderTarget.h

+//
+// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// RenderTarget.h: Defines an abstract wrapper class to manage IDirect3DSurface9
+// and ID3D11View objects belonging to renderbuffers.
+
+#ifndef LIBGLESV2_RENDERER_RENDERTARGET_H_
+#define LIBGLESV2_RENDERER_RENDERTARGET_H_
+
+#define GL_APICALL
+#include <GLES2/gl2.h>
+
+#include "common/angleutils.h"
+
+namespace rx
+{
+class RenderTarget
+{
+  public:
+    RenderTarget() {};
+    virtual ~RenderTarget() {};
+
+    GLsizei getWidth() { return mWidth; }
+    GLsizei getHeight() { return mHeight; }
+    GLenum getInternalFormat() { return mInternalFormat; }
+    GLenum getActualFormat() { return mActualFormat; }
+    GLsizei getSamples() { return mSamples; }
+
+    virtual IDirect3DSurface9 *getSurface() = 0; // D3D9_REPLACE - temporary pass-through function
+
+  protected:
+    GLsizei mWidth;
+    GLsizei mHeight;
+    GLenum mInternalFormat;
+    GLenum mActualFormat;
+    GLsizei mSamples;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(RenderTarget);
+};
+
+}
+
+#endif // LIBGLESV2_RENDERTARGET_H_

src/libGLESv2/renderer/RenderTarget9.cpp

+//
+// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// RenderTarget9.cpp: Implements a D3D9-specific wrapper for IDirect3DSurface9
+// pointers retained by renderbuffers.
+
+#include "libGLESv2/renderer/RenderTarget9.h"
+#include "libGLESv2/renderer/Renderer9.h"
+
+#include "libGLESv2/renderer/renderer9_utils.h"
+#include "libGLESv2/main.h"
+
+namespace rx
+{
+
+RenderTarget9::RenderTarget9(Renderer *renderer, IDirect3DSurface9 *surface)
+{
+    ASSERT(dynamic_cast<rx::Renderer9*>(renderer) != NULL);
+    mRenderer = static_cast<rx::Renderer9*>(renderer);
+    mRenderTarget = surface;
+
+    if (mRenderTarget)
+    {
+        D3DSURFACE_DESC description;
+        mRenderTarget->GetDesc(&description);
+
+        mWidth = description.Width;
+        mHeight = description.Height;
+        
+        mInternalFormat = d3d9_gl::ConvertRenderTargetFormat(description.Format);
+        mActualFormat = d3d9_gl::GetEquivalentFormat(description.Format);
+        mSamples = d3d9_gl::GetSamplesFromMultisampleType(description.MultiSampleType);
+    }
+}
+
+RenderTarget9::RenderTarget9(Renderer *renderer, GLsizei width, GLsizei height, GLenum format, GLsizei samples)
+{
+    ASSERT(dynamic_cast<rx::Renderer9*>(renderer) != NULL);
+    mRenderer = static_cast<rx::Renderer9*>(renderer);
+    mRenderTarget = NULL;
+
+    D3DFORMAT requestedFormat = gl_d3d9::ConvertRenderbufferFormat(format);
+    int supportedSamples = mRenderer->getNearestSupportedSamples(requestedFormat, samples);
+
+    if (supportedSamples == -1)
+    {
+        error(GL_OUT_OF_MEMORY);
+
+        return;
+    }
+
+    HRESULT result = D3DERR_INVALIDCALL;
+    
+    if (width > 0 && height > 0)
+    {
+        if (requestedFormat == D3DFMT_D24S8)
+        {
+            result = mRenderer->getDevice()->CreateDepthStencilSurface(width, height, requestedFormat,
+                                                                       gl_d3d9::GetMultisampleTypeFromSamples(supportedSamples),
+                                                                       0, FALSE, &mRenderTarget, NULL);
+        }
+        else
+        {
+            result = mRenderer->getDevice()->CreateRenderTarget(width, height, requestedFormat, 
+                                                                gl_d3d9::GetMultisampleTypeFromSamples(supportedSamples),
+                                                                0, FALSE, &mRenderTarget, NULL);
+        }
+
+        if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
+        {
+            error(GL_OUT_OF_MEMORY);
+
+            return;
+        }
+
+        ASSERT(SUCCEEDED(result));
+    }
+
+    mWidth = width;
+    mHeight = height;
+    mInternalFormat = format;
+    mSamples = supportedSamples;
+    mActualFormat = d3d9_gl::GetEquivalentFormat(requestedFormat);
+}
+
+RenderTarget9::~RenderTarget9()
+{
+    if (mRenderTarget)
+    {
+        mRenderTarget->Release();
+    }
+}
+
+IDirect3DSurface9 *RenderTarget9::getSurface()
+{
+    // Caller is responsible for releasing the returned surface reference.
+    if (mRenderTarget)
+    {
+        mRenderTarget->AddRef();
+    }
+
+    return mRenderTarget;
+}
+
+}
\ No newline at end of file

src/libGLESv2/renderer/RenderTarget9.h

+//
+// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// RenderTarget9.h: Defines a D3D9-specific wrapper for IDirect3DSurface9 pointers
+// retained by Renderbuffers.
+
+#ifndef LIBGLESV2_RENDERER_RENDERER11_H_
+#define LIBGLESV2_RENDERER_RENDERER11_H_
+
+#include <d3d9.h>
+
+#include "libGLESv2/renderer/RenderTarget.h"
+
+namespace rx
+{
+class Renderer;
+class Renderer9;
+
+class RenderTarget9 : public RenderTarget
+{
+  public:
+    RenderTarget9(Renderer *renderer, IDirect3DSurface9 *surface);
+    RenderTarget9(Renderer *renderer, GLsizei width, GLsizei height, GLenum format, GLsizei samples);
+    virtual ~RenderTarget9();
+
+    IDirect3DSurface9 *getSurface();
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(RenderTarget9);
+
+    IDirect3DSurface9 *mRenderTarget;
+
+    Renderer9 *mRenderer;
+};
+
+}
+
+#endif