/*
* Copyright (C) 2009 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#if ENABLE(WEBGL)
#include "WebGLFramebuffer.h"
#include "WebGLRenderingContext.h"
namespace WebCore {
namespace {
// This function is only for depth/stencil/depth_stencil attachment.
// Currently we assume these attachments are all renderbuffers.
GC3Denum getInternalFormat(WebGLObject* buffer)
{
ASSERT(buffer && buffer->isRenderbuffer());
return (reinterpret_cast<WebGLRenderbuffer*>(buffer))->getInternalFormat();
}
bool isUninitialized(WebGLObject* attachedObject)
{
if (attachedObject && attachedObject->object() && attachedObject->isRenderbuffer()
&& !(reinterpret_cast<WebGLRenderbuffer*>(attachedObject))->isInitialized())
return true;
return false;
}
void setInitialized(WebGLObject* attachedObject)
{
if (attachedObject && attachedObject->object() && attachedObject->isRenderbuffer())
(reinterpret_cast<WebGLRenderbuffer*>(attachedObject))->setInitialized();
}
bool isValid(WebGLObject* attachedObject)
{
if (attachedObject && attachedObject->object() && attachedObject->isRenderbuffer()) {
if (!(reinterpret_cast<WebGLRenderbuffer*>(attachedObject))->isValid())
return false;
}
return true;
}
} // anonymous namespace
PassRefPtr<WebGLFramebuffer> WebGLFramebuffer::create(WebGLRenderingContext* ctx)
{
return adoptRef(new WebGLFramebuffer(ctx));
}
WebGLFramebuffer::WebGLFramebuffer(WebGLRenderingContext* ctx)
: WebGLObject(ctx)
, m_hasEverBeenBound(false)
, m_texTarget(0)
, m_texLevel(-1)
{
setObject(context()->graphicsContext3D()->createFramebuffer());
}
void WebGLFramebuffer::setAttachment(GC3Denum attachment, GC3Denum texTarget, WebGLTexture* texture, GC3Dint level)
{
if (!object())
return;
if (texture && !texture->object())
texture = 0;
switch (attachment) {
case GraphicsContext3D::COLOR_ATTACHMENT0:
m_colorAttachment = texture;
if (texture) {
m_texTarget = texTarget;
m_texLevel = level;
}
break;
case GraphicsContext3D::DEPTH_ATTACHMENT:
m_depthAttachment = texture;
break;
case GraphicsContext3D::STENCIL_ATTACHMENT:
m_stencilAttachment = texture;
break;
case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:
m_depthStencilAttachment = texture;
break;
default:
return;
}
}
void WebGLFramebuffer::setAttachment(GC3Denum attachment, WebGLRenderbuffer* renderbuffer)
{
if (!object())
return;
if (renderbuffer && !renderbuffer->object())
renderbuffer = 0;
switch (attachment) {
case GraphicsContext3D::COLOR_ATTACHMENT0:
m_colorAttachment = renderbuffer;
break;
case GraphicsContext3D::DEPTH_ATTACHMENT:
m_depthAttachment = renderbuffer;
break;
case GraphicsContext3D::STENCIL_ATTACHMENT:
m_stencilAttachment = renderbuffer;
break;
case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:
m_depthStencilAttachment = renderbuffer;
break;
default:
return;
}
}
WebGLObject* WebGLFramebuffer::getAttachment(GC3Denum attachment) const
{
if (!object())
return 0;
switch (attachment) {
case GraphicsContext3D::COLOR_ATTACHMENT0:
return m_colorAttachment.get();
case GraphicsContext3D::DEPTH_ATTACHMENT:
return m_depthAttachment.get();
case GraphicsContext3D::STENCIL_ATTACHMENT:
return m_stencilAttachment.get();
case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:
return m_depthStencilAttachment.get();
default:
return 0;
}
}
void WebGLFramebuffer::removeAttachment(WebGLObject* attachment)
{
if (!object())
return;
if (attachment == m_colorAttachment.get())
m_colorAttachment = 0;
else if (attachment == m_depthAttachment.get())
m_depthAttachment = 0;
else if (attachment == m_stencilAttachment.get())
m_stencilAttachment = 0;
else if (attachment == m_depthStencilAttachment.get())
m_depthStencilAttachment = 0;
else
return;
}
GC3Dsizei WebGLFramebuffer::getWidth() const
{
if (!object() || !isColorAttached())
return 0;
if (m_colorAttachment->isRenderbuffer())
return (reinterpret_cast<WebGLRenderbuffer*>(m_colorAttachment.get()))->getWidth();
if (m_colorAttachment->isTexture())
return (reinterpret_cast<WebGLTexture*>(m_colorAttachment.get()))->getWidth(m_texTarget, m_texLevel);
ASSERT_NOT_REACHED();
return 0;
}
GC3Dsizei WebGLFramebuffer::getHeight() const
{
if (!object() || !isColorAttached())
return 0;
if (m_colorAttachment->isRenderbuffer())
return (reinterpret_cast<WebGLRenderbuffer*>(m_colorAttachment.get()))->getHeight();
if (m_colorAttachment->isTexture())
return (reinterpret_cast<WebGLTexture*>(m_colorAttachment.get()))->getHeight(m_texTarget, m_texLevel);
ASSERT_NOT_REACHED();
return 0;
}
GC3Denum WebGLFramebuffer::getColorBufferFormat() const
{
if (!object() || !isColorAttached())
return 0;
if (m_colorAttachment->isRenderbuffer()) {
unsigned long format = (reinterpret_cast<WebGLRenderbuffer*>(m_colorAttachment.get()))->getInternalFormat();
switch (format) {
case GraphicsContext3D::RGBA4:
case GraphicsContext3D::RGB5_A1:
return GraphicsContext3D::RGBA;
case GraphicsContext3D::RGB565:
return GraphicsContext3D::RGB;
}
return 0;
}
if (m_colorAttachment->isTexture())
return (reinterpret_cast<WebGLTexture*>(m_colorAttachment.get()))->getInternalFormat(m_texTarget, m_texLevel);
ASSERT_NOT_REACHED();
return 0;
}
bool WebGLFramebuffer::isIncomplete(bool checkInternalFormat) const
{
unsigned int count = 0;
if (isDepthAttached()) {
if (checkInternalFormat && getInternalFormat(m_depthAttachment.get()) != GraphicsContext3D::DEPTH_COMPONENT16)
return true;
count++;
}
if (isStencilAttached()) {
if (checkInternalFormat && getInternalFormat(m_stencilAttachment.get()) != GraphicsContext3D::STENCIL_INDEX8)
return true;
count++;
}
if (isDepthStencilAttached()) {
if (checkInternalFormat && getInternalFormat(m_depthStencilAttachment.get()) != GraphicsContext3D::DEPTH_STENCIL)
return true;
if (!isValid(m_depthStencilAttachment.get()))
return true;
count++;
}
if (count > 1)
return true;
return false;
}
bool WebGLFramebuffer::onAccess(bool needToInitializeRenderbuffers)
{
if (isIncomplete(true))
return false;
if (needToInitializeRenderbuffers)
return initializeRenderbuffers();
return true;
}
void WebGLFramebuffer::deleteObjectImpl(Platform3DObject object)
{
context()->graphicsContext3D()->deleteFramebuffer(object);
m_colorAttachment = 0;
m_depthAttachment = 0;
m_stencilAttachment = 0;
m_depthStencilAttachment = 0;
}
bool WebGLFramebuffer::initializeRenderbuffers()
{
ASSERT(object());
bool initColor = false, initDepth = false, initStencil = false;
GC3Dbitfield mask = 0;
if (isUninitialized(m_colorAttachment.get())) {
initColor = true;
mask |= GraphicsContext3D::COLOR_BUFFER_BIT;
}
if (isUninitialized(m_depthAttachment.get())) {
initDepth = true;
mask |= GraphicsContext3D::DEPTH_BUFFER_BIT;
}
if (isUninitialized(m_stencilAttachment.get())) {
initStencil = true;
mask |= GraphicsContext3D::STENCIL_BUFFER_BIT;
}
if (isUninitialized(m_depthStencilAttachment.get())) {
initDepth = true;
initStencil = true;
mask |= (GraphicsContext3D::DEPTH_BUFFER_BIT | GraphicsContext3D::STENCIL_BUFFER_BIT);
}
if (!initColor && !initDepth && !initStencil)
return true;
// We only clear un-initialized renderbuffers when they are ready to be
// read, i.e., when the framebuffer is complete.
GraphicsContext3D* g3d = context()->graphicsContext3D();
if (g3d->checkFramebufferStatus(GraphicsContext3D::FRAMEBUFFER) != GraphicsContext3D::FRAMEBUFFER_COMPLETE)
return false;
GC3Dfloat colorClearValue[] = {0, 0, 0, 0}, depthClearValue = 0;
GC3Dint stencilClearValue = 0;
GC3Dboolean colorMask[] = {0, 0, 0, 0}, depthMask = 0;
GC3Duint stencilMask = 0xffffffff;
GC3Dboolean isScissorEnabled = 0;
GC3Dboolean isDitherEnabled = 0;
if (initColor) {
g3d->getFloatv(GraphicsContext3D::COLOR_CLEAR_VALUE, colorClearValue);
g3d->getBooleanv(GraphicsContext3D::COLOR_WRITEMASK, colorMask);
g3d->clearColor(0, 0, 0, 0);
g3d->colorMask(true, true, true, true);
}
if (initDepth) {
g3d->getFloatv(GraphicsContext3D::DEPTH_CLEAR_VALUE, &depthClearValue);
g3d->getBooleanv(GraphicsContext3D::DEPTH_WRITEMASK, &depthMask);
g3d->clearDepth(0);
g3d->depthMask(true);
}
if (initStencil) {
g3d->getIntegerv(GraphicsContext3D::STENCIL_CLEAR_VALUE, &stencilClearValue);
g3d->getIntegerv(GraphicsContext3D::STENCIL_WRITEMASK, reinterpret_cast<GC3Dint*>(&stencilMask));
g3d->clearStencil(0);
g3d->stencilMask(0xffffffff);
}
isScissorEnabled = g3d->isEnabled(GraphicsContext3D::SCISSOR_TEST);
g3d->disable(GraphicsContext3D::SCISSOR_TEST);
isDitherEnabled = g3d->isEnabled(GraphicsContext3D::DITHER);
g3d->disable(GraphicsContext3D::DITHER);
g3d->clear(mask);
if (initColor) {
g3d->clearColor(colorClearValue[0], colorClearValue[1], colorClearValue[2], colorClearValue[3]);
g3d->colorMask(colorMask[0], colorMask[1], colorMask[2], colorMask[3]);
}
if (initDepth) {
g3d->clearDepth(depthClearValue);
g3d->depthMask(depthMask);
}
if (initStencil) {
g3d->clearStencil(stencilClearValue);
g3d->stencilMask(stencilMask);
}
if (isScissorEnabled)
g3d->enable(GraphicsContext3D::SCISSOR_TEST);
else
g3d->disable(GraphicsContext3D::SCISSOR_TEST);
if (isDitherEnabled)
g3d->enable(GraphicsContext3D::DITHER);
else
g3d->disable(GraphicsContext3D::DITHER);
if (initColor)
setInitialized(m_colorAttachment.get());
if (initDepth && initStencil && m_depthStencilAttachment)
setInitialized(m_depthStencilAttachment.get());
else {
if (initDepth)
setInitialized(m_depthAttachment.get());
if (initStencil)
setInitialized(m_stencilAttachment.get());
}
return true;
}
}
#endif // ENABLE(WEBGL)