diff options
Diffstat (limited to 'src/3rdparty/angle/src/libGLESv2/FramebufferAttachment.cpp')
-rw-r--r-- | src/3rdparty/angle/src/libGLESv2/FramebufferAttachment.cpp | 495 |
1 files changed, 495 insertions, 0 deletions
diff --git a/src/3rdparty/angle/src/libGLESv2/FramebufferAttachment.cpp b/src/3rdparty/angle/src/libGLESv2/FramebufferAttachment.cpp new file mode 100644 index 0000000000..5855301c97 --- /dev/null +++ b/src/3rdparty/angle/src/libGLESv2/FramebufferAttachment.cpp @@ -0,0 +1,495 @@ +#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 (gl::GetRedBits(getInternalFormat()) > 0) ? gl::GetRedBits(getActualFormat()) : 0; +} + +GLuint FramebufferAttachment::getGreenSize() const +{ + return (gl::GetGreenBits(getInternalFormat()) > 0) ? gl::GetGreenBits(getActualFormat()) : 0; +} + +GLuint FramebufferAttachment::getBlueSize() const +{ + return (gl::GetBlueBits(getInternalFormat()) > 0) ? gl::GetBlueBits(getActualFormat()) : 0; +} + +GLuint FramebufferAttachment::getAlphaSize() const +{ + return (gl::GetAlphaBits(getInternalFormat()) > 0) ? gl::GetAlphaBits(getActualFormat()) : 0; +} + +GLuint FramebufferAttachment::getDepthSize() const +{ + return (gl::GetDepthBits(getInternalFormat()) > 0) ? gl::GetDepthBits(getActualFormat()) : 0; +} + +GLuint FramebufferAttachment::getStencilSize() const +{ + return (gl::GetStencilBits(getInternalFormat()) > 0) ? gl::GetStencilBits(getActualFormat()) : 0; +} + +GLenum FramebufferAttachment::getComponentType() const +{ + return gl::GetComponentType(getActualFormat()); +} + +GLenum FramebufferAttachment::getColorEncoding() const +{ + return gl::GetColorEncoding(getActualFormat()); +} + +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; +} + +} |