src/third_party/angle/src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.cpp

   1 #include "precompiled.h"
   2 //
   3 // Copyright (c) 2012-2014 The ANGLE Project Authors. All rights reserved.
   4 // Use of this source code is governed by a BSD-style license that can be
   5 // found in the LICENSE file.
   6 //
   7
   8 // TextureStorage9.cpp: Implements the abstract rx::TextureStorage9 class and its concrete derived
   9 // classes TextureStorage9_2D and TextureStorage9_Cube, which act as the interface to the
  10 // D3D9 texture.
  11
  12 #include "libGLESv2/main.h"
  13 #include "libGLESv2/renderer/d3d/TextureD3D.h"
  14 #include "libGLESv2/renderer/d3d/d3d9/Renderer9.h"
  15 #include "libGLESv2/renderer/d3d/d3d9/TextureStorage9.h"
  16 #include "libGLESv2/renderer/d3d/d3d9/SwapChain9.h"
  17 #include "libGLESv2/renderer/d3d/d3d9/RenderTarget9.h"
  18 #include "libGLESv2/renderer/d3d/d3d9/renderer9_utils.h"
  19 #include "libGLESv2/renderer/d3d/d3d9/formatutils9.h"
  20 #include "libGLESv2/Texture.h"
  21
  22 namespace rx
  23 {
  24 TextureStorage9::TextureStorage9(Renderer *renderer, DWORD usage)
  25     : mTopLevel(0),
  26       mRenderer(Renderer9::makeRenderer9(renderer)),
  27       mD3DUsage(usage),
  28       mD3DPool(mRenderer->getTexturePool(usage))
  29 {
  30 }
  31
  32 TextureStorage9::~TextureStorage9()
  33 {
  34 }
  35
  36 TextureStorage9 *TextureStorage9::makeTextureStorage9(TextureStorage *storage)
  37 {
  38     ASSERT(HAS_DYNAMIC_TYPE(TextureStorage9*, storage));
  39     return static_cast<TextureStorage9*>(storage);
  40 }
  41
  42 DWORD TextureStorage9::GetTextureUsage(GLenum internalformat, bool renderTarget)
  43 {
  44     DWORD d3dusage = 0;
  45
  46     const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalformat);
  47     const d3d9::TextureFormat &d3dFormatInfo = d3d9::GetTextureFormatInfo(internalformat);
  48     if (formatInfo.depthBits > 0 || formatInfo.stencilBits > 0)
  49     {
  50         d3dusage |= D3DUSAGE_DEPTHSTENCIL;
  51     }
  52     else if (renderTarget && (d3dFormatInfo.renderFormat != D3DFMT_UNKNOWN))
  53     {
  54         d3dusage |= D3DUSAGE_RENDERTARGET;
  55     }
  56
  57     return d3dusage;
  58 }
  59
  60
  61 bool TextureStorage9::isRenderTarget() const
  62 {
  63     return (mD3DUsage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL)) != 0;
  64 }
  65
  66 bool TextureStorage9::isManaged() const
  67 {
  68     return (mD3DPool == D3DPOOL_MANAGED);
  69 }
  70
  71 D3DPOOL TextureStorage9::getPool() const
  72 {
  73     return mD3DPool;
  74 }
  75
  76 DWORD TextureStorage9::getUsage() const
  77 {
  78     return mD3DUsage;
  79 }
  80
  81 int TextureStorage9::getTopLevel() const
  82 {
  83     return mTopLevel;
  84 }
  85
  86 int TextureStorage9::getLevelCount() const
  87 {
  88     return getBaseTexture() ? (getBaseTexture()->GetLevelCount() - getTopLevel()) : 0;
  89 }
  90
  91 TextureStorage9_2D::TextureStorage9_2D(Renderer *renderer, SwapChain9 *swapchain)
  92     : TextureStorage9(renderer, D3DUSAGE_RENDERTARGET)
  93 {
  94     IDirect3DTexture9 *surfaceTexture = swapchain->getOffscreenTexture();
  95     mTexture = surfaceTexture;
  96     mRenderTarget = NULL;
  97
  98     initializeRenderTarget();
  99 }
 100
 101 TextureStorage9_2D::TextureStorage9_2D(Renderer *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels)
 102     : TextureStorage9(renderer, GetTextureUsage(internalformat, renderTarget))
 103 {
 104     mTexture = NULL;
 105     mRenderTarget = NULL;
 106     // if the width or height is not positive this should be treated as an incomplete texture
 107     // we handle that here by skipping the d3d texture creation
 108     if (width > 0 && height > 0)
 109     {
 110         IDirect3DDevice9 *device = mRenderer->getDevice();
 111         const d3d9::TextureFormat &d3dFormatInfo = d3d9::GetTextureFormatInfo(internalformat);
 112         d3d9::MakeValidSize(false, d3dFormatInfo.texFormat, &width, &height, &mTopLevel);
 113         UINT creationLevels = (levels == 0) ? 0 : mTopLevel + levels;
 114
 115         HRESULT result = device->CreateTexture(width, height, creationLevels, getUsage(), d3dFormatInfo.texFormat, getPool(), &mTexture, NULL);
 116
 117         if (FAILED(result))
 118         {
 119             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
 120             gl::error(GL_OUT_OF_MEMORY);
 121         }
 122     }
 123
 124     initializeRenderTarget();
 125 }
 126
 127 TextureStorage9_2D::~TextureStorage9_2D()
 128 {
 129     SafeRelease(mTexture);
 130     SafeDelete(mRenderTarget);
 131 }
 132
 133 TextureStorage9_2D *TextureStorage9_2D::makeTextureStorage9_2D(TextureStorage *storage)
 134 {
 135     ASSERT(HAS_DYNAMIC_TYPE(TextureStorage9_2D*, storage));
 136     return static_cast<TextureStorage9_2D*>(storage);
 137 }
 138
 139 // Increments refcount on surface.
 140 // caller must Release() the returned surface
 141 IDirect3DSurface9 *TextureStorage9_2D::getSurfaceLevel(int level, bool dirty)
 142 {
 143     IDirect3DSurface9 *surface = NULL;
 144
 145     if (mTexture)
 146     {
 147         HRESULT result = mTexture->GetSurfaceLevel(level + mTopLevel, &surface);
 148         UNUSED_ASSERTION_VARIABLE(result);
 149         ASSERT(SUCCEEDED(result));
 150
 151         // With managed textures the driver needs to be informed of updates to the lower mipmap levels
 152         if (level + mTopLevel != 0 && isManaged() && dirty)
 153         {
 154             mTexture->AddDirtyRect(NULL);
 155         }
 156     }
 157
 158     return surface;
 159 }
 160
 161 RenderTarget *TextureStorage9_2D::getRenderTarget(int level)
 162 {
 163     return mRenderTarget;
 164 }
 165
 166 void TextureStorage9_2D::generateMipmap(int level)
 167 {
 168     IDirect3DSurface9 *upper = getSurfaceLevel(level - 1, false);
 169     IDirect3DSurface9 *lower = getSurfaceLevel(level, true);
 170
 171     if (upper != NULL && lower != NULL)
 172     {
 173         mRenderer->boxFilter(upper, lower);
 174     }
 175
 176     SafeRelease(upper);
 177     SafeRelease(lower);
 178 }
 179
 180 IDirect3DBaseTexture9 *TextureStorage9_2D::getBaseTexture() const
 181 {
 182     return mTexture;
 183 }
 184
 185 void TextureStorage9_2D::initializeRenderTarget()
 186 {
 187     ASSERT(mRenderTarget == NULL);
 188
 189     if (mTexture != NULL && isRenderTarget())
 190     {
 191         IDirect3DSurface9 *surface = getSurfaceLevel(0, false);
 192
 193         mRenderTarget = new RenderTarget9(mRenderer, surface);
 194     }
 195 }
 196
 197 TextureStorage9_Cube::TextureStorage9_Cube(Renderer *renderer, GLenum internalformat, bool renderTarget, int size, int levels)
 198     : TextureStorage9(renderer, GetTextureUsage(internalformat, renderTarget))
 199 {
 200     mTexture = NULL;
 201     for (int i = 0; i < 6; ++i)
 202     {
 203         mRenderTarget[i] = NULL;
 204     }
 205
 206     // if the size is not positive this should be treated as an incomplete texture
 207     // we handle that here by skipping the d3d texture creation
 208     if (size > 0)
 209     {
 210         IDirect3DDevice9 *device = mRenderer->getDevice();
 211         int height = size;
 212         const d3d9::TextureFormat &d3dFormatInfo = d3d9::GetTextureFormatInfo(internalformat);
 213         d3d9::MakeValidSize(false, d3dFormatInfo.texFormat, &size, &height, &mTopLevel);
 214         UINT creationLevels = (levels == 0) ? 0 : mTopLevel + levels;
 215
 216         HRESULT result = device->CreateCubeTexture(size, creationLevels, getUsage(), d3dFormatInfo.texFormat, getPool(), &mTexture, NULL);
 217
 218         if (FAILED(result))
 219         {
 220             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
 221             gl::error(GL_OUT_OF_MEMORY);
 222         }
 223     }
 224
 225     initializeRenderTarget();
 226 }
 227
 228 TextureStorage9_Cube::~TextureStorage9_Cube()
 229 {
 230     SafeRelease(mTexture);
 231
 232     for (int i = 0; i < 6; ++i)
 233     {
 234         SafeDelete(mRenderTarget[i]);
 235     }
 236 }
 237
 238 TextureStorage9_Cube *TextureStorage9_Cube::makeTextureStorage9_Cube(TextureStorage *storage)
 239 {
 240     ASSERT(HAS_DYNAMIC_TYPE(TextureStorage9_Cube*, storage));
 241     return static_cast<TextureStorage9_Cube*>(storage);
 242 }
 243
 244 // Increments refcount on surface.
 245 // caller must Release() the returned surface
 246 IDirect3DSurface9 *TextureStorage9_Cube::getCubeMapSurface(GLenum faceTarget, int level, bool dirty)
 247 {
 248     IDirect3DSurface9 *surface = NULL;
 249
 250     if (mTexture)
 251     {
 252         D3DCUBEMAP_FACES face = gl_d3d9::ConvertCubeFace(faceTarget);
 253         HRESULT result = mTexture->GetCubeMapSurface(face, level + mTopLevel, &surface);
 254         UNUSED_ASSERTION_VARIABLE(result);
 255         ASSERT(SUCCEEDED(result));
 256
 257         // With managed textures the driver needs to be informed of updates to the lower mipmap levels
 258         if (level != 0 && isManaged() && dirty)
 259         {
 260             mTexture->AddDirtyRect(face, NULL);
 261         }
 262     }
 263
 264     return surface;
 265 }
 266
 267 RenderTarget *TextureStorage9_Cube::getRenderTargetFace(GLenum faceTarget, int level)
 268 {
 269     return mRenderTarget[gl::TextureCubeMap::targetToLayerIndex(faceTarget)];
 270 }
 271
 272 void TextureStorage9_Cube::generateMipmap(int faceIndex, int level)
 273 {
 274     IDirect3DSurface9 *upper = getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex, level - 1, false);
 275     IDirect3DSurface9 *lower = getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex, level, true);
 276
 277     if (upper != NULL && lower != NULL)
 278     {
 279         mRenderer->boxFilter(upper, lower);
 280     }
 281
 282     SafeRelease(upper);
 283     SafeRelease(lower);
 284 }
 285
 286 IDirect3DBaseTexture9 *TextureStorage9_Cube::getBaseTexture() const
 287 {
 288     return mTexture;
 289 }
 290
 291 void TextureStorage9_Cube::initializeRenderTarget()
 292 {
 293     if (mTexture != NULL && isRenderTarget())
 294     {
 295         IDirect3DSurface9 *surface = NULL;
 296
 297         for (int i = 0; i < 6; ++i)
 298         {
 299             ASSERT(mRenderTarget[i] == NULL);
 300
 301             surface = getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, false);
 302
 303             mRenderTarget[i] = new RenderTarget9(mRenderer, surface);
 304         }
 305     }
 306 }
 307
 308 }