Source code
Revision control
Copy as Markdown
Other Tools
//
// Copyright 2002 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Framebuffer.cpp: Implements the gl::Framebuffer class. Implements GL framebuffer
// objects and related functionality. [OpenGL ES 2.0.24] section 4.4 page 105.
#include "libANGLE/Framebuffer.h"
#include "common/Optional.h"
#include "common/bitset_utils.h"
#include "common/utilities.h"
#include "libANGLE/Config.h"
#include "libANGLE/Context.h"
#include "libANGLE/Display.h"
#include "libANGLE/ErrorStrings.h"
#include "libANGLE/FramebufferAttachment.h"
#include "libANGLE/PixelLocalStorage.h"
#include "libANGLE/Renderbuffer.h"
#include "libANGLE/Surface.h"
#include "libANGLE/Texture.h"
#include "libANGLE/angletypes.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/ContextImpl.h"
#include "libANGLE/renderer/FramebufferImpl.h"
#include "libANGLE/renderer/GLImplFactory.h"
#include "libANGLE/renderer/RenderbufferImpl.h"
#include "libANGLE/renderer/SurfaceImpl.h"
using namespace angle;
namespace gl
{
namespace
{
// Check the |checkAttachment| in reference to |firstAttachment| for the sake of multiview
// framebuffer completeness.
FramebufferStatus CheckMultiviewStateMatchesForCompleteness(
const FramebufferAttachment *firstAttachment,
const FramebufferAttachment *checkAttachment)
{
ASSERT(firstAttachment && checkAttachment);
ASSERT(firstAttachment->isAttached() && checkAttachment->isAttached());
if (firstAttachment->isMultiview() != checkAttachment->isMultiview())
{
return FramebufferStatus::Incomplete(GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR,
err::kFramebufferIncompleteMultiviewMismatch);
}
if (firstAttachment->getNumViews() != checkAttachment->getNumViews())
{
return FramebufferStatus::Incomplete(GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR,
err::kFramebufferIncompleteMultiviewViewsMismatch);
}
if (checkAttachment->getBaseViewIndex() + checkAttachment->getNumViews() >
checkAttachment->getSize().depth)
{
return FramebufferStatus::Incomplete(GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR,
err::kFramebufferIncompleteMultiviewBaseViewMismatch);
}
return FramebufferStatus::Complete();
}
FramebufferStatus CheckAttachmentCompleteness(const Context *context,
const FramebufferAttachment &attachment)
{
ASSERT(attachment.isAttached());
const Extents &size = attachment.getSize();
if (size.width == 0 || size.height == 0)
{
return FramebufferStatus::Incomplete(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
err::kFramebufferIncompleteAttachmentZeroSize);
}
if (!attachment.isRenderable(context))
{
return FramebufferStatus::Incomplete(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
err::kFramebufferIncompleteAttachmentNotRenderable);
}
if (attachment.type() == GL_TEXTURE)
{
// [EXT_geometry_shader] Section 9.4.1, "Framebuffer Completeness"
// If <image> is a three-dimensional texture or a two-dimensional array texture and the
// attachment is not layered, the selected layer is less than the depth or layer count,
// respectively, of the texture.
if (!attachment.isLayered())
{
if (attachment.layer() >= size.depth)
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
err::kFramebufferIncompleteAttachmentLayerGreaterThanDepth);
}
}
// If <image> is a three-dimensional texture or a two-dimensional array texture and the
// attachment is layered, the depth or layer count, respectively, of the texture is less
// than or equal to the value of MAX_FRAMEBUFFER_LAYERS_EXT.
else
{
if (size.depth >= context->getCaps().maxFramebufferLayers)
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
err::kFramebufferIncompleteAttachmentDepthGreaterThanMaxLayers);
}
}
// ES3 specifies that cube map texture attachments must be cube complete.
// This language is missing from the ES2 spec, but we enforce it here because some
// desktop OpenGL drivers also enforce this validation.
// TODO(jmadill): Check if OpenGL ES2 drivers enforce cube completeness.
const Texture *texture = attachment.getTexture();
ASSERT(texture);
if (texture->getType() == TextureType::CubeMap &&
!texture->getTextureState().isCubeComplete())
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
err::kFramebufferIncompleteAttachmentNotCubeComplete);
}
if (!texture->getImmutableFormat())
{
GLuint attachmentMipLevel = static_cast<GLuint>(attachment.mipLevel());
// From the ES 3.0 spec, pg 213:
// If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is TEXTURE and the value of
// FRAMEBUFFER_ATTACHMENT_OBJECT_NAME does not name an immutable-format texture,
// then the value of FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL must be in the
// range[levelbase, q], where levelbase is the value of TEXTURE_BASE_LEVEL and q is
// the effective maximum texture level defined in the Mipmapping discussion of
// section 3.8.10.4.
if (attachmentMipLevel < texture->getBaseLevel() ||
attachmentMipLevel > texture->getMipmapMaxLevel())
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
err::kFramebufferIncompleteAttachmentLevelOutOfBaseMaxLevelRange);
}
// Form the ES 3.0 spec, pg 213/214:
// If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is TEXTURE and the value of
// FRAMEBUFFER_ATTACHMENT_OBJECT_NAME does not name an immutable-format texture and
// the value of FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL is not levelbase, then the
// texture must be mipmap complete, and if FRAMEBUFFER_ATTACHMENT_OBJECT_NAME names
// a cubemap texture, the texture must also be cube complete.
if (attachmentMipLevel != texture->getBaseLevel() && !texture->isMipmapComplete())
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
err::kFramebufferIncompleteAttachmentLevelNotBaseLevelForIncompleteMipTexture);
}
}
}
return FramebufferStatus::Complete();
}
FramebufferStatus CheckAttachmentSampleCounts(const Context *context,
GLsizei currAttachmentSamples,
GLsizei samples,
bool colorAttachment)
{
if (currAttachmentSamples != samples)
{
if (colorAttachment)
{
// APPLE_framebuffer_multisample, which EXT_draw_buffers refers to, requires that
// all color attachments have the same number of samples for the FBO to be complete.
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE,
err::kFramebufferIncompleteMultisampleInconsistentSampleCounts);
}
else
{
// CHROMIUM_framebuffer_mixed_samples allows a framebuffer to be considered complete
// when its depth or stencil samples are a multiple of the number of color samples.
if (!context->getExtensions().framebufferMixedSamplesCHROMIUM)
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE,
err::kFramebufferIncompleteMultisampleInconsistentSampleCounts);
}
if ((currAttachmentSamples % std::max(samples, 1)) != 0)
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE,
err::
kFramebufferIncompleteMultisampleDepthStencilSampleCountDivisibleByColorSampleCount);
}
}
}
return FramebufferStatus::Complete();
}
FramebufferStatus CheckAttachmentSampleCompleteness(const Context *context,
const FramebufferAttachment &attachment,
bool colorAttachment,
Optional<int> *samples,
Optional<bool> *fixedSampleLocations,
Optional<int> *renderToTextureSamples)
{
ASSERT(attachment.isAttached());
if (attachment.type() == GL_TEXTURE)
{
const Texture *texture = attachment.getTexture();
ASSERT(texture);
GLenum sizedInternalFormat = attachment.getFormat().info->sizedInternalFormat;
const TextureCaps &formatCaps = context->getTextureCaps().get(sizedInternalFormat);
if (static_cast<GLuint>(attachment.getSamples()) > formatCaps.getMaxSamples())
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE,
err::kFramebufferIncompleteAttachmentSamplesGreaterThanMaxSupportedSamples);
}
const ImageIndex &attachmentImageIndex = attachment.getTextureImageIndex();
bool fixedSampleloc = texture->getAttachmentFixedSampleLocations(attachmentImageIndex);
if (fixedSampleLocations->valid() && fixedSampleloc != fixedSampleLocations->value())
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE,
err::kFramebufferIncompleteMultisampleInconsistentFixedSampleLocations);
}
else
{
*fixedSampleLocations = fixedSampleloc;
}
}
if (renderToTextureSamples->valid())
{
// Only check against RenderToTextureSamples if they actually exist.
if (renderToTextureSamples->value() !=
FramebufferAttachment::kDefaultRenderToTextureSamples)
{
FramebufferStatus sampleCountStatus =
CheckAttachmentSampleCounts(context, attachment.getRenderToTextureSamples(),
renderToTextureSamples->value(), colorAttachment);
if (!sampleCountStatus.isComplete())
{
return sampleCountStatus;
}
}
}
else
{
*renderToTextureSamples = attachment.getRenderToTextureSamples();
}
if (samples->valid())
{
// RenderToTextureSamples takes precedence if they exist.
if (renderToTextureSamples->value() ==
FramebufferAttachment::kDefaultRenderToTextureSamples)
{
FramebufferStatus sampleCountStatus = CheckAttachmentSampleCounts(
context, attachment.getSamples(), samples->value(), colorAttachment);
if (!sampleCountStatus.isComplete())
{
return sampleCountStatus;
}
}
}
else
{
*samples = attachment.getSamples();
}
return FramebufferStatus::Complete();
}
// Needed to index into the attachment arrays/bitsets.
static_assert(static_cast<size_t>(IMPLEMENTATION_MAX_DRAW_BUFFERS) ==
Framebuffer::DIRTY_BIT_COLOR_ATTACHMENT_MAX,
"Framebuffer Dirty bit mismatch");
static_assert(static_cast<size_t>(IMPLEMENTATION_MAX_DRAW_BUFFERS) ==
Framebuffer::DIRTY_BIT_DEPTH_ATTACHMENT,
"Framebuffer Dirty bit mismatch");
static_assert(static_cast<size_t>(IMPLEMENTATION_MAX_DRAW_BUFFERS + 1) ==
Framebuffer::DIRTY_BIT_STENCIL_ATTACHMENT,
"Framebuffer Dirty bit mismatch");
angle::Result InitAttachment(const Context *context, FramebufferAttachment *attachment)
{
ASSERT(attachment->isAttached());
if (attachment->initState() == InitState::MayNeedInit)
{
ANGLE_TRY(attachment->initializeContents(context));
}
return angle::Result::Continue;
}
bool AttachmentOverlapsWithTexture(const FramebufferAttachment &attachment,
const Texture *texture,
const Sampler *sampler)
{
if (!attachment.isTextureWithId(texture->id()))
{
return false;
}
const gl::ImageIndex &index = attachment.getTextureImageIndex();
GLuint attachmentLevel = static_cast<GLuint>(index.getLevelIndex());
GLuint textureEffectiveBaseLevel = texture->getTextureState().getEffectiveBaseLevel();
GLuint textureMaxLevel = textureEffectiveBaseLevel;
if ((sampler && IsMipmapFiltered(sampler->getSamplerState().getMinFilter())) ||
IsMipmapFiltered(texture->getSamplerState().getMinFilter()))
{
textureMaxLevel = texture->getMipmapMaxLevel();
}
return attachmentLevel >= textureEffectiveBaseLevel && attachmentLevel <= textureMaxLevel;
}
} // anonymous namespace
bool FramebufferStatus::isComplete() const
{
return status == GL_FRAMEBUFFER_COMPLETE;
}
FramebufferStatus FramebufferStatus::Complete()
{
FramebufferStatus result;
result.status = GL_FRAMEBUFFER_COMPLETE;
result.reason = nullptr;
return result;
}
FramebufferStatus FramebufferStatus::Incomplete(GLenum status, const char *reason)
{
ASSERT(status != GL_FRAMEBUFFER_COMPLETE);
FramebufferStatus result;
result.status = status;
result.reason = reason;
return result;
}
// This constructor is only used for default framebuffers.
FramebufferState::FramebufferState(rx::Serial serial)
: mId(Framebuffer::kDefaultDrawFramebufferHandle),
mFramebufferSerial(serial),
mLabel(),
mColorAttachments(1),
mColorAttachmentsMask(0),
mDrawBufferStates(1, GL_BACK),
mReadBufferState(GL_BACK),
mDrawBufferTypeMask(),
mDefaultWidth(0),
mDefaultHeight(0),
mDefaultSamples(0),
mDefaultFixedSampleLocations(GL_FALSE),
mDefaultLayers(0),
mFlipY(GL_FALSE),
mWebGLDepthStencilConsistent(true),
mDefaultFramebufferReadAttachmentInitialized(false),
mSrgbWriteControlMode(SrgbWriteControlMode::Default)
{
ASSERT(mDrawBufferStates.size() > 0);
mEnabledDrawBuffers.set(0);
}
FramebufferState::FramebufferState(const Caps &caps, FramebufferID id, rx::Serial serial)
: mId(id),
mFramebufferSerial(serial),
mLabel(),
mColorAttachments(caps.maxColorAttachments),
mColorAttachmentsMask(0),
mDrawBufferStates(caps.maxDrawBuffers, GL_NONE),
mReadBufferState(GL_COLOR_ATTACHMENT0_EXT),
mDrawBufferTypeMask(),
mDefaultWidth(0),
mDefaultHeight(0),
mDefaultSamples(0),
mDefaultFixedSampleLocations(GL_FALSE),
mDefaultLayers(0),
mFlipY(GL_FALSE),
mWebGLDepthStencilConsistent(true),
mDefaultFramebufferReadAttachmentInitialized(false),
mSrgbWriteControlMode(SrgbWriteControlMode::Default)
{
ASSERT(mId != Framebuffer::kDefaultDrawFramebufferHandle);
ASSERT(mDrawBufferStates.size() > 0);
mDrawBufferStates[0] = GL_COLOR_ATTACHMENT0_EXT;
}
FramebufferState::~FramebufferState() {}
const std::string &FramebufferState::getLabel() const
{
return mLabel;
}
const FramebufferAttachment *FramebufferState::getAttachment(const Context *context,
GLenum attachment) const
{
if (attachment >= GL_COLOR_ATTACHMENT0 && attachment <= GL_COLOR_ATTACHMENT15)
{
return getColorAttachment(attachment - GL_COLOR_ATTACHMENT0);
}
// WebGL1 allows a developer to query for attachment parameters even when "inconsistant" (i.e.
// multiple conflicting attachment points) and requires us to return the framebuffer attachment
// associated with WebGL.
switch (attachment)
{
case GL_COLOR:
case GL_BACK:
return getColorAttachment(0);
case GL_DEPTH:
case GL_DEPTH_ATTACHMENT:
if (context->isWebGL1())
{
return getWebGLDepthAttachment();
}
else
{
return getDepthAttachment();
}
case GL_STENCIL:
case GL_STENCIL_ATTACHMENT:
if (context->isWebGL1())
{
return getWebGLStencilAttachment();
}
else
{
return getStencilAttachment();
}
case GL_DEPTH_STENCIL:
case GL_DEPTH_STENCIL_ATTACHMENT:
if (context->isWebGL1())
{
return getWebGLDepthStencilAttachment();
}
else
{
return getDepthStencilAttachment();
}
default:
UNREACHABLE();
return nullptr;
}
}
uint32_t FramebufferState::getReadIndex() const
{
ASSERT(mReadBufferState == GL_BACK ||
(mReadBufferState >= GL_COLOR_ATTACHMENT0 && mReadBufferState <= GL_COLOR_ATTACHMENT15));
uint32_t readIndex = mReadBufferState == GL_BACK ? 0 : mReadBufferState - GL_COLOR_ATTACHMENT0;
ASSERT(readIndex < mColorAttachments.size());
return readIndex;
}
const FramebufferAttachment *FramebufferState::getReadAttachment() const
{
if (mReadBufferState == GL_NONE)
{
return nullptr;
}
uint32_t readIndex = getReadIndex();
const gl::FramebufferAttachment &framebufferAttachment =
isDefault() ? mDefaultFramebufferReadAttachment : mColorAttachments[readIndex];
return framebufferAttachment.isAttached() ? &framebufferAttachment : nullptr;
}
const FramebufferAttachment *FramebufferState::getReadPixelsAttachment(GLenum readFormat) const
{
switch (readFormat)
{
case GL_DEPTH_COMPONENT:
return getDepthAttachment();
case GL_STENCIL_INDEX_OES:
return getStencilOrDepthStencilAttachment();
case GL_DEPTH_STENCIL_OES:
return getDepthStencilAttachment();
default:
return getReadAttachment();
}
}
const FramebufferAttachment *FramebufferState::getFirstNonNullAttachment() const
{
auto *colorAttachment = getFirstColorAttachment();
if (colorAttachment)
{
return colorAttachment;
}
return getDepthOrStencilAttachment();
}
const FramebufferAttachment *FramebufferState::getFirstColorAttachment() const
{
for (const FramebufferAttachment &colorAttachment : mColorAttachments)
{
if (colorAttachment.isAttached())
{
return &colorAttachment;
}
}
return nullptr;
}
const FramebufferAttachment *FramebufferState::getDepthOrStencilAttachment() const
{
if (mDepthAttachment.isAttached())
{
return &mDepthAttachment;
}
if (mStencilAttachment.isAttached())
{
return &mStencilAttachment;
}
return nullptr;
}
const FramebufferAttachment *FramebufferState::getStencilOrDepthStencilAttachment() const
{
if (mStencilAttachment.isAttached())
{
return &mStencilAttachment;
}
return getDepthStencilAttachment();
}
const FramebufferAttachment *FramebufferState::getColorAttachment(size_t colorAttachment) const
{
ASSERT(colorAttachment < mColorAttachments.size());
return mColorAttachments[colorAttachment].isAttached() ? &mColorAttachments[colorAttachment]
: nullptr;
}
const FramebufferAttachment *FramebufferState::getDepthAttachment() const
{
return mDepthAttachment.isAttached() ? &mDepthAttachment : nullptr;
}
const FramebufferAttachment *FramebufferState::getWebGLDepthAttachment() const
{
return mWebGLDepthAttachment.isAttached() ? &mWebGLDepthAttachment : nullptr;
}
const FramebufferAttachment *FramebufferState::getWebGLDepthStencilAttachment() const
{
return mWebGLDepthStencilAttachment.isAttached() ? &mWebGLDepthStencilAttachment : nullptr;
}
const FramebufferAttachment *FramebufferState::getStencilAttachment() const
{
return mStencilAttachment.isAttached() ? &mStencilAttachment : nullptr;
}
const FramebufferAttachment *FramebufferState::getWebGLStencilAttachment() const
{
return mWebGLStencilAttachment.isAttached() ? &mWebGLStencilAttachment : nullptr;
}
const FramebufferAttachment *FramebufferState::getDepthStencilAttachment() const
{
// A valid depth-stencil attachment has the same resource bound to both the
// depth and stencil attachment points.
if (mDepthAttachment.isAttached() && mStencilAttachment.isAttached() &&
mDepthAttachment == mStencilAttachment)
{
return &mDepthAttachment;
}
return nullptr;
}
const Extents FramebufferState::getAttachmentExtentsIntersection() const
{
int32_t width = std::numeric_limits<int32_t>::max();
int32_t height = std::numeric_limits<int32_t>::max();
for (const FramebufferAttachment &attachment : mColorAttachments)
{
if (attachment.isAttached())
{
width = std::min(width, attachment.getSize().width);
height = std::min(height, attachment.getSize().height);
}
}
if (mDepthAttachment.isAttached())
{
width = std::min(width, mDepthAttachment.getSize().width);
height = std::min(height, mDepthAttachment.getSize().height);
}
if (mStencilAttachment.isAttached())
{
width = std::min(width, mStencilAttachment.getSize().width);
height = std::min(height, mStencilAttachment.getSize().height);
}
return Extents(width, height, 0);
}
bool FramebufferState::attachmentsHaveSameDimensions() const
{
Optional<Extents> attachmentSize;
auto hasMismatchedSize = [&attachmentSize](const FramebufferAttachment &attachment) {
if (!attachment.isAttached())
{
return false;
}
if (!attachmentSize.valid())
{
attachmentSize = attachment.getSize();
return false;
}
const auto &prevSize = attachmentSize.value();
const auto &curSize = attachment.getSize();
return (curSize.width != prevSize.width || curSize.height != prevSize.height);
};
for (const auto &attachment : mColorAttachments)
{
if (hasMismatchedSize(attachment))
{
return false;
}
}
if (hasMismatchedSize(mDepthAttachment))
{
return false;
}
return !hasMismatchedSize(mStencilAttachment);
}
bool FramebufferState::hasSeparateDepthAndStencilAttachments() const
{
// if we have both a depth and stencil buffer, they must refer to the same object
// since we only support packed_depth_stencil and not separate depth and stencil
return (getDepthAttachment() != nullptr && getStencilAttachment() != nullptr &&
getDepthStencilAttachment() == nullptr);
}
const FramebufferAttachment *FramebufferState::getDrawBuffer(size_t drawBufferIdx) const
{
ASSERT(drawBufferIdx < mDrawBufferStates.size());
if (mDrawBufferStates[drawBufferIdx] != GL_NONE)
{
// ES3 spec: "If the GL is bound to a draw framebuffer object, the ith buffer listed in bufs
// must be COLOR_ATTACHMENTi or NONE"
ASSERT(mDrawBufferStates[drawBufferIdx] == GL_COLOR_ATTACHMENT0 + drawBufferIdx ||
(drawBufferIdx == 0 && mDrawBufferStates[drawBufferIdx] == GL_BACK));
if (mDrawBufferStates[drawBufferIdx] == GL_BACK)
{
return getColorAttachment(0);
}
else
{
return getColorAttachment(mDrawBufferStates[drawBufferIdx] - GL_COLOR_ATTACHMENT0);
}
}
else
{
return nullptr;
}
}
size_t FramebufferState::getDrawBufferCount() const
{
return mDrawBufferStates.size();
}
bool FramebufferState::colorAttachmentsAreUniqueImages() const
{
for (size_t firstAttachmentIdx = 0; firstAttachmentIdx < mColorAttachments.size();
firstAttachmentIdx++)
{
const FramebufferAttachment &firstAttachment = mColorAttachments[firstAttachmentIdx];
if (!firstAttachment.isAttached())
{
continue;
}
for (size_t secondAttachmentIdx = firstAttachmentIdx + 1;
secondAttachmentIdx < mColorAttachments.size(); secondAttachmentIdx++)
{
const FramebufferAttachment &secondAttachment = mColorAttachments[secondAttachmentIdx];
if (!secondAttachment.isAttached())
{
continue;
}
if (firstAttachment == secondAttachment)
{
return false;
}
}
}
return true;
}
bool FramebufferState::hasDepth() const
{
return (mDepthAttachment.isAttached() && mDepthAttachment.getDepthSize() > 0);
}
bool FramebufferState::hasStencil() const
{
return (mStencilAttachment.isAttached() && mStencilAttachment.getStencilSize() > 0);
}
bool FramebufferState::hasExternalTextureAttachment() const
{
// External textures can only be bound to color attachment 0
return (mColorAttachments[0].isAttached() && mColorAttachments[0].isExternalTexture());
}
bool FramebufferState::hasYUVAttachment() const
{
// The only attachments that can be YUV are external textures and surfaces, both are attached at
// color attachment 0.
return (mColorAttachments[0].isAttached() && mColorAttachments[0].isYUV());
}
bool FramebufferState::isMultiview() const
{
const FramebufferAttachment *attachment = getFirstNonNullAttachment();
if (attachment == nullptr)
{
return false;
}
return attachment->isMultiview();
}
int FramebufferState::getBaseViewIndex() const
{
const FramebufferAttachment *attachment = getFirstNonNullAttachment();
if (attachment == nullptr)
{
return GL_NONE;
}
return attachment->getBaseViewIndex();
}
Box FramebufferState::getDimensions() const
{
Extents extents = getExtents();
return Box(0, 0, 0, extents.width, extents.height, extents.depth);
}
Extents FramebufferState::getExtents() const
{
// section 4.4.4.2) allows attachments have unequal size.
const FramebufferAttachment *first = getFirstNonNullAttachment();
if (first)
{
return getAttachmentExtentsIntersection();
}
return Extents(getDefaultWidth(), getDefaultHeight(), 0);
}
bool FramebufferState::isDefault() const
{
return mId == Framebuffer::kDefaultDrawFramebufferHandle;
}
bool FramebufferState::isBoundAsDrawFramebuffer(const Context *context) const
{
return context->getState().getDrawFramebuffer()->id() == mId;
}
const FramebufferID Framebuffer::kDefaultDrawFramebufferHandle = {0};
Framebuffer::Framebuffer(const Context *context, rx::GLImplFactory *factory)
: mState(context->getShareGroup()->generateFramebufferSerial()),
mImpl(factory->createFramebuffer(mState)),
mCachedStatus(FramebufferStatus::Incomplete(GL_FRAMEBUFFER_UNDEFINED_OES,
err::kFramebufferIncompleteSurfaceless)),
mDirtyDepthAttachmentBinding(this, DIRTY_BIT_DEPTH_ATTACHMENT),
mDirtyStencilAttachmentBinding(this, DIRTY_BIT_STENCIL_ATTACHMENT)
{
mDirtyColorAttachmentBindings.emplace_back(this, DIRTY_BIT_COLOR_ATTACHMENT_0);
SetComponentTypeMask(getDrawbufferWriteType(0), 0, &mState.mDrawBufferTypeMask);
}
Framebuffer::Framebuffer(const Context *context, rx::GLImplFactory *factory, FramebufferID id)
: mState(context->getCaps(), id, context->getShareGroup()->generateFramebufferSerial()),
mImpl(factory->createFramebuffer(mState)),
mCachedStatus(),
mDirtyDepthAttachmentBinding(this, DIRTY_BIT_DEPTH_ATTACHMENT),
mDirtyStencilAttachmentBinding(this, DIRTY_BIT_STENCIL_ATTACHMENT)
{
ASSERT(mImpl != nullptr);
ASSERT(mState.mColorAttachments.size() ==
static_cast<size_t>(context->getCaps().maxColorAttachments));
for (uint32_t colorIndex = 0;
colorIndex < static_cast<uint32_t>(mState.mColorAttachments.size()); ++colorIndex)
{
mDirtyColorAttachmentBindings.emplace_back(this, DIRTY_BIT_COLOR_ATTACHMENT_0 + colorIndex);
}
if (context->getClientVersion() >= ES_3_0)
{
mDirtyBits.set(DIRTY_BIT_READ_BUFFER);
}
}
Framebuffer::~Framebuffer()
{
SafeDelete(mImpl);
}
void Framebuffer::onDestroy(const Context *context)
{
if (isDefault())
{
std::ignore = unsetSurfaces(context);
}
for (auto &attachment : mState.mColorAttachments)
{
attachment.detach(context, mState.mFramebufferSerial);
}
mState.mDepthAttachment.detach(context, mState.mFramebufferSerial);
mState.mStencilAttachment.detach(context, mState.mFramebufferSerial);
mState.mWebGLDepthAttachment.detach(context, mState.mFramebufferSerial);
mState.mWebGLStencilAttachment.detach(context, mState.mFramebufferSerial);
mState.mWebGLDepthStencilAttachment.detach(context, mState.mFramebufferSerial);
if (mPixelLocalStorage)
{
mPixelLocalStorage->onFramebufferDestroyed(context);
}
mImpl->destroy(context);
}
egl::Error Framebuffer::setSurfaces(const Context *context,
egl::Surface *surface,
egl::Surface *readSurface)
{
// This has to be a default framebuffer.
ASSERT(isDefault());
ASSERT(mDirtyColorAttachmentBindings.size() == 1);
ASSERT(mDirtyColorAttachmentBindings[0].getSubjectIndex() == DIRTY_BIT_COLOR_ATTACHMENT_0);
ASSERT(!mState.mColorAttachments[0].isAttached());
ASSERT(!mState.mDepthAttachment.isAttached());
ASSERT(!mState.mStencilAttachment.isAttached());
if (surface)
{
setAttachmentImpl(context, GL_FRAMEBUFFER_DEFAULT, GL_BACK, ImageIndex(), surface,
FramebufferAttachment::kDefaultNumViews,
FramebufferAttachment::kDefaultBaseViewIndex, false,
FramebufferAttachment::kDefaultRenderToTextureSamples);
mDirtyBits.set(DIRTY_BIT_COLOR_ATTACHMENT_0);
if (surface->getConfig()->depthSize > 0)
{
setAttachmentImpl(context, GL_FRAMEBUFFER_DEFAULT, GL_DEPTH, ImageIndex(), surface,
FramebufferAttachment::kDefaultNumViews,
FramebufferAttachment::kDefaultBaseViewIndex, false,
FramebufferAttachment::kDefaultRenderToTextureSamples);
mDirtyBits.set(DIRTY_BIT_DEPTH_ATTACHMENT);
}
if (surface->getConfig()->stencilSize > 0)
{
setAttachmentImpl(context, GL_FRAMEBUFFER_DEFAULT, GL_STENCIL, ImageIndex(), surface,
FramebufferAttachment::kDefaultNumViews,
FramebufferAttachment::kDefaultBaseViewIndex, false,
FramebufferAttachment::kDefaultRenderToTextureSamples);
mDirtyBits.set(DIRTY_BIT_STENCIL_ATTACHMENT);
}
mState.mSurfaceTextureOffset = surface->getTextureOffset();
// Ensure the backend has a chance to synchronize its content for a new backbuffer.
mDirtyBits.set(DIRTY_BIT_COLOR_BUFFER_CONTENTS_0);
}
setReadSurface(context, readSurface);
SetComponentTypeMask(getDrawbufferWriteType(0), 0, &mState.mDrawBufferTypeMask);
ASSERT(mCachedStatus.value().status == GL_FRAMEBUFFER_UNDEFINED_OES);
ASSERT(mCachedStatus.value().reason == err::kFramebufferIncompleteSurfaceless);
if (surface)
{
mCachedStatus = FramebufferStatus::Complete();
ANGLE_TRY(surface->getImplementation()->attachToFramebuffer(context, this));
}
return egl::NoError();
}
void Framebuffer::setReadSurface(const Context *context, egl::Surface *readSurface)
{
// This has to be a default framebuffer.
ASSERT(isDefault());
ASSERT(mDirtyColorAttachmentBindings.size() == 1);
ASSERT(mDirtyColorAttachmentBindings[0].getSubjectIndex() == DIRTY_BIT_COLOR_ATTACHMENT_0);
// Read surface is not attached.
ASSERT(!mState.mDefaultFramebufferReadAttachment.isAttached());
// updateAttachment() without mState.mResourceNeedsInit.set()
mState.mDefaultFramebufferReadAttachment.attach(
context, GL_FRAMEBUFFER_DEFAULT, GL_BACK, ImageIndex(), readSurface,
FramebufferAttachment::kDefaultNumViews, FramebufferAttachment::kDefaultBaseViewIndex,
false, FramebufferAttachment::kDefaultRenderToTextureSamples, mState.mFramebufferSerial);
if (context->getClientVersion() >= ES_3_0)
{
mDirtyBits.set(DIRTY_BIT_READ_BUFFER);
}
}
egl::Error Framebuffer::unsetSurfaces(const Context *context)
{
// This has to be a default framebuffer.
ASSERT(isDefault());
ASSERT(mDirtyColorAttachmentBindings.size() == 1);
ASSERT(mDirtyColorAttachmentBindings[0].getSubjectIndex() == DIRTY_BIT_COLOR_ATTACHMENT_0);
if (mState.mColorAttachments[0].isAttached())
{
const egl::Surface *surface = mState.mColorAttachments[0].getSurface();
mState.mColorAttachments[0].detach(context, mState.mFramebufferSerial);
mDirtyBits.set(DIRTY_BIT_COLOR_ATTACHMENT_0);
if (mState.mDepthAttachment.isAttached())
{
mState.mDepthAttachment.detach(context, mState.mFramebufferSerial);
mDirtyBits.set(DIRTY_BIT_DEPTH_ATTACHMENT);
}
if (mState.mStencilAttachment.isAttached())
{
mState.mStencilAttachment.detach(context, mState.mFramebufferSerial);
mDirtyBits.set(DIRTY_BIT_STENCIL_ATTACHMENT);
}
ANGLE_TRY(surface->getImplementation()->detachFromFramebuffer(context, this));
ASSERT(mCachedStatus.value().status == GL_FRAMEBUFFER_COMPLETE);
mCachedStatus = FramebufferStatus::Incomplete(GL_FRAMEBUFFER_UNDEFINED_OES,
err::kFramebufferIncompleteSurfaceless);
}
else
{
ASSERT(!mState.mDepthAttachment.isAttached());
ASSERT(!mState.mStencilAttachment.isAttached());
ASSERT(mCachedStatus.value().status == GL_FRAMEBUFFER_UNDEFINED_OES);
ASSERT(mCachedStatus.value().reason == err::kFramebufferIncompleteSurfaceless);
}
mState.mDefaultFramebufferReadAttachment.detach(context, mState.mFramebufferSerial);
mState.mDefaultFramebufferReadAttachmentInitialized = false;
return egl::NoError();
}
angle::Result Framebuffer::setLabel(const Context *context, const std::string &label)
{
mState.mLabel = label;
if (mImpl)
{
return mImpl->onLabelUpdate(context);
}
return angle::Result::Continue;
}
const std::string &Framebuffer::getLabel() const
{
return mState.mLabel;
}
bool Framebuffer::detachTexture(const Context *context, TextureID textureId)
{
return detachResourceById(context, GL_TEXTURE, textureId.value);
}
bool Framebuffer::detachRenderbuffer(const Context *context, RenderbufferID renderbufferId)
{
return detachResourceById(context, GL_RENDERBUFFER, renderbufferId.value);
}
bool Framebuffer::detachResourceById(const Context *context, GLenum resourceType, GLuint resourceId)
{
bool found = false;
for (size_t colorIndex = 0; colorIndex < mState.mColorAttachments.size(); ++colorIndex)
{
if (detachMatchingAttachment(context, &mState.mColorAttachments[colorIndex], resourceType,
resourceId))
{
found = true;
}
}
if (context->isWebGL1())
{
const std::array<FramebufferAttachment *, 3> attachments = {
{&mState.mWebGLDepthStencilAttachment, &mState.mWebGLDepthAttachment,
&mState.mWebGLStencilAttachment}};
for (FramebufferAttachment *attachment : attachments)
{
if (detachMatchingAttachment(context, attachment, resourceType, resourceId))
{
found = true;
}
}
}
else
{
if (detachMatchingAttachment(context, &mState.mDepthAttachment, resourceType, resourceId))
{
found = true;
}
if (detachMatchingAttachment(context, &mState.mStencilAttachment, resourceType, resourceId))
{
found = true;
}
}
return found;
}
bool Framebuffer::detachMatchingAttachment(const Context *context,
FramebufferAttachment *attachment,
GLenum matchType,
GLuint matchId)
{
if (attachment->isAttached() && attachment->type() == matchType && attachment->id() == matchId)
{
// We go through resetAttachment to make sure that all the required bookkeeping will be done
// such as updating enabled draw buffer state.
resetAttachment(context, attachment->getBinding());
return true;
}
return false;
}
const FramebufferAttachment *Framebuffer::getColorAttachment(size_t colorAttachment) const
{
return mState.getColorAttachment(colorAttachment);
}
const FramebufferAttachment *Framebuffer::getDepthAttachment() const
{
return mState.getDepthAttachment();
}
const FramebufferAttachment *Framebuffer::getStencilAttachment() const
{
return mState.getStencilAttachment();
}
const FramebufferAttachment *Framebuffer::getDepthStencilAttachment() const
{
return mState.getDepthStencilAttachment();
}
const FramebufferAttachment *Framebuffer::getDepthOrStencilAttachment() const
{
return mState.getDepthOrStencilAttachment();
}
const FramebufferAttachment *Framebuffer::getStencilOrDepthStencilAttachment() const
{
return mState.getStencilOrDepthStencilAttachment();
}
const FramebufferAttachment *Framebuffer::getReadColorAttachment() const
{
return mState.getReadAttachment();
}
GLenum Framebuffer::getReadColorAttachmentType() const
{
const FramebufferAttachment *readAttachment = mState.getReadAttachment();
return (readAttachment != nullptr ? readAttachment->type() : GL_NONE);
}
const FramebufferAttachment *Framebuffer::getFirstColorAttachment() const
{
return mState.getFirstColorAttachment();
}
const FramebufferAttachment *Framebuffer::getFirstNonNullAttachment() const
{
return mState.getFirstNonNullAttachment();
}
const FramebufferAttachment *Framebuffer::getAttachment(const Context *context,
GLenum attachment) const
{
return mState.getAttachment(context, attachment);
}
size_t Framebuffer::getDrawbufferStateCount() const
{
return mState.mDrawBufferStates.size();
}
GLenum Framebuffer::getDrawBufferState(size_t drawBuffer) const
{
ASSERT(drawBuffer < mState.mDrawBufferStates.size());
return mState.mDrawBufferStates[drawBuffer];
}
const DrawBuffersVector<GLenum> &Framebuffer::getDrawBufferStates() const
{
return mState.getDrawBufferStates();
}
void Framebuffer::setDrawBuffers(size_t count, const GLenum *buffers)
{
auto &drawStates = mState.mDrawBufferStates;
ASSERT(count <= drawStates.size());
std::copy(buffers, buffers + count, drawStates.begin());
std::fill(drawStates.begin() + count, drawStates.end(), GL_NONE);
mDirtyBits.set(DIRTY_BIT_DRAW_BUFFERS);
mState.mEnabledDrawBuffers.reset();
mState.mDrawBufferTypeMask.reset();
for (size_t index = 0; index < count; ++index)
{
SetComponentTypeMask(getDrawbufferWriteType(index), index, &mState.mDrawBufferTypeMask);
if (drawStates[index] != GL_NONE && mState.mColorAttachments[index].isAttached())
{
mState.mEnabledDrawBuffers.set(index);
}
}
}
const FramebufferAttachment *Framebuffer::getDrawBuffer(size_t drawBuffer) const
{
return mState.getDrawBuffer(drawBuffer);
}
ComponentType Framebuffer::getDrawbufferWriteType(size_t drawBuffer) const
{
const FramebufferAttachment *attachment = mState.getDrawBuffer(drawBuffer);
if (attachment == nullptr)
{
return ComponentType::NoType;
}
GLenum componentType = attachment->getFormat().info->componentType;
switch (componentType)
{
case GL_INT:
return ComponentType::Int;
case GL_UNSIGNED_INT:
return ComponentType::UnsignedInt;
default:
return ComponentType::Float;
}
}
ComponentTypeMask Framebuffer::getDrawBufferTypeMask() const
{
return mState.mDrawBufferTypeMask;
}
DrawBufferMask Framebuffer::getDrawBufferMask() const
{
return mState.mEnabledDrawBuffers;
}
bool Framebuffer::hasEnabledDrawBuffer() const
{
for (size_t drawbufferIdx = 0; drawbufferIdx < mState.mDrawBufferStates.size(); ++drawbufferIdx)
{
if (getDrawBuffer(drawbufferIdx) != nullptr)
{
return true;
}
}
return false;
}
GLenum Framebuffer::getReadBufferState() const
{
return mState.mReadBufferState;
}
void Framebuffer::setReadBuffer(GLenum buffer)
{
ASSERT(buffer == GL_BACK || buffer == GL_NONE ||
(buffer >= GL_COLOR_ATTACHMENT0 &&
(buffer - GL_COLOR_ATTACHMENT0) < mState.mColorAttachments.size()));
if (mState.mReadBufferState != buffer)
{
mState.mReadBufferState = buffer;
mDirtyBits.set(DIRTY_BIT_READ_BUFFER);
}
}
size_t Framebuffer::getNumColorAttachments() const
{
return mState.mColorAttachments.size();
}
bool Framebuffer::hasDepth() const
{
return mState.hasDepth();
}
bool Framebuffer::hasStencil() const
{
return mState.hasStencil();
}
bool Framebuffer::hasExternalTextureAttachment() const
{
return mState.hasExternalTextureAttachment();
}
bool Framebuffer::hasYUVAttachment() const
{
return mState.hasYUVAttachment();
}
bool Framebuffer::usingExtendedDrawBuffers() const
{
for (size_t drawbufferIdx = 1; drawbufferIdx < mState.mDrawBufferStates.size(); ++drawbufferIdx)
{
if (getDrawBuffer(drawbufferIdx) != nullptr)
{
return true;
}
}
return false;
}
void Framebuffer::invalidateCompletenessCache()
{
if (!isDefault())
{
mCachedStatus.reset();
}
onStateChange(angle::SubjectMessage::DirtyBitsFlagged);
}
const FramebufferStatus &Framebuffer::checkStatusImpl(const Context *context) const
{
ASSERT(!isDefault());
ASSERT(hasAnyDirtyBit() || !mCachedStatus.valid());
mCachedStatus = checkStatusWithGLFrontEnd(context);
if (mCachedStatus.value().isComplete())
{
// We can skip syncState on several back-ends.
if (mImpl->shouldSyncStateBeforeCheckStatus())
{
// This binding is not totally correct. It is ok because the parameter isn't used in
// the GL back-end and the GL back-end is the only user of syncStateBeforeCheckStatus.
angle::Result err = syncState(context, GL_FRAMEBUFFER, Command::Other);
if (err != angle::Result::Continue)
{
mCachedStatus =
FramebufferStatus::Incomplete(0, err::kFramebufferIncompleteInternalError);
return mCachedStatus.value();
}
}
mCachedStatus = mImpl->checkStatus(context);
}
return mCachedStatus.value();
}
FramebufferStatus Framebuffer::checkStatusWithGLFrontEnd(const Context *context) const
{
const State &state = context->getState();
ASSERT(!isDefault());
bool hasAttachments = false;
Optional<unsigned int> colorbufferSize;
Optional<int> samples;
Optional<bool> fixedSampleLocations;
bool hasRenderbuffer = false;
Optional<int> renderToTextureSamples;
const FramebufferAttachment *firstAttachment = getFirstNonNullAttachment();
Optional<bool> isLayered;
Optional<TextureType> colorAttachmentsTextureType;
for (const FramebufferAttachment &colorAttachment : mState.mColorAttachments)
{
if (colorAttachment.isAttached())
{
FramebufferStatus attachmentCompleteness =
CheckAttachmentCompleteness(context, colorAttachment);
if (!attachmentCompleteness.isComplete())
{
return attachmentCompleteness;
}
const InternalFormat &format = *colorAttachment.getFormat().info;
if (format.depthBits > 0 || format.stencilBits > 0)
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
err::kFramebufferIncompleteDepthStencilInColorBuffer);
}
FramebufferStatus attachmentSampleCompleteness =
CheckAttachmentSampleCompleteness(context, colorAttachment, true, &samples,
&fixedSampleLocations, &renderToTextureSamples);
if (!attachmentSampleCompleteness.isComplete())
{
return attachmentSampleCompleteness;
}
// in GLES 2.0, all color attachments attachments must have the same number of bitplanes
// in GLES 3.0, there is no such restriction
if (state.getClientMajorVersion() < 3)
{
if (colorbufferSize.valid())
{
if (format.pixelBytes != colorbufferSize.value())
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_UNSUPPORTED,
err::kFramebufferIncompleteAttachmentInconsistantBitPlanes);
}
}
else
{
colorbufferSize = format.pixelBytes;
}
}
FramebufferStatus attachmentMultiviewCompleteness =
CheckMultiviewStateMatchesForCompleteness(firstAttachment, &colorAttachment);
if (!attachmentMultiviewCompleteness.isComplete())
{
return attachmentMultiviewCompleteness;
}
hasRenderbuffer = hasRenderbuffer || (colorAttachment.type() == GL_RENDERBUFFER);
if (!hasAttachments)
{
isLayered = colorAttachment.isLayered();
if (isLayered.value())
{
colorAttachmentsTextureType = colorAttachment.getTextureImageIndex().getType();
}
hasAttachments = true;
}
else
{
// [EXT_geometry_shader] section 9.4.1, "Framebuffer Completeness"
// If any framebuffer attachment is layered, all populated attachments
// must be layered. Additionally, all populated color attachments must
// be from textures of the same target. {FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT }
ASSERT(isLayered.valid());
if (isLayered.value() != colorAttachment.isLayered())
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT,
err::kFramebufferIncompleteMismatchedLayeredAttachments);
}
else if (isLayered.value())
{
ASSERT(colorAttachmentsTextureType.valid());
if (colorAttachmentsTextureType.value() !=
colorAttachment.getTextureImageIndex().getType())
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT,
err::kFramebufferIncompleteMismatchedLayeredTexturetypes);
}
}
}
}
}
const FramebufferAttachment &depthAttachment = mState.mDepthAttachment;
if (depthAttachment.isAttached())
{
FramebufferStatus attachmentCompleteness =
CheckAttachmentCompleteness(context, depthAttachment);
if (!attachmentCompleteness.isComplete())
{
return attachmentCompleteness;
}
const InternalFormat &format = *depthAttachment.getFormat().info;
if (format.depthBits == 0)
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
err::kFramebufferIncompleteAttachmentNoDepthBitsInDepthBuffer);
}
FramebufferStatus attachmentSampleCompleteness =
CheckAttachmentSampleCompleteness(context, depthAttachment, false, &samples,
&fixedSampleLocations, &renderToTextureSamples);
if (!attachmentSampleCompleteness.isComplete())
{
return attachmentSampleCompleteness;
}
FramebufferStatus attachmentMultiviewCompleteness =
CheckMultiviewStateMatchesForCompleteness(firstAttachment, &depthAttachment);
if (!attachmentMultiviewCompleteness.isComplete())
{
return attachmentMultiviewCompleteness;
}
hasRenderbuffer = hasRenderbuffer || (depthAttachment.type() == GL_RENDERBUFFER);
if (!hasAttachments)
{
isLayered = depthAttachment.isLayered();
hasAttachments = true;
}
else
{
// [EXT_geometry_shader] section 9.4.1, "Framebuffer Completeness"
// If any framebuffer attachment is layered, all populated attachments
// must be layered. {FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT }
ASSERT(isLayered.valid());
if (isLayered.value() != depthAttachment.isLayered())
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT,
err::kFramebufferIncompleteMismatchedLayeredAttachments);
}
}
}
const FramebufferAttachment &stencilAttachment = mState.mStencilAttachment;
if (stencilAttachment.isAttached())
{
FramebufferStatus attachmentCompleteness =
CheckAttachmentCompleteness(context, stencilAttachment);
if (!attachmentCompleteness.isComplete())
{
return attachmentCompleteness;
}
const InternalFormat &format = *stencilAttachment.getFormat().info;
if (format.stencilBits == 0)
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
err::kFramebufferIncompleteAttachmentNoStencilBitsInStencilBuffer);
}
FramebufferStatus attachmentSampleCompleteness =
CheckAttachmentSampleCompleteness(context, stencilAttachment, false, &samples,
&fixedSampleLocations, &renderToTextureSamples);
if (!attachmentSampleCompleteness.isComplete())
{
return attachmentSampleCompleteness;
}
FramebufferStatus attachmentMultiviewCompleteness =
CheckMultiviewStateMatchesForCompleteness(firstAttachment, &stencilAttachment);
if (!attachmentMultiviewCompleteness.isComplete())
{
return attachmentMultiviewCompleteness;
}
hasRenderbuffer = hasRenderbuffer || (stencilAttachment.type() == GL_RENDERBUFFER);
if (!hasAttachments)
{
hasAttachments = true;
}
else
{
// [EXT_geometry_shader] section 9.4.1, "Framebuffer Completeness"
// If any framebuffer attachment is layered, all populated attachments
// must be layered.
// {FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT }
ASSERT(isLayered.valid());
if (isLayered.value() != stencilAttachment.isLayered())
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT,
err::kFramebufferIncompleteMismatchedLayeredAttachments);
}
}
}
// Starting from ES 3.0 stencil and depth, if present, should be the same image
if (state.getClientMajorVersion() >= 3 && depthAttachment.isAttached() &&
stencilAttachment.isAttached() && stencilAttachment != depthAttachment)
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_UNSUPPORTED,
err::kFramebufferIncompleteDepthAndStencilBuffersNotTheSame);
}
// Special additional validation for WebGL 1 DEPTH/STENCIL/DEPTH_STENCIL.
if (state.isWebGL1())
{
if (!mState.mWebGLDepthStencilConsistent)
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_UNSUPPORTED,
err::kFramebufferIncompleteWebGLDepthStencilInconsistant);
}
if (mState.mWebGLDepthStencilAttachment.isAttached())
{
if (mState.mWebGLDepthStencilAttachment.getDepthSize() == 0 ||
mState.mWebGLDepthStencilAttachment.getStencilSize() == 0)
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
err::kFramebufferIncompleteAttachmentWebGLDepthStencilNoDepthOrStencilBits);
}
FramebufferStatus attachmentMultiviewCompleteness =
CheckMultiviewStateMatchesForCompleteness(firstAttachment,
&mState.mWebGLDepthStencilAttachment);
if (!attachmentMultiviewCompleteness.isComplete())
{
return attachmentMultiviewCompleteness;
}
}
else if (mState.mStencilAttachment.isAttached() &&
mState.mStencilAttachment.getDepthSize() > 0)
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
err::kFramebufferIncompleteAttachmentWebGLStencilBufferHasDepthBits);
}
else if (mState.mDepthAttachment.isAttached() &&
mState.mDepthAttachment.getStencilSize() > 0)
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT,
err::kFramebufferIncompleteAttachmentWebGLDepthBufferHasStencilBits);
}
}
// ES3.1(section 9.4) requires that if no image is attached to the framebuffer, and either the
// value of the framebuffer's FRAMEBUFFER_DEFAULT_WIDTH or FRAMEBUFFER_DEFAULT_HEIGHT parameters
// is zero, the framebuffer is considered incomplete.
GLint defaultWidth = mState.getDefaultWidth();
GLint defaultHeight = mState.getDefaultHeight();
if (!hasAttachments && (defaultWidth == 0 || defaultHeight == 0))
{
return FramebufferStatus::Incomplete(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT,
err::kFramebufferIncompleteDefaultZeroSize);
}
// In ES 2.0 and WebGL, all color attachments must have the same width and height.
// In ES 3.0, there is no such restriction.
if ((state.getClientMajorVersion() < 3 || state.getExtensions().webglCompatibilityANGLE) &&
!mState.attachmentsHaveSameDimensions())
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS,
err::kFramebufferIncompleteInconsistantAttachmentSizes);
}
// ES3.1(section 9.4) requires that if the attached images are a mix of renderbuffers and
// textures, the value of TEXTURE_FIXED_SAMPLE_LOCATIONS must be TRUE for all attached textures.
if (fixedSampleLocations.valid() && hasRenderbuffer && !fixedSampleLocations.value())
{
return FramebufferStatus::Incomplete(
GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE,
err::kFramebufferIncompleteMultisampleNonFixedSamplesWithRenderbuffers);
}
// The WebGL conformance tests implicitly define that all framebuffer
// attachments must be unique. For example, the same level of a texture can
// not be attached to two different color attachments.
if (state.getExtensions().webglCompatibilityANGLE)
{
if (!mState.colorAttachmentsAreUniqueImages())
{
return FramebufferStatus::Incomplete(GL_FRAMEBUFFER_UNSUPPORTED,
err::kFramebufferIncompleteAttachmentsNotUnique);
}
}
return FramebufferStatus::Complete();
}
angle::Result Framebuffer::discard(const Context *context, size_t count, const GLenum *attachments)
{
// Back-ends might make the contents of the FBO undefined. In WebGL 2.0, invalidate operations
// can be no-ops, so we should probably do that to ensure consistency.
// TODO(jmadill): WebGL behaviour, and robust resource init behaviour without WebGL.
return mImpl->discard(context, count, attachments);
}
angle::Result Framebuffer::invalidate(const Context *context,
size_t count,
const GLenum *attachments)
{
// Back-ends might make the contents of the FBO undefined. In WebGL 2.0, invalidate operations
// can be no-ops, so we should probably do that to ensure consistency.
// TODO(jmadill): WebGL behaviour, and robust resource init behaviour without WebGL.
return mImpl->invalidate(context, count, attachments);
}
bool Framebuffer::partialClearNeedsInit(const Context *context,
bool color,
bool depth,
bool stencil)
{
const auto &glState = context->getState();
if (!glState.isRobustResourceInitEnabled())
{
return false;
}
if (depth && context->getFrontendFeatures().forceDepthAttachmentInitOnClear.enabled)
{
return true;
}
// Scissors can affect clearing.
// TODO(jmadill): Check for complete scissor overlap.
if (glState.isScissorTestEnabled())
{
return true;
}
// If colors masked, we must clear before we clear. Do a simple check.
// TODO(jmadill): Filter out unused color channels from the test.
if (color && glState.anyActiveDrawBufferChannelMasked())
{
return true;
}
const auto &depthStencil = glState.getDepthStencilState();
if (stencil && (depthStencil.stencilMask != depthStencil.stencilWritemask ||
depthStencil.stencilBackMask != depthStencil.stencilBackWritemask))
{
return true;
}
return false;
}
angle::Result Framebuffer::invalidateSub(const Context *context,
size_t count,
const GLenum *attachments,
const Rectangle &area)
{
// Back-ends might make the contents of the FBO undefined. In WebGL 2.0, invalidate operations
// can be no-ops, so we should probably do that to ensure consistency.
// TODO(jmadill): Make a invalidate no-op in WebGL 2.0.
return mImpl->invalidateSub(context, count, attachments, area);
}
angle::Result Framebuffer::clear(const Context *context, GLbitfield mask)
{
ASSERT(mask && !context->getState().isRasterizerDiscardEnabled());
return mImpl->clear(context, mask);
}
angle::Result Framebuffer::clearBufferfv(const Context *context,
GLenum buffer,
GLint drawbuffer,
const GLfloat *values)
{
return mImpl->clearBufferfv(context, buffer, drawbuffer, values);
}
angle::Result Framebuffer::clearBufferuiv(const Context *context,
GLenum buffer,
GLint drawbuffer,
const GLuint *values)
{
return mImpl->clearBufferuiv(context, buffer, drawbuffer, values);
}
angle::Result Framebuffer::clearBufferiv(const Context *context,
GLenum buffer,
GLint drawbuffer,
const GLint *values)
{
return mImpl->clearBufferiv(context, buffer, drawbuffer, values);
}
angle::Result Framebuffer::clearBufferfi(const Context *context,
GLenum buffer,
GLint drawbuffer,
GLfloat depth,
GLint stencil)
{
const bool clearDepth =
getDepthAttachment() != nullptr && context->getState().getDepthStencilState().depthMask;
const bool clearStencil = getStencilAttachment() != nullptr &&
context->getState().getDepthStencilState().stencilWritemask != 0;
if (clearDepth && clearStencil)
{
ASSERT(buffer == GL_DEPTH_STENCIL);
ANGLE_TRY(mImpl->clearBufferfi(context, GL_DEPTH_STENCIL, drawbuffer, depth, stencil));
}
else if (clearDepth && !clearStencil)
{
ANGLE_TRY(mImpl->clearBufferfv(context, GL_DEPTH, drawbuffer, &depth));
}
else if (!clearDepth && clearStencil)
{
ANGLE_TRY(mImpl->clearBufferiv(context, GL_STENCIL, drawbuffer, &stencil));
}
return angle::Result::Continue;
}
GLenum Framebuffer::getImplementationColorReadFormat(const Context *context)
{
const gl::InternalFormat &format = mImpl->getImplementationColorReadFormat(context);
return format.getReadPixelsFormat(context->getExtensions());
}
GLenum Framebuffer::getImplementationColorReadType(const Context *context)
{
const gl::InternalFormat &format = mImpl->getImplementationColorReadFormat(context);
return format.getReadPixelsType(context->getClientVersion());
}
angle::Result Framebuffer::readPixels(const Context *context,
const Rectangle &area,
GLenum format,
GLenum type,
const PixelPackState &pack,
Buffer *packBuffer,
void *pixels)
{
ANGLE_TRY(mImpl->readPixels(context, area, format, type, pack, packBuffer, pixels));
if (packBuffer)
{
packBuffer->onDataChanged();
}
return angle::Result::Continue;
}
angle::Result Framebuffer::blit(const Context *context,
const Rectangle &sourceArea,
const Rectangle &destArea,
GLbitfield mask,
GLenum filter)
{
ASSERT(mask != 0);
ANGLE_TRY(mImpl->blit(context, sourceArea, destArea, mask, filter));
// Mark the contents of the attachments dirty
if ((mask & GL_COLOR_BUFFER_BIT) != 0)
{
for (size_t colorIndex : mState.mEnabledDrawBuffers)
{
mDirtyBits.set(DIRTY_BIT_COLOR_BUFFER_CONTENTS_0 + colorIndex);
}
}
if ((mask & GL_DEPTH_BUFFER_BIT) != 0)
{
mDirtyBits.set(DIRTY_BIT_DEPTH_BUFFER_CONTENTS);
}
if ((mask & GL_STENCIL_BUFFER_BIT) != 0)
{
mDirtyBits.set(DIRTY_BIT_STENCIL_BUFFER_CONTENTS);
}
onStateChange(angle::SubjectMessage::DirtyBitsFlagged);
return angle::Result::Continue;
}
int Framebuffer::getSamples(const Context *context) const
{
if (!isComplete(context))
{
return 0;
}
ASSERT(mCachedStatus.valid() && mCachedStatus.value().isComplete());
// For a complete framebuffer, all attachments must have the same sample count.
// In this case return the first nonzero sample size.
const FramebufferAttachment *firstNonNullAttachment = mState.getFirstNonNullAttachment();
ASSERT(firstNonNullAttachment == nullptr || firstNonNullAttachment->isAttached());
return firstNonNullAttachment ? firstNonNullAttachment->getSamples() : 0;
}
int Framebuffer::getReadBufferResourceSamples(const Context *context) const
{
if (!isComplete(context))
{
return 0;
}
ASSERT(mCachedStatus.valid() && mCachedStatus.value().isComplete());
const FramebufferAttachment *readAttachment = mState.getReadAttachment();
ASSERT(readAttachment == nullptr || readAttachment->isAttached());
return readAttachment ? readAttachment->getResourceSamples() : 0;
}
angle::Result Framebuffer::getSamplePosition(const Context *context,
size_t index,
GLfloat *xy) const
{
ANGLE_TRY(mImpl->getSamplePosition(context, index, xy));
return angle::Result::Continue;
}
bool Framebuffer::hasValidDepthStencil() const
{
return mState.getDepthStencilAttachment() != nullptr;
}
const gl::Offset &Framebuffer::getSurfaceTextureOffset() const
{
return mState.getSurfaceTextureOffset();
}
void Framebuffer::setAttachment(const Context *context,
GLenum type,
GLenum binding,
const ImageIndex &textureIndex,
FramebufferAttachmentObject *resource)
{
setAttachment(context, type, binding, textureIndex, resource,
FramebufferAttachment::kDefaultNumViews,
FramebufferAttachment::kDefaultBaseViewIndex, false,
FramebufferAttachment::kDefaultRenderToTextureSamples);
}
void Framebuffer::setAttachmentMultisample(const Context *context,
GLenum type,
GLenum binding,
const ImageIndex &textureIndex,
FramebufferAttachmentObject *resource,
GLsizei samples)
{
setAttachment(context, type, binding, textureIndex, resource,
FramebufferAttachment::kDefaultNumViews,
FramebufferAttachment::kDefaultBaseViewIndex, false, samples);
}
void Framebuffer::setAttachment(const Context *context,
GLenum type,
GLenum binding,
const ImageIndex &textureIndex,
FramebufferAttachmentObject *resource,
GLsizei numViews,
GLuint baseViewIndex,
bool isMultiview,
GLsizei samplesIn)
{
GLsizei samples = samplesIn;
// Match the sample count to the attachment's sample count.
if (resource)
{
const InternalFormat *info = resource->getAttachmentFormat(binding, textureIndex).info;
ASSERT(info);
GLenum sizedInternalFormat = info->sizedInternalFormat;
const TextureCaps &formatCaps = context->getTextureCaps().get(sizedInternalFormat);
samples = formatCaps.getNearestSamples(samples);
}
// Context may be null in unit tests.
if (!context || !context->isWebGL1())
{
setAttachmentImpl(context, type, binding, textureIndex, resource, numViews, baseViewIndex,
isMultiview, samples);
return;
}
switch (binding)
{
case GL_DEPTH_STENCIL:
case GL_DEPTH_STENCIL_ATTACHMENT:
mState.mWebGLDepthStencilAttachment.attach(
context, type, binding, textureIndex, resource, numViews, baseViewIndex,
isMultiview, samples, mState.mFramebufferSerial);
break;
case GL_DEPTH:
case GL_DEPTH_ATTACHMENT:
mState.mWebGLDepthAttachment.attach(context, type, binding, textureIndex, resource,
numViews, baseViewIndex, isMultiview, samples,
mState.mFramebufferSerial);
break;
case GL_STENCIL:
case GL_STENCIL_ATTACHMENT:
mState.mWebGLStencilAttachment.attach(context, type, binding, textureIndex, resource,
numViews, baseViewIndex, isMultiview, samples,
mState.mFramebufferSerial);
break;
default:
setAttachmentImpl(context, type, binding, textureIndex, resource, numViews,
baseViewIndex, isMultiview, samples);
return;
}
commitWebGL1DepthStencilIfConsistent(context, numViews, baseViewIndex, isMultiview, samples);
}
void Framebuffer::setAttachmentMultiview(const Context *context,
GLenum type,
GLenum binding,
const ImageIndex &textureIndex,
FramebufferAttachmentObject *resource,
GLsizei numViews,
GLint baseViewIndex)
{
setAttachment(context, type, binding, textureIndex, resource, numViews, baseViewIndex, true,
FramebufferAttachment::kDefaultRenderToTextureSamples);
}
void Framebuffer::commitWebGL1DepthStencilIfConsistent(const Context *context,
GLsizei numViews,
GLuint baseViewIndex,
bool isMultiview,
GLsizei samples)
{
int count = 0;
std::array<FramebufferAttachment *, 3> attachments = {{&mState.mWebGLDepthStencilAttachment,
&mState.mWebGLDepthAttachment,
&mState.mWebGLStencilAttachment}};
for (FramebufferAttachment *attachment : attachments)
{
if (attachment->isAttached())
{
count++;
}
}
mState.mWebGLDepthStencilConsistent = (count <= 1);
if (!mState.mWebGLDepthStencilConsistent)
{
// Inconsistent.
return;
}
auto getImageIndexIfTextureAttachment = [](const FramebufferAttachment &attachment) {
if (attachment.type() == GL_TEXTURE)
{
return attachment.getTextureImageIndex();
}
else
{
return ImageIndex();
}
};
if (mState.mWebGLDepthAttachment.isAttached())
{
const auto &depth = mState.mWebGLDepthAttachment;
setAttachmentImpl(context, depth.type(), GL_DEPTH_ATTACHMENT,
getImageIndexIfTextureAttachment(depth), depth.getResource(), numViews,
baseViewIndex, isMultiview, samples);
setAttachmentImpl(context, GL_NONE, GL_STENCIL_ATTACHMENT, ImageIndex(), nullptr, numViews,
baseViewIndex, isMultiview, samples);
}
else if (mState.mWebGLStencilAttachment.isAttached())
{
const auto &stencil = mState.mWebGLStencilAttachment;
setAttachmentImpl(context, GL_NONE, GL_DEPTH_ATTACHMENT, ImageIndex(), nullptr, numViews,
baseViewIndex, isMultiview, samples);
setAttachmentImpl(context, stencil.type(), GL_STENCIL_ATTACHMENT,
getImageIndexIfTextureAttachment(stencil), stencil.getResource(),
numViews, baseViewIndex, isMultiview, samples);
}
else if (mState.mWebGLDepthStencilAttachment.isAttached())
{
const auto &depthStencil = mState.mWebGLDepthStencilAttachment;
setAttachmentImpl(context, depthStencil.type(), GL_DEPTH_ATTACHMENT,
getImageIndexIfTextureAttachment(depthStencil),
depthStencil.getResource(), numViews, baseViewIndex, isMultiview,
samples);
setAttachmentImpl(context, depthStencil.type(), GL_STENCIL_ATTACHMENT,
getImageIndexIfTextureAttachment(depthStencil),
depthStencil.getResource(), numViews, baseViewIndex, isMultiview,
samples);
}
else
{
setAttachmentImpl(context, GL_NONE, GL_DEPTH_ATTACHMENT, ImageIndex(), nullptr, numViews,
baseViewIndex, isMultiview, samples);
setAttachmentImpl(context, GL_NONE, GL_STENCIL_ATTACHMENT, ImageIndex(), nullptr, numViews,
baseViewIndex, isMultiview, samples);
}
}
void Framebuffer::setAttachmentImpl(const Context *context,
GLenum type,
GLenum binding,
const ImageIndex &textureIndex,
FramebufferAttachmentObject *resource,
GLsizei numViews,
GLuint baseViewIndex,
bool isMultiview,
GLsizei samples)
{
switch (binding)
{
case GL_DEPTH_STENCIL:
case GL_DEPTH_STENCIL_ATTACHMENT:
updateAttachment(context, &mState.mDepthAttachment, DIRTY_BIT_DEPTH_ATTACHMENT,
&mDirtyDepthAttachmentBinding, type, binding, textureIndex, resource,
numViews, baseViewIndex, isMultiview, samples);
updateAttachment(context, &mState.mStencilAttachment, DIRTY_BIT_STENCIL_ATTACHMENT,
&mDirtyStencilAttachmentBinding, type, binding, textureIndex, resource,
numViews, baseViewIndex, isMultiview, samples);
break;
case GL_DEPTH:
case GL_DEPTH_ATTACHMENT:
updateAttachment(context, &mState.mDepthAttachment, DIRTY_BIT_DEPTH_ATTACHMENT,
&mDirtyDepthAttachmentBinding, type, binding, textureIndex, resource,
numViews, baseViewIndex, isMultiview, samples);
break;
case GL_STENCIL:
case GL_STENCIL_ATTACHMENT:
updateAttachment(context, &mState.mStencilAttachment, DIRTY_BIT_STENCIL_ATTACHMENT,
&mDirtyStencilAttachmentBinding, type, binding, textureIndex, resource,
numViews, baseViewIndex, isMultiview, samples);
break;
case GL_BACK:
updateAttachment(context, &mState.mColorAttachments[0], DIRTY_BIT_COLOR_ATTACHMENT_0,
&mDirtyColorAttachmentBindings[0], type, binding, textureIndex,
resource, numViews, baseViewIndex, isMultiview, samples);
mState.mColorAttachmentsMask.set(0);
break;
default:
{
size_t colorIndex = binding - GL_COLOR_ATTACHMENT0;
ASSERT(colorIndex < mState.mColorAttachments.size());
size_t dirtyBit = DIRTY_BIT_COLOR_ATTACHMENT_0 + colorIndex;
updateAttachment(context, &mState.mColorAttachments[colorIndex], dirtyBit,
&mDirtyColorAttachmentBindings[colorIndex], type, binding,
textureIndex, resource, numViews, baseViewIndex, isMultiview, samples);
if (!resource)
{
mFloat32ColorAttachmentBits.reset(colorIndex);
mState.mColorAttachmentsMask.reset(colorIndex);
}
else
{
updateFloat32ColorAttachmentBits(
colorIndex, resource->getAttachmentFormat(binding, textureIndex).info);
mState.mColorAttachmentsMask.set(colorIndex);
}
bool enabled = (type != GL_NONE && getDrawBufferState(colorIndex) != GL_NONE);
mState.mEnabledDrawBuffers.set(colorIndex, enabled);
SetComponentTypeMask(getDrawbufferWriteType(colorIndex), colorIndex,
&mState.mDrawBufferTypeMask);
}
break;
}
}
void Framebuffer::updateAttachment(const Context *context,
FramebufferAttachment *attachment,
size_t dirtyBit,
angle::ObserverBinding *onDirtyBinding,
GLenum type,
GLenum binding,
const ImageIndex &textureIndex,
FramebufferAttachmentObject *resource,
GLsizei numViews,
GLuint baseViewIndex,
bool isMultiview,
GLsizei samples)
{
attachment->attach(context, type, binding, textureIndex, resource, numViews, baseViewIndex,
isMultiview, samples, mState.mFramebufferSerial);
mDirtyBits.set(dirtyBit);
mState.mResourceNeedsInit.set(dirtyBit, attachment->initState() == InitState::MayNeedInit);
onDirtyBinding->bind(resource);
invalidateCompletenessCache();
}
void Framebuffer::resetAttachment(const Context *context, GLenum binding)
{
setAttachment(context, GL_NONE, binding, ImageIndex(), nullptr);
}
void Framebuffer::setWriteControlMode(SrgbWriteControlMode srgbWriteControlMode)
{
if (srgbWriteControlMode != mState.getWriteControlMode())
{
mState.mSrgbWriteControlMode = srgbWriteControlMode;
mDirtyBits.set(DIRTY_BIT_FRAMEBUFFER_SRGB_WRITE_CONTROL_MODE);
}
}
angle::Result Framebuffer::syncState(const Context *context,
GLenum framebufferBinding,
Command command) const
{
if (mDirtyBits.any())
{
mDirtyBitsGuard = mDirtyBits;
ANGLE_TRY(mImpl->syncState(context, framebufferBinding, mDirtyBits, command));
mDirtyBits.reset();
mDirtyBitsGuard.reset();
}
return angle::Result::Continue;
}
void Framebuffer::onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message)
{
if (message != angle::SubjectMessage::SubjectChanged)
{
// This can be triggered by SubImage calls for Textures.
if (message == angle::SubjectMessage::ContentsChanged)
{
mDirtyBits.set(DIRTY_BIT_COLOR_BUFFER_CONTENTS_0 + index);
onStateChange(angle::SubjectMessage::DirtyBitsFlagged);
return;
}
// Swapchain changes should only result in color buffer changes.
if (message == angle::SubjectMessage::SwapchainImageChanged)
{
if (index < DIRTY_BIT_COLOR_ATTACHMENT_MAX)
{
mDirtyBits.set(DIRTY_BIT_COLOR_BUFFER_CONTENTS_0 + index);
onStateChange(angle::SubjectMessage::DirtyBitsFlagged);
}
return;
}
ASSERT(message != angle::SubjectMessage::BindingChanged);
// This can be triggered by external changes to the default framebuffer.
if (message == angle::SubjectMessage::SurfaceChanged)
{
onStateChange(angle::SubjectMessage::SurfaceChanged);
return;
}
// This can be triggered by freeing TextureStorage in D3D back-end.
if (message == angle::SubjectMessage::StorageReleased)
{
mDirtyBits.set(index);
invalidateCompletenessCache();
return;
}
// This can be triggered by the GL back-end TextureGL class.
ASSERT(message == angle::SubjectMessage::DirtyBitsFlagged);
return;
}
ASSERT(!mDirtyBitsGuard.valid() || mDirtyBitsGuard.value().test(index));
mDirtyBits.set(index);
invalidateCompletenessCache();
FramebufferAttachment *attachment = getAttachmentFromSubjectIndex(index);
// Mark the appropriate init flag.
mState.mResourceNeedsInit.set(index, attachment->initState() == InitState::MayNeedInit);
// Update mFloat32ColorAttachmentBits Cache
if (index < DIRTY_BIT_COLOR_ATTACHMENT_MAX)
{
ASSERT(index != DIRTY_BIT_DEPTH_ATTACHMENT);
ASSERT(index != DIRTY_BIT_STENCIL_ATTACHMENT);
updateFloat32ColorAttachmentBits(index - DIRTY_BIT_COLOR_ATTACHMENT_0,
attachment->getFormat().info);
}
}
FramebufferAttachment *Framebuffer::getAttachmentFromSubjectIndex(angle::SubjectIndex index)
{
switch (index)
{
case DIRTY_BIT_DEPTH_ATTACHMENT:
return &mState.mDepthAttachment;
case DIRTY_BIT_STENCIL_ATTACHMENT:
return &mState.mStencilAttachment;
default:
size_t colorIndex = (index - DIRTY_BIT_COLOR_ATTACHMENT_0);
ASSERT(colorIndex < mState.mColorAttachments.size());
return &mState.mColorAttachments[colorIndex];
}
}
bool Framebuffer::formsRenderingFeedbackLoopWith(const Context *context) const
{
const State &glState = context->getState();
const ProgramExecutable *executable = glState.getLinkedProgramExecutable(context);
// In some error cases there may be no bound program or executable.
if (!executable)
return false;
const ActiveTextureMask &activeTextures = executable->getActiveSamplersMask();
const ActiveTextureTypeArray &textureTypes = executable->getActiveSamplerTypes();
for (size_t textureIndex : activeTextures)
{
unsigned int uintIndex = static_cast<unsigned int>(textureIndex);
Texture *texture = glState.getSamplerTexture(uintIndex, textureTypes[textureIndex]);
const Sampler *sampler = glState.getSampler(uintIndex);
if (texture && texture->isSamplerComplete(context, sampler) &&
texture->isBoundToFramebuffer(mState.mFramebufferSerial))
{
// Check for level overlap.
for (const FramebufferAttachment &attachment : mState.mColorAttachments)
{
if (AttachmentOverlapsWithTexture(attachment, texture, sampler))
{
return true;
}
}
if (AttachmentOverlapsWithTexture(mState.mDepthAttachment, texture, sampler))
{
return true;
}
if (AttachmentOverlapsWithTexture(mState.mStencilAttachment, texture, sampler))
{
return true;
}
}
}
return false;
}
bool Framebuffer::formsCopyingFeedbackLoopWith(TextureID copyTextureID,
GLint copyTextureLevel,
GLint copyTextureLayer) const
{
if (mState.isDefault())
{
// It seems impossible to form a texture copying feedback loop with the default FBO.
return false;
}
const FramebufferAttachment *readAttachment = getReadColorAttachment();
ASSERT(readAttachment);
if (readAttachment->isTextureWithId(copyTextureID))
{
const auto &imageIndex = readAttachment->getTextureImageIndex();
if (imageIndex.getLevelIndex() == copyTextureLevel)
{
// Check 3D/Array texture layers.
return !imageIndex.hasLayer() || copyTextureLayer == ImageIndex::kEntireLevel ||
imageIndex.getLayerIndex() == copyTextureLayer;
}
}
return false;
}
GLint Framebuffer::getDefaultWidth() const
{
return mState.getDefaultWidth();
}
GLint Framebuffer::getDefaultHeight() const
{
return mState.getDefaultHeight();
}
GLint Framebuffer::getDefaultSamples() const
{
return mState.getDefaultSamples();
}
bool Framebuffer::getDefaultFixedSampleLocations() const
{
return mState.getDefaultFixedSampleLocations();
}
GLint Framebuffer::getDefaultLayers() const
{
return mState.getDefaultLayers();
}
bool Framebuffer::getFlipY() const
{
return mState.getFlipY();
}
void Framebuffer::setDefaultWidth(const Context *context, GLint defaultWidth)
{
mState.mDefaultWidth = defaultWidth;
mDirtyBits.set(DIRTY_BIT_DEFAULT_WIDTH);
invalidateCompletenessCache();
}
void Framebuffer::setDefaultHeight(const Context *context, GLint defaultHeight)
{
mState.mDefaultHeight = defaultHeight;
mDirtyBits.set(DIRTY_BIT_DEFAULT_HEIGHT);
invalidateCompletenessCache();
}
void Framebuffer::setDefaultSamples(const Context *context, GLint defaultSamples)
{
mState.mDefaultSamples = defaultSamples;
mDirtyBits.set(DIRTY_BIT_DEFAULT_SAMPLES);
invalidateCompletenessCache();
}
void Framebuffer::setDefaultFixedSampleLocations(const Context *context,
bool defaultFixedSampleLocations)
{
mState.mDefaultFixedSampleLocations = defaultFixedSampleLocations;
mDirtyBits.set(DIRTY_BIT_DEFAULT_FIXED_SAMPLE_LOCATIONS);
invalidateCompletenessCache();
}
void Framebuffer::setDefaultLayers(GLint defaultLayers)
{
mState.mDefaultLayers = defaultLayers;
mDirtyBits.set(DIRTY_BIT_DEFAULT_LAYERS);
}
void Framebuffer::setFlipY(bool flipY)
{
mState.mFlipY = flipY;
mDirtyBits.set(DIRTY_BIT_FLIP_Y);
invalidateCompletenessCache();
}
GLsizei Framebuffer::getNumViews() const
{
return mState.getNumViews();
}
GLint Framebuffer::getBaseViewIndex() const
{
return mState.getBaseViewIndex();
}
bool Framebuffer::isMultiview() const
{
return mState.isMultiview();
}
bool Framebuffer::readDisallowedByMultiview() const
{
return (mState.isMultiview() && mState.getNumViews() > 1);
}
angle::Result Framebuffer::ensureClearAttachmentsInitialized(const Context *context,
GLbitfield mask)
{
const auto &glState = context->getState();
if (!context->isRobustResourceInitEnabled() || glState.isRasterizerDiscardEnabled())
{
return angle::Result::Continue;
}
const DepthStencilState &depthStencil = glState.getDepthStencilState();
bool color = (mask & GL_COLOR_BUFFER_BIT) != 0 && !glState.allActiveDrawBufferChannelsMasked();
bool depth = (mask & GL_DEPTH_BUFFER_BIT) != 0 && !depthStencil.isDepthMaskedOut();
bool stencil = (mask & GL_STENCIL_BUFFER_BIT) != 0 && !depthStencil.isStencilMaskedOut();
if (!color && !depth && !stencil)
{
return angle::Result::Continue;
}
if (partialClearNeedsInit(context, color, depth, stencil))
{
ANGLE_TRY(ensureDrawAttachmentsInitialized(context));
}
// If the impl encounters an error during a a full (non-partial) clear, the attachments will
// still be marked initialized. This simplifies design, allowing this method to be called before
// the clear.
markDrawAttachmentsInitialized(color, depth, stencil);
return angle::Result::Continue;
}
angle::Result Framebuffer::ensureClearBufferAttachmentsInitialized(const Context *context,
GLenum buffer,
GLint drawbuffer)
{
if (!context->isRobustResourceInitEnabled() ||
context->getState().isRasterizerDiscardEnabled() ||
context->isClearBufferMaskedOut(buffer, drawbuffer))
{
return angle::Result::Continue;
}
if (partialBufferClearNeedsInit(context, buffer))
{
ANGLE_TRY(ensureBufferInitialized(context, buffer, drawbuffer));
}
// If the impl encounters an error during a a full (non-partial) clear, the attachments will
// still be marked initialized. This simplifies design, allowing this method to be called before
// the clear.
markBufferInitialized(buffer, drawbuffer);
return angle::Result::Continue;
}
angle::Result Framebuffer::ensureDrawAttachmentsInitialized(const Context *context)
{
if (!context->isRobustResourceInitEnabled())
{
return angle::Result::Continue;
}
// Note: we don't actually filter by the draw attachment enum. Just init everything.
for (size_t bit : mState.mResourceNeedsInit)
{
switch (bit)
{
case DIRTY_BIT_DEPTH_ATTACHMENT:
ANGLE_TRY(InitAttachment(context, &mState.mDepthAttachment));
break;
case DIRTY_BIT_STENCIL_ATTACHMENT:
ANGLE_TRY(InitAttachment(context, &mState.mStencilAttachment));
break;
default:
ANGLE_TRY(InitAttachment(context, &mState.mColorAttachments[bit]));
break;
}
}
mState.mResourceNeedsInit.reset();
return angle::Result::Continue;
}
angle::Result Framebuffer::ensureReadAttachmentsInitialized(const Context *context)
{
ASSERT(context->isRobustResourceInitEnabled());
if (mState.mResourceNeedsInit.none())
{
return angle::Result::Continue;
}
if (mState.mReadBufferState != GL_NONE)
{
if (isDefault())
{
if (!mState.mDefaultFramebufferReadAttachmentInitialized)
{
ANGLE_TRY(InitAttachment(context, &mState.mDefaultFramebufferReadAttachment));
mState.mDefaultFramebufferReadAttachmentInitialized = true;
}
}
else
{
size_t readIndex = mState.getReadIndex();
if (mState.mResourceNeedsInit[readIndex])
{
ANGLE_TRY(InitAttachment(context, &mState.mColorAttachments[readIndex]));
mState.mResourceNeedsInit.reset(readIndex);
}
}
}
// Conservatively init depth since it can be read by BlitFramebuffer.
if (hasDepth())
{
if (mState.mResourceNeedsInit[DIRTY_BIT_DEPTH_ATTACHMENT])
{
ANGLE_TRY(InitAttachment(context, &mState.mDepthAttachment));
mState.mResourceNeedsInit.reset(DIRTY_BIT_DEPTH_ATTACHMENT);
}
}
// Conservatively init stencil since it can be read by BlitFramebuffer.
if (hasStencil())
{
if (mState.mResourceNeedsInit[DIRTY_BIT_STENCIL_ATTACHMENT])
{
ANGLE_TRY(InitAttachment(context, &mState.mStencilAttachment));
mState.mResourceNeedsInit.reset(DIRTY_BIT_STENCIL_ATTACHMENT);
}
}
return angle::Result::Continue;
}
void Framebuffer::markDrawAttachmentsInitialized(bool color, bool depth, bool stencil)
{
// Mark attachments as initialized.
if (color)
{
for (auto colorIndex : mState.mEnabledDrawBuffers)
{
auto &colorAttachment = mState.mColorAttachments[colorIndex];
ASSERT(colorAttachment.isAttached());
colorAttachment.setInitState(InitState::Initialized);
mState.mResourceNeedsInit.reset(colorIndex);
}
}
if (depth && mState.mDepthAttachment.isAttached())
{
mState.mDepthAttachment.setInitState(InitState::Initialized);
mState.mResourceNeedsInit.reset(DIRTY_BIT_DEPTH_ATTACHMENT);
}
if (stencil && mState.mStencilAttachment.isAttached())
{
mState.mStencilAttachment.setInitState(InitState::Initialized);
mState.mResourceNeedsInit.reset(DIRTY_BIT_STENCIL_ATTACHMENT);
}
}
void Framebuffer::markBufferInitialized(GLenum bufferType, GLint bufferIndex)
{
switch (bufferType)
{
case GL_COLOR:
{
ASSERT(bufferIndex < static_cast<GLint>(mState.mColorAttachments.size()));
if (mState.mColorAttachments[bufferIndex].isAttached())
{
mState.mColorAttachments[bufferIndex].setInitState(InitState::Initialized);
mState.mResourceNeedsInit.reset(bufferIndex);
}
break;
}
case GL_DEPTH:
{
if (mState.mDepthAttachment.isAttached())
{
mState.mDepthAttachment.setInitState(InitState::Initialized);
mState.mResourceNeedsInit.reset(DIRTY_BIT_DEPTH_ATTACHMENT);
}
break;
}
case GL_STENCIL:
{
if (mState.mStencilAttachment.isAttached())
{
mState.mStencilAttachment.setInitState(InitState::Initialized);
mState.mResourceNeedsInit.reset(DIRTY_BIT_STENCIL_ATTACHMENT);
}
break;
}
case GL_DEPTH_STENCIL:
{
if (mState.mDepthAttachment.isAttached())
{
mState.mDepthAttachment.setInitState(InitState::Initialized);
mState.mResourceNeedsInit.reset(DIRTY_BIT_DEPTH_ATTACHMENT);
}
if (mState.mStencilAttachment.isAttached())
{
mState.mStencilAttachment.setInitState(InitState::Initialized);
mState.mResourceNeedsInit.reset(DIRTY_BIT_STENCIL_ATTACHMENT);
}
break;
}
default:
UNREACHABLE();
break;
}
}
Box Framebuffer::getDimensions() const
{
return mState.getDimensions();
}
Extents Framebuffer::getExtents() const
{
return mState.getExtents();
}
angle::Result Framebuffer::ensureBufferInitialized(const Context *context,
GLenum bufferType,
GLint bufferIndex)
{
ASSERT(context->isRobustResourceInitEnabled());
if (mState.mResourceNeedsInit.none())
{
return angle::Result::Continue;
}
switch (bufferType)
{
case GL_COLOR:
{
ASSERT(bufferIndex < static_cast<GLint>(mState.mColorAttachments.size()));
if (mState.mResourceNeedsInit[bufferIndex])
{
ANGLE_TRY(InitAttachment(context, &mState.mColorAttachments[bufferIndex]));
mState.mResourceNeedsInit.reset(bufferIndex);
}
break;
}
case GL_DEPTH:
{
if (mState.mResourceNeedsInit[DIRTY_BIT_DEPTH_ATTACHMENT])
{
ANGLE_TRY(InitAttachment(context, &mState.mDepthAttachment));
mState.mResourceNeedsInit.reset(DIRTY_BIT_DEPTH_ATTACHMENT);
}
break;
}
case GL_STENCIL:
{
if (mState.mResourceNeedsInit[DIRTY_BIT_STENCIL_ATTACHMENT])
{
ANGLE_TRY(InitAttachment(context, &mState.mStencilAttachment));
mState.mResourceNeedsInit.reset(DIRTY_BIT_STENCIL_ATTACHMENT);
}
break;
}
case GL_DEPTH_STENCIL:
{
if (mState.mResourceNeedsInit[DIRTY_BIT_DEPTH_ATTACHMENT])
{
ANGLE_TRY(InitAttachment(context, &mState.mDepthAttachment));
mState.mResourceNeedsInit.reset(DIRTY_BIT_DEPTH_ATTACHMENT);
}
if (mState.mResourceNeedsInit[DIRTY_BIT_STENCIL_ATTACHMENT])
{
ANGLE_TRY(InitAttachment(context, &mState.mStencilAttachment));
mState.mResourceNeedsInit.reset(DIRTY_BIT_STENCIL_ATTACHMENT);
}
break;
}
default:
UNREACHABLE();
break;
}
return angle::Result::Continue;
}
bool Framebuffer::partialBufferClearNeedsInit(const Context *context, GLenum bufferType)
{
if (!context->isRobustResourceInitEnabled() || mState.mResourceNeedsInit.none())
{
return false;
}
switch (bufferType)
{
case GL_COLOR:
return partialClearNeedsInit(context, true, false, false);
case GL_DEPTH:
return partialClearNeedsInit(context, false, true, false);
case GL_STENCIL:
return partialClearNeedsInit(context, false, false, true);
case GL_DEPTH_STENCIL:
return partialClearNeedsInit(context, false, true, true);
default:
UNREACHABLE();
return false;
}
}
PixelLocalStorage &Framebuffer::getPixelLocalStorage(const Context *context)
{
if (!mPixelLocalStorage)
{
mPixelLocalStorage = PixelLocalStorage::Make(context);
}
return *mPixelLocalStorage.get();
}
std::unique_ptr<PixelLocalStorage> Framebuffer::detachPixelLocalStorage()
{
return std::move(mPixelLocalStorage);
}
} // namespace gl