path: root/dom/canvas/WebGLFramebuffer.cpp

/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "WebGLFramebuffer.h"

// You know it's going to be fun when these two show up:
#include <algorithm>
#include <iterator>

#include "GLContext.h"
#include "GLScreenBuffer.h"
#include "mozilla/dom/WebGLRenderingContextBinding.h"
#include "nsPrintfCString.h"
#include "WebGLContext.h"
#include "WebGLContextUtils.h"
#include "WebGLExtensions.h"
#include "WebGLRenderbuffer.h"
#include "WebGLShader.h"
#include "WebGLTexture.h"
#include "WebGLObjectModel.h"

namespace mozilla {

WebGLFBAttachPoint::WebGLFBAttachPoint()
    : mFB(nullptr)
    , mAttachmentPoint(0)
    , mTexImageTarget(LOCAL_GL_NONE)
    , mTexImageLayer(0)
    , mTexImageLevel(0)
{ }

WebGLFBAttachPoint::WebGLFBAttachPoint(WebGLFramebuffer* fb, GLenum attachmentPoint)
    : mFB(fb)
    , mAttachmentPoint(attachmentPoint)
    , mTexImageTarget(LOCAL_GL_NONE)
    , mTexImageLayer(0)
    , mTexImageLevel(0)
{ }

WebGLFBAttachPoint::~WebGLFBAttachPoint()
{
    MOZ_ASSERT(mFB, "Should have been Init'd.");
    MOZ_ASSERT(!mRenderbufferPtr);
    MOZ_ASSERT(!mTexturePtr);
}

void
WebGLFBAttachPoint::Unlink()
{
    Clear();
}

bool
WebGLFBAttachPoint::IsDeleteRequested() const
{
    return Texture() ? Texture()->IsDeleteRequested()
         : Renderbuffer() ? Renderbuffer()->IsDeleteRequested()
         : false;
}

bool
WebGLFBAttachPoint::IsDefined() const
{
    /*
    return (Renderbuffer() && Renderbuffer()->IsDefined()) ||
           (Texture() && Texture()->ImageInfoAt(mTexImageTarget,
                                                mTexImageLevel).IsDefined());
    */
    return (Renderbuffer() || Texture());
}

const webgl::FormatUsageInfo*
WebGLFBAttachPoint::Format() const
{
    MOZ_ASSERT(IsDefined());

    if (Texture())
        return Texture()->ImageInfoAt(mTexImageTarget, mTexImageLevel).mFormat;

    if (Renderbuffer())
        return Renderbuffer()->Format();

    return nullptr;
}

uint32_t
WebGLFBAttachPoint::Samples() const
{
    MOZ_ASSERT(IsDefined());

    if (mRenderbufferPtr)
        return mRenderbufferPtr->Samples();

    return 0;
}

bool
WebGLFBAttachPoint::HasAlpha() const
{
    return Format()->format->a;
}

bool
WebGLFBAttachPoint::IsReadableFloat() const
{
    auto formatUsage = Format();
    MOZ_ASSERT(formatUsage);

    auto format = formatUsage->format;
    if (!format->IsColorFormat())
        return false;

    return format->componentType == webgl::ComponentType::Float;
}

void
WebGLFBAttachPoint::Clear()
{
    if (mRenderbufferPtr) {
        MOZ_ASSERT(!mTexturePtr);
        mRenderbufferPtr->UnmarkAttachment(*this);
    } else if (mTexturePtr) {
        mTexturePtr->ImageInfoAt(mTexImageTarget, mTexImageLevel).RemoveAttachPoint(this);
    }

    mTexturePtr = nullptr;
    mRenderbufferPtr = nullptr;

    OnBackingStoreRespecified();
}

void
WebGLFBAttachPoint::SetTexImage(WebGLTexture* tex, TexImageTarget target, GLint level,
                                GLint layer)
{
    Clear();

    mTexturePtr = tex;
    mTexImageTarget = target;
    mTexImageLevel = level;
    mTexImageLayer = layer;

    if (mTexturePtr) {
        mTexturePtr->ImageInfoAt(mTexImageTarget, mTexImageLevel).AddAttachPoint(this);
    }
}

void
WebGLFBAttachPoint::SetRenderbuffer(WebGLRenderbuffer* rb)
{
    Clear();

    mRenderbufferPtr = rb;

    if (mRenderbufferPtr) {
        mRenderbufferPtr->MarkAttachment(*this);
    }
}

bool
WebGLFBAttachPoint::HasUninitializedImageData() const
{
    if (!HasImage())
        return false;

    if (mRenderbufferPtr)
        return mRenderbufferPtr->HasUninitializedImageData();

    MOZ_ASSERT(mTexturePtr);

    auto& imageInfo = mTexturePtr->ImageInfoAt(mTexImageTarget, mTexImageLevel);
    MOZ_ASSERT(imageInfo.IsDefined());

    return !imageInfo.IsDataInitialized();
}

void
WebGLFBAttachPoint::SetImageDataStatus(WebGLImageDataStatus newStatus) const
{
    if (!HasImage())
        return;

    if (mRenderbufferPtr) {
        mRenderbufferPtr->mImageDataStatus = newStatus;
        return;
    }

    MOZ_ASSERT(mTexturePtr);

    auto& imageInfo = mTexturePtr->ImageInfoAt(mTexImageTarget, mTexImageLevel);
    MOZ_ASSERT(imageInfo.IsDefined());

    const bool isDataInitialized = (newStatus == WebGLImageDataStatus::InitializedImageData);
    imageInfo.SetIsDataInitialized(isDataInitialized, mTexturePtr);
}

bool
WebGLFBAttachPoint::HasImage() const
{
    if (Texture() && Texture()->ImageInfoAt(mTexImageTarget, mTexImageLevel).IsDefined())
        return true;

    if (Renderbuffer() && Renderbuffer()->IsDefined())
        return true;

    return false;
}

void
WebGLFBAttachPoint::Size(uint32_t* const out_width, uint32_t* const out_height) const
{
    MOZ_ASSERT(HasImage());

    if (Renderbuffer()) {
        *out_width = Renderbuffer()->Width();
        *out_height = Renderbuffer()->Height();
        return;
    }

    MOZ_ASSERT(Texture());
    MOZ_ASSERT(Texture()->ImageInfoAt(mTexImageTarget, mTexImageLevel).IsDefined());
    const auto& imageInfo = Texture()->ImageInfoAt(mTexImageTarget, mTexImageLevel);

    *out_width = imageInfo.mWidth;
    *out_height = imageInfo.mHeight;
}

void
WebGLFBAttachPoint::OnBackingStoreRespecified() const
{
    mFB->InvalidateFramebufferStatus();
}

void
WebGLFBAttachPoint::AttachmentName(nsCString* out) const
{
    switch (mAttachmentPoint) {
    case LOCAL_GL_DEPTH_ATTACHMENT:
        out->AssignLiteral("DEPTH_ATTACHMENT");
        return;

    case LOCAL_GL_STENCIL_ATTACHMENT:
        out->AssignLiteral("STENCIL_ATTACHMENT");
        return;

    case LOCAL_GL_DEPTH_STENCIL_ATTACHMENT:
        out->AssignLiteral("DEPTH_STENCIL_ATTACHMENT");
        return;

    default:
        MOZ_ASSERT(mAttachmentPoint >= LOCAL_GL_COLOR_ATTACHMENT0);
        out->AssignLiteral("COLOR_ATTACHMENT");
        const uint32_t n = mAttachmentPoint - LOCAL_GL_COLOR_ATTACHMENT0;
        out->AppendInt(n);
        return;
    }
}

bool
WebGLFBAttachPoint::IsComplete(WebGLContext* webgl, nsCString* const out_info) const
{
    MOZ_ASSERT(IsDefined());

    if (!HasImage()) {
        AttachmentName(out_info);
        out_info->AppendLiteral("'s image is not defined");
        return false;
    }

    uint32_t width;
    uint32_t height;
    Size(&width, &height);
    if (!width || !height) {
        AttachmentName(out_info);
        out_info->AppendLiteral(" has no width or height");
        return false;
    }

    const auto formatUsage = Format();
    if (!formatUsage->IsRenderable()) {
        nsAutoCString attachName;
        AttachmentName(&attachName);

        *out_info = nsPrintfCString("%s has an effective format of %s, which is not"
                                    " renderable",
                                    attachName.BeginReading(), formatUsage->format->name);
        return false;
    }

    if (webgl->IsWebGL2() && Texture() &&
        Texture()->IsCubeMap() && !Texture()->IsCubeComplete())
    {
        AttachmentName(out_info);
        out_info->AppendLiteral(" is not cube complete");
        return false;
    }

    const auto format = formatUsage->format;

    bool hasRequiredBits;

    switch (mAttachmentPoint) {
    case LOCAL_GL_DEPTH_ATTACHMENT:
        hasRequiredBits = format->d;
        break;

    case LOCAL_GL_STENCIL_ATTACHMENT:
        hasRequiredBits = format->s;
        break;

    case LOCAL_GL_DEPTH_STENCIL_ATTACHMENT:
        MOZ_ASSERT(!webgl->IsWebGL2());
        hasRequiredBits = (format->d && format->s);
        break;

    default:
        MOZ_ASSERT(mAttachmentPoint >= LOCAL_GL_COLOR_ATTACHMENT0);
        hasRequiredBits = format->IsColorFormat();
        break;
    }

    if (!hasRequiredBits) {
        AttachmentName(out_info);
        out_info->AppendLiteral("'s format is missing required color/depth/stencil bits");
        return false;
    }

    if (!webgl->IsWebGL2()) {
        bool hasSurplusPlanes = false;

        switch (mAttachmentPoint) {
        case LOCAL_GL_DEPTH_ATTACHMENT:
            hasSurplusPlanes = format->s;
            break;

        case LOCAL_GL_STENCIL_ATTACHMENT:
            hasSurplusPlanes = format->d;
            break;
        }

        if (hasSurplusPlanes) {
            AttachmentName(out_info);
            out_info->AppendLiteral("'s format has depth or stencil bits when it"
                                    " shouldn't");
            return false;
        }
    }

    return true;
}

void
WebGLFBAttachPoint::Resolve(gl::GLContext* gl) const
{
    if (!HasImage())
        return;

    if (Renderbuffer()) {
        Renderbuffer()->DoFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER, mAttachmentPoint);
        return;
    }
    MOZ_ASSERT(Texture());

    MOZ_ASSERT(gl == Texture()->mContext->GL());

    const auto& texName = Texture()->mGLName;

    ////

    const auto fnAttach2D = [&](GLenum attachmentPoint) {
        gl->fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER, attachmentPoint,
                                  mTexImageTarget.get(), texName, mTexImageLevel);
    };

    ////

    switch (mTexImageTarget.get()) {
    case LOCAL_GL_TEXTURE_2D:
    case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X:
    case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
    case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
    case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
    case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
    case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
        if (mAttachmentPoint == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
            fnAttach2D(LOCAL_GL_DEPTH_ATTACHMENT);
            fnAttach2D(LOCAL_GL_STENCIL_ATTACHMENT);
        } else {
            fnAttach2D(mAttachmentPoint);
        }
        break;

    case LOCAL_GL_TEXTURE_2D_ARRAY:
    case LOCAL_GL_TEXTURE_3D:
        // If we have fFramebufferTextureLayer, we can rely on having
        // DEPTH_STENCIL_ATTACHMENT.
        gl->fFramebufferTextureLayer(LOCAL_GL_FRAMEBUFFER, mAttachmentPoint, texName,
                                     mTexImageLevel, mTexImageLayer);
        break;
    }
}

JS::Value
WebGLFBAttachPoint::GetParameter(const char* funcName, WebGLContext* webgl, JSContext* cx,
                                 GLenum target, GLenum attachment, GLenum pname,
                                 ErrorResult* const out_error) const
{
    const bool hasAttachment = (mTexturePtr || mRenderbufferPtr);
    if (!hasAttachment) {
        // Divergent between GLES 3 and 2.

        // GLES 2.0.25 p127:
        // "If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is NONE, then querying any
        //  other pname will generate INVALID_ENUM."

        // GLES 3.0.4 p240:
        // "If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is NONE, no framebuffer is
        //  bound to target. In this case querying pname
        //  FRAMEBUFFER_ATTACHMENT_OBJECT_NAME will return zero, and all other queries
        //  will generate an INVALID_OPERATION error."
        switch (pname) {
        case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
            return JS::Int32Value(LOCAL_GL_NONE);

        case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
            if (webgl->IsWebGL2())
                return JS::NullValue();

            break;

        default:
            break;
        }
        nsCString attachmentName;
        WebGLContext::EnumName(attachment, &attachmentName);
        if (webgl->IsWebGL2()) {
            webgl->ErrorInvalidOperation("%s: No attachment at %s.", funcName,
                                         attachmentName.BeginReading());
        } else {
            webgl->ErrorInvalidEnum("%s: No attachment at %s.", funcName,
                                    attachmentName.BeginReading());
        }
        return JS::NullValue();
    }

    bool isPNameValid = false;
    switch (pname) {
    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
        return JS::Int32Value(mTexturePtr ? LOCAL_GL_TEXTURE
                                          : LOCAL_GL_RENDERBUFFER);

    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
        return (mTexturePtr ? webgl->WebGLObjectAsJSValue(cx, mTexturePtr.get(),
                                                          *out_error)
                            : webgl->WebGLObjectAsJSValue(cx, mRenderbufferPtr.get(),
                                                          *out_error));

        //////

    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
        if (mTexturePtr)
            return JS::Int32Value(MipLevel());
        break;

    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
        if (mTexturePtr) {
            GLenum face = 0;
            if (mTexturePtr->Target() == LOCAL_GL_TEXTURE_CUBE_MAP) {
                face = ImageTarget().get();
            }
            return JS::Int32Value(face);
        }
        break;

        //////

    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
        if (webgl->IsWebGL2() && mTexturePtr) {
            int32_t layer = 0;
            if (ImageTarget() == LOCAL_GL_TEXTURE_2D_ARRAY ||
                ImageTarget() == LOCAL_GL_TEXTURE_3D)
            {
                layer = Layer();
            }
            return JS::Int32Value(layer);
        }
        break;

        //////

    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
        isPNameValid = webgl->IsWebGL2();
        break;

    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
        isPNameValid = (webgl->IsWebGL2() ||
                        webgl->IsExtensionEnabled(WebGLExtensionID::EXT_sRGB));
        break;
    }

    if (!isPNameValid) {
        webgl->ErrorInvalidEnum("%s: Invalid pname: 0x%04x", funcName, pname);
        return JS::NullValue();
    }

    const auto usage = Format();
    if (!usage) {
        if (pname == LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)
            return JS::NumberValue(LOCAL_GL_LINEAR);

        return JS::NullValue();
    }

    auto format = usage->format;

    GLint ret = 0;
    switch (pname) {
    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
        ret = format->r;
        break;
    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
        ret = format->g;
        break;
    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
        ret = format->b;
        break;
    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
        ret = format->a;
        break;
    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
        ret = format->d;
        break;
    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
        ret = format->s;
        break;

    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
        ret = (format->isSRGB ? LOCAL_GL_SRGB
                              : LOCAL_GL_LINEAR);
        break;

    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
        MOZ_ASSERT(attachment != LOCAL_GL_DEPTH_STENCIL_ATTACHMENT);

        if (format->componentType == webgl::ComponentType::Special) {
            // Special format is used for DS mixed format(e.g. D24S8 and D32FS8).
            MOZ_ASSERT(format->unsizedFormat == webgl::UnsizedFormat::DEPTH_STENCIL);
            MOZ_ASSERT(attachment == LOCAL_GL_DEPTH_ATTACHMENT ||
                       attachment == LOCAL_GL_STENCIL_ATTACHMENT);

            if (attachment == LOCAL_GL_DEPTH_ATTACHMENT) {
                switch (format->effectiveFormat) {
                case webgl::EffectiveFormat::DEPTH24_STENCIL8:
                    format = webgl::GetFormat(webgl::EffectiveFormat::DEPTH_COMPONENT24);
                    break;
                case webgl::EffectiveFormat::DEPTH32F_STENCIL8:
                    format = webgl::GetFormat(webgl::EffectiveFormat::DEPTH_COMPONENT32F);
                    break;
                default:
                    MOZ_ASSERT(false, "no matched DS format");
                    break;
                }
            } else if (attachment == LOCAL_GL_STENCIL_ATTACHMENT) {
                switch (format->effectiveFormat) {
                case webgl::EffectiveFormat::DEPTH24_STENCIL8:
                case webgl::EffectiveFormat::DEPTH32F_STENCIL8:
                    format = webgl::GetFormat(webgl::EffectiveFormat::STENCIL_INDEX8);
                    break;
                default:
                    MOZ_ASSERT(false, "no matched DS format");
                    break;
                }
            }
        }

        switch (format->componentType) {
        case webgl::ComponentType::None:
            ret = LOCAL_GL_NONE;
            break;
        case webgl::ComponentType::Int:
            ret = LOCAL_GL_INT;
            break;
        case webgl::ComponentType::UInt:
            ret = LOCAL_GL_UNSIGNED_INT;
            break;
        case webgl::ComponentType::NormInt:
            ret = LOCAL_GL_SIGNED_NORMALIZED;
            break;
        case webgl::ComponentType::NormUInt:
            ret = LOCAL_GL_UNSIGNED_NORMALIZED;
            break;
        case webgl::ComponentType::Float:
            ret = LOCAL_GL_FLOAT;
            break;
        default:
            MOZ_ASSERT(false, "No matched component type");
            break;
        }
        break;

    default:
        MOZ_ASSERT(false, "Missing case.");
        break;
    }

    return JS::Int32Value(ret);
}

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// WebGLFramebuffer

WebGLFramebuffer::WebGLFramebuffer(WebGLContext* webgl, GLuint fbo)
    : WebGLRefCountedObject(webgl)
    , mGLName(fbo)
    , mDepthAttachment(this, LOCAL_GL_DEPTH_ATTACHMENT)
    , mStencilAttachment(this, LOCAL_GL_STENCIL_ATTACHMENT)
    , mDepthStencilAttachment(this, LOCAL_GL_DEPTH_STENCIL_ATTACHMENT)
{
    mContext->mFramebuffers.insertBack(this);

    size_t i = 0;
    for (auto& cur : mColorAttachments) {
        new (&cur) WebGLFBAttachPoint(this, LOCAL_GL_COLOR_ATTACHMENT0 + i);
        i++;
    }

    mColorDrawBuffers.push_back(&mColorAttachments[0]);
    mColorReadBuffer = &mColorAttachments[0];
}

void
WebGLFramebuffer::Delete()
{
    InvalidateFramebufferStatus();

    mDepthAttachment.Clear();
    mStencilAttachment.Clear();
    mDepthStencilAttachment.Clear();

    for (auto& cur : mColorAttachments) {
        cur.Clear();
    }

    mContext->MakeContextCurrent();
    mContext->gl->fDeleteFramebuffers(1, &mGLName);

    LinkedListElement<WebGLFramebuffer>::removeFrom(mContext->mFramebuffers);
}

////

Maybe<WebGLFBAttachPoint*>
WebGLFramebuffer::GetColorAttachPoint(GLenum attachPoint)
{
    if (attachPoint == LOCAL_GL_NONE)
        return Some<WebGLFBAttachPoint*>(nullptr);

    if (attachPoint < LOCAL_GL_COLOR_ATTACHMENT0)
        return Nothing();

    const size_t colorId = attachPoint - LOCAL_GL_COLOR_ATTACHMENT0;

    MOZ_ASSERT(mContext->mImplMaxColorAttachments <= kMaxColorAttachments);
    if (colorId >= mContext->mImplMaxColorAttachments)
        return Nothing();

    return Some(&mColorAttachments[colorId]);
}

Maybe<WebGLFBAttachPoint*>
WebGLFramebuffer::GetAttachPoint(GLenum attachPoint)
{
    switch (attachPoint) {
    case LOCAL_GL_DEPTH_STENCIL_ATTACHMENT:
        return Some(&mDepthStencilAttachment);

    case LOCAL_GL_DEPTH_ATTACHMENT:
        return Some(&mDepthAttachment);

    case LOCAL_GL_STENCIL_ATTACHMENT:
        return Some(&mStencilAttachment);

    default:
        return GetColorAttachPoint(attachPoint);
    }
}

#define FOR_EACH_ATTACHMENT(X)            \
    X(mDepthAttachment);                  \
    X(mStencilAttachment);                \
    X(mDepthStencilAttachment);           \
                                          \
    for (auto& cur : mColorAttachments) { \
        X(cur);                           \
    }

void
WebGLFramebuffer::DetachTexture(const WebGLTexture* tex)
{
    const auto fnDetach = [&](WebGLFBAttachPoint& attach) {
        if (attach.Texture() == tex) {
            attach.Clear();
        }
    };

    FOR_EACH_ATTACHMENT(fnDetach)
}

void
WebGLFramebuffer::DetachRenderbuffer(const WebGLRenderbuffer* rb)
{
    const auto fnDetach = [&](WebGLFBAttachPoint& attach) {
        if (attach.Renderbuffer() == rb) {
            attach.Clear();
        }
    };

    FOR_EACH_ATTACHMENT(fnDetach)
}

////////////////////////////////////////////////////////////////////////////////
// Completeness

bool
WebGLFramebuffer::HasDefinedAttachments() const
{
    bool hasAttachments = false;
    const auto func = [&](const WebGLFBAttachPoint& attach) {
        hasAttachments |= attach.IsDefined();
    };

    FOR_EACH_ATTACHMENT(func)
    return hasAttachments;
}

bool
WebGLFramebuffer::HasIncompleteAttachments(nsCString* const out_info) const
{
    bool hasIncomplete = false;
    const auto func = [&](const WebGLFBAttachPoint& cur) {
        if (!cur.IsDefined())
            return; // Not defined, so can't count as incomplete.

        hasIncomplete |= !cur.IsComplete(mContext, out_info);
    };

    FOR_EACH_ATTACHMENT(func)
    return hasIncomplete;
}

bool
WebGLFramebuffer::AllImageRectsMatch() const
{
    MOZ_ASSERT(HasDefinedAttachments());
    DebugOnly<nsCString> fbStatusInfo;
    MOZ_ASSERT(!HasIncompleteAttachments(&fbStatusInfo));

    bool needsInit = true;
    uint32_t width = 0;
    uint32_t height = 0;

    bool hasMismatch = false;
    const auto func = [&](const WebGLFBAttachPoint& attach) {
        if (!attach.HasImage())
            return;

        uint32_t curWidth;
        uint32_t curHeight;
        attach.Size(&curWidth, &curHeight);

        if (needsInit) {
            needsInit = false;
            width = curWidth;
            height = curHeight;
            return;
        }

        hasMismatch |= (curWidth != width ||
                        curHeight != height);
    };

    FOR_EACH_ATTACHMENT(func)
    return !hasMismatch;
}

bool
WebGLFramebuffer::AllImageSamplesMatch() const
{
    MOZ_ASSERT(HasDefinedAttachments());
    DebugOnly<nsCString> fbStatusInfo;
    MOZ_ASSERT(!HasIncompleteAttachments(&fbStatusInfo));

    bool needsInit = true;
    uint32_t samples = 0;

    bool hasMismatch = false;
    const auto func = [&](const WebGLFBAttachPoint& attach) {
        if (!attach.HasImage())
          return;

        const uint32_t curSamples = attach.Samples();

        if (needsInit) {
            needsInit = false;
            samples = curSamples;
            return;
        }

        hasMismatch |= (curSamples != samples);
    };

    FOR_EACH_ATTACHMENT(func)
    return !hasMismatch;
}

#undef FOR_EACH_ATTACHMENT

FBStatus
WebGLFramebuffer::PrecheckFramebufferStatus(nsCString* const out_info) const
{
    MOZ_ASSERT(mContext->mBoundDrawFramebuffer == this ||
               mContext->mBoundReadFramebuffer == this);

    if (!HasDefinedAttachments())
        return LOCAL_GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT; // No attachments

    if (HasIncompleteAttachments(out_info))
        return LOCAL_GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;

    if (!AllImageRectsMatch())
        return LOCAL_GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS; // Inconsistent sizes

    if (!AllImageSamplesMatch())
        return LOCAL_GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE; // Inconsistent samples

    if (mContext->IsWebGL2()) {
        MOZ_ASSERT(!mDepthStencilAttachment.IsDefined());
    } else {
        const auto depthOrStencilCount = int(mDepthAttachment.IsDefined()) +
                                         int(mStencilAttachment.IsDefined()) +
                                         int(mDepthStencilAttachment.IsDefined());
        if (depthOrStencilCount > 1)
            return LOCAL_GL_FRAMEBUFFER_UNSUPPORTED;
    }

    return LOCAL_GL_FRAMEBUFFER_COMPLETE;
}

////////////////////////////////////////
// Validation

bool
WebGLFramebuffer::ValidateAndInitAttachments(const char* funcName)
{
    MOZ_ASSERT(mContext->mBoundDrawFramebuffer == this ||
               mContext->mBoundReadFramebuffer == this);

    const auto fbStatus = CheckFramebufferStatus(funcName);
    if (fbStatus == LOCAL_GL_FRAMEBUFFER_COMPLETE)
        return true;

    mContext->ErrorInvalidFramebufferOperation("%s: Framebuffer must be"
                                               " complete.",
                                               funcName);
    return false;
}

bool
WebGLFramebuffer::ValidateClearBufferType(const char* funcName, GLenum buffer,
                                          uint32_t drawBuffer, GLenum funcType) const
{
    if (buffer != LOCAL_GL_COLOR)
        return true;

    const auto& attach = mColorAttachments[drawBuffer];
    if (!attach.IsDefined())
        return true;

    if (!count(mColorDrawBuffers.begin(), mColorDrawBuffers.end(), &attach))
        return true; // DRAW_BUFFERi set to NONE.

    GLenum attachType;
    switch (attach.Format()->format->componentType) {
    case webgl::ComponentType::Int:
        attachType = LOCAL_GL_INT;
        break;
    case webgl::ComponentType::UInt:
        attachType = LOCAL_GL_UNSIGNED_INT;
        break;
    default:
        attachType = LOCAL_GL_FLOAT;
        break;
    }

    if (attachType != funcType) {
        mContext->ErrorInvalidOperation("%s: This attachment is of type 0x%04x, but"
                                        " this function is of type 0x%04x.",
                                        funcName, attachType, funcType);
        return false;
    }

    return true;
}

bool
WebGLFramebuffer::ValidateForRead(const char* funcName,
                                  const webgl::FormatUsageInfo** const out_format,
                                  uint32_t* const out_width, uint32_t* const out_height)
{
    if (!ValidateAndInitAttachments(funcName))
        return false;

    if (!mColorReadBuffer) {
        mContext->ErrorInvalidOperation("%s: READ_BUFFER must not be NONE.", funcName);
        return false;
    }

    if (!mColorReadBuffer->IsDefined()) {
        mContext->ErrorInvalidOperation("%s: The READ_BUFFER attachment is not defined.",
                                        funcName);
        return false;
    }

    if (mColorReadBuffer->Samples()) {
        mContext->ErrorInvalidOperation("%s: The READ_BUFFER attachment is multisampled.",
                                        funcName);
        return false;
    }

    *out_format = mColorReadBuffer->Format();
    mColorReadBuffer->Size(out_width, out_height);
    return true;
}

////////////////////////////////////////////////////////////////////////////////
// Resolution and caching

void
WebGLFramebuffer::ResolveAttachments() const
{
    const auto& gl = mContext->gl;

    ////
    // Nuke attachment points.

    for (uint32_t i = 0; i < mContext->mImplMaxColorAttachments; i++) {
        const GLenum attachEnum = LOCAL_GL_COLOR_ATTACHMENT0 + i;
        gl->fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER, attachEnum,
                                     LOCAL_GL_RENDERBUFFER, 0);
    }

    gl->fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER, LOCAL_GL_DEPTH_ATTACHMENT,
                                 LOCAL_GL_RENDERBUFFER, 0);
    gl->fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER, LOCAL_GL_STENCIL_ATTACHMENT,
                                 LOCAL_GL_RENDERBUFFER, 0);

    ////

    for (const auto& attach : mColorAttachments) {
        attach.Resolve(gl);
    }

    mDepthAttachment.Resolve(gl);
    mStencilAttachment.Resolve(gl);
    mDepthStencilAttachment.Resolve(gl);
}

bool
WebGLFramebuffer::ResolveAttachmentData(const char* funcName) const
{
    //////
    // Check if we need to initialize anything

    const auto fnIs3D = [&](const WebGLFBAttachPoint& attach) {
        const auto& tex = attach.Texture();
        if (!tex)
            return false;

        const auto& info = tex->ImageInfoAt(attach.ImageTarget(), attach.MipLevel());
        if (info.mDepth == 1)
            return false;

        return true;
    };

    uint32_t clearBits = 0;
    std::vector<const WebGLFBAttachPoint*> attachmentsToClear;
    std::vector<const WebGLFBAttachPoint*> colorAttachmentsToClear;
    std::vector<const WebGLFBAttachPoint*> tex3DAttachmentsToInit;

    const auto fnGather = [&](const WebGLFBAttachPoint& attach, GLenum attachClearBits) {
        if (!attach.HasUninitializedImageData())
            return false;

        if (fnIs3D(attach)) {
            tex3DAttachmentsToInit.push_back(&attach);
            return false;
        }

        clearBits |= attachClearBits;
        attachmentsToClear.push_back(&attach);
        return true;
    };

    //////

    for (auto& cur : mColorDrawBuffers) {
        if (fnGather(*cur, LOCAL_GL_COLOR_BUFFER_BIT)) {
            colorAttachmentsToClear.push_back(cur);
        }
    }

    fnGather(mDepthAttachment, LOCAL_GL_DEPTH_BUFFER_BIT);
    fnGather(mStencilAttachment, LOCAL_GL_STENCIL_BUFFER_BIT);
    fnGather(mDepthStencilAttachment, LOCAL_GL_DEPTH_BUFFER_BIT |
                                      LOCAL_GL_STENCIL_BUFFER_BIT);

    //////

    for (const auto& attach : tex3DAttachmentsToInit) {
        const auto& tex = attach->Texture();
        if (!tex->InitializeImageData(funcName, attach->ImageTarget(),
                                      attach->MipLevel()))
        {
            return false;
        }
    }

    if (clearBits) {
        const auto fnDrawBuffers = [&](const std::vector<const WebGLFBAttachPoint*>& src)
        {
            std::vector<GLenum> enumList;

            for (const auto& cur : src) {
                const auto& attachEnum = cur->mAttachmentPoint;
                const GLenum attachId = attachEnum - LOCAL_GL_COLOR_ATTACHMENT0;

                while (enumList.size() < attachId) {
                    enumList.push_back(LOCAL_GL_NONE);
                }
                enumList.push_back(attachEnum);
            }

            mContext->gl->fDrawBuffers(enumList.size(), enumList.data());
        };

        ////
        // Clear

        mContext->MakeContextCurrent();

        const bool hasDrawBuffers = mContext->HasDrawBuffers();
        if (hasDrawBuffers) {
            fnDrawBuffers(colorAttachmentsToClear);
        }

        {
            gl::ScopedBindFramebuffer autoBind(mContext->gl, mGLName);

            mContext->ForceClearFramebufferWithDefaultValues(clearBits, false);
        }

        if (hasDrawBuffers) {
            RefreshDrawBuffers();
        }

        // Mark initialized.
        for (const auto& cur : attachmentsToClear) {
            cur->SetImageDataStatus(WebGLImageDataStatus::InitializedImageData);
        }
    }

    return true;
}

WebGLFramebuffer::ResolvedData::ResolvedData(const WebGLFramebuffer& parent)
{

    texDrawBuffers.reserve(parent.mColorDrawBuffers.size() + 2); // +2 for depth+stencil.

    const auto fnCommon = [&](const WebGLFBAttachPoint& attach) {
        if (!attach.IsDefined())
            return false;

        if (attach.Texture()) {
            texDrawBuffers.push_back(&attach);
        }
        return true;
    };

    ////

    const auto fnDepthStencil = [&](const WebGLFBAttachPoint& attach) {
        if (!fnCommon(attach))
            return;

        drawSet.insert(WebGLFBAttachPoint::Ordered(attach));
        readSet.insert(WebGLFBAttachPoint::Ordered(attach));
    };

    fnDepthStencil(parent.mDepthAttachment);
    fnDepthStencil(parent.mStencilAttachment);
    fnDepthStencil(parent.mDepthStencilAttachment);

    ////

    for (const auto& pAttach : parent.mColorDrawBuffers) {
        const auto& attach = *pAttach;
        if (!fnCommon(attach))
            return;

        drawSet.insert(WebGLFBAttachPoint::Ordered(attach));
    }

    if (parent.mColorReadBuffer) {
        const auto& attach = *parent.mColorReadBuffer;
        if (!fnCommon(attach))
            return;

        readSet.insert(WebGLFBAttachPoint::Ordered(attach));
    }
}

void
WebGLFramebuffer::RefreshResolvedData()
{
    if (mResolvedCompleteData) {
        mResolvedCompleteData.reset(new ResolvedData(*this));
    }
}

////////////////////////////////////////////////////////////////////////////////
// Entrypoints

FBStatus
WebGLFramebuffer::CheckFramebufferStatus(const char* funcName)
{
    if (IsResolvedComplete())
        return LOCAL_GL_FRAMEBUFFER_COMPLETE;

    // Ok, let's try to resolve it!

    nsCString statusInfo;
    FBStatus ret = PrecheckFramebufferStatus(&statusInfo);
    do {
        if (ret != LOCAL_GL_FRAMEBUFFER_COMPLETE)
            break;

        // Looks good on our end. Let's ask the driver.
        gl::GLContext* const gl = mContext->gl;
        gl->MakeCurrent();

        const ScopedFBRebinder autoFB(mContext);
        gl->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, mGLName);

        ////

        ResolveAttachments(); // OK, attach everything properly!
        RefreshDrawBuffers();
        RefreshReadBuffer();

        ret = gl->fCheckFramebufferStatus(LOCAL_GL_FRAMEBUFFER);

        ////

        if (ret != LOCAL_GL_FRAMEBUFFER_COMPLETE) {
            const nsPrintfCString text("Bad status according to the driver: 0x%04x",
                                       ret.get());
            statusInfo = text;
            break;
        }

        if (!ResolveAttachmentData(funcName)) {
            ret = LOCAL_GL_FRAMEBUFFER_UNSUPPORTED;
            statusInfo.AssignLiteral("Failed to lazily-initialize attachment data.");
            break;
        }

        mResolvedCompleteData.reset(new ResolvedData(*this));
        return LOCAL_GL_FRAMEBUFFER_COMPLETE;
    } while (false);

    MOZ_ASSERT(ret != LOCAL_GL_FRAMEBUFFER_COMPLETE);
    mContext->GenerateWarning("%s: Framebuffer not complete. (status: 0x%04x) %s",
                              funcName, ret.get(), statusInfo.BeginReading());
    return ret;
}

////

void
WebGLFramebuffer::RefreshDrawBuffers() const
{
    const auto& gl = mContext->gl;
    if (!gl->IsSupported(gl::GLFeature::draw_buffers))
        return;

    // Prior to GL4.1, having a no-image FB attachment that's selected by DrawBuffers
    // yields a framebuffer status of FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER.
    // We could workaround this only on affected versions, but it's easier be
    // unconditional.
    std::vector<GLenum> driverBuffers(mContext->mImplMaxDrawBuffers, LOCAL_GL_NONE);
    for (const auto& attach : mColorDrawBuffers) {
        if (attach->HasImage()) {
            const uint32_t index = attach->mAttachmentPoint - LOCAL_GL_COLOR_ATTACHMENT0;
            driverBuffers[index] = attach->mAttachmentPoint;
        }
    }

    gl->fDrawBuffers(driverBuffers.size(), driverBuffers.data());
}

void
WebGLFramebuffer::RefreshReadBuffer() const
{
    const auto& gl = mContext->gl;
    if (!gl->IsSupported(gl::GLFeature::read_buffer))
        return;

    // Prior to GL4.1, having a no-image FB attachment that's selected by ReadBuffer
    // yields a framebuffer status of FRAMEBUFFER_INCOMPLETE_READ_BUFFER.
    // We could workaround this only on affected versions, but it's easier be
    // unconditional.
    GLenum driverBuffer = LOCAL_GL_NONE;
    if (mColorReadBuffer && mColorReadBuffer->HasImage()) {
        driverBuffer = mColorReadBuffer->mAttachmentPoint;
    }

    gl->fReadBuffer(driverBuffer);
}

////

void
WebGLFramebuffer::DrawBuffers(const char* funcName, const dom::Sequence<GLenum>& buffers)
{
    if (buffers.Length() > mContext->mImplMaxDrawBuffers) {
        // "An INVALID_VALUE error is generated if `n` is greater than MAX_DRAW_BUFFERS."
        mContext->ErrorInvalidValue("%s: `buffers` must have a length <="
                                    " MAX_DRAW_BUFFERS.", funcName);
        return;
    }

    std::vector<const WebGLFBAttachPoint*> newColorDrawBuffers;
    newColorDrawBuffers.reserve(buffers.Length());

    for (size_t i = 0; i < buffers.Length(); i++) {
        // "If the GL is bound to a draw framebuffer object, the `i`th buffer listed in
        //  bufs must be COLOR_ATTACHMENTi or NONE. Specifying a buffer out of order,
        //  BACK, or COLOR_ATTACHMENTm where `m` is greater than or equal to the value of
        // MAX_COLOR_ATTACHMENTS, will generate the error INVALID_OPERATION.

        // WEBGL_draw_buffers:
        // "The value of the MAX_COLOR_ATTACHMENTS_WEBGL parameter must be greater than or
        //  equal to that of the MAX_DRAW_BUFFERS_WEBGL parameter."
        // This means that if buffers.Length() isn't larger than MaxDrawBuffers, it won't
        // be larger than MaxColorAttachments.
        const auto& cur = buffers[i];
        if (cur == LOCAL_GL_COLOR_ATTACHMENT0 + i) {
            const auto& attach = mColorAttachments[i];
            newColorDrawBuffers.push_back(&attach);
        } else if (cur != LOCAL_GL_NONE) {
            const bool isColorEnum = (cur >= LOCAL_GL_COLOR_ATTACHMENT0 &&
                                      cur < mContext->LastColorAttachmentEnum());
            if (cur != LOCAL_GL_BACK &&
                !isColorEnum)
            {
                mContext->ErrorInvalidEnum("%s: Unexpected enum in buffers.", funcName);
                return;
            }

            mContext->ErrorInvalidOperation("%s: `buffers[i]` must be NONE or"
                                            " COLOR_ATTACHMENTi.",
                                            funcName);
            return;
        }
    }

    ////

    mContext->MakeContextCurrent();

    mColorDrawBuffers.swap(newColorDrawBuffers);
    RefreshDrawBuffers(); // Calls glDrawBuffers.
    RefreshResolvedData();
}

void
WebGLFramebuffer::ReadBuffer(const char* funcName, GLenum attachPoint)
{
    const auto& maybeAttach = GetColorAttachPoint(attachPoint);
    if (!maybeAttach) {
        const char text[] = "%s: `mode` must be a COLOR_ATTACHMENTi, for 0 <= i <"
                            " MAX_DRAW_BUFFERS.";
        if (attachPoint == LOCAL_GL_BACK) {
            mContext->ErrorInvalidOperation(text, funcName);
        } else {
            mContext->ErrorInvalidEnum(text, funcName);
        }
        return;
    }
    const auto& attach = maybeAttach.value(); // Might be nullptr.

    ////

    mContext->MakeContextCurrent();

    mColorReadBuffer = attach;
    RefreshReadBuffer(); // Calls glReadBuffer.
    RefreshResolvedData();
}

////

void
WebGLFramebuffer::FramebufferRenderbuffer(const char* funcName, GLenum attachEnum,
                                          GLenum rbtarget, WebGLRenderbuffer* rb)
{
    MOZ_ASSERT(mContext->mBoundDrawFramebuffer == this ||
               mContext->mBoundReadFramebuffer == this);

    // `attachment`
    const auto maybeAttach = GetAttachPoint(attachEnum);
    if (!maybeAttach || !maybeAttach.value()) {
        mContext->ErrorInvalidEnum("%s: Bad `attachment`: 0x%x.", funcName, attachEnum);
        return;
    }
    const auto& attach = maybeAttach.value();

    // `rbTarget`
    if (rbtarget != LOCAL_GL_RENDERBUFFER) {
        mContext->ErrorInvalidEnumInfo("framebufferRenderbuffer: rbtarget:", rbtarget);
        return;
    }

    // `rb`
    if (rb && !mContext->ValidateObject("framebufferRenderbuffer: rb", *rb))
        return;

    // End of validation.

    if (mContext->IsWebGL2() && attachEnum == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
        mDepthAttachment.SetRenderbuffer(rb);
        mStencilAttachment.SetRenderbuffer(rb);
    } else {
        attach->SetRenderbuffer(rb);
    }

    InvalidateFramebufferStatus();
}

void
WebGLFramebuffer::FramebufferTexture2D(const char* funcName, GLenum attachEnum,
                                       GLenum texImageTarget, WebGLTexture* tex,
                                       GLint level)
{
    MOZ_ASSERT(mContext->mBoundDrawFramebuffer == this ||
               mContext->mBoundReadFramebuffer == this);

    // `attachment`
    const auto maybeAttach = GetAttachPoint(attachEnum);
    if (!maybeAttach || !maybeAttach.value()) {
        mContext->ErrorInvalidEnum("%s: Bad `attachment`: 0x%x.", funcName, attachEnum);
        return;
    }
    const auto& attach = maybeAttach.value();

    // `texImageTarget`
    if (texImageTarget != LOCAL_GL_TEXTURE_2D &&
        (texImageTarget < LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X ||
         texImageTarget > LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z))
    {
        mContext->ErrorInvalidEnumInfo("framebufferTexture2D: texImageTarget:",
                                       texImageTarget);
        return;
    }

    // `texture`
    if (tex) {
        if (!mContext->ValidateObject("framebufferTexture2D: texture", *tex))
            return;

        if (!tex->HasEverBeenBound()) {
            mContext->ErrorInvalidOperation("%s: `texture` has never been bound.",
                                            funcName);
            return;
        }

        const TexTarget destTexTarget = TexImageTargetToTexTarget(texImageTarget);
        if (tex->Target() != destTexTarget) {
            mContext->ErrorInvalidOperation("%s: Mismatched texture and texture target.",
                                            funcName);
            return;
        }
    }

    // `level`
    if (level < 0)
        return mContext->ErrorInvalidValue("%s: `level` must not be negative.", funcName);

    if (mContext->IsWebGL2()) {
        /* GLES 3.0.4 p208:
         *   If textarget is one of TEXTURE_CUBE_MAP_POSITIVE_X,
         *   TEXTURE_CUBE_MAP_POSITIVE_Y, TEXTURE_CUBE_MAP_POSITIVE_Z,
         *   TEXTURE_CUBE_MAP_NEGATIVE_X, TEXTURE_CUBE_MAP_NEGATIVE_Y,
         *   or TEXTURE_CUBE_MAP_NEGATIVE_Z, then level must be greater
         *   than or equal to zero and less than or equal to log2 of the
         *   value of MAX_CUBE_MAP_TEXTURE_SIZE. If textarget is TEXTURE_2D,
         *   level must be greater than or equal to zero and no larger than
         *   log2 of the value of MAX_TEXTURE_SIZE. Otherwise, an
         *   INVALID_VALUE error is generated.
         */

        if (texImageTarget == LOCAL_GL_TEXTURE_2D) {
            if (uint32_t(level) > FloorLog2(mContext->mImplMaxTextureSize))
                return mContext->ErrorInvalidValue("%s: `level` is too large.", funcName);
        } else {
            MOZ_ASSERT(texImageTarget >= LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X &&
                       texImageTarget <= LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z);

            if (uint32_t(level) > FloorLog2(mContext->mImplMaxCubeMapTextureSize))
                return mContext->ErrorInvalidValue("%s: `level` is too large.", funcName);
        }
    } else if (level != 0) {
        return mContext->ErrorInvalidValue("%s: `level` must be 0.", funcName);
    }

    // End of validation.

    if (mContext->IsWebGL2() && attachEnum == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
        mDepthAttachment.SetTexImage(tex, texImageTarget, level);
        mStencilAttachment.SetTexImage(tex, texImageTarget, level);
    } else {
        attach->SetTexImage(tex, texImageTarget, level);
    }

    InvalidateFramebufferStatus();
}

void
WebGLFramebuffer::FramebufferTextureLayer(const char* funcName, GLenum attachEnum,
                                          WebGLTexture* tex, GLint level, GLint layer)
{
    MOZ_ASSERT(mContext->mBoundDrawFramebuffer == this ||
               mContext->mBoundReadFramebuffer == this);

    // `attachment`
    const auto maybeAttach = GetAttachPoint(attachEnum);
    if (!maybeAttach || !maybeAttach.value()) {
        mContext->ErrorInvalidEnum("%s: Bad `attachment`: 0x%x.", funcName, attachEnum);
        return;
    }
    const auto& attach = maybeAttach.value();

    // `level`, `layer`
    if (layer < 0)
        return mContext->ErrorInvalidValue("%s: `layer` must be >= 0.", funcName);

    if (level < 0)
        return mContext->ErrorInvalidValue("%s: `level` must be >= 0.", funcName);

    // `texture`
    TexImageTarget texImageTarget = LOCAL_GL_TEXTURE_3D;
    if (tex) {
        if (!mContext->ValidateObject("framebufferTextureLayer: texture", *tex))
            return;

        if (!tex->HasEverBeenBound()) {
            mContext->ErrorInvalidOperation("%s: `texture` has never been bound.",
                                            funcName);
            return;
        }

        texImageTarget = tex->Target().get();
        switch (texImageTarget.get()) {
        case LOCAL_GL_TEXTURE_3D:
            if (uint32_t(layer) >= mContext->mImplMax3DTextureSize) {
                mContext->ErrorInvalidValue("%s: `layer` must be < %s.", funcName,
                                            "MAX_3D_TEXTURE_SIZE");
                return;
            }

            if (uint32_t(level) > FloorLog2(mContext->mImplMax3DTextureSize)) {
                mContext->ErrorInvalidValue("%s: `level` must be <= log2(%s).", funcName,
                                            "MAX_3D_TEXTURE_SIZE");
                return;
            }
            break;

        case LOCAL_GL_TEXTURE_2D_ARRAY:
            if (uint32_t(layer) >= mContext->mImplMaxArrayTextureLayers) {
                mContext->ErrorInvalidValue("%s: `layer` must be < %s.", funcName,
                                            "MAX_ARRAY_TEXTURE_LAYERS");
                return;
            }

            if (uint32_t(level) > FloorLog2(mContext->mImplMaxTextureSize)) {
                mContext->ErrorInvalidValue("%s: `level` must be <= log2(%s).", funcName,
                                            "MAX_TEXTURE_SIZE");
                return;
            }
            break;

        default:
            mContext->ErrorInvalidOperation("%s: `texture` must be a TEXTURE_3D or"
                                            " TEXTURE_2D_ARRAY.",
                                            funcName);
            return;
        }
    }

    // End of validation.

    if (mContext->IsWebGL2() && attachEnum == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
        mDepthAttachment.SetTexImage(tex, texImageTarget, level, layer);
        mStencilAttachment.SetTexImage(tex, texImageTarget, level, layer);
    } else {
        attach->SetTexImage(tex, texImageTarget, level, layer);
    }

    InvalidateFramebufferStatus();
}

JS::Value
WebGLFramebuffer::GetAttachmentParameter(const char* funcName, JSContext* cx,
                                         GLenum target, GLenum attachEnum, GLenum pname,
                                         ErrorResult* const out_error)
{
    const auto maybeAttach = GetAttachPoint(attachEnum);
    if (!maybeAttach || attachEnum == LOCAL_GL_NONE) {
        mContext->ErrorInvalidEnum("%s: Can only query COLOR_ATTACHMENTi,"
                                   " DEPTH_ATTACHMENT, DEPTH_STENCIL_ATTACHMENT, or"
                                   " STENCIL_ATTACHMENT for a framebuffer.",
                                   funcName);
        return JS::NullValue();
    }
    auto attach = maybeAttach.value();

    if (mContext->IsWebGL2() && attachEnum == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
        // There are a couple special rules for this one.

        if (pname == LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE) {
            mContext->ErrorInvalidOperation("%s: Querying"
                                            " FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE"
                                            " against DEPTH_STENCIL_ATTACHMENT is an"
                                            " error.",
                                            funcName);
            return JS::NullValue();
        }

        if (mDepthAttachment.Renderbuffer() != mStencilAttachment.Renderbuffer() ||
            mDepthAttachment.Texture() != mStencilAttachment.Texture())
        {
            mContext->ErrorInvalidOperation("%s: DEPTH_ATTACHMENT and STENCIL_ATTACHMENT"
                                            " have different objects bound.",
                                            funcName);
            return JS::NullValue();
        }

        attach = &mDepthAttachment;
    }

    return attach->GetParameter(funcName, mContext, cx, target, attachEnum, pname,
                                out_error);
}

////////////////////

static void
GetBackbufferFormats(const WebGLContext* webgl,
                     const webgl::FormatInfo** const out_color,
                     const webgl::FormatInfo** const out_depth,
                     const webgl::FormatInfo** const out_stencil)
{
    const auto& options = webgl->Options();

    const auto effFormat = (options.alpha ? webgl::EffectiveFormat::RGBA8
                                          : webgl::EffectiveFormat::RGB8);
    *out_color = webgl::GetFormat(effFormat);

    *out_depth = nullptr;
    *out_stencil = nullptr;
    if (options.depth && options.stencil) {
        *out_depth = webgl::GetFormat(webgl::EffectiveFormat::DEPTH24_STENCIL8);
        *out_stencil = *out_depth;
    } else {
        if (options.depth) {
            *out_depth = webgl::GetFormat(webgl::EffectiveFormat::DEPTH_COMPONENT16);
        }
        if (options.stencil) {
            *out_stencil = webgl::GetFormat(webgl::EffectiveFormat::STENCIL_INDEX8);
        }
    }
}

/*static*/ void
WebGLFramebuffer::BlitFramebuffer(WebGLContext* webgl,
                                  const WebGLFramebuffer* srcFB, GLint srcX0, GLint srcY0,
                                  GLint srcX1, GLint srcY1,
                                  const WebGLFramebuffer* dstFB, GLint dstX0, GLint dstY0,
                                  GLint dstX1, GLint dstY1,
                                  GLbitfield mask, GLenum filter)
{
    const char funcName[] = "blitFramebuffer";
    const auto& gl = webgl->gl;

    ////
    // Collect data

    const auto fnGetDepthAndStencilAttach = [](const WebGLFramebuffer* fb,
                                               const WebGLFBAttachPoint** const out_depth,
                                               const WebGLFBAttachPoint** const out_stencil)
    {
        *out_depth = nullptr;
        *out_stencil = nullptr;

        if (!fb)
            return;

        if (fb->mDepthStencilAttachment.IsDefined()) {
            *out_depth = *out_stencil = &fb->mDepthStencilAttachment;
            return;
        }
        if (fb->mDepthAttachment.IsDefined()) {
            *out_depth = &fb->mDepthAttachment;
        }
        if (fb->mStencilAttachment.IsDefined()) {
            *out_stencil = &fb->mStencilAttachment;
        }
    };

    const WebGLFBAttachPoint* srcDepthAttach;
    const WebGLFBAttachPoint* srcStencilAttach;
    fnGetDepthAndStencilAttach(srcFB, &srcDepthAttach, &srcStencilAttach);
    const WebGLFBAttachPoint* dstDepthAttach;
    const WebGLFBAttachPoint* dstStencilAttach;
    fnGetDepthAndStencilAttach(dstFB, &dstDepthAttach, &dstStencilAttach);

    ////

    const auto fnGetFormat = [](const WebGLFBAttachPoint* cur,
                                bool* const out_hasSamples) -> const webgl::FormatInfo*
    {
        if (!cur || !cur->IsDefined())
            return nullptr;

        *out_hasSamples |= bool(cur->Samples());
        return cur->Format()->format;
    };

    const auto fnNarrowComponentType = [&](const webgl::FormatInfo* format) {
        switch (format->componentType) {
        case webgl::ComponentType::NormInt:
        case webgl::ComponentType::NormUInt:
            return webgl::ComponentType::Float;

        default:
            return format->componentType;
        }
    };

    bool srcHasSamples;
    const webgl::FormatInfo* srcColorFormat;
    webgl::ComponentType srcColorType = webgl::ComponentType::None;
    const webgl::FormatInfo* srcDepthFormat;
    const webgl::FormatInfo* srcStencilFormat;

    if (srcFB) {
        srcHasSamples = false;
        srcColorFormat = fnGetFormat(srcFB->mColorReadBuffer, &srcHasSamples);
        srcDepthFormat = fnGetFormat(srcDepthAttach, &srcHasSamples);
        srcStencilFormat = fnGetFormat(srcStencilAttach, &srcHasSamples);
    } else {
        srcHasSamples = false; // Always false.

        GetBackbufferFormats(webgl, &srcColorFormat, &srcDepthFormat, &srcStencilFormat);
    }

    if (srcColorFormat) {
        srcColorType = fnNarrowComponentType(srcColorFormat);
    }

    ////

    bool dstHasSamples;
    const webgl::FormatInfo* dstDepthFormat;
    const webgl::FormatInfo* dstStencilFormat;
    bool dstHasColor = false;
    bool colorFormatsMatch = true;
    bool colorTypesMatch = true;

    const auto fnCheckColorFormat = [&](const webgl::FormatInfo* dstFormat) {
        MOZ_ASSERT(dstFormat->r || dstFormat->g || dstFormat->b || dstFormat->a);
        dstHasColor = true;
        colorFormatsMatch &= (dstFormat == srcColorFormat);
        colorTypesMatch &= ( fnNarrowComponentType(dstFormat) == srcColorType );
    };

    if (dstFB) {
        dstHasSamples = false;

        for (const auto& cur : dstFB->mColorDrawBuffers) {
            const auto& format = fnGetFormat(cur, &dstHasSamples);
            if (!format)
                continue;

            fnCheckColorFormat(format);
        }

        dstDepthFormat = fnGetFormat(dstDepthAttach, &dstHasSamples);
        dstStencilFormat = fnGetFormat(dstStencilAttach, &dstHasSamples);
    } else {
        dstHasSamples = bool(gl->Screen()->Samples());

        const webgl::FormatInfo* dstColorFormat;
        GetBackbufferFormats(webgl, &dstColorFormat, &dstDepthFormat, &dstStencilFormat);

        fnCheckColorFormat(dstColorFormat);
    }

    ////
    // Clear unused buffer bits

    if (mask & LOCAL_GL_COLOR_BUFFER_BIT &&
        !srcColorFormat && !dstHasColor)
    {
        mask ^= LOCAL_GL_COLOR_BUFFER_BIT;
    }

    if (mask & LOCAL_GL_DEPTH_BUFFER_BIT &&
        !srcDepthFormat && !dstDepthFormat)
    {
        mask ^= LOCAL_GL_DEPTH_BUFFER_BIT;
    }

    if (mask & LOCAL_GL_STENCIL_BUFFER_BIT &&
        !srcStencilFormat && !dstStencilFormat)
    {
        mask ^= LOCAL_GL_STENCIL_BUFFER_BIT;
    }

    ////
    // Validation

    if (mask & LOCAL_GL_COLOR_BUFFER_BIT) {
        if (srcColorFormat && filter == LOCAL_GL_LINEAR) {
            const auto& type = srcColorFormat->componentType;
            if (type == webgl::ComponentType::Int ||
                type == webgl::ComponentType::UInt)
            {
                webgl->ErrorInvalidOperation("%s: `filter` is LINEAR and READ_BUFFER"
                                             " contains integer data.",
                                             funcName);
                return;
            }
        }

        if (!colorTypesMatch) {
            webgl->ErrorInvalidOperation("%s: Color component types (fixed/float/uint/"
                                         "int) must match.",
                                         funcName);
            return;
        }
    }

    const GLbitfield depthAndStencilBits = LOCAL_GL_DEPTH_BUFFER_BIT |
                                           LOCAL_GL_STENCIL_BUFFER_BIT;
    if (bool(mask & depthAndStencilBits) &&
        filter != LOCAL_GL_NEAREST)
    {
        webgl->ErrorInvalidOperation("%s: DEPTH_BUFFER_BIT and STENCIL_BUFFER_BIT can"
                                     " only be used with NEAREST filtering.",
                                     funcName);
        return;
    }

    /* GLES 3.0.4, p199:
     *   Calling BlitFramebuffer will result in an INVALID_OPERATION error if
     *   mask includes DEPTH_BUFFER_BIT or STENCIL_BUFFER_BIT, and the source
     *   and destination depth and stencil buffer formats do not match.
     *
     * jgilbert: The wording is such that if only DEPTH_BUFFER_BIT is specified,
     * the stencil formats must match. This seems wrong. It could be a spec bug,
     * or I could be missing an interaction in one of the earlier paragraphs.
     */
    if (mask & LOCAL_GL_DEPTH_BUFFER_BIT &&
        dstDepthFormat && dstDepthFormat != srcDepthFormat)
    {
        webgl->ErrorInvalidOperation("%s: Depth buffer formats must match if selected.",
                                     funcName);
        return;
    }

    if (mask & LOCAL_GL_STENCIL_BUFFER_BIT &&
        dstStencilFormat && dstStencilFormat != srcStencilFormat)
    {
        webgl->ErrorInvalidOperation("%s: Stencil buffer formats must match if selected.",
                                     funcName);
        return;
    }

    ////

    if (dstHasSamples) {
        webgl->ErrorInvalidOperation("%s: DRAW_FRAMEBUFFER may not have multiple"
                                     " samples.",
                                     funcName);
        return;
    }

    if (srcHasSamples) {
        if (mask & LOCAL_GL_COLOR_BUFFER_BIT &&
            dstHasColor && !colorFormatsMatch)
        {
            webgl->ErrorInvalidOperation("%s: Color buffer formats must match if"
                                         " selected, when reading from a multisampled"
                                         " source.",
                                         funcName);
            return;
        }

        if (dstX0 != srcX0 ||
            dstX1 != srcX1 ||
            dstY0 != srcY0 ||
            dstY1 != srcY1)
        {
            webgl->ErrorInvalidOperation("%s: If the source is multisampled, then the"
                                         " source and dest regions must match exactly.",
                                         funcName);
            return;
        }
    }

    ////
    // Check for feedback

    if (srcFB && dstFB) {
        const WebGLFBAttachPoint* feedback = nullptr;

        if (mask & LOCAL_GL_COLOR_BUFFER_BIT) {
            MOZ_ASSERT(srcFB->mColorReadBuffer->IsDefined());
            for (const auto& cur : dstFB->mColorDrawBuffers) {
                if (srcFB->mColorReadBuffer->IsEquivalentForFeedback(*cur)) {
                    feedback = cur;
                    break;
                }
            }
        }

        if (mask & LOCAL_GL_DEPTH_BUFFER_BIT &&
            srcDepthAttach->IsEquivalentForFeedback(*dstDepthAttach))
        {
            feedback = dstDepthAttach;
        }

        if (mask & LOCAL_GL_STENCIL_BUFFER_BIT &&
            srcStencilAttach->IsEquivalentForFeedback(*dstStencilAttach))
        {
            feedback = dstStencilAttach;
        }

        if (feedback) {
            webgl->ErrorInvalidOperation("%s: Feedback detected into DRAW_FRAMEBUFFER's"
                                         " 0x%04x attachment.",
                                         funcName, feedback->mAttachmentPoint);
            return;
        }
    } else if (!srcFB && !dstFB) {
        webgl->ErrorInvalidOperation("%s: Feedback with default framebuffer.", funcName);
        return;
    }

    ////

    gl->MakeCurrent();
    webgl->OnBeforeReadCall();
    WebGLContext::ScopedDrawCallWrapper wrapper(*webgl);
    gl->fBlitFramebuffer(srcX0, srcY0, srcX1, srcY1,
                         dstX0, dstY0, dstX1, dstY1,
                         mask, filter);
}

////////////////////////////////////////////////////////////////////////////////
// Goop.

JSObject*
WebGLFramebuffer::WrapObject(JSContext* cx, JS::Handle<JSObject*> givenProto)
{
    return dom::WebGLFramebufferBinding::Wrap(cx, this, givenProto);
}

inline void
ImplCycleCollectionUnlink(mozilla::WebGLFBAttachPoint& field)
{
    field.Unlink();
}

inline void
ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& callback,
                            mozilla::WebGLFBAttachPoint& field,
                            const char* name,
                            uint32_t flags = 0)
{
    CycleCollectionNoteChild(callback, field.Texture(), name, flags);
    CycleCollectionNoteChild(callback, field.Renderbuffer(), name, flags);
}

template<typename C>
inline void
ImplCycleCollectionUnlink(C& field)
{
    for (auto& cur : field) {
        cur.Unlink();
    }
}

template<typename C>
inline void
ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& callback,
                            C& field,
                            const char* name,
                            uint32_t flags = 0)
{
    for (auto& cur : field) {
        ImplCycleCollectionTraverse(callback, cur, name, flags);
    }
}


NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(WebGLFramebuffer,
                                      mDepthAttachment,
                                      mStencilAttachment,
                                      mDepthStencilAttachment,
                                      mColorAttachments)

NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(WebGLFramebuffer, AddRef)
NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(WebGLFramebuffer, Release)

} // namespace mozilla