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

• Show log

  Commit

• Hash : 685dd27a
  Author :
  Date : 2014-08-29T15:46:43
  

  Replace getDepthStencil with getRenderTarget.
  
  In all places where we called this method, we treated a NULL return
  value as an internal error. This implies to me that we don't need the
  two getRenderTarget and getDepthStencil methods, since we aren't using
  them to check if a surface is depth or stencil.
  
  BUG=angle:732
  
  Change-Id: I4d1dc148abf3383b1b101bbff4f4d22de27ad03e
  Reviewed-on: https://chromium-review.googlesource.com/213852
  Tested-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Brandon Jones <bajones@chromium.org>
  Reviewed-by: Shannon Woods <shannonwoods@chromium.org>
  

Download

• src/libGLESv2/FramebufferAttachment.cpp

• //
  // 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/Texture.h"
  #include "libGLESv2/formatutils.h"
  #include "libGLESv2/Renderbuffer.h"
  #include "libGLESv2/renderer/RenderTarget.h"
  #include "libGLESv2/renderer/Renderer.h"
  #include "libGLESv2/renderer/d3d/TextureStorage.h"
  
  #include "common/utilities.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::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::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::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::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::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;
  }
  
  }
  

Download