nagai/fune
3
0
Fork 0
forked from mirrors/gecko-dev
Code Pull requests Activity
fune/dom/canvas/WebGLFramebuffer.cpp
Jeff Gilbert 39129f8f9d Bug 1696075 - Match spec for webgl sampling feedback detection. r=lsalzman 
I lean really hard into using the precise variable names and language
from the spec here. Previously I had more qualitative/descriptive names,
but I found this to mostly cause confusion. When we're up to our waists
in spec edge cases like we are here, descriptive qualitative names can
just be deceptive, and lead to incorrect intuitions.

Differential Revision: https://phabricator.services.mozilla.com/D107016
2021-03-04 03:14:50 +00:00

1716 lines
54 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 "GLBlitHelper.h"
#include "GLContext.h"
#include "GLScreenBuffer.h"
#include "MozFramebuffer.h"
#include "mozilla/dom/WebGLRenderingContextBinding.h"
#include "mozilla/IntegerRange.h"
#include "nsPrintfCString.h"
#include "WebGLContext.h"
#include "WebGLContextUtils.h"
#include "WebGLExtensions.h"
#include "WebGLFormats.h"
#include "WebGLRenderbuffer.h"
#include "WebGLTexture.h"
namespace mozilla {
static bool ShouldDeferAttachment(const WebGLContext* const webgl,
const GLenum attachPoint) {
if (webgl->IsWebGL2()) return false;
switch (attachPoint) {
case LOCAL_GL_DEPTH_ATTACHMENT:
case LOCAL_GL_STENCIL_ATTACHMENT:
case LOCAL_GL_DEPTH_STENCIL_ATTACHMENT:
return true;
default:
return false;
}
}
WebGLFBAttachPoint::WebGLFBAttachPoint() = default;
WebGLFBAttachPoint::WebGLFBAttachPoint(WebGLFBAttachPoint&) = default;
WebGLFBAttachPoint::WebGLFBAttachPoint(const WebGLContext* const webgl,
const GLenum attachmentPoint)
: mAttachmentPoint(attachmentPoint),
mDeferAttachment(ShouldDeferAttachment(webgl, mAttachmentPoint)) {}
WebGLFBAttachPoint::~WebGLFBAttachPoint() {
MOZ_ASSERT(!mRenderbufferPtr);
MOZ_ASSERT(!mTexturePtr);
}
void WebGLFBAttachPoint::Clear() { Set(nullptr, {}); }
void WebGLFBAttachPoint::Set(gl::GLContext* const gl,
const webgl::FbAttachInfo& toAttach) {
mRenderbufferPtr = toAttach.rb;
mTexturePtr = toAttach.tex;
mTexImageLayer = AssertedCast<uint32_t>(toAttach.zLayer);
mTexImageZLayerCount = AssertedCast<uint8_t>(toAttach.zLayerCount);
mTexImageLevel = AssertedCast<uint8_t>(toAttach.mipLevel);
mIsMultiview = toAttach.isMultiview;
if (gl && !mDeferAttachment) {
DoAttachment(gl);
}
}
const webgl::ImageInfo* WebGLFBAttachPoint::GetImageInfo() const {
if (mTexturePtr) {
const auto target = Texture()->Target();
uint8_t face = 0;
if (target == LOCAL_GL_TEXTURE_CUBE_MAP) {
face = Layer() % 6;
}
return &mTexturePtr->ImageInfoAtFace(face, mTexImageLevel);
}
if (mRenderbufferPtr) return &mRenderbufferPtr->ImageInfo();
return nullptr;
}
bool WebGLFBAttachPoint::IsComplete(WebGLContext* webgl,
nsCString* const out_info) const {
MOZ_ASSERT(HasAttachment());
const auto fnWriteErrorInfo = [&](const char* const text) {
WebGLContext::EnumName(mAttachmentPoint, out_info);
out_info->AppendLiteral(": ");
out_info->AppendASCII(text);
};
const auto& imageInfo = *GetImageInfo();
if (!imageInfo.mWidth || !imageInfo.mHeight) {
fnWriteErrorInfo("Attachment has no width or height.");
return false;
}
MOZ_ASSERT(imageInfo.IsDefined());
const auto& tex = Texture();
if (tex) {
// ES 3.0 spec, pg 213 has giant blocks of text that bake down to requiring
// that attached *non-immutable* tex images are within the valid mip-levels
// of the texture. We still need to check immutable textures though, because
// checking completeness is also when we zero invalidated/no-data tex
// images.
const auto attachedMipLevel = MipLevel();
const bool withinValidMipLevels = [&]() {
const bool ensureInit = false;
const auto texCompleteness = tex->CalcCompletenessInfo(ensureInit);
if (!texCompleteness) return false; // OOM
if (tex->Immutable()) {
// Immutable textures can attach a level that's not valid for sampling.
// It still has to exist though!
return attachedMipLevel < tex->ImmutableLevelCount();
}
// Base level must be complete.
if (!texCompleteness->levels) return false;
const auto baseLevel = tex->Es3_level_base();
if (attachedMipLevel == baseLevel) return true;
// If not base level, must be mip-complete and within mips.
if (!texCompleteness->mipmapComplete) return false;
const auto maxLevel = baseLevel + texCompleteness->levels - 1;
return baseLevel <= attachedMipLevel && attachedMipLevel <= maxLevel;
}();
if (!withinValidMipLevels) {
fnWriteErrorInfo("Attached mip level is invalid for texture.");
return false;
}
const auto& levelInfo = tex->ImageInfoAtFace(0, attachedMipLevel);
const auto faceDepth = levelInfo.mDepth * tex->FaceCount();
const bool withinValidZLayers = Layer() + ZLayerCount() - 1 < faceDepth;
if (!withinValidZLayers) {
fnWriteErrorInfo("Attached z layer is invalid for texture.");
return false;
}
}
const auto& formatUsage = imageInfo.mFormat;
if (!formatUsage->IsRenderable()) {
const auto info = nsPrintfCString(
"Attachment has an effective format of %s,"
" which is not renderable.",
formatUsage->format->name);
fnWriteErrorInfo(info.BeginReading());
return false;
}
if (!formatUsage->IsExplicitlyRenderable()) {
webgl->WarnIfImplicit(formatUsage->GetExtensionID());
}
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) {
fnWriteErrorInfo(
"Attachment'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) {
fnWriteErrorInfo(
"Attachment has depth or stencil bits when it shouldn't.");
return false;
}
}
return true;
}
void WebGLFBAttachPoint::DoAttachment(gl::GLContext* const gl) const {
if (Renderbuffer()) {
Renderbuffer()->DoFramebufferRenderbuffer(mAttachmentPoint);
return;
}
if (!Texture()) {
MOZ_ASSERT(mAttachmentPoint != LOCAL_GL_DEPTH_STENCIL_ATTACHMENT);
// WebGL 2 doesn't have a real attachment for this, and WebGL 1 is defered
// and only DoAttachment if HasAttachment.
gl->fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER, mAttachmentPoint,
LOCAL_GL_RENDERBUFFER, 0);
return;
}
const auto& texName = Texture()->mGLName;
switch (Texture()->Target().get()) {
case LOCAL_GL_TEXTURE_2D:
case LOCAL_GL_TEXTURE_CUBE_MAP: {
TexImageTarget imageTarget = LOCAL_GL_TEXTURE_2D;
if (Texture()->Target() == LOCAL_GL_TEXTURE_CUBE_MAP) {
imageTarget = LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X + Layer();
}
if (mAttachmentPoint == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
gl->fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER,
LOCAL_GL_DEPTH_ATTACHMENT, imageTarget.get(),
texName, MipLevel());
gl->fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER,
LOCAL_GL_STENCIL_ATTACHMENT,
imageTarget.get(), texName, MipLevel());
} else {
gl->fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER, mAttachmentPoint,
imageTarget.get(), texName, MipLevel());
}
break;
}
case LOCAL_GL_TEXTURE_2D_ARRAY:
case LOCAL_GL_TEXTURE_3D:
if (ZLayerCount() != 1) {
gl->fFramebufferTextureMultiview(LOCAL_GL_FRAMEBUFFER, mAttachmentPoint,
texName, MipLevel(), Layer(),
ZLayerCount());
} else {
gl->fFramebufferTextureLayer(LOCAL_GL_FRAMEBUFFER, mAttachmentPoint,
texName, MipLevel(), Layer());
}
break;
}
}
Maybe<double> WebGLFBAttachPoint::GetParameter(WebGLContext* webgl,
GLenum attachment,
GLenum pname) const {
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 Some(LOCAL_GL_NONE);
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
if (webgl->IsWebGL2()) return Nothing();
break;
default:
break;
}
nsCString attachmentName;
WebGLContext::EnumName(attachment, &attachmentName);
if (webgl->IsWebGL2()) {
webgl->ErrorInvalidOperation("No attachment at %s.",
attachmentName.BeginReading());
} else {
webgl->ErrorInvalidEnum("No attachment at %s.",
attachmentName.BeginReading());
}
return Nothing();
}
bool isPNameValid = false;
switch (pname) {
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
return Some(mTexturePtr ? LOCAL_GL_TEXTURE : LOCAL_GL_RENDERBUFFER);
//////
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
if (mTexturePtr) return Some(AssertedCast<uint32_t>(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 = LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X + Layer();
}
return Some(face);
}
break;
//////
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
if (webgl->IsWebGL2()) {
return Some(AssertedCast<int32_t>(Layer()));
}
break;
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR:
if (webgl->IsExtensionEnabled(WebGLExtensionID::OVR_multiview2)) {
return Some(AssertedCast<int32_t>(Layer()));
}
break;
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR:
if (webgl->IsExtensionEnabled(WebGLExtensionID::OVR_multiview2)) {
return Some(AssertedCast<uint32_t>(ZLayerCount()));
}
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("Invalid pname: 0x%04x", pname);
return Nothing();
}
const auto& imageInfo = *GetImageInfo();
const auto& usage = imageInfo.mFormat;
if (!usage) {
if (pname == LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)
return Some(LOCAL_GL_LINEAR);
return Nothing();
}
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->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::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;
}
break;
default:
MOZ_ASSERT(false, "Missing case.");
break;
}
return Some(ret);
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// WebGLFramebuffer
WebGLFramebuffer::WebGLFramebuffer(WebGLContext* webgl, GLuint fbo)
: WebGLContextBoundObject(webgl),
mGLName(fbo),
mDepthAttachment(webgl, LOCAL_GL_DEPTH_ATTACHMENT),
mStencilAttachment(webgl, LOCAL_GL_STENCIL_ATTACHMENT),
mDepthStencilAttachment(webgl, LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
mAttachments.push_back(&mDepthAttachment);
mAttachments.push_back(&mStencilAttachment);
if (!webgl->IsWebGL2()) {
// Only WebGL1 has a separate depth+stencil attachment point.
mAttachments.push_back(&mDepthStencilAttachment);
}
size_t i = 0;
for (auto& cur : mColorAttachments) {
new (&cur) WebGLFBAttachPoint(webgl, LOCAL_GL_COLOR_ATTACHMENT0 + i);
i++;
mAttachments.push_back(&cur);
}
mColorDrawBuffers.push_back(&mColorAttachments[0]);
mColorReadBuffer = &mColorAttachments[0];
}
WebGLFramebuffer::WebGLFramebuffer(WebGLContext* webgl,
UniquePtr<gl::MozFramebuffer> fbo)
: WebGLContextBoundObject(webgl),
mGLName(fbo->mFB),
mOpaque(std::move(fbo)),
mColorReadBuffer(nullptr) {
// Opaque Framebuffer is guaranteed to be complete at this point.
// Cache the Completeness info.
CompletenessInfo info;
info.width = mOpaque->mSize.width;
info.height = mOpaque->mSize.height;
info.hasFloat32 = false;
info.zLayerCount = 1;
info.isMultiview = false;
mCompletenessInfo = Some(std::move(info));
}
WebGLFramebuffer::~WebGLFramebuffer() {
InvalidateCaches();
mDepthAttachment.Clear();
mStencilAttachment.Clear();
mDepthStencilAttachment.Clear();
for (auto& cur : mColorAttachments) {
cur.Clear();
}
if (!mContext) return;
// If opaque, fDeleteFramebuffers is called in the destructor of
// MozFramebuffer.
if (!mOpaque) {
mContext->gl->fDeleteFramebuffers(1, &mGLName);
}
}
////
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->Limits().maxColorDrawBuffers <= kMaxColorAttachments);
if (colorId >= mContext->MaxValidDrawBuffers()) 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);
}
}
void WebGLFramebuffer::DetachTexture(const WebGLTexture* tex) {
for (const auto& attach : mAttachments) {
if (attach->Texture() == tex) {
attach->Clear();
}
}
InvalidateCaches();
}
void WebGLFramebuffer::DetachRenderbuffer(const WebGLRenderbuffer* rb) {
for (const auto& attach : mAttachments) {
if (attach->Renderbuffer() == rb) {
attach->Clear();
}
}
InvalidateCaches();
}
////////////////////////////////////////////////////////////////////////////////
// Completeness
bool WebGLFramebuffer::HasDuplicateAttachments() const {
std::set<WebGLFBAttachPoint::Ordered> uniqueAttachSet;
for (const auto& attach : mColorAttachments) {
if (!attach.HasAttachment()) continue;
const WebGLFBAttachPoint::Ordered ordered(attach);
const bool didInsert = uniqueAttachSet.insert(ordered).second;
if (!didInsert) return true;
}
return false;
}
bool WebGLFramebuffer::HasDefinedAttachments() const {
bool hasAttachments = false;
for (const auto& attach : mAttachments) {
hasAttachments |= attach->HasAttachment();
}
return hasAttachments;
}
bool WebGLFramebuffer::HasIncompleteAttachments(
nsCString* const out_info) const {
bool hasIncomplete = false;
for (const auto& cur : mAttachments) {
if (!cur->HasAttachment())
continue; // Not defined, so can't count as incomplete.
hasIncomplete |= !cur->IsComplete(mContext, out_info);
}
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;
for (const auto& attach : mAttachments) {
const auto& imageInfo = attach->GetImageInfo();
if (!imageInfo) continue;
const auto& curWidth = imageInfo->mWidth;
const auto& curHeight = imageInfo->mHeight;
if (needsInit) {
needsInit = false;
width = curWidth;
height = curHeight;
continue;
}
hasMismatch |= (curWidth != width || curHeight != height);
}
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;
for (const auto& attach : mAttachments) {
const auto& imageInfo = attach->GetImageInfo();
if (!imageInfo) continue;
const auto& curSamples = imageInfo->mSamples;
if (needsInit) {
needsInit = false;
samples = curSamples;
continue;
}
hasMismatch |= (curSamples != samples);
};
return !hasMismatch;
}
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 (HasDuplicateAttachments()) return LOCAL_GL_FRAMEBUFFER_UNSUPPORTED;
if (mContext->IsWebGL2()) {
MOZ_ASSERT(!mDepthStencilAttachment.HasAttachment());
if (mDepthAttachment.HasAttachment() &&
mStencilAttachment.HasAttachment()) {
if (!mDepthAttachment.IsEquivalentForFeedback(mStencilAttachment))
return LOCAL_GL_FRAMEBUFFER_UNSUPPORTED;
}
} else {
const auto depthOrStencilCount =
int(mDepthAttachment.HasAttachment()) +
int(mStencilAttachment.HasAttachment()) +
int(mDepthStencilAttachment.HasAttachment());
if (depthOrStencilCount > 1) return LOCAL_GL_FRAMEBUFFER_UNSUPPORTED;
}
{
const WebGLFBAttachPoint* example = nullptr;
for (const auto& x : mAttachments) {
if (!x->HasAttachment()) continue;
if (!example) {
example = x;
continue;
}
if (x->ZLayerCount() != example->ZLayerCount()) {
return LOCAL_GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR;
}
}
}
return LOCAL_GL_FRAMEBUFFER_COMPLETE;
}
////////////////////////////////////////
// Validation
bool WebGLFramebuffer::ValidateAndInitAttachments(
const GLenum incompleteFbError) const {
MOZ_ASSERT(mContext->mBoundDrawFramebuffer == this ||
mContext->mBoundReadFramebuffer == this);
const auto fbStatus = CheckFramebufferStatus();
if (fbStatus == LOCAL_GL_FRAMEBUFFER_COMPLETE) return true;
mContext->GenerateError(incompleteFbError, "Framebuffer must be complete.");
return false;
}
bool WebGLFramebuffer::ValidateClearBufferType(
GLenum buffer, uint32_t drawBuffer,
const webgl::AttribBaseType funcType) const {
if (buffer != LOCAL_GL_COLOR) return true;
const auto& attach = mColorAttachments[drawBuffer];
const auto& imageInfo = attach.GetImageInfo();
if (!imageInfo) return true;
if (!count(mColorDrawBuffers.begin(), mColorDrawBuffers.end(), &attach))
return true; // DRAW_BUFFERi set to NONE.
auto attachType = webgl::AttribBaseType::Float;
switch (imageInfo->mFormat->format->componentType) {
case webgl::ComponentType::Int:
attachType = webgl::AttribBaseType::Int;
break;
case webgl::ComponentType::UInt:
attachType = webgl::AttribBaseType::Uint;
break;
default:
break;
}
if (attachType != funcType) {
mContext->ErrorInvalidOperation(
"This attachment is of type %s, but"
" this function is of type %s.",
ToString(attachType), ToString(funcType));
return false;
}
return true;
}
bool WebGLFramebuffer::ValidateForColorRead(
const webgl::FormatUsageInfo** const out_format, uint32_t* const out_width,
uint32_t* const out_height) const {
if (!mColorReadBuffer) {
mContext->ErrorInvalidOperation("READ_BUFFER must not be NONE.");
return false;
}
if (mColorReadBuffer->ZLayerCount() > 1) {
mContext->GenerateError(LOCAL_GL_INVALID_FRAMEBUFFER_OPERATION,
"The READ_BUFFER attachment has multiple views.");
return false;
}
const auto& imageInfo = mColorReadBuffer->GetImageInfo();
if (!imageInfo) {
mContext->ErrorInvalidOperation(
"The READ_BUFFER attachment is not defined.");
return false;
}
if (imageInfo->mSamples) {
mContext->ErrorInvalidOperation(
"The READ_BUFFER attachment is multisampled.");
return false;
}
*out_format = imageInfo->mFormat;
*out_width = imageInfo->mWidth;
*out_height = imageInfo->mHeight;
return true;
}
////////////////////////////////////////////////////////////////////////////////
// Resolution and caching
void WebGLFramebuffer::DoDeferredAttachments() const {
if (mContext->IsWebGL2()) return;
const auto& gl = mContext->gl;
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);
const auto fn = [&](const WebGLFBAttachPoint& attach) {
MOZ_ASSERT(attach.mDeferAttachment);
if (attach.HasAttachment()) {
attach.DoAttachment(gl);
}
};
// Only one of these will have an attachment.
fn(mDepthAttachment);
fn(mStencilAttachment);
fn(mDepthStencilAttachment);
}
void WebGLFramebuffer::ResolveAttachmentData() const {
// GLES 3.0.5 p188:
// The result of clearing integer color buffers with `Clear` is undefined.
// Two different approaches:
// On WebGL 2, we have glClearBuffer, and *must* use it for integer buffers,
// so let's just use it for all the buffers. One WebGL 1, we might not have
// glClearBuffer,
// WebGL 1 is easier, because we can just call glClear, possibly with
// glDrawBuffers.
const auto& gl = mContext->gl;
const webgl::ScopedPrepForResourceClear scopedPrep(*mContext);
if (mContext->IsWebGL2()) {
const uint32_t uiZeros[4] = {};
const int32_t iZeros[4] = {};
const float fZeros[4] = {};
const float fOne[] = {1.0f};
for (const auto& cur : mAttachments) {
const auto& imageInfo = cur->GetImageInfo();
if (!imageInfo || !imageInfo->mUninitializedSlices)
continue; // Nothing attached, or already has data.
const auto fnClearBuffer = [&]() {
const auto& format = imageInfo->mFormat->format;
MOZ_ASSERT(format->estimatedBytesPerPixel <= sizeof(uiZeros));
MOZ_ASSERT(format->estimatedBytesPerPixel <= sizeof(iZeros));
MOZ_ASSERT(format->estimatedBytesPerPixel <= sizeof(fZeros));
switch (cur->mAttachmentPoint) {
case LOCAL_GL_DEPTH_ATTACHMENT:
gl->fClearBufferfv(LOCAL_GL_DEPTH, 0, fOne);
break;
case LOCAL_GL_STENCIL_ATTACHMENT:
gl->fClearBufferiv(LOCAL_GL_STENCIL, 0, iZeros);
break;
default:
MOZ_ASSERT(cur->mAttachmentPoint !=
LOCAL_GL_DEPTH_STENCIL_ATTACHMENT);
const uint32_t drawBuffer =
cur->mAttachmentPoint - LOCAL_GL_COLOR_ATTACHMENT0;
MOZ_ASSERT(drawBuffer <= 100);
switch (format->componentType) {
case webgl::ComponentType::Int:
gl->fClearBufferiv(LOCAL_GL_COLOR, drawBuffer, iZeros);
break;
case webgl::ComponentType::UInt:
gl->fClearBufferuiv(LOCAL_GL_COLOR, drawBuffer, uiZeros);
break;
default:
gl->fClearBufferfv(LOCAL_GL_COLOR, drawBuffer, fZeros);
break;
}
}
};
if (imageInfo->mDepth > 1) {
const auto& tex = cur->Texture();
const gl::ScopedFramebuffer scopedFB(gl);
const gl::ScopedBindFramebuffer scopedBindFB(gl, scopedFB.FB());
for (const auto z : IntegerRange(imageInfo->mDepth)) {
if ((*imageInfo->mUninitializedSlices)[z]) {
gl->fFramebufferTextureLayer(LOCAL_GL_FRAMEBUFFER,
cur->mAttachmentPoint, tex->mGLName,
cur->MipLevel(), z);
fnClearBuffer();
}
}
} else {
fnClearBuffer();
}
imageInfo->mUninitializedSlices = Nothing();
}
return;
}
uint32_t clearBits = 0;
std::vector<GLenum> drawBufferForClear;
const auto fnGather = [&](const WebGLFBAttachPoint& attach,
const uint32_t attachClearBits) {
const auto& imageInfo = attach.GetImageInfo();
if (!imageInfo || !imageInfo->mUninitializedSlices) return false;
clearBits |= attachClearBits;
imageInfo->mUninitializedSlices = Nothing(); // Just mark it now.
return true;
};
//////
for (const auto& cur : mColorAttachments) {
if (fnGather(cur, LOCAL_GL_COLOR_BUFFER_BIT)) {
const uint32_t id = cur.mAttachmentPoint - LOCAL_GL_COLOR_ATTACHMENT0;
MOZ_ASSERT(id <= 100);
drawBufferForClear.resize(id + 1); // Pads with zeros!
drawBufferForClear[id] = cur.mAttachmentPoint;
}
}
(void)fnGather(mDepthAttachment, LOCAL_GL_DEPTH_BUFFER_BIT);
(void)fnGather(mStencilAttachment, LOCAL_GL_STENCIL_BUFFER_BIT);
(void)fnGather(mDepthStencilAttachment,
LOCAL_GL_DEPTH_BUFFER_BIT | LOCAL_GL_STENCIL_BUFFER_BIT);
//////
if (!clearBits) return;
if (gl->IsSupported(gl::GLFeature::draw_buffers)) {
gl->fDrawBuffers(drawBufferForClear.size(), drawBufferForClear.data());
}
gl->fClear(clearBits);
RefreshDrawBuffers();
}
WebGLFramebuffer::CompletenessInfo::~CompletenessInfo() {
if (!this->fb) return;
const auto& fb = *this->fb;
const auto& webgl = fb.mContext;
fb.mNumFBStatusInvals++;
if (fb.mNumFBStatusInvals > webgl->mMaxAcceptableFBStatusInvals) {
webgl->GeneratePerfWarning(
"FB was invalidated after being complete %u"
" times. [webgl.perf.max-acceptable-fb-status-invals]",
uint32_t(fb.mNumFBStatusInvals));
}
}
////////////////////////////////////////////////////////////////////////////////
// Entrypoints
FBStatus WebGLFramebuffer::CheckFramebufferStatus() const {
if (MOZ_UNLIKELY(mOpaque && !mInOpaqueRAF)) {
// Opaque Framebuffers are considered incomplete outside of a RAF.
return LOCAL_GL_FRAMEBUFFER_UNSUPPORTED;
}
if (mCompletenessInfo) 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;
const ScopedFBRebinder autoFB(mContext);
gl->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, mGLName);
////
DoDeferredAttachments();
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;
}
ResolveAttachmentData();
// Sweet, let's cache that.
auto info = CompletenessInfo{this, UINT32_MAX, UINT32_MAX};
mCompletenessInfo.ResetInvalidators({});
mCompletenessInfo.AddInvalidator(*this);
const auto fnIsFloat32 = [](const webgl::FormatInfo& info) {
if (info.componentType != webgl::ComponentType::Float) return false;
return info.r == 32;
};
for (const auto& cur : mAttachments) {
const auto& tex = cur->Texture();
const auto& rb = cur->Renderbuffer();
if (tex) {
mCompletenessInfo.AddInvalidator(*tex);
info.texAttachments.push_back(cur);
} else if (rb) {
mCompletenessInfo.AddInvalidator(*rb);
} else {
continue;
}
const auto& imageInfo = cur->GetImageInfo();
MOZ_ASSERT(imageInfo);
info.width = std::min(info.width, imageInfo->mWidth);
info.height = std::min(info.height, imageInfo->mHeight);
info.hasFloat32 |= fnIsFloat32(*imageInfo->mFormat->format);
info.zLayerCount = cur->ZLayerCount();
info.isMultiview = cur->IsMultiview();
}
mCompletenessInfo = Some(std::move(info));
info.fb = nullptr; // Don't trigger the invalidation warning.
return LOCAL_GL_FRAMEBUFFER_COMPLETE;
} while (false);
MOZ_ASSERT(ret != LOCAL_GL_FRAMEBUFFER_COMPLETE);
mContext->GenerateWarning("Framebuffer not complete. (status: 0x%04x) %s",
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->Limits().maxColorDrawBuffers,
LOCAL_GL_NONE);
for (const auto& attach : mColorDrawBuffers) {
if (attach->HasAttachment()) {
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->HasAttachment()) {
driverBuffer = mColorReadBuffer->mAttachmentPoint;
}
gl->fReadBuffer(driverBuffer);
}
////
void WebGLFramebuffer::DrawBuffers(const std::vector<GLenum>& buffers) {
if (buffers.size() > mContext->MaxValidDrawBuffers()) {
// "An INVALID_VALUE error is generated if `n` is greater than
// MAX_DRAW_BUFFERS."
mContext->ErrorInvalidValue(
"`buffers` must have a length <="
" MAX_DRAW_BUFFERS.");
return;
}
std::vector<const WebGLFBAttachPoint*> newColorDrawBuffers;
newColorDrawBuffers.reserve(buffers.size());
for (const auto i : IntegerRange(buffers.size())) {
// "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("Unexpected enum in buffers.");
return;
}
mContext->ErrorInvalidOperation(
"`buffers[i]` must be NONE or"
" COLOR_ATTACHMENTi.");
return;
}
}
////
mColorDrawBuffers = std::move(newColorDrawBuffers);
RefreshDrawBuffers(); // Calls glDrawBuffers.
}
bool WebGLFramebuffer::IsDrawBufferEnabled(const uint32_t slotId) const {
const auto attachEnum = LOCAL_GL_COLOR_ATTACHMENT0 + slotId;
for (const auto& cur : mColorDrawBuffers) {
if (cur->mAttachmentPoint == attachEnum) {
return true;
}
}
return false;
}
void WebGLFramebuffer::ReadBuffer(GLenum attachPoint) {
const auto& maybeAttach = GetColorAttachPoint(attachPoint);
if (!maybeAttach) {
const char text[] =
"`mode` must be a COLOR_ATTACHMENTi, for 0 <= i <"
" MAX_DRAW_BUFFERS.";
if (attachPoint == LOCAL_GL_BACK) {
mContext->ErrorInvalidOperation(text);
} else {
mContext->ErrorInvalidEnum(text);
}
return;
}
const auto& attach = maybeAttach.value(); // Might be nullptr.
////
mColorReadBuffer = attach;
RefreshReadBuffer(); // Calls glReadBuffer.
}
////
bool WebGLFramebuffer::FramebufferAttach(const GLenum attachEnum,
const webgl::FbAttachInfo& toAttach) {
MOZ_ASSERT(mContext->mBoundDrawFramebuffer == this ||
mContext->mBoundReadFramebuffer == this);
if (MOZ_UNLIKELY(mOpaque)) {
// An opaque framebuffer's attachments cannot be inspected or changed.
return false;
}
// `attachment`
const auto maybeAttach = GetAttachPoint(attachEnum);
if (!maybeAttach || !maybeAttach.value()) return false;
const auto& attach = maybeAttach.value();
const auto& gl = mContext->gl;
gl->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, mGLName);
if (mContext->IsWebGL2() && attachEnum == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
mDepthAttachment.Set(gl, toAttach);
mStencilAttachment.Set(gl, toAttach);
} else {
attach->Set(gl, toAttach);
}
InvalidateCaches();
return true;
}
Maybe<double> WebGLFramebuffer::GetAttachmentParameter(GLenum attachEnum,
GLenum pname) {
const auto maybeAttach = GetAttachPoint(attachEnum);
if (!maybeAttach || attachEnum == LOCAL_GL_NONE) {
mContext->ErrorInvalidEnum(
"Can only query COLOR_ATTACHMENTi,"
" DEPTH_ATTACHMENT, DEPTH_STENCIL_ATTACHMENT, or"
" STENCIL_ATTACHMENT for a framebuffer.");
return Nothing();
}
if (MOZ_UNLIKELY(mOpaque)) {
mContext->ErrorInvalidOperation(
"An opaque framebuffer's attachments cannot be inspected or changed.");
return Nothing();
}
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(
"Querying"
" FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE"
" against DEPTH_STENCIL_ATTACHMENT is an"
" error.");
return Nothing();
}
if (mDepthAttachment.Renderbuffer() != mStencilAttachment.Renderbuffer() ||
mDepthAttachment.Texture() != mStencilAttachment.Texture()) {
mContext->ErrorInvalidOperation(
"DEPTH_ATTACHMENT and STENCIL_ATTACHMENT"
" have different objects bound.");
return Nothing();
}
attach = &mDepthAttachment;
}
return attach->GetParameter(mContext, attachEnum, pname);
}
////////////////////
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, GLint _srcX0,
GLint _srcY0, GLint _srcX1, GLint _srcY1,
GLint _dstX0, GLint _dstY0, GLint _dstX1,
GLint _dstY1, GLbitfield mask,
GLenum filter) {
auto srcP0 = ivec2{_srcX0, _srcY0};
auto srcP1 = ivec2{_srcX1, _srcY1};
auto dstP0 = ivec2{_dstX0, _dstY0};
auto dstP1 = ivec2{_dstX1, _dstY1};
const GLbitfield depthAndStencilBits =
LOCAL_GL_DEPTH_BUFFER_BIT | LOCAL_GL_STENCIL_BUFFER_BIT;
if (bool(mask & depthAndStencilBits) && filter == LOCAL_GL_LINEAR) {
webgl->ErrorInvalidOperation(
"DEPTH_BUFFER_BIT and STENCIL_BUFFER_BIT can"
" only be used with NEAREST filtering.");
return;
}
const auto& srcFB = webgl->mBoundReadFramebuffer;
const auto& dstFB = webgl->mBoundDrawFramebuffer;
////
// Collect data
const auto fnGetFormat =
[](const WebGLFBAttachPoint& cur,
bool* const out_hasSamples) -> const webgl::FormatInfo* {
const auto& imageInfo = cur.GetImageInfo();
if (!imageInfo) return nullptr; // No attachment.
*out_hasSamples = bool(imageInfo->mSamples);
return imageInfo->mFormat->format;
};
bool srcHasSamples = false;
bool srcIsFilterable = true;
const webgl::FormatInfo* srcColorFormat;
const webgl::FormatInfo* srcDepthFormat;
const webgl::FormatInfo* srcStencilFormat;
gfx::IntSize srcSize;
if (srcFB) {
const auto& info = *srcFB->GetCompletenessInfo();
if (info.zLayerCount != 1) {
webgl->GenerateError(
LOCAL_GL_INVALID_FRAMEBUFFER_OPERATION,
"Source framebuffer cannot have more than one multiview layer.");
return;
}
srcColorFormat = nullptr;
if (srcFB->mColorReadBuffer) {
const auto& imageInfo = srcFB->mColorReadBuffer->GetImageInfo();
if (imageInfo) {
srcIsFilterable &= imageInfo->mFormat->isFilterable;
}
srcColorFormat = fnGetFormat(*(srcFB->mColorReadBuffer), &srcHasSamples);
}
srcDepthFormat = fnGetFormat(srcFB->DepthAttachment(), &srcHasSamples);
srcStencilFormat = fnGetFormat(srcFB->StencilAttachment(), &srcHasSamples);
MOZ_ASSERT(!srcFB->DepthStencilAttachment().HasAttachment());
srcSize = {info.width, info.height};
} else {
srcHasSamples = false; // Always false.
GetBackbufferFormats(webgl, &srcColorFormat, &srcDepthFormat,
&srcStencilFormat);
const auto& size = webgl->DrawingBufferSize();
srcSize = {size.x, size.y};
}
////
bool dstHasSamples = false;
const webgl::FormatInfo* dstDepthFormat;
const webgl::FormatInfo* dstStencilFormat;
bool dstHasColor = false;
bool colorFormatsMatch = true;
bool colorTypesMatch = true;
bool colorSrgbMatches = true;
gfx::IntSize dstSize;
const auto fnCheckColorFormat = [&](const webgl::FormatInfo* dstFormat) {
MOZ_ASSERT(dstFormat->r || dstFormat->g || dstFormat->b || dstFormat->a);
dstHasColor = true;
colorFormatsMatch &= (dstFormat == srcColorFormat);
colorTypesMatch &=
srcColorFormat && (dstFormat->baseType == srcColorFormat->baseType);
colorSrgbMatches &=
srcColorFormat && (dstFormat->isSRGB == srcColorFormat->isSRGB);
};
if (dstFB) {
for (const auto& cur : dstFB->mColorDrawBuffers) {
const auto& format = fnGetFormat(*cur, &dstHasSamples);
if (!format) continue;
fnCheckColorFormat(format);
}
dstDepthFormat = fnGetFormat(dstFB->DepthAttachment(), &dstHasSamples);
dstStencilFormat = fnGetFormat(dstFB->StencilAttachment(), &dstHasSamples);
MOZ_ASSERT(!dstFB->DepthStencilAttachment().HasAttachment());
const auto& info = *dstFB->GetCompletenessInfo();
if (info.isMultiview) {
webgl->GenerateError(
LOCAL_GL_INVALID_FRAMEBUFFER_OPERATION,
"Destination framebuffer cannot have multiview attachments.");
return;
}
dstSize = {info.width, info.height};
} else {
dstHasSamples = webgl->Options().antialias;
const webgl::FormatInfo* dstColorFormat;
GetBackbufferFormats(webgl, &dstColorFormat, &dstDepthFormat,
&dstStencilFormat);
fnCheckColorFormat(dstColorFormat);
const auto& size = webgl->DrawingBufferSize();
dstSize = {size.x, size.y};
}
////
// 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 (dstHasSamples) {
webgl->ErrorInvalidOperation(
"DRAW_FRAMEBUFFER may not have multiple"
" samples.");
return;
}
bool requireFilterable = (filter == LOCAL_GL_LINEAR);
if (srcHasSamples) {
requireFilterable = false; // It picks one.
if (mask & LOCAL_GL_COLOR_BUFFER_BIT && dstHasColor && !colorFormatsMatch) {
webgl->ErrorInvalidOperation(
"Color buffer formats must match if"
" selected, when reading from a multisampled"
" source.");
return;
}
if (srcP0 != dstP0 || srcP1 != dstP1) {
webgl->ErrorInvalidOperation(
"If the source is multisampled, then the"
" source and dest regions must match exactly.");
return;
}
}
// -
if (mask & LOCAL_GL_COLOR_BUFFER_BIT) {
if (requireFilterable && !srcIsFilterable) {
webgl->ErrorInvalidOperation(
"`filter` is LINEAR and READ_BUFFER"
" contains integer data.");
return;
}
if (!colorTypesMatch) {
webgl->ErrorInvalidOperation(
"Color component types (float/uint/"
"int) must match.");
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(
"Depth buffer formats must match if selected.");
return;
}
if (mask & LOCAL_GL_STENCIL_BUFFER_BIT && dstStencilFormat &&
dstStencilFormat != srcStencilFormat) {
webgl->ErrorInvalidOperation(
"Stencil buffer formats must match if selected.");
return;
}
////
// Check for feedback
if (srcFB && dstFB) {
const WebGLFBAttachPoint* feedback = nullptr;
if (mask & LOCAL_GL_COLOR_BUFFER_BIT) {
MOZ_ASSERT(srcFB->mColorReadBuffer->HasAttachment());
for (const auto& cur : dstFB->mColorDrawBuffers) {
if (srcFB->mColorReadBuffer->IsEquivalentForFeedback(*cur)) {
feedback = cur;
break;
}
}
}
if (mask & LOCAL_GL_DEPTH_BUFFER_BIT &&
srcFB->DepthAttachment().IsEquivalentForFeedback(
dstFB->DepthAttachment())) {
feedback = &dstFB->DepthAttachment();
}
if (mask & LOCAL_GL_STENCIL_BUFFER_BIT &&
srcFB->StencilAttachment().IsEquivalentForFeedback(
dstFB->StencilAttachment())) {
feedback = &dstFB->StencilAttachment();
}
if (feedback) {
webgl->ErrorInvalidOperation(
"Feedback detected into DRAW_FRAMEBUFFER's"
" 0x%04x attachment.",
feedback->mAttachmentPoint);
return;
}
} else if (!srcFB && !dstFB) {
webgl->ErrorInvalidOperation("Feedback with default framebuffer.");
return;
}
// -
// Mutually constrain src and dst rects for eldritch blits.
[&] {
using fvec2 = avec2<float>; // Switch to float, because there's no perfect
// solution anyway.
const auto zero2f = fvec2{0, 0};
const auto srcSizef = AsVec(srcSize).StaticCast<fvec2>();
const auto dstSizef = AsVec(dstSize).StaticCast<fvec2>();
const auto srcP0f = srcP0.StaticCast<fvec2>();
const auto srcP1f = srcP1.StaticCast<fvec2>();
const auto dstP0f = dstP0.StaticCast<fvec2>();
const auto dstP1f = dstP1.StaticCast<fvec2>();
const auto srcRectDiff = srcP1f - srcP0f;
const auto dstRectDiff = dstP1f - dstP0f;
// Skip if zero-sized.
if (!srcRectDiff.x || !srcRectDiff.y || !dstRectDiff.x || !dstRectDiff.y) {
srcP0 = srcP1 = dstP0 = dstP1 = {0, 0};
return;
}
// Clamp the rect points
const auto srcQ0 = srcP0f.ClampMinMax(zero2f, srcSizef);
const auto srcQ1 = srcP1f.ClampMinMax(zero2f, srcSizef);
// Normalized to the [0,1] abstact copy rect
const auto srcQ0Norm = (srcQ0 - srcP0f) / srcRectDiff;
const auto srcQ1Norm = (srcQ1 - srcP0f) / srcRectDiff;
// Map into dst
const auto srcQ0InDst = dstP0f + srcQ0Norm * dstRectDiff;
const auto srcQ1InDst = dstP0f + srcQ1Norm * dstRectDiff;
// Clamp the rect points
const auto dstQ0 = srcQ0InDst.ClampMinMax(zero2f, dstSizef);
const auto dstQ1 = srcQ1InDst.ClampMinMax(zero2f, dstSizef);
// Alright, time to go back to src!
// Normalized to the [0,1] abstact copy rect
const auto dstQ0Norm = (dstQ0 - dstP0f) / dstRectDiff;
const auto dstQ1Norm = (dstQ1 - dstP0f) / dstRectDiff;
// Map into src
const auto dstQ0InSrc = srcP0f + dstQ0Norm * srcRectDiff;
const auto dstQ1InSrc = srcP0f + dstQ1Norm * srcRectDiff;
const auto srcQ0Constrained = dstQ0InSrc.ClampMinMax(zero2f, srcSizef);
const auto srcQ1Constrained = dstQ1InSrc.ClampMinMax(zero2f, srcSizef);
// Round, don't floor:
srcP0 = (srcQ0Constrained + 0.5).StaticCast<ivec2>();
srcP1 = (srcQ1Constrained + 0.5).StaticCast<ivec2>();
dstP0 = (dstQ0 + 0.5).StaticCast<ivec2>();
dstP1 = (dstQ1 + 0.5).StaticCast<ivec2>();
}();
bool inBounds = true;
inBounds &= (srcP0 == srcP0.Clamp({0, 0}, AsVec(srcSize)));
inBounds &= (srcP1 == srcP1.Clamp({0, 0}, AsVec(srcSize)));
inBounds &= (dstP0 == dstP0.Clamp({0, 0}, AsVec(dstSize)));
inBounds &= (dstP1 == dstP1.Clamp({0, 0}, AsVec(dstSize)));
if (!inBounds) {
webgl->ErrorImplementationBug(
"Subrects still not within src and dst after constraining.");
return;
}
// -
// Execute as constrained
const auto& gl = webgl->gl;
const ScopedDrawCallWrapper wrapper(*webgl);
gl->fBlitFramebuffer(srcP0.x, srcP0.y, srcP1.x, srcP1.y, dstP0.x, dstP0.y,
dstP1.x, dstP1.y, mask, filter);
// -
if (mask & LOCAL_GL_COLOR_BUFFER_BIT && !colorSrgbMatches && !gl->IsGLES() &&
gl->Version() < 440) {
// Mostly for Mac.
// Remember, we have to filter in the *linear* format blit.
// src -Blit-> fbB -DrawBlit-> fbC -Blit-> dst
const auto fbB = gl::MozFramebuffer::Create(gl, {1, 1}, 0, false);
const auto fbC = gl::MozFramebuffer::Create(gl, {1, 1}, 0, false);
// -
auto sizeBC = srcSize;
GLenum formatC = LOCAL_GL_RGBA8;
if (srcColorFormat->isSRGB) {
// srgb -> linear
} else {
// linear -> srgb
sizeBC = dstSize;
formatC = LOCAL_GL_SRGB8_ALPHA8;
}
const auto fnSetTex = [&](const gl::MozFramebuffer& fb,
const GLenum format) {
const gl::ScopedBindTexture bindTex(gl, fb.ColorTex());
gl->fTexStorage2D(LOCAL_GL_TEXTURE_2D, 1, format, sizeBC.width,
sizeBC.height);
};
fnSetTex(*fbB, srcColorFormat->sizedFormat);
fnSetTex(*fbC, formatC);
// -
{
const gl::ScopedBindFramebuffer bindFb(gl);
gl->fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER, fbB->mFB);
if (srcColorFormat->isSRGB) {
// srgb -> linear
gl->fBlitFramebuffer(srcP0.x, srcP0.y, srcP1.x, srcP1.y, srcP0.x,
srcP0.y, srcP1.x, srcP1.y,
LOCAL_GL_COLOR_BUFFER_BIT, LOCAL_GL_NEAREST);
} else {
// linear -> srgb
gl->fBlitFramebuffer(srcP0.x, srcP0.y, srcP1.x, srcP1.y, dstP0.x,
dstP0.y, dstP1.x, dstP1.y,
LOCAL_GL_COLOR_BUFFER_BIT, filter);
}
const auto& blitHelper = *gl->BlitHelper();
gl->fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER, fbC->mFB);
blitHelper.DrawBlitTextureToFramebuffer(fbB->ColorTex(), sizeBC, sizeBC);
}
{
const gl::ScopedBindFramebuffer bindFb(gl);
gl->fBindFramebuffer(LOCAL_GL_READ_FRAMEBUFFER, fbC->mFB);
if (srcColorFormat->isSRGB) {
// srgb -> linear
gl->fBlitFramebuffer(srcP0.x, srcP0.y, srcP1.x, srcP1.y, dstP0.x,
dstP0.y, dstP1.x, dstP1.y,
LOCAL_GL_COLOR_BUFFER_BIT, filter);
} else {
// linear -> srgb
gl->fBlitFramebuffer(dstP0.x, dstP0.y, dstP1.x, dstP1.y, dstP0.x,
dstP0.y, dstP1.x, dstP1.y,
LOCAL_GL_COLOR_BUFFER_BIT, LOCAL_GL_NEAREST);
}
}
}
// -
// glBlitFramebuffer ignores glColorMask!
if (!webgl->mBoundDrawFramebuffer && webgl->mNeedsFakeNoAlpha) {
if (!webgl->mScissorTestEnabled) {
gl->fEnable(LOCAL_GL_SCISSOR_TEST);
}
if (webgl->mRasterizerDiscardEnabled) {
gl->fDisable(LOCAL_GL_RASTERIZER_DISCARD);
}
const auto dstRectMin = MinExtents(dstP0, dstP1);
const auto dstRectMax = MaxExtents(dstP0, dstP1);
const auto dstRectSize = dstRectMax - dstRectMin;
const WebGLContext::ScissorRect dstRect = {dstRectMin.x, dstRectMin.y,
dstRectSize.x, dstRectSize.y};
dstRect.Apply(*gl);
gl->fClearColor(0, 0, 0, 1);
webgl->DoColorMask(1 << 3);
gl->fClear(LOCAL_GL_COLOR_BUFFER_BIT);
if (!webgl->mScissorTestEnabled) {
gl->fDisable(LOCAL_GL_SCISSOR_TEST);
}
if (webgl->mRasterizerDiscardEnabled) {
gl->fEnable(LOCAL_GL_RASTERIZER_DISCARD);
}
webgl->mScissorRect.Apply(*gl);
gl->fClearColor(webgl->mColorClearValue[0], webgl->mColorClearValue[1],
webgl->mColorClearValue[2], webgl->mColorClearValue[3]);
}
}
} // namespace mozilla
View git blame Copy permalink