diff -r 000000000000 -r 6474c204b198 gfx/angle/src/libGLESv2/Renderbuffer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gfx/angle/src/libGLESv2/Renderbuffer.cpp Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,485 @@ +#include "precompiled.h" +// +// Copyright (c) 2002-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. +// + +// Renderbuffer.cpp: the gl::Renderbuffer class and its derived classes +// Colorbuffer, Depthbuffer and Stencilbuffer. Implements GL renderbuffer +// objects and related functionality. [OpenGL ES 2.0.24] section 4.4.3 page 108. + +#include "libGLESv2/Renderbuffer.h" +#include "libGLESv2/renderer/RenderTarget.h" + +#include "libGLESv2/Texture.h" +#include "libGLESv2/renderer/Renderer.h" +#include "libGLESv2/utilities.h" + +namespace gl +{ +unsigned int RenderbufferStorage::mCurrentSerial = 1; + +RenderbufferInterface::RenderbufferInterface() +{ +} + +// The default case for classes inherited from RenderbufferInterface is not to +// need to do anything upon the reference count to the parent Renderbuffer incrementing +// or decrementing. +void RenderbufferInterface::addProxyRef(const Renderbuffer *proxy) +{ +} + +void RenderbufferInterface::releaseProxy(const Renderbuffer *proxy) +{ +} + +GLuint RenderbufferInterface::getRedSize() const +{ + return gl::GetRedSize(getActualFormat()); +} + +GLuint RenderbufferInterface::getGreenSize() const +{ + return gl::GetGreenSize(getActualFormat()); +} + +GLuint RenderbufferInterface::getBlueSize() const +{ + return gl::GetBlueSize(getActualFormat()); +} + +GLuint RenderbufferInterface::getAlphaSize() const +{ + return gl::GetAlphaSize(getActualFormat()); +} + +GLuint RenderbufferInterface::getDepthSize() const +{ + return gl::GetDepthSize(getActualFormat()); +} + +GLuint RenderbufferInterface::getStencilSize() const +{ + return gl::GetStencilSize(getActualFormat()); +} + +///// RenderbufferTexture2D Implementation //////// + +RenderbufferTexture2D::RenderbufferTexture2D(Texture2D *texture, GLenum target) : mTarget(target) +{ + mTexture2D.set(texture); +} + +RenderbufferTexture2D::~RenderbufferTexture2D() +{ + mTexture2D.set(NULL); +} + +// Textures need to maintain their own reference count for references via +// Renderbuffers acting as proxies. Here, we notify the texture of a reference. +void RenderbufferTexture2D::addProxyRef(const Renderbuffer *proxy) +{ + mTexture2D->addProxyRef(proxy); +} + +void RenderbufferTexture2D::releaseProxy(const Renderbuffer *proxy) +{ + mTexture2D->releaseProxy(proxy); +} + +rx::RenderTarget *RenderbufferTexture2D::getRenderTarget() +{ + return mTexture2D->getRenderTarget(mTarget); +} + +rx::RenderTarget *RenderbufferTexture2D::getDepthStencil() +{ + return mTexture2D->getDepthStencil(mTarget); +} + +GLsizei RenderbufferTexture2D::getWidth() const +{ + return mTexture2D->getWidth(0); +} + +GLsizei RenderbufferTexture2D::getHeight() const +{ + return mTexture2D->getHeight(0); +} + +GLenum RenderbufferTexture2D::getInternalFormat() const +{ + return mTexture2D->getInternalFormat(0); +} + +GLenum RenderbufferTexture2D::getActualFormat() const +{ + return mTexture2D->getActualFormat(0); +} + +GLsizei RenderbufferTexture2D::getSamples() const +{ + return 0; +} + +unsigned int RenderbufferTexture2D::getSerial() const +{ + return mTexture2D->getRenderTargetSerial(mTarget); +} + +///// RenderbufferTextureCubeMap Implementation //////// + +RenderbufferTextureCubeMap::RenderbufferTextureCubeMap(TextureCubeMap *texture, GLenum target) : mTarget(target) +{ + mTextureCubeMap.set(texture); +} + +RenderbufferTextureCubeMap::~RenderbufferTextureCubeMap() +{ + mTextureCubeMap.set(NULL); +} + +// Textures need to maintain their own reference count for references via +// Renderbuffers acting as proxies. Here, we notify the texture of a reference. +void RenderbufferTextureCubeMap::addProxyRef(const Renderbuffer *proxy) +{ + mTextureCubeMap->addProxyRef(proxy); +} + +void RenderbufferTextureCubeMap::releaseProxy(const Renderbuffer *proxy) +{ + mTextureCubeMap->releaseProxy(proxy); +} + +rx::RenderTarget *RenderbufferTextureCubeMap::getRenderTarget() +{ + return mTextureCubeMap->getRenderTarget(mTarget); +} + +rx::RenderTarget *RenderbufferTextureCubeMap::getDepthStencil() +{ + return NULL; +} + +GLsizei RenderbufferTextureCubeMap::getWidth() const +{ + return mTextureCubeMap->getWidth(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0); +} + +GLsizei RenderbufferTextureCubeMap::getHeight() const +{ + return mTextureCubeMap->getHeight(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0); +} + +GLenum RenderbufferTextureCubeMap::getInternalFormat() const +{ + return mTextureCubeMap->getInternalFormat(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0); +} + +GLenum RenderbufferTextureCubeMap::getActualFormat() const +{ + return mTextureCubeMap->getActualFormat(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0); +} + +GLsizei RenderbufferTextureCubeMap::getSamples() const +{ + return 0; +} + +unsigned int RenderbufferTextureCubeMap::getSerial() const +{ + return mTextureCubeMap->getRenderTargetSerial(mTarget); +} + +////// Renderbuffer Implementation ////// + +Renderbuffer::Renderbuffer(rx::Renderer *renderer, GLuint id, RenderbufferInterface *instance) : RefCountObject(id) +{ + ASSERT(instance != NULL); + mInstance = instance; +} + +Renderbuffer::~Renderbuffer() +{ + delete mInstance; +} + +// The RenderbufferInterface contained in this Renderbuffer may need to maintain +// its own reference count, so we pass it on here. +void Renderbuffer::addRef() const +{ + mInstance->addProxyRef(this); + + RefCountObject::addRef(); +} + +void Renderbuffer::release() const +{ + mInstance->releaseProxy(this); + + RefCountObject::release(); +} + +rx::RenderTarget *Renderbuffer::getRenderTarget() +{ + return mInstance->getRenderTarget(); +} + +rx::RenderTarget *Renderbuffer::getDepthStencil() +{ + return mInstance->getDepthStencil(); +} + +GLsizei Renderbuffer::getWidth() const +{ + return mInstance->getWidth(); +} + +GLsizei Renderbuffer::getHeight() const +{ + return mInstance->getHeight(); +} + +GLenum Renderbuffer::getInternalFormat() const +{ + return mInstance->getInternalFormat(); +} + +GLenum Renderbuffer::getActualFormat() const +{ + return mInstance->getActualFormat(); +} + +GLuint Renderbuffer::getRedSize() const +{ + return mInstance->getRedSize(); +} + +GLuint Renderbuffer::getGreenSize() const +{ + return mInstance->getGreenSize(); +} + +GLuint Renderbuffer::getBlueSize() const +{ + return mInstance->getBlueSize(); +} + +GLuint Renderbuffer::getAlphaSize() const +{ + return mInstance->getAlphaSize(); +} + +GLuint Renderbuffer::getDepthSize() const +{ + return mInstance->getDepthSize(); +} + +GLuint Renderbuffer::getStencilSize() const +{ + return mInstance->getStencilSize(); +} + +GLsizei Renderbuffer::getSamples() const +{ + return mInstance->getSamples(); +} + +unsigned int Renderbuffer::getSerial() const +{ + return mInstance->getSerial(); +} + +void Renderbuffer::setStorage(RenderbufferStorage *newStorage) +{ + ASSERT(newStorage != NULL); + + delete mInstance; + mInstance = newStorage; +} + +RenderbufferStorage::RenderbufferStorage() : mSerial(issueSerial()) +{ + mWidth = 0; + mHeight = 0; + mInternalFormat = GL_RGBA4; + mActualFormat = GL_RGBA8_OES; + mSamples = 0; +} + +RenderbufferStorage::~RenderbufferStorage() +{ +} + +rx::RenderTarget *RenderbufferStorage::getRenderTarget() +{ + return NULL; +} + +rx::RenderTarget *RenderbufferStorage::getDepthStencil() +{ + return NULL; +} + +GLsizei RenderbufferStorage::getWidth() const +{ + return mWidth; +} + +GLsizei RenderbufferStorage::getHeight() const +{ + return mHeight; +} + +GLenum RenderbufferStorage::getInternalFormat() const +{ + return mInternalFormat; +} + +GLenum RenderbufferStorage::getActualFormat() const +{ + return mActualFormat; +} + +GLsizei RenderbufferStorage::getSamples() const +{ + return mSamples; +} + +unsigned int RenderbufferStorage::getSerial() const +{ + return mSerial; +} + +unsigned int RenderbufferStorage::issueSerial() +{ + return mCurrentSerial++; +} + +unsigned int RenderbufferStorage::issueCubeSerials() +{ + unsigned int firstSerial = mCurrentSerial; + mCurrentSerial += 6; + return firstSerial; +} + +Colorbuffer::Colorbuffer(rx::Renderer *renderer, rx::SwapChain *swapChain) +{ + mRenderTarget = renderer->createRenderTarget(swapChain, false); + + if (mRenderTarget) + { + mWidth = mRenderTarget->getWidth(); + mHeight = mRenderTarget->getHeight(); + mInternalFormat = mRenderTarget->getInternalFormat(); + mActualFormat = mRenderTarget->getActualFormat(); + mSamples = mRenderTarget->getSamples(); + } +} + +Colorbuffer::Colorbuffer(rx::Renderer *renderer, int width, int height, GLenum format, GLsizei samples) : mRenderTarget(NULL) +{ + mRenderTarget = renderer->createRenderTarget(width, height, format, samples, false); + + if (mRenderTarget) + { + mWidth = width; + mHeight = height; + mInternalFormat = format; + mActualFormat = mRenderTarget->getActualFormat(); + mSamples = mRenderTarget->getSamples(); + } +} + +Colorbuffer::~Colorbuffer() +{ + if (mRenderTarget) + { + delete mRenderTarget; + } +} + +rx::RenderTarget *Colorbuffer::getRenderTarget() +{ + if (mRenderTarget) + { + return mRenderTarget; + } + + return NULL; +} + +DepthStencilbuffer::DepthStencilbuffer(rx::Renderer *renderer, rx::SwapChain *swapChain) +{ + mDepthStencil = renderer->createRenderTarget(swapChain, true); + if (mDepthStencil) + { + mWidth = mDepthStencil->getWidth(); + mHeight = mDepthStencil->getHeight(); + mInternalFormat = mDepthStencil->getInternalFormat(); + mSamples = mDepthStencil->getSamples(); + mActualFormat = mDepthStencil->getActualFormat(); + } +} + +DepthStencilbuffer::DepthStencilbuffer(rx::Renderer *renderer, int width, int height, GLsizei samples) +{ + + mDepthStencil = renderer->createRenderTarget(width, height, GL_DEPTH24_STENCIL8_OES, samples, true); + + mWidth = mDepthStencil->getWidth(); + mHeight = mDepthStencil->getHeight(); + mInternalFormat = GL_DEPTH24_STENCIL8_OES; + mActualFormat = mDepthStencil->getActualFormat(); + mSamples = mDepthStencil->getSamples(); +} + +DepthStencilbuffer::~DepthStencilbuffer() +{ + if (mDepthStencil) + { + delete mDepthStencil; + } +} + +rx::RenderTarget *DepthStencilbuffer::getDepthStencil() +{ + if (mDepthStencil) + { + return mDepthStencil; + } + + return NULL; +} + +Depthbuffer::Depthbuffer(rx::Renderer *renderer, int width, int height, GLsizei samples) : DepthStencilbuffer(renderer, width, height, samples) +{ + if (mDepthStencil) + { + mInternalFormat = GL_DEPTH_COMPONENT16; // If the renderbuffer parameters are queried, the calling function + // will expect one of the valid renderbuffer formats for use in + // glRenderbufferStorage + } +} + +Depthbuffer::~Depthbuffer() +{ +} + +Stencilbuffer::Stencilbuffer(rx::Renderer *renderer, int width, int height, GLsizei samples) : DepthStencilbuffer(renderer, width, height, samples) +{ + if (mDepthStencil) + { + mInternalFormat = GL_STENCIL_INDEX8; // If the renderbuffer parameters are queried, the calling function + // will expect one of the valid renderbuffer formats for use in + // glRenderbufferStorage + } +} + +Stencilbuffer::~Stencilbuffer() +{ +} + +}