src/third_party/angle/src/libGLESv2/renderer/d3d/TextureStorage.cpp

   1 #include "precompiled.h"
   2 //
   3 // Copyright (c) 2002-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 // TextureStorage.cpp: Implements the abstract rx::TextureStorageInterface class and its concrete derived
   9 // classes TextureStorageInterface2D and TextureStorageInterfaceCube, which act as the interface to the
  10 // GPU-side texture.
  11
  12 #include "libGLESv2/renderer/d3d/TextureStorage.h"
  13 #include "libGLESv2/renderer/d3d/TextureD3D.h"
  14 #include "libGLESv2/renderer/Renderer.h"
  15 #include "libGLESv2/Renderbuffer.h"
  16 #include "libGLESv2/Texture.h"
  17
  18 #include "common/debug.h"
  19 #include "common/mathutil.h"
  20
  21 namespace rx
  22 {
  23 unsigned int TextureStorageInterface::mCurrentTextureSerial = 1;
  24
  25 TextureStorageInterface::TextureStorageInterface()
  26     : mTextureSerial(issueTextureSerial()),
  27       mInstance(NULL)
  28 {
  29 }
  30
  31 TextureStorageInterface::~TextureStorageInterface()
  32 {
  33     delete mInstance;
  34 }
  35
  36 bool TextureStorageInterface::isRenderTarget() const
  37 {
  38     return mInstance->isRenderTarget();
  39 }
  40
  41 bool TextureStorageInterface::isManaged() const
  42 {
  43     return mInstance->isManaged();
  44 }
  45
  46 unsigned int TextureStorageInterface::getTextureSerial() const
  47 {
  48     return mTextureSerial;
  49 }
  50
  51 unsigned int TextureStorageInterface::issueTextureSerial()
  52 {
  53     return mCurrentTextureSerial++;
  54 }
  55
  56 int TextureStorageInterface::getTopLevel() const
  57 {
  58     return mInstance->getTopLevel();
  59 }
  60
  61 int TextureStorageInterface::getLevelCount() const
  62 {
  63     return mInstance->getLevelCount();
  64 }
  65
  66 TextureStorageInterface2D::TextureStorageInterface2D(Renderer *renderer, SwapChain *swapchain)
  67 {
  68     mFirstRenderTargetSerial = gl::RenderbufferStorage::issueSerials(1);
  69
  70     mInstance = renderer->createTextureStorage2D(swapchain);
  71 }
  72
  73 TextureStorageInterface2D::TextureStorageInterface2D(Renderer *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels)
  74 {
  75     mInstance = renderer->createTextureStorage2D(internalformat, renderTarget, width, height, levels);
  76     mFirstRenderTargetSerial = gl::RenderbufferStorage::issueSerials(static_cast<GLuint>(mInstance->getLevelCount()));
  77 }
  78
  79 TextureStorageInterface2D::~TextureStorageInterface2D()
  80 {
  81 }
  82
  83 RenderTarget *TextureStorageInterface2D::getRenderTarget(GLint level) const
  84 {
  85     return mInstance->getRenderTarget(level);
  86 }
  87
  88 void TextureStorageInterface2D::generateMipmap(int level)
  89 {
  90     mInstance->generateMipmap(level);
  91 }
  92
  93 unsigned int TextureStorageInterface2D::getRenderTargetSerial(GLint level) const
  94 {
  95     return mFirstRenderTargetSerial + level;
  96 }
  97
  98 TextureStorageInterfaceCube::TextureStorageInterfaceCube(Renderer *renderer, GLenum internalformat, bool renderTarget, int size, int levels)
  99 {
 100     mInstance = renderer->createTextureStorageCube(internalformat, renderTarget, size, levels);
 101     mFirstRenderTargetSerial = gl::RenderbufferStorage::issueSerials(static_cast<GLuint>(mInstance->getLevelCount() * 6));
 102 }
 103
 104 TextureStorageInterfaceCube::~TextureStorageInterfaceCube()
 105 {
 106 }
 107
 108 RenderTarget *TextureStorageInterfaceCube::getRenderTarget(GLenum faceTarget, GLint level) const
 109 {
 110     return mInstance->getRenderTargetFace(faceTarget, level);
 111 }
 112
 113 void TextureStorageInterfaceCube::generateMipmap(int faceIndex, int level)
 114 {
 115     mInstance->generateMipmap(faceIndex, level);
 116 }
 117
 118 unsigned int TextureStorageInterfaceCube::getRenderTargetSerial(GLenum target, GLint level) const
 119 {
 120     return mFirstRenderTargetSerial + (level * 6) + gl::TextureCubeMap::targetToLayerIndex(target);
 121 }
 122
 123 TextureStorageInterface3D::TextureStorageInterface3D(Renderer *renderer, GLenum internalformat, bool renderTarget,
 124                                                      GLsizei width, GLsizei height, GLsizei depth, int levels)
 125 {
 126
 127     mInstance = renderer->createTextureStorage3D(internalformat, renderTarget, width, height, depth, levels);
 128     mFirstRenderTargetSerial = gl::RenderbufferStorage::issueSerials(static_cast<GLuint>(mInstance->getLevelCount() * depth));
 129 }
 130
 131 TextureStorageInterface3D::~TextureStorageInterface3D()
 132 {
 133 }
 134
 135 void TextureStorageInterface3D::generateMipmap(int level)
 136 {
 137     mInstance->generateMipmap(level);
 138 }
 139
 140 RenderTarget *TextureStorageInterface3D::getRenderTarget(GLint level) const
 141 {
 142     return mInstance->getRenderTarget(level);
 143 }
 144
 145 RenderTarget *TextureStorageInterface3D::getRenderTarget(GLint level, GLint layer) const
 146 {
 147     return mInstance->getRenderTargetLayer(level, layer);
 148 }
 149
 150 unsigned int TextureStorageInterface3D::getRenderTargetSerial(GLint level, GLint layer) const
 151 {
 152     return mFirstRenderTargetSerial + static_cast<unsigned int>((layer * mInstance->getLevelCount()) + level);
 153 }
 154
 155 TextureStorageInterface2DArray::TextureStorageInterface2DArray(Renderer *renderer, GLenum internalformat, bool renderTarget,
 156                                                                GLsizei width, GLsizei height, GLsizei depth, int levels)
 157 {
 158     mInstance = renderer->createTextureStorage2DArray(internalformat, renderTarget, width, height, depth, levels);
 159     mFirstRenderTargetSerial = gl::RenderbufferStorage::issueSerials(static_cast<GLuint>(mInstance->getLevelCount() * depth));
 160 }
 161
 162 TextureStorageInterface2DArray::~TextureStorageInterface2DArray()
 163 {
 164 }
 165
 166 void TextureStorageInterface2DArray::generateMipmap(int level)
 167 {
 168     mInstance->generateMipmap(level);
 169 }
 170
 171 RenderTarget *TextureStorageInterface2DArray::getRenderTarget(GLint level, GLint layer) const
 172 {
 173     return mInstance->getRenderTargetLayer(level, layer);
 174 }
 175
 176 unsigned int TextureStorageInterface2DArray::getRenderTargetSerial(GLint level, GLint layer) const
 177 {
 178     return mFirstRenderTargetSerial + static_cast<unsigned int>((layer * mInstance->getLevelCount()) + level);
 179 }
 180
 181 }