WebGLFramebuffer.cpp   [plain text]

/*
 * 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(3D_CANVAS)

#include "WebGLFramebuffer.h"
#include "WebGLRenderingContext.h"

namespace WebCore {
    
PassRefPtr<WebGLFramebuffer> WebGLFramebuffer::create(WebGLRenderingContext* ctx)
{
    return adoptRef(new WebGLFramebuffer(ctx));
}

WebGLFramebuffer::WebGLFramebuffer(WebGLRenderingContext* ctx)
    : CanvasObject(ctx)
    , m_colorAttachment(0)
    , m_depthAttachment(0)
    , m_stencilAttachment(0)
    , m_depthStencilAttachment(0)
{
    setObject(context()->graphicsContext3D()->createFramebuffer());
}

void WebGLFramebuffer::setAttachment(unsigned long attachment, CanvasObject* attachedObject)
{
    if (!object())
        return;
    if (attachedObject && !attachedObject->object())
        attachedObject = 0;
    switch (attachment) {
    case GraphicsContext3D::COLOR_ATTACHMENT0:
        m_colorAttachment = attachedObject;
        break;
    case GraphicsContext3D::DEPTH_ATTACHMENT:
        m_depthAttachment = attachedObject;
        break;
    case GraphicsContext3D::STENCIL_ATTACHMENT:
        m_stencilAttachment = attachedObject;
        break;
    case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:
        m_depthStencilAttachment = attachedObject;
        break;
    default:
        return;
    }
    initializeRenderbuffers();
}

void WebGLFramebuffer::onBind()
{
    initializeRenderbuffers();
}

void WebGLFramebuffer::onAttachedObjectChange(CanvasObject* object)
{
    // Currently object == 0 is not considered, but this might change if the
    // lifespan of CanvasObject changes.
    if (object
        && (object == m_colorAttachment || object == m_depthAttachment
            || object == m_stencilAttachment || object == m_depthStencilAttachment))
        initializeRenderbuffers();
}

unsigned long WebGLFramebuffer::getColorBufferFormat()
{
    if (object() && m_colorAttachment && m_colorAttachment->object()) {
        if (m_colorAttachment->isRenderbuffer()) {
            unsigned long format = (reinterpret_cast<WebGLRenderbuffer*>(m_colorAttachment))->getInternalFormat();
            switch (format) {
            case GraphicsContext3D::RGBA4:
            case GraphicsContext3D::RGB5_A1:
                return GraphicsContext3D::RGBA;
            case GraphicsContext3D::RGB565:
                return GraphicsContext3D::RGB;
            }
        } else if (m_colorAttachment->isTexture())
            return (reinterpret_cast<WebGLTexture*>(m_colorAttachment))->getInternalFormat();
    }
    return 0;
}

void WebGLFramebuffer::_deleteObject(Platform3DObject object)
{
    context()->graphicsContext3D()->deleteFramebuffer(object);
}

bool WebGLFramebuffer::isUninitialized(CanvasObject* attachedObject)
{
    if (attachedObject && attachedObject->object() && attachedObject->isRenderbuffer()
        && !(reinterpret_cast<WebGLRenderbuffer*>(attachedObject))->isInitialized())
        return true;
    return false;
}

void WebGLFramebuffer::setInitialized(CanvasObject* attachedObject)
{
    if (attachedObject && attachedObject->object() && attachedObject->isRenderbuffer())
        (reinterpret_cast<WebGLRenderbuffer*>(attachedObject))->setInitialized();
}

void WebGLFramebuffer::initializeRenderbuffers()
{
    if (!object())
        return;
    bool initColor = false, initDepth = false, initStencil = false;
    unsigned long mask = 0;
    if (isUninitialized(m_colorAttachment)) {
        initColor = true;
        mask |= GraphicsContext3D::COLOR_BUFFER_BIT;
    }
    if (isUninitialized(m_depthAttachment)) {
        initDepth = true;
        mask |= GraphicsContext3D::DEPTH_BUFFER_BIT;
    }
    if (isUninitialized(m_stencilAttachment)) {
        initStencil = true;
        mask |= GraphicsContext3D::STENCIL_BUFFER_BIT;
    }
    if (isUninitialized(m_depthStencilAttachment)) {
        initDepth = true;
        initStencil = true;
        mask |= (GraphicsContext3D::DEPTH_BUFFER_BIT | GraphicsContext3D::STENCIL_BUFFER_BIT);
    }
    if (!initColor && !initDepth && !initStencil)
        return;

    // 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;

    float colorClearValue[] = {0, 0, 0, 0}, depthClearValue = 0;
    int stencilClearValue = 0;
    unsigned char colorMask[] = {1, 1, 1, 1}, depthMask = 1;
    unsigned int stencilMask = 0xffffffff;
    bool isScissorEnabled = false;
    bool isDitherEnabled = false;
    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<int*>(&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);
    if (initDepth && initStencil && m_depthStencilAttachment)
        setInitialized(m_depthStencilAttachment);
    else {
        if (initDepth)
            setInitialized(m_depthAttachment);
        if (initStencil)
            setInitialized(m_stencilAttachment);
    }
}

}

#endif // ENABLE(3D_CANVAS)