kc3-lang/angle/src/libGLESv2/renderer/TextureStorage11.h

Branch : - branch - main - tag -

• Show log

  Commit

• Author : shannon.woods%transgaming.com@gtempaccount.com
  Date : 2013-04-13 03:45:45
  Hash : 6c86bd5f
  Message : Created the TextureStorageInterface2DArray class. TRAC #22705 Signed-off-by: Jamie Madill Signed-off-by: Shannon Woods Author: Geoff Lang git-svn-id: https://angleproject.googlecode.com/svn/branches/es3proto@2176 736b8ea6-26fd-11df-bfd4-992fa37f6226

• src/libGLESv2/renderer/TextureStorage11.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.
  //
  
  // TextureStorage11.h: Defines the abstract rx::TextureStorage11 class and its concrete derived
  // classes TextureStorage11_2D and TextureStorage11_Cube, which act as the interface to the D3D11 texture.
  
  #ifndef LIBGLESV2_RENDERER_TEXTURESTORAGE11_H_
  #define LIBGLESV2_RENDERER_TEXTURESTORAGE11_H_
  
  #include "libGLESv2/Texture.h"
  #include "libGLESv2/renderer/TextureStorage.h"
  
  namespace rx
  {
  class RenderTarget;
  class RenderTarget11;
  class Renderer;
  class Renderer11;
  class SwapChain11;
  
  class TextureStorage11 : public TextureStorage
  {
    public:
      TextureStorage11(Renderer *renderer, UINT bindFlags);
      virtual ~TextureStorage11();
  
      static TextureStorage11 *makeTextureStorage11(TextureStorage *storage);
  
      static DWORD GetTextureBindFlags(DXGI_FORMAT d3dfmt, GLenum glusage, bool forceRenderable);
      static bool IsTextureFormatRenderable(DXGI_FORMAT format);
  
      UINT getBindFlags() const;
  
      virtual ID3D11Resource *getBaseTexture() const = 0;
      virtual ID3D11ShaderResourceView *getSRV() = 0;
      virtual RenderTarget *getRenderTarget(int level) { return NULL; }
      virtual RenderTarget *getRenderTarget(GLenum faceTarget, int level) { return NULL; }
      virtual RenderTarget *getRenderTargetLayer(int mipLevel, int layer) { return NULL; }
  
      virtual void generateMipmap(int level) {};
      virtual void generateMipmap(int face, int level) {};
  
      virtual int getLodOffset() const;
      virtual bool isRenderTarget() const;
      virtual bool isManaged() const;
      virtual int levelCount();
      UINT getSubresourceIndex(int mipLevel, int layerTarget);
  
      bool updateSubresourceLevel(ID3D11Resource *texture, unsigned int sourceSubresource, int level,
                                  int layerTarget, GLint xoffset, GLint yoffset, GLint zoffset,
                                  GLsizei width, GLsizei height, GLsizei depth);
  
    protected:
      void generateMipmapLayer(RenderTarget11 *source, RenderTarget11 *dest);
  
      Renderer11 *mRenderer;
      int mLodOffset;
      unsigned int mMipLevels;
  
      DXGI_FORMAT mTextureFormat;
      DXGI_FORMAT mShaderResourceFormat;
      DXGI_FORMAT mRenderTargetFormat;
      DXGI_FORMAT mDepthStencilFormat;
      unsigned int mTextureWidth;
      unsigned int mTextureHeight;
      unsigned int mTextureDepth;
  
      ID3D11ShaderResourceView *mSRV;
  
    private:
      DISALLOW_COPY_AND_ASSIGN(TextureStorage11);
  
      const UINT mBindFlags;
  };
  
  class TextureStorage11_2D : public TextureStorage11
  {
    public:
      TextureStorage11_2D(Renderer *renderer, SwapChain11 *swapchain);
      TextureStorage11_2D(Renderer *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, GLsizei width, GLsizei height);
      virtual ~TextureStorage11_2D();
  
      static TextureStorage11_2D *makeTextureStorage11_2D(TextureStorage *storage);
  
      virtual ID3D11Resource *getBaseTexture() const;
      virtual ID3D11ShaderResourceView *getSRV();
      virtual RenderTarget *getRenderTarget(int level);
  
      virtual void generateMipmap(int level);
  
    private:
      DISALLOW_COPY_AND_ASSIGN(TextureStorage11_2D);
  
      ID3D11Texture2D *mTexture;
      RenderTarget11 *mRenderTarget[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
  };
  
  class TextureStorage11_Cube : public TextureStorage11
  {
    public:
      TextureStorage11_Cube(Renderer *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, int size);
      virtual ~TextureStorage11_Cube();
  
      static TextureStorage11_Cube *makeTextureStorage11_Cube(TextureStorage *storage);
  
      virtual ID3D11Resource *getBaseTexture() const;
      virtual ID3D11ShaderResourceView *getSRV();
      virtual RenderTarget *getRenderTarget(GLenum faceTarget, int level);
  
      virtual void generateMipmap(int face, int level);
  
    private:
      DISALLOW_COPY_AND_ASSIGN(TextureStorage11_Cube);
  
      ID3D11Texture2D *mTexture;
      RenderTarget11 *mRenderTarget[6][gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
  };
  
  class TextureStorage11_3D : public TextureStorage11
  {
    public:
      TextureStorage11_3D(Renderer *renderer, int levels, GLenum internalformat, GLenum usage,
                          GLsizei width, GLsizei height, GLsizei depth);
      virtual ~TextureStorage11_3D();
  
      static TextureStorage11_3D *makeTextureStorage11_3D(TextureStorage *storage);
  
      virtual ID3D11Resource *getBaseTexture() const;
      virtual ID3D11ShaderResourceView *getSRV();
      virtual RenderTarget *getRenderTargetLayer(int mipLevel, int layer);
  
      virtual void generateMipmap(int level);
  
    private:
      DISALLOW_COPY_AND_ASSIGN(TextureStorage11_3D);
  
      typedef std::pair<int, int> LevelLayerKey;
      typedef std::map<LevelLayerKey, RenderTarget11*> RenderTargetMap;
      RenderTargetMap mRenderTargets;
  
      ID3D11Texture3D *mTexture;
  };
  
  class TextureStorage11_2DArray : public TextureStorage11
  {
    public:
      TextureStorage11_2DArray(Renderer *renderer, int levels, GLenum internalformat, GLenum usage,
                               GLsizei width, GLsizei height, GLsizei depth);
      virtual ~TextureStorage11_2DArray();
  
      static TextureStorage11_2DArray *makeTextureStorage11_2DArray(TextureStorage *storage);
  
      virtual ID3D11Resource *getBaseTexture() const;
      virtual ID3D11ShaderResourceView *getSRV();
      virtual RenderTarget *getRenderTargetLayer(int mipLevel, int layer);
  
      virtual void generateMipmap(int level);
  
    private:
      DISALLOW_COPY_AND_ASSIGN(TextureStorage11_2DArray);
  
      typedef std::pair<int, int> LevelLayerKey;
      typedef std::map<LevelLayerKey, RenderTarget11*> RenderTargetMap;
      RenderTargetMap mRenderTargets;
  
      ID3D11Texture2D *mTexture;
  };
  
  }
  
  #endif // LIBGLESV2_RENDERER_TEXTURESTORAGE11_H_