1 #include "precompiled.h" 2 // 3 // Copyright (c) 2012-2013 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/d3d9/Renderer9.h" 14 #include "libGLESv2/renderer/d3d9/TextureStorage9.h" 15 #include "libGLESv2/renderer/d3d9/SwapChain9.h" 16 #include "libGLESv2/renderer/d3d9/RenderTarget9.h" 17 #include "libGLESv2/renderer/d3d9/renderer9_utils.h" 18 #include "libGLESv2/renderer/d3d9/formatutils9.h" 19 #include "libGLESv2/Texture.h" 20 21 namespace rx 22 { 23 TextureStorage9::TextureStorage9(Renderer *renderer, DWORD usage) 24 : mTopLevel(0), 25 mRenderer(Renderer9::makeRenderer9(renderer)), 26 mD3DUsage(usage), 27 mD3DPool(mRenderer->getTexturePool(usage)) 28 { 29 } 30 31 TextureStorage9::~TextureStorage9() 32 { 33 } 34 35 TextureStorage9 *TextureStorage9::makeTextureStorage9(TextureStorage *storage) 36 { 37 ASSERT(HAS_DYNAMIC_TYPE(TextureStorage9*, storage)); 38 return static_cast<TextureStorage9*>(storage); 39 } 40 41 DWORD TextureStorage9::GetTextureUsage(GLenum internalformat, Renderer9 *renderer, bool renderTarget) 42 { 43 GLuint clientVersion = renderer->getCurrentClientVersion(); 44 45 DWORD d3dusage = 0; 46 47 if (gl::GetDepthBits(internalformat, clientVersion) > 0 || 48 gl::GetStencilBits(internalformat, clientVersion) > 0) 49 { 50 d3dusage |= D3DUSAGE_DEPTHSTENCIL; 51 } 52 else if (renderTarget && (gl_d3d9::GetRenderFormat(internalformat, renderer) != 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, Renderer9::makeRenderer9(renderer), 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 D3DFORMAT format = gl_d3d9::GetTextureFormat(internalformat, mRenderer); 112 d3d9::MakeValidSize(false, format, &width, &height, &mTopLevel); 113 UINT creationLevels = (levels == 0) ? 0 : mTopLevel + levels; 114 115 HRESULT result = device->CreateTexture(width, height, creationLevels, getUsage(), format, 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, Renderer9::makeRenderer9(renderer), 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 D3DFORMAT format = gl_d3d9::GetTextureFormat(internalformat, mRenderer); 213 d3d9::MakeValidSize(false, format, &size, &height, &mTopLevel); 214 UINT creationLevels = (levels == 0) ? 0 : mTopLevel + levels; 215 216 HRESULT result = device->CreateCubeTexture(size, creationLevels, getUsage(), format, 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::targetToIndex(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 }
