The Tor Browser: gfx/angle/src/libGLESv2/renderer/TextureStorage9.cpp@6474c204b198 (annotated)

gfx/angle/src/libGLESv2/renderer/TextureStorage9.cpp@6474c204b198 (annotated)

gfx/angle/src/libGLESv2/renderer/TextureStorage9.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 #include "precompiled.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.
 //
 // TextureStorage9.cpp: Implements the abstract rx::TextureStorage9 class and its concrete derived
 // classes TextureStorage9_2D and TextureStorage9_Cube, which act as the interface to the
 // D3D9 texture.
 #include "libGLESv2/main.h"
 #include "libGLESv2/renderer/Renderer9.h"
 #include "libGLESv2/renderer/TextureStorage9.h"
 #include "libGLESv2/renderer/SwapChain9.h"
 #include "libGLESv2/renderer/RenderTarget9.h"
 #include "libGLESv2/renderer/renderer9_utils.h"
 #include "libGLESv2/Texture.h"
 namespace rx
 {
 TextureStorage9::TextureStorage9(Renderer *renderer, DWORD usage)
     : mLodOffset(0),
       mRenderer(Renderer9::makeRenderer9(renderer)),
       mD3DUsage(usage),
       mD3DPool(mRenderer->getTexturePool(usage))
 {
 }
 TextureStorage9::~TextureStorage9()
 {
 }
 TextureStorage9 *TextureStorage9::makeTextureStorage9(TextureStorage *storage)
 {
     ASSERT(HAS_DYNAMIC_TYPE(TextureStorage9*, storage));
     return static_cast<TextureStorage9*>(storage);
 }
 DWORD TextureStorage9::GetTextureUsage(D3DFORMAT d3dfmt, GLenum glusage, bool forceRenderable)
 {
     DWORD d3dusage = 0;
     if (d3dfmt == D3DFMT_INTZ)
     {
         d3dusage |= D3DUSAGE_DEPTHSTENCIL;
     }
     else if(forceRenderable || (TextureStorage9::IsTextureFormatRenderable(d3dfmt) && (glusage == GL_FRAMEBUFFER_ATTACHMENT_ANGLE)))
     {
         d3dusage |= D3DUSAGE_RENDERTARGET;
     }
     return d3dusage;
 }
 bool TextureStorage9::IsTextureFormatRenderable(D3DFORMAT format)
 {
     if (format == D3DFMT_INTZ)
     {
         return true;
     }
     switch(format)
     {
       case D3DFMT_L8:
       case D3DFMT_A8L8:
       case D3DFMT_DXT1:
       case D3DFMT_DXT3:
       case D3DFMT_DXT5:
         return false;
       case D3DFMT_A8R8G8B8:
       case D3DFMT_X8R8G8B8:
       case D3DFMT_A16B16G16R16F:
       case D3DFMT_A32B32G32R32F:
         return true;
       default:
         UNREACHABLE();
     }
     return false;
 }
 bool TextureStorage9::isRenderTarget() const
 {
     return (mD3DUsage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL)) != 0;
 }
 bool TextureStorage9::isManaged() const
 {
     return (mD3DPool == D3DPOOL_MANAGED);
 }
 D3DPOOL TextureStorage9::getPool() const
 {
     return mD3DPool;
 }
 DWORD TextureStorage9::getUsage() const
 {
     return mD3DUsage;
 }
 int TextureStorage9::getLodOffset() const
 {
     return mLodOffset;
 }
 int TextureStorage9::levelCount()
 {
     return getBaseTexture() ? getBaseTexture()->GetLevelCount() - getLodOffset() : 0;
 }
 TextureStorage9_2D::TextureStorage9_2D(Renderer *renderer, SwapChain9 *swapchain) : TextureStorage9(renderer, D3DUSAGE_RENDERTARGET)
 {
     IDirect3DTexture9 *surfaceTexture = swapchain->getOffscreenTexture();
     mTexture = surfaceTexture;
     mRenderTarget = NULL;
     initializeRenderTarget();
 }
 TextureStorage9_2D::TextureStorage9_2D(Renderer *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, GLsizei width, GLsizei height)
     : TextureStorage9(renderer, GetTextureUsage(Renderer9::makeRenderer9(renderer)->ConvertTextureInternalFormat(internalformat), usage, forceRenderable))
 {
     mTexture = NULL;
     mRenderTarget = NULL;
     // if the width or height is not positive this should be treated as an incomplete texture
     // we handle that here by skipping the d3d texture creation
     if (width > 0 && height > 0)
     {
         IDirect3DDevice9 *device = mRenderer->getDevice();
         gl::MakeValidSize(false, gl::IsCompressed(internalformat), &width, &height, &mLodOffset);
         HRESULT result = device->CreateTexture(width, height, levels ? levels + mLodOffset : 0, getUsage(),
                                                mRenderer->ConvertTextureInternalFormat(internalformat), getPool(), &mTexture, NULL);
         if (FAILED(result))
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
             gl::error(GL_OUT_OF_MEMORY);
         }
     }
     initializeRenderTarget();
 }
 TextureStorage9_2D::~TextureStorage9_2D()
 {
     if (mTexture)
     {
         mTexture->Release();
     }
     delete mRenderTarget;
 }
 TextureStorage9_2D *TextureStorage9_2D::makeTextureStorage9_2D(TextureStorage *storage)
 {
     ASSERT(HAS_DYNAMIC_TYPE(TextureStorage9_2D*, storage));
     return static_cast<TextureStorage9_2D*>(storage);
 }
 // Increments refcount on surface.
 // caller must Release() the returned surface
 IDirect3DSurface9 *TextureStorage9_2D::getSurfaceLevel(int level, bool dirty)
 {
     IDirect3DSurface9 *surface = NULL;
     if (mTexture)
     {
         HRESULT result = mTexture->GetSurfaceLevel(level + mLodOffset, &surface);
         ASSERT(SUCCEEDED(result));
         // With managed textures the driver needs to be informed of updates to the lower mipmap levels
         if (level + mLodOffset != 0 && isManaged() && dirty)
         {
             mTexture->AddDirtyRect(NULL);
         }
     }
     return surface;
 }
 RenderTarget *TextureStorage9_2D::getRenderTarget()
 {
     return mRenderTarget;
 }
 void TextureStorage9_2D::generateMipmap(int level)
 {
     IDirect3DSurface9 *upper = getSurfaceLevel(level - 1, false);
     IDirect3DSurface9 *lower = getSurfaceLevel(level, true);
     if (upper != NULL && lower != NULL)
     {
         mRenderer->boxFilter(upper, lower);
     }
     if (upper != NULL) upper->Release();
     if (lower != NULL) lower->Release();
 }
 IDirect3DBaseTexture9 *TextureStorage9_2D::getBaseTexture() const
 {
     return mTexture;
 }
 void TextureStorage9_2D::initializeRenderTarget()
 {
     ASSERT(mRenderTarget == NULL);
     if (mTexture != NULL && isRenderTarget())
     {
         IDirect3DSurface9 *surface = getSurfaceLevel(0, false);
         mRenderTarget = new RenderTarget9(mRenderer, surface);
     }
 }
 TextureStorage9_Cube::TextureStorage9_Cube(Renderer *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, int size)
     : TextureStorage9(renderer, GetTextureUsage(Renderer9::makeRenderer9(renderer)->ConvertTextureInternalFormat(internalformat), usage, forceRenderable))
 {
     mTexture = NULL;
     for (int i = 0; i < 6; ++i)
     {
         mRenderTarget[i] = NULL;
     }
     // if the size is not positive this should be treated as an incomplete texture
     // we handle that here by skipping the d3d texture creation
     if (size > 0)
     {
         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(),
                                                    mRenderer->ConvertTextureInternalFormat(internalformat), getPool(), &mTexture, NULL);
         if (FAILED(result))
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
             gl::error(GL_OUT_OF_MEMORY);
         }
     }
     initializeRenderTarget();
 }
 TextureStorage9_Cube::~TextureStorage9_Cube()
 {
     if (mTexture)
     {
         mTexture->Release();
     }
     for (int i = 0; i < 6; ++i)
     {
         delete mRenderTarget[i];
     }
 }
 TextureStorage9_Cube *TextureStorage9_Cube::makeTextureStorage9_Cube(TextureStorage *storage)
 {
     ASSERT(HAS_DYNAMIC_TYPE(TextureStorage9_Cube*, storage));
     return static_cast<TextureStorage9_Cube*>(storage);
 }
 // Increments refcount on surface.
 // caller must Release() the returned surface
 IDirect3DSurface9 *TextureStorage9_Cube::getCubeMapSurface(GLenum faceTarget, int level, bool dirty)
 {
     IDirect3DSurface9 *surface = NULL;
     if (mTexture)
     {
         D3DCUBEMAP_FACES face = gl_d3d9::ConvertCubeFace(faceTarget);
         HRESULT result = mTexture->GetCubeMapSurface(face, level + mLodOffset, &surface);
         ASSERT(SUCCEEDED(result));
         // With managed textures the driver needs to be informed of updates to the lower mipmap levels
         if (level != 0 && isManaged() && dirty)
         {
             mTexture->AddDirtyRect(face, NULL);
         }
     }
     return surface;
 }
 RenderTarget *TextureStorage9_Cube::getRenderTarget(GLenum faceTarget)
 {
     return mRenderTarget[gl::TextureCubeMap::faceIndex(faceTarget)];
 }
 void TextureStorage9_Cube::generateMipmap(int face, int level)
 {
     IDirect3DSurface9 *upper = getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level - 1, false);
     IDirect3DSurface9 *lower = getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, true);
     if (upper != NULL && lower != NULL)
     {
         mRenderer->boxFilter(upper, lower);
     }
     if (upper != NULL) upper->Release();
     if (lower != NULL) lower->Release();
 }
 IDirect3DBaseTexture9 *TextureStorage9_Cube::getBaseTexture() const
 {
     return mTexture;
 }
 void TextureStorage9_Cube::initializeRenderTarget()
 {
     if (mTexture != NULL && isRenderTarget())
     {
         IDirect3DSurface9 *surface = NULL;
         for (int i = 0; i < 6; ++i)
         {
             ASSERT(mRenderTarget[i] == NULL);
             surface = getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, false);
             mRenderTarget[i] = new RenderTarget9(mRenderer, surface);
         }
     }
 }
 }

The Tor Browser / annotate

gfx/angle/src/libGLESv2/renderer/TextureStorage9.cpp@6474c204b198 (annotated)

gfx/angle/src/libGLESv2/renderer/TextureStorage9.cpp