kc3-lang/angle/src/libGLESv2/FramebufferAttachment.cpp

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Geoff Lang
  Date : 2014-07-22 15:14:06
  Hash : 5d601382
  Message : Simplify formatutils.h by exposing the info structures. Removed all the separate query functions and simply expose the internal info structures. This reduces the number of std::map/std::set operations that were hidden behind the API. Moved the validation tables for ES3 format combinations and effective internal formats into validationES3.cpp so that formatutils.h only has generic GL format queries. BUG=angle:658 Change-Id: Ieb60d42b8eafcdb4f21dcbec130b39478ce5f7c5 Reviewed-on: https://chromium-review.googlesource.com/206835 Reviewed-by: Nicolas Capens <capn@chromium.org> Tested-by: Geoff Lang <geofflang@chromium.org>

• src/libGLESv2/FramebufferAttachment.cpp

• #include "precompiled.h"
  //
  // Copyright (c) 2014 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.
  //
  
  // FramebufferAttachment.cpp: the gl::FramebufferAttachment class and its derived classes
  // objects and related functionality. [OpenGL ES 2.0.24] section 4.4.3 page 108.
  
  #include "libGLESv2/FramebufferAttachment.h"
  #include "libGLESv2/renderer/RenderTarget.h"
  
  #include "libGLESv2/Texture.h"
  #include "libGLESv2/renderer/Renderer.h"
  #include "libGLESv2/renderer/d3d/TextureStorage.h"
  #include "common/utilities.h"
  #include "libGLESv2/formatutils.h"
  #include "libGLESv2/Renderbuffer.h"
  
  namespace gl
  {
  
  ////// FramebufferAttachment Implementation //////
  
  FramebufferAttachment::FramebufferAttachment()
  {
  }
  
  FramebufferAttachment::~FramebufferAttachment()
  {
  }
  
  GLuint FramebufferAttachment::getRedSize() const
  {
      return (GetInternalFormatInfo(getInternalFormat()).redBits > 0) ? GetInternalFormatInfo(getActualFormat()).redBits : 0;
  }
  
  GLuint FramebufferAttachment::getGreenSize() const
  {
      return (GetInternalFormatInfo(getInternalFormat()).greenBits > 0) ? GetInternalFormatInfo(getActualFormat()).greenBits : 0;
  }
  
  GLuint FramebufferAttachment::getBlueSize() const
  {
      return (GetInternalFormatInfo(getInternalFormat()).blueBits > 0) ? GetInternalFormatInfo(getActualFormat()).blueBits : 0;
  }
  
  GLuint FramebufferAttachment::getAlphaSize() const
  {
      return (GetInternalFormatInfo(getInternalFormat()).alphaBits > 0) ? GetInternalFormatInfo(getActualFormat()).alphaBits : 0;
  }
  
  GLuint FramebufferAttachment::getDepthSize() const
  {
      return (GetInternalFormatInfo(getInternalFormat()).depthBits > 0) ? GetInternalFormatInfo(getActualFormat()).depthBits : 0;
  }
  
  GLuint FramebufferAttachment::getStencilSize() const
  {
      return (GetInternalFormatInfo(getInternalFormat()).stencilBits > 0) ? GetInternalFormatInfo(getActualFormat()).stencilBits : 0;
  }
  
  GLenum FramebufferAttachment::getComponentType() const
  {
      return GetInternalFormatInfo(getActualFormat()).componentType;
  }
  
  GLenum FramebufferAttachment::getColorEncoding() const
  {
      return GetInternalFormatInfo(getActualFormat()).colorEncoding;
  }
  
  bool FramebufferAttachment::isTexture() const
  {
      return (type() != GL_RENDERBUFFER);
  }
  
  ///// Texture2DAttachment Implementation ////////
  
  Texture2DAttachment::Texture2DAttachment(Texture2D *texture, GLint level) : mLevel(level)
  {
      mTexture2D.set(texture);
  }
  
  Texture2DAttachment::~Texture2DAttachment()
  {
      mTexture2D.set(NULL);
  }
  
  rx::RenderTarget *Texture2DAttachment::getRenderTarget()
  {
      return mTexture2D->getRenderTarget(mLevel);
  }
  
  rx::RenderTarget *Texture2DAttachment::getDepthStencil()
  {
      return mTexture2D->getDepthSencil(mLevel);
  }
  
  rx::TextureStorage *Texture2DAttachment::getTextureStorage()
  {
      return mTexture2D->getNativeTexture()->getStorageInstance();
  }
  
  GLsizei Texture2DAttachment::getWidth() const
  {
      return mTexture2D->getWidth(mLevel);
  }
  
  GLsizei Texture2DAttachment::getHeight() const
  {
      return mTexture2D->getHeight(mLevel);
  }
  
  GLenum Texture2DAttachment::getInternalFormat() const
  {
      return mTexture2D->getInternalFormat(mLevel);
  }
  
  GLenum Texture2DAttachment::getActualFormat() const
  {
      return mTexture2D->getActualFormat(mLevel);
  }
  
  GLsizei Texture2DAttachment::getSamples() const
  {
      return 0;
  }
  
  unsigned int Texture2DAttachment::getSerial() const
  {
      return mTexture2D->getRenderTargetSerial(mLevel);
  }
  
  GLuint Texture2DAttachment::id() const
  {
      return mTexture2D->id();
  }
  
  GLenum Texture2DAttachment::type() const
  {
      return GL_TEXTURE_2D;
  }
  
  GLint Texture2DAttachment::mipLevel() const
  {
      return mLevel;
  }
  
  GLint Texture2DAttachment::layer() const
  {
      return 0;
  }
  
  unsigned int Texture2DAttachment::getTextureSerial() const
  {
      return mTexture2D->getTextureSerial();
  }
  
  ///// TextureCubeMapAttachment Implementation ////////
  
  TextureCubeMapAttachment::TextureCubeMapAttachment(TextureCubeMap *texture, GLenum faceTarget, GLint level)
      : mFaceTarget(faceTarget), mLevel(level)
  {
      mTextureCubeMap.set(texture);
  }
  
  TextureCubeMapAttachment::~TextureCubeMapAttachment()
  {
      mTextureCubeMap.set(NULL);
  }
  
  rx::RenderTarget *TextureCubeMapAttachment::getRenderTarget()
  {
      return mTextureCubeMap->getRenderTarget(mFaceTarget, mLevel);
  }
  
  rx::RenderTarget *TextureCubeMapAttachment::getDepthStencil()
  {
      return mTextureCubeMap->getDepthStencil(mFaceTarget, mLevel);
  }
  
  rx::TextureStorage *TextureCubeMapAttachment::getTextureStorage()
  {
      return mTextureCubeMap->getNativeTexture()->getStorageInstance();
  }
  
  GLsizei TextureCubeMapAttachment::getWidth() const
  {
      return mTextureCubeMap->getWidth(mFaceTarget, mLevel);
  }
  
  GLsizei TextureCubeMapAttachment::getHeight() const
  {
      return mTextureCubeMap->getHeight(mFaceTarget, mLevel);
  }
  
  GLenum TextureCubeMapAttachment::getInternalFormat() const
  {
      return mTextureCubeMap->getInternalFormat(mFaceTarget, mLevel);
  }
  
  GLenum TextureCubeMapAttachment::getActualFormat() const
  {
      return mTextureCubeMap->getActualFormat(mFaceTarget, mLevel);
  }
  
  GLsizei TextureCubeMapAttachment::getSamples() const
  {
      return 0;
  }
  
  unsigned int TextureCubeMapAttachment::getSerial() const
  {
      return mTextureCubeMap->getRenderTargetSerial(mFaceTarget, mLevel);
  }
  
  GLuint TextureCubeMapAttachment::id() const
  {
      return mTextureCubeMap->id();
  }
  
  GLenum TextureCubeMapAttachment::type() const
  {
      return mFaceTarget;
  }
  
  GLint TextureCubeMapAttachment::mipLevel() const
  {
      return mLevel;
  }
  
  GLint TextureCubeMapAttachment::layer() const
  {
      return 0;
  }
  
  unsigned int TextureCubeMapAttachment::getTextureSerial() const
  {
      return mTextureCubeMap->getTextureSerial();
  }
  
  ///// Texture3DAttachment Implementation ////////
  
  Texture3DAttachment::Texture3DAttachment(Texture3D *texture, GLint level, GLint layer)
      : mLevel(level), mLayer(layer)
  {
      mTexture3D.set(texture);
  }
  
  Texture3DAttachment::~Texture3DAttachment()
  {
      mTexture3D.set(NULL);
  }
  
  rx::RenderTarget *Texture3DAttachment::getRenderTarget()
  {
      return mTexture3D->getRenderTarget(mLevel, mLayer);
  }
  
  rx::RenderTarget *Texture3DAttachment::getDepthStencil()
  {
      return mTexture3D->getDepthStencil(mLevel, mLayer);
  }
  
  rx::TextureStorage *Texture3DAttachment::getTextureStorage()
  {
      return mTexture3D->getNativeTexture()->getStorageInstance();
  }
  
  GLsizei Texture3DAttachment::getWidth() const
  {
      return mTexture3D->getWidth(mLevel);
  }
  
  GLsizei Texture3DAttachment::getHeight() const
  {
      return mTexture3D->getHeight(mLevel);
  }
  
  GLenum Texture3DAttachment::getInternalFormat() const
  {
      return mTexture3D->getInternalFormat(mLevel);
  }
  
  GLenum Texture3DAttachment::getActualFormat() const
  {
      return mTexture3D->getActualFormat(mLevel);
  }
  
  GLsizei Texture3DAttachment::getSamples() const
  {
      return 0;
  }
  
  unsigned int Texture3DAttachment::getSerial() const
  {
      return mTexture3D->getRenderTargetSerial(mLevel, mLayer);
  }
  
  GLuint Texture3DAttachment::id() const
  {
      return mTexture3D->id();
  }
  
  GLenum Texture3DAttachment::type() const
  {
      return GL_TEXTURE_3D;
  }
  
  GLint Texture3DAttachment::mipLevel() const
  {
      return mLevel;
  }
  
  GLint Texture3DAttachment::layer() const
  {
      return mLayer;
  }
  
  unsigned int Texture3DAttachment::getTextureSerial() const
  {
      return mTexture3D->getTextureSerial();
  }
  
  ////// Texture2DArrayAttachment Implementation //////
  
  Texture2DArrayAttachment::Texture2DArrayAttachment(Texture2DArray *texture, GLint level, GLint layer)
      : mLevel(level), mLayer(layer)
  {
      mTexture2DArray.set(texture);
  }
  
  Texture2DArrayAttachment::~Texture2DArrayAttachment()
  {
      mTexture2DArray.set(NULL);
  }
  
  rx::RenderTarget *Texture2DArrayAttachment::getRenderTarget()
  {
      return mTexture2DArray->getRenderTarget(mLevel, mLayer);
  }
  
  rx::RenderTarget *Texture2DArrayAttachment::getDepthStencil()
  {
      return mTexture2DArray->getDepthStencil(mLevel, mLayer);
  }
  
  rx::TextureStorage *Texture2DArrayAttachment::getTextureStorage()
  {
      return mTexture2DArray->getNativeTexture()->getStorageInstance();
  }
  
  GLsizei Texture2DArrayAttachment::getWidth() const
  {
      return mTexture2DArray->getWidth(mLevel);
  }
  
  GLsizei Texture2DArrayAttachment::getHeight() const
  {
      return mTexture2DArray->getHeight(mLevel);
  }
  
  GLenum Texture2DArrayAttachment::getInternalFormat() const
  {
      return mTexture2DArray->getInternalFormat(mLevel);
  }
  
  GLenum Texture2DArrayAttachment::getActualFormat() const
  {
      return mTexture2DArray->getActualFormat(mLevel);
  }
  
  GLsizei Texture2DArrayAttachment::getSamples() const
  {
      return 0;
  }
  
  unsigned int Texture2DArrayAttachment::getSerial() const
  {
      return mTexture2DArray->getRenderTargetSerial(mLevel, mLayer);
  }
  
  GLuint Texture2DArrayAttachment::id() const
  {
      return mTexture2DArray->id();
  }
  
  GLenum Texture2DArrayAttachment::type() const
  {
      return GL_TEXTURE_2D_ARRAY;
  }
  
  GLint Texture2DArrayAttachment::mipLevel() const
  {
      return mLevel;
  }
  
  GLint Texture2DArrayAttachment::layer() const
  {
      return mLayer;
  }
  
  unsigned int Texture2DArrayAttachment::getTextureSerial() const
  {
      return mTexture2DArray->getTextureSerial();
  }
  
  ////// RenderbufferAttachment Implementation //////
  
  RenderbufferAttachment::RenderbufferAttachment(Renderbuffer *renderbuffer)
  {
      ASSERT(renderbuffer);
      mRenderbuffer.set(renderbuffer);
  }
  
  RenderbufferAttachment::~RenderbufferAttachment()
  {
      mRenderbuffer.set(NULL);
  }
  
  rx::RenderTarget *RenderbufferAttachment::getRenderTarget()
  {
      return mRenderbuffer->getStorage()->getRenderTarget();
  }
  
  rx::RenderTarget *RenderbufferAttachment::getDepthStencil()
  {
      return mRenderbuffer->getStorage()->getDepthStencil();
  }
  
  rx::TextureStorage *RenderbufferAttachment::getTextureStorage()
  {
      UNREACHABLE();
      return NULL;
  }
  
  GLsizei RenderbufferAttachment::getWidth() const
  {
      return mRenderbuffer->getWidth();
  }
  
  GLsizei RenderbufferAttachment::getHeight() const
  {
      return mRenderbuffer->getHeight();
  }
  
  GLenum RenderbufferAttachment::getInternalFormat() const
  {
      return mRenderbuffer->getInternalFormat();
  }
  
  GLenum RenderbufferAttachment::getActualFormat() const
  {
      return mRenderbuffer->getActualFormat();
  }
  
  GLsizei RenderbufferAttachment::getSamples() const
  {
      return mRenderbuffer->getStorage()->getSamples();
  }
  
  unsigned int RenderbufferAttachment::getSerial() const
  {
      return mRenderbuffer->getStorage()->getSerial();
  }
  
  GLuint RenderbufferAttachment::id() const
  {
      return mRenderbuffer->id();
  }
  
  GLenum RenderbufferAttachment::type() const
  {
      return GL_RENDERBUFFER;
  }
  
  GLint RenderbufferAttachment::mipLevel() const
  {
      return 0;
  }
  
  GLint RenderbufferAttachment::layer() const
  {
      return 0;
  }
  
  unsigned int RenderbufferAttachment::getTextureSerial() const
  {
      UNREACHABLE();
      return 0;
  }
  
  }