mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-17 15:03:25 +09:00
[Refactor] (P13 W6e): the backends' frontend-framebuffer clear, blit and readback entries go - the verb port owns those slots in every mode - with Magma's frontend render-pass, pending-clear and renderbuffer halves.
This commit is contained in:
@@ -10389,91 +10389,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
m_syncedAttachmentRecordHash = 0;
|
||||
}
|
||||
|
||||
static Bool SyncAttachmentObject(GLenum glFBOTarget,
|
||||
const MG_State::GLState::FramebufferAttachmentObject& attachmentObject,
|
||||
GLenum glBackendAttachment) {
|
||||
if (attachmentObject.IsTexture()) {
|
||||
const auto& textureObject = attachmentObject.GetTexture();
|
||||
SharedPtr<TextureImpl::BackendTextureObject> backendTextureObject;
|
||||
// P5c (G6, CONTRACT-P5C §5.4): frontend-keyed twin resolution (and the mint on
|
||||
// a first attach), named debt inside the scope - P3b/P4b rekeys the registry.
|
||||
const MG_Pipe::MGPipeFrontendKeyedRegistryScope frontendKeyedRegistry;
|
||||
if (auto* backendTextureSlot = TextureImpl::g_backendTextureObjects.Find(textureObject.get())) {
|
||||
backendTextureObject = *backendTextureSlot;
|
||||
} else {
|
||||
auto& newTextureSlot = TextureImpl::g_backendTextureObjects.GetOrCreate(textureObject);
|
||||
if (!newTextureSlot) {
|
||||
newTextureSlot = MakeShared<TextureImpl::BackendTextureObject>();
|
||||
}
|
||||
backendTextureObject = newTextureSlot;
|
||||
}
|
||||
if (!backendTextureObject) {
|
||||
MGLOG_E_ONCE("%s: No backend texture found for FBO attachment, cannot bind texture.", __func__);
|
||||
return false;
|
||||
}
|
||||
backendTextureObject->SyncMipmapsToBackend(textureObject);
|
||||
// From here on every draw, clear and blit into this framebuffer can write the
|
||||
// texture behind the shadow's back.
|
||||
TextureImpl::NoteDriverSideTextureWrite(textureObject);
|
||||
if (attachmentObject.IsLayered()) {
|
||||
g_GLESFuncs.glFramebufferTexture(glFBOTarget, glBackendAttachment,
|
||||
backendTextureObject->GetBackendTextureId(),
|
||||
static_cast<GLint>(attachmentObject.GetTextureLevel()));
|
||||
} else if (const auto uploadTarget = attachmentObject.GetTextureUploadTarget();
|
||||
uploadTarget == TextureUploadTarget::Texture3D ||
|
||||
uploadTarget == TextureUploadTarget::Texture2DArray ||
|
||||
uploadTarget == TextureUploadTarget::Texture1DArray ||
|
||||
uploadTarget == TextureUploadTarget::CubeMapArray ||
|
||||
uploadTarget == TextureUploadTarget::Texture2DMultisampleArray) {
|
||||
// Single slice/layer of a 3D or array texture: ES has no
|
||||
// glFramebufferTexture3D, layers attach via glFramebufferTextureLayer.
|
||||
g_GLESFuncs.glFramebufferTextureLayer(glFBOTarget, glBackendAttachment,
|
||||
backendTextureObject->GetBackendTextureId(),
|
||||
static_cast<GLint>(attachmentObject.GetTextureLevel()),
|
||||
static_cast<GLint>(attachmentObject.GetTextureLayer()));
|
||||
} else {
|
||||
auto glTextureTarget = TextureImpl::ConvertTextureUploadTargetToBackendGLEnum(
|
||||
attachmentObject.GetTextureUploadTarget());
|
||||
if (glTextureTarget == GL_UNKNOWN_MGL) {
|
||||
glTextureTarget = TextureImpl::ConvertTextureTargetToBackendGLEnum(textureObject->GetTarget());
|
||||
}
|
||||
// glBindTexture rejects cube-face enums (INVALID_ENUM with no
|
||||
// bind, while Bind() would still record the cube-map cache slot
|
||||
// as bound): bind via the owning cube target; the attach below
|
||||
// keeps the face target.
|
||||
const Bool isCubeFace = glTextureTarget >= GL_TEXTURE_CUBE_MAP_POSITIVE_X &&
|
||||
glTextureTarget <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
|
||||
backendTextureObject->Bind(isCubeFace ? GL_TEXTURE_CUBE_MAP : glTextureTarget);
|
||||
g_GLESFuncs.glFramebufferTexture2D(glFBOTarget, glBackendAttachment, glTextureTarget,
|
||||
backendTextureObject->GetBackendTextureId(),
|
||||
static_cast<GLint>(attachmentObject.GetTextureLevel()));
|
||||
}
|
||||
} else if (attachmentObject.IsRenderbuffer()) {
|
||||
const auto& renderbufferObject = attachmentObject.GetRenderbuffer();
|
||||
// P5c (G6, CONTRACT-P5C §5.4): frontend-keyed twin resolution (and the mint on
|
||||
// a first attach), named debt inside the scope - P3b/P4b rekeys the registry.
|
||||
const MG_Pipe::MGPipeFrontendKeyedRegistryScope frontendKeyedRegistry;
|
||||
SharedPtr<RenderbufferImpl::BackendRenderbufferObject> backendRenderbufferObject;
|
||||
if (auto* backendRenderbufferSlot =
|
||||
RenderbufferImpl::g_backendRenderbufferObjects.Find(renderbufferObject.get())) {
|
||||
backendRenderbufferObject = *backendRenderbufferSlot;
|
||||
} else {
|
||||
auto& newRenderbufferSlot =
|
||||
RenderbufferImpl::g_backendRenderbufferObjects.GetOrCreate(renderbufferObject);
|
||||
if (!newRenderbufferSlot) {
|
||||
newRenderbufferSlot = MakeShared<RenderbufferImpl::BackendRenderbufferObject>();
|
||||
}
|
||||
backendRenderbufferObject = newRenderbufferSlot;
|
||||
}
|
||||
|
||||
backendRenderbufferObject->SyncToBackend(renderbufferObject);
|
||||
backendRenderbufferObject->Bind();
|
||||
g_GLESFuncs.glFramebufferRenderbuffer(glFBOTarget, glBackendAttachment, GL_RENDERBUFFER,
|
||||
backendRenderbufferObject->GetBackendRenderbufferId());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
static Bool IsSnormFormat(TextureInternalFormat format) {
|
||||
switch (format) {
|
||||
case TextureInternalFormat::R8Snorm:
|
||||
@@ -10502,53 +10417,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
}
|
||||
}
|
||||
|
||||
static Bool IsSnormFallbackAttachment(
|
||||
const MG_State::GLState::FramebufferAttachmentObject& attachmentObject) {
|
||||
if (attachmentObject.IsTexture()) {
|
||||
const auto& textureObject = attachmentObject.GetTexture();
|
||||
return textureObject && IsSnormFormat(textureObject->GetFormat()) &&
|
||||
TextureImpl::ShouldUseCaveatTextureFormat(textureObject->GetFormat(), textureObject->GetTarget());
|
||||
}
|
||||
if (attachmentObject.IsRenderbuffer()) {
|
||||
const auto& renderbufferObject = attachmentObject.GetRenderbuffer();
|
||||
return renderbufferObject &&
|
||||
IsSnormFormat(renderbufferObject->GetInternalFormat()) &&
|
||||
TextureImpl::ShouldUseCaveatRenderbufferFormat(renderbufferObject->GetInternalFormat());
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static Bool IsUnormFallbackAttachment(
|
||||
const MG_State::GLState::FramebufferAttachmentObject& attachmentObject) {
|
||||
if (attachmentObject.IsTexture()) {
|
||||
const auto& textureObject = attachmentObject.GetTexture();
|
||||
return textureObject && IsUnormFormat(textureObject->GetFormat()) &&
|
||||
TextureImpl::ShouldUseCaveatTextureFormat(textureObject->GetFormat(), textureObject->GetTarget());
|
||||
}
|
||||
if (attachmentObject.IsRenderbuffer()) {
|
||||
const auto& renderbufferObject = attachmentObject.GetRenderbuffer();
|
||||
return renderbufferObject &&
|
||||
IsUnormFormat(renderbufferObject->GetInternalFormat()) &&
|
||||
TextureImpl::ShouldUseCaveatRenderbufferFormat(renderbufferObject->GetInternalFormat());
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
Bool IsAlphaWidenedColorAttachment(
|
||||
const MG_State::GLState::FramebufferAttachmentObject& attachmentObject) {
|
||||
if (attachmentObject.IsTexture()) {
|
||||
const auto& textureObject = attachmentObject.GetTexture();
|
||||
return textureObject && TextureImpl::BackendTextureFormatAddsAlpha(textureObject->GetFormat(),
|
||||
textureObject->GetTarget());
|
||||
}
|
||||
if (attachmentObject.IsRenderbuffer()) {
|
||||
const auto& renderbufferObject = attachmentObject.GetRenderbuffer();
|
||||
return renderbufferObject &&
|
||||
TextureImpl::BackendRenderbufferFormatAddsAlpha(renderbufferObject->GetInternalFormat());
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
Uint32 g_alphaWidenedDrawBufferMask = 0;
|
||||
Uint32 g_integerColorDrawBufferMask = 0;
|
||||
|
||||
@@ -10585,19 +10453,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
}
|
||||
}
|
||||
|
||||
static Bool IsIntegerColorAttachment(
|
||||
const MG_State::GLState::FramebufferAttachmentObject& attachmentObject) {
|
||||
if (attachmentObject.IsTexture()) {
|
||||
const auto& textureObject = attachmentObject.GetTexture();
|
||||
return textureObject && IsIntegerColorFormat(textureObject->GetFormat());
|
||||
}
|
||||
if (attachmentObject.IsRenderbuffer()) {
|
||||
const auto& renderbufferObject = attachmentObject.GetRenderbuffer();
|
||||
return renderbufferObject && IsIntegerColorFormat(renderbufferObject->GetInternalFormat());
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// THE FOUR CROSS-OBJECT MASKS, ANSWERED FROM THE RECORD (ID-12 DV-5, review M-3 / DV-5).
|
||||
//
|
||||
// All four reduce to (internal format, TEXTURE TARGET) for a texture attachment and to
|
||||
@@ -10850,23 +10705,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
return false;
|
||||
}
|
||||
|
||||
Uint32 ComputeAlphaWidenedDrawBufferMask(const MG_State::GLState::FramebufferObject& fbo) {
|
||||
using FBO = MG_State::GLState::FramebufferObject;
|
||||
const auto& drawBuffers = fbo.GetDrawBuffers();
|
||||
Uint32 mask = 0;
|
||||
for (Uint i = 0; i < FBO::MAX_DRAW_BUFFERS && i < 32; ++i) {
|
||||
const auto frontendBuf = drawBuffers[i];
|
||||
if (frontendBuf < FramebufferAttachmentType::Color0 ||
|
||||
frontendBuf > FramebufferAttachmentType::Color31) {
|
||||
continue;
|
||||
}
|
||||
if (IsAlphaWidenedColorAttachment(fbo.GetAttachment(frontendBuf))) {
|
||||
mask |= (1u << i);
|
||||
}
|
||||
}
|
||||
return mask;
|
||||
}
|
||||
|
||||
// The read attachment's storage carries an alpha channel its frontend format does not
|
||||
// (the three-channel colour-renderable widening). GL answers such a read with 1.0, but
|
||||
// the storage holds whatever the draw wrote there, so the readback has to overwrite it.
|
||||
@@ -11011,49 +10849,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
ApplyReadBufferFromRecord(*record, 0);
|
||||
}
|
||||
|
||||
void BackendFramebufferObject::SyncReadBufferToBackend(
|
||||
const SharedPtr<MG_State::GLState::FramebufferObject>& stateFBOObject) {
|
||||
if (!stateFBOObject) {
|
||||
return;
|
||||
}
|
||||
// P4a (D-C2): the READ buffer is answered from the RESOLVED read surface of the READ
|
||||
// framebuffer's own record, which is what structurally closes the read-buffer
|
||||
// shared-FBO defect class. The comment two lines below - "when this is reached from
|
||||
// SyncCurrentFBO's 'same FBO as draw' skip path" - describes a hazard that becomes
|
||||
// unrepresentable: the record says which target it is, and ReadSurface was resolved
|
||||
// from the read framebuffer's own read buffer before it ever crossed.
|
||||
//
|
||||
// The record carries the resolved SURFACE and not an index, so the attachment POINT
|
||||
// is recovered by matching it against Color[] - the one place both spellings sit
|
||||
// side by side. An empty surface (Res == the null handle, which D-C1 makes the
|
||||
// spelling of "no attachment" independently of Kind's numbering) is
|
||||
// FramebufferAttachmentType::None, i.e. GL_NONE. A surface that matches no colour
|
||||
// point cannot be a legal read buffer and is refused rather than guessed.
|
||||
//
|
||||
// P5e (fb): THAT DECISION now lives in ApplyReadBufferFromRecord, which takes no
|
||||
// frontend object; what is left in this overload is the monolith glue that finds
|
||||
// the handle by identity. Under an active transport nothing reaches it -
|
||||
// SyncToBackendByHandle runs the record form directly.
|
||||
// P5c (hd): with an active transport the handle is the caller's
|
||||
// (m_pushedSyncHandle), never the client allocator's - see SyncToBackend.
|
||||
const MG_Pipe::MGPipeHandle fbo =
|
||||
m_pushedSyncHandle;
|
||||
// ID-19: the OBJECT's record, not "the record of whatever is bound to READ". A
|
||||
// framebuffer whose read buffer is being pushed need not be the read binding at
|
||||
// all - glNamedFramebufferReadBuffer and the DSA clears reach here by name - and
|
||||
// ReadSurface is resolved from THIS framebuffer's own read buffer under every
|
||||
// Target, Named included (c0e's MGPFramebufferState comment).
|
||||
const auto* record = PushedFramebufferRecord(fbo);
|
||||
if (record == nullptr) {
|
||||
MGLOG_E_ONCE("MGPipe: framebuffer %u has no applier record on the handle arm, so "
|
||||
"its read buffer cannot be pushed (handle {%u, %u})",
|
||||
stateFBOObject->GetExternalIndex(), fbo.Slot, fbo.Gen);
|
||||
return;
|
||||
}
|
||||
ApplyReadBufferFromRecord(*record, stateFBOObject->GetExternalIndex());
|
||||
return;
|
||||
}
|
||||
|
||||
Bool BackendFramebufferObject::RecomputeBackendColorSlots(
|
||||
const FramebufferObject::FramebufferAttachmentArray& stateDrawBuffers) {
|
||||
// Only the first GL_MAX_COLOR_ATTACHMENTS points exist in the backend. The frontend's own
|
||||
@@ -11143,380 +10938,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
return moved;
|
||||
}
|
||||
|
||||
void BackendFramebufferObject::SyncToBackend(
|
||||
const SharedPtr<MG_State::GLState::FramebufferObject>& stateFBOObject, FramebufferTarget asTarget) {
|
||||
#ifdef TRACY_ENABLE
|
||||
ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
|
||||
#endif
|
||||
if (!stateFBOObject) {
|
||||
MGLOG_E_ONCE("State FBO object is null, cannot sync to backend.");
|
||||
return;
|
||||
}
|
||||
MGLOG_D("Syncing FBO with backend ID %u to backend for state ID %u, as %s FBO", m_backendFBOId,
|
||||
stateFBOObject->GetExternalIndex(), (asTarget == FramebufferTarget::Draw ? "DRAW" : "READ"));
|
||||
GLenum glFBOTarget = MG_Util::ConvertFramebufferTargetToGLEnum(asTarget);
|
||||
|
||||
// P4a (D-C2 as corrected by ID-19): THE RECORD OF THIS FRAMEBUFFER OBJECT, resolved
|
||||
// BEFORE the driver framebuffer is bound.
|
||||
//
|
||||
// The order is the whole of C-1's fix. v1 bound first and refused afterwards, so a
|
||||
// glClearNamedFramebufferfv / glBlitNamedFramebuffer on a framebuffer that is bound
|
||||
// to neither target left this twin's freshly minted driver FBO bound with NO
|
||||
// ATTACHMENTS and the caller then issued the clear or the blit against it -
|
||||
// GL_INVALID_FRAMEBUFFER_OPERATION and nothing cleared, where the legacy arm cleared
|
||||
// correctly. What the reorder buys is exactly this and no more: THE REFUSAL ITSELF
|
||||
// HAS NO DRIVER EFFECT - it no longer mints and binds a driver FBO as a side effect
|
||||
// of declining. It does NOT decide the driver's binding (review N-1): every caller
|
||||
// binds immediately afterwards and none of them looks at a return value -
|
||||
// SyncAndBindFramebufferObject is SyncToBackend then an unconditional Bind(target)
|
||||
// (DirectGLES.cpp:3292-3293, the path all five DSA entry points take), and
|
||||
// BindCurrentFBO binds the current FBO's twin whether or not SyncCurrentFBO synced
|
||||
// it. So an unconfigured framebuffer can still end up bound; what the log line
|
||||
// promises is only that this function did not put it there.
|
||||
//
|
||||
// The record is per FRAMEBUFFER OBJECT and is found by handle, so it describes this
|
||||
// object whether it is bound to Draw, to Read, to both or to neither, and its own
|
||||
// Target is NOT compared against `asTarget`: a Named record legitimately names no
|
||||
// binding at all. What is still gated on `asTarget` is what reaches the DRIVER's
|
||||
// bound target - glDrawBuffers and the four cross-object masks below, which stay
|
||||
// Draw-only for the reason the OIT comment gives.
|
||||
const MG_Pipe::MGPFramebufferState* pushedRecord = nullptr;
|
||||
FramebufferObject::FramebufferAttachmentArray pushedDrawBuffers{};
|
||||
// MONOLITH GLUE, named as such: the Framebuffer handle of an object this backend
|
||||
// still arrives holding. A framebuffer has a handle but NO wire lifetime (D-I2) -
|
||||
// there is no framebuffer create or destroy in the catalogue and none is invented
|
||||
// - so the handle exists purely to key set_framebuffer_state, which is exactly
|
||||
// what it is used for here.
|
||||
//
|
||||
// P5c (hd): with an active transport the handle is the one the caller is applying
|
||||
// (m_pushedSyncHandle - the record-driven sync set it), and the client allocator
|
||||
// is never probed (T2). A null there means a caller reached this arm without a
|
||||
// record, which the null-record refusal below names.
|
||||
const MG_Pipe::MGPipeHandle fbo =
|
||||
m_pushedSyncHandle;
|
||||
pushedRecord = PushedFramebufferRecord(fbo);
|
||||
if (pushedRecord == nullptr) {
|
||||
MGLOG_E_ONCE("MGPipe: framebuffer %u has no applier record on the handle arm, so it "
|
||||
"is not configured here; nothing is bound by this refusal, but the "
|
||||
"caller's own bind still targets it (handle {%u, %u})",
|
||||
stateFBOObject->GetExternalIndex(), fbo.Slot, fbo.Gen);
|
||||
return;
|
||||
}
|
||||
DecodePushedDrawBuffers(*pushedRecord, pushedDrawBuffers.data());
|
||||
Bind(asTarget);
|
||||
|
||||
// -------------------- Connect attachments (set buffers) -----------------------
|
||||
// 1. Remap draw buffers
|
||||
const FramebufferObject::FramebufferAttachmentArray& stateDrawBuffers =
|
||||
pushedRecord != nullptr ? pushedDrawBuffers : stateFBOObject->GetDrawBuffers();
|
||||
Bool drawBufferClean = false;
|
||||
if (memcmp(m_frontendDrawBuffers, stateDrawBuffers.data(),
|
||||
FramebufferObject::MAX_DRAW_BUFFERS * sizeof(FramebufferAttachmentType)) == 0) {
|
||||
drawBufferClean = true;
|
||||
}
|
||||
|
||||
// glDrawBuffers writes the state of the FBO bound to GL_DRAW_FRAMEBUFFER.
|
||||
// When this object is only bound as the READ target the call would land on
|
||||
// whatever framebuffer is draw-bound AND falsely stamp this object's memo,
|
||||
// so the later draw-target sync skips as "clean" while the real state is
|
||||
// stale (Minecraft 26.x OIT: the scratch clear-FBO kept draw buffers NONE
|
||||
// from its blit-destination configuration, silently dropping every
|
||||
// offscreen color clear).
|
||||
if (!drawBufferClean && asTarget == FramebufferTarget::Draw) {
|
||||
memcpy(m_frontendDrawBuffers, stateDrawBuffers.data(),
|
||||
FramebufferObject::MAX_DRAW_BUFFERS * sizeof(FramebufferAttachmentType));
|
||||
std::fill(m_backendDrawBuffers, m_backendDrawBuffers + FramebufferObject::MAX_DRAW_BUFFERS, GL_NONE);
|
||||
int nEffectiveBuffers = 0;
|
||||
for (GLint i = 0; i < FramebufferObject::MAX_DRAW_BUFFERS; ++i) {
|
||||
auto& frontendBuf = stateDrawBuffers[i];
|
||||
if (frontendBuf == FramebufferAttachmentType::None) {
|
||||
m_backendDrawBuffers[i] = GL_NONE;
|
||||
continue;
|
||||
}
|
||||
|
||||
// Create compacted mapping
|
||||
if (frontendBuf == FramebufferAttachmentType::FrontLeft ||
|
||||
frontendBuf == FramebufferAttachmentType::FrontRight ||
|
||||
frontendBuf == FramebufferAttachmentType::BackLeft ||
|
||||
frontendBuf == FramebufferAttachmentType::BackRight) {
|
||||
MGLOG_D("%s: frontend buf token found for default fbo, shouldn't remap", __func__);
|
||||
m_backendDrawBuffers[i] = MG_Util::ConvertFramebufferAttachmentTypeToGLEnum(frontendBuf);
|
||||
} else {
|
||||
m_backendDrawBuffers[i] = GL_COLOR_ATTACHMENT0 + i;
|
||||
}
|
||||
nEffectiveBuffers = i + 1;
|
||||
}
|
||||
g_GLESFuncs.glDrawBuffers(nEffectiveBuffers, m_backendDrawBuffers);
|
||||
// The line above pinned backend point s to draw-buffer slot s, so the images have to
|
||||
// be moved under those points. Rebuild the whole colour map and, when anything moved,
|
||||
// also drop the read-buffer memo: SyncReadBufferToBackend keys it on the frontend
|
||||
// enum alone, which does not change when the point under it does.
|
||||
if (RecomputeBackendColorSlots(stateDrawBuffers)) {
|
||||
m_frontendReadBuffer = FramebufferAttachmentType::Unknown;
|
||||
}
|
||||
MGLOG_D("DBAPPLY beFbo=%u target=%d n=%d db0=0x%x feDb0=%d", m_backendFBOId, (int)asTarget,
|
||||
nEffectiveBuffers, m_backendDrawBuffers[0], (int)stateDrawBuffers[0]);
|
||||
}
|
||||
|
||||
if (asTarget == FramebufferTarget::Draw) {
|
||||
Uint32 snormClampOutputMask = 0;
|
||||
Uint32 unormClampOutputMask = 0;
|
||||
Uint32 alphaWidenedMask = 0;
|
||||
Uint32 integerColorMask = 0;
|
||||
for (Uint i = 0; i < FramebufferObject::MAX_DRAW_BUFFERS && i < 32; ++i) {
|
||||
const auto frontendBuf = stateDrawBuffers[i];
|
||||
if (frontendBuf < FramebufferAttachmentType::Color0 ||
|
||||
frontendBuf > FramebufferAttachmentType::Color31) {
|
||||
continue;
|
||||
}
|
||||
// ID-12 DV-5 / M-3: on the handle arm the four masks are answered from the
|
||||
// record's own surface for the point this draw buffer names, and the frontend
|
||||
// attachment object below is never touched - the whole arm returns here.
|
||||
// A draw buffer that names a point the record cannot describe is D-C3's
|
||||
// refusal arriving too late to refuse, so it is loud and contributes no bit.
|
||||
if (pushedRecord != nullptr) {
|
||||
const MG_Pipe::MGPSurface* pushedSurface =
|
||||
PushedSurfaceForAttachment(*pushedRecord, frontendBuf);
|
||||
if (pushedSurface == nullptr) {
|
||||
MGLOG_E_ONCE("MGPipe: framebuffer %u's draw buffer %u names colour point %d, "
|
||||
"which its record does not describe (the record carries %u "
|
||||
"colour points) - contributing no fallback mask bit",
|
||||
stateFBOObject->GetExternalIndex(), i,
|
||||
static_cast<Int>(frontendBuf) -
|
||||
static_cast<Int>(FramebufferAttachmentType::Color0),
|
||||
MG_Pipe::kMGPipeMaxColorAttachments);
|
||||
continue;
|
||||
}
|
||||
if (IsSnormFallbackSurface(*pushedSurface)) {
|
||||
snormClampOutputMask |= (1u << i);
|
||||
} else if (IsUnormFallbackSurface(*pushedSurface)) {
|
||||
unormClampOutputMask |= (1u << i);
|
||||
}
|
||||
if (IsAlphaWidenedColorSurface(*pushedSurface)) {
|
||||
alphaWidenedMask |= (1u << i);
|
||||
}
|
||||
if (IsIntegerColorSurface(*pushedSurface)) {
|
||||
integerColorMask |= (1u << i);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
const auto& attachmentObject = stateFBOObject->GetAttachment(frontendBuf);
|
||||
if (IsSnormFallbackAttachment(attachmentObject)) {
|
||||
snormClampOutputMask |= (1u << i);
|
||||
} else if (IsUnormFallbackAttachment(attachmentObject)) {
|
||||
unormClampOutputMask |= (1u << i);
|
||||
}
|
||||
// Independent of the two above: a widened attachment can be SNORM
|
||||
// (GL_RGB8_SNORM -> GL_RGBA16F, which also clamps) or not (GL_SRGB8 ->
|
||||
// GL_SRGB8_ALPHA8, which does not), so it gets its own bit rather than an
|
||||
// `else if` branch of theirs.
|
||||
if (IsAlphaWidenedColorAttachment(attachmentObject)) {
|
||||
alphaWidenedMask |= (1u << i);
|
||||
}
|
||||
if (IsIntegerColorAttachment(attachmentObject)) {
|
||||
integerColorMask |= (1u << i);
|
||||
}
|
||||
}
|
||||
PrgramImpl::g_snormFallbackClampOutputMask = snormClampOutputMask;
|
||||
PrgramImpl::g_unormFallbackClampOutputMask = unormClampOutputMask;
|
||||
g_alphaWidenedDrawBufferMask = alphaWidenedMask;
|
||||
g_integerColorDrawBufferMask = integerColorMask;
|
||||
}
|
||||
|
||||
// 2. Remap read buffer. glReadBuffer writes the READ-bound FBO's state, so
|
||||
// only apply (and stamp the memo) when this object is bound as READ.
|
||||
if (asTarget == FramebufferTarget::Read) {
|
||||
SyncReadBufferToBackend(stateFBOObject);
|
||||
}
|
||||
|
||||
// -------------------- Attach texture to backend FBO -----------------------
|
||||
// A backend texture id was re-minted since this twin's last walk
|
||||
// (RecreateBackendTexture): any point here may still hold the dead id while
|
||||
// its frontend attachment version is unchanged, so the memo below would skip
|
||||
// exactly the attachment that needs repair. Re-arm every point first.
|
||||
if (m_syncedBackendIdGeneration != g_attachmentBackendIdGeneration) {
|
||||
std::fill(m_syncedFrontendAttachmentVersions.begin(), m_syncedFrontendAttachmentVersions.end(),
|
||||
static_cast<Uint16>(~0u));
|
||||
m_syncedBackendIdGeneration = g_attachmentBackendIdGeneration;
|
||||
}
|
||||
// P4a (D-C4): the record's ContentHash is what says this framebuffer's resolved state
|
||||
// moved, and it REPLACES the frontend attachment versions AS A KEY. It covers every
|
||||
// field the record carries, so an attachment set that moved, a draw-buffer array
|
||||
// that moved, an extent that moved and a recycled Fbo whose successor happens to
|
||||
// carry an identical attachment set are all one compare - and it moves in ONE place
|
||||
// rather than in an array of 41 the twin had to walk.
|
||||
//
|
||||
// The re-arm is expressed through m_syncedFrontendAttachmentVersions rather than
|
||||
// around it, so the attachment loop below is unchanged on both arms: a moved record
|
||||
// arms every point and the loop then does exactly what it does today, including the
|
||||
// empty-colour-point detach that keeps m_backendColorSlots a permutation of the
|
||||
// PHYSICAL layout.
|
||||
//
|
||||
// OVER-FIRING IS FREE AND UNDER-FIRING IS FATAL, so the per-attachment versions stay
|
||||
// as a second, narrower gate underneath: a frontend attachment that moved without
|
||||
// the record moving still re-attaches. That direction is the safe one and it is the
|
||||
// reason the array is re-armed rather than retired here. It is what the array is FOR
|
||||
// now: the walk below resolves each attachment from the record (SyncAttachmentSurface),
|
||||
// so the versions no longer say WHICH object a point holds - they say only "this point
|
||||
// may have moved since I last looked", and they retire with the frontend attachment
|
||||
// array itself, which is a later phase's.
|
||||
if (pushedRecord != nullptr && m_syncedRecordHashes[SizeT(asTarget)] != pushedRecord->ContentHash) {
|
||||
std::fill(m_syncedFrontendAttachmentVersions.begin(), m_syncedFrontendAttachmentVersions.end(),
|
||||
static_cast<Uint16>(~0u));
|
||||
m_syncedRecordHashes[SizeT(asTarget)] = pushedRecord->ContentHash;
|
||||
}
|
||||
const auto& attachments = stateFBOObject->GetAllAttachmentObjects();
|
||||
const auto& attachmentVersions = stateFBOObject->GetAllFramebufferAttachmentVersions();
|
||||
for (SizeT i = 0; i < attachments.size(); ++i) {
|
||||
const auto& attachmentObject = attachments[i];
|
||||
auto frontendType = static_cast<FramebufferAttachmentType>(i);
|
||||
GLenum glBackendAttachment = GL_NONE;
|
||||
if (frontendType >= FramebufferAttachmentType::Color0 &&
|
||||
frontendType <= FramebufferAttachmentType::Color31)
|
||||
glBackendAttachment = GetBackendAttachmentType(frontendType);
|
||||
else
|
||||
glBackendAttachment = MG_Util::ConvertFramebufferAttachmentTypeToGLEnum(frontendType);
|
||||
|
||||
// relevant FRONTEND!!! version should be checked and updated
|
||||
if (m_syncedFrontendAttachmentVersions[i] != attachmentVersions[i]) {
|
||||
// SyncAttachmentObject only ever attaches: for an empty frontend attachment it
|
||||
// returns true and issues nothing, so the point keeps whatever was there. That is
|
||||
// what makes m_backendColorSlots a permutation of the PHYSICAL layout rather than
|
||||
// a claim about one - a point handed to an attachment with no image would
|
||||
// otherwise still hold the previous owner's image and glReadBuffer would return
|
||||
// it. Bounded by GL_MAX_COLOR_ATTACHMENTS because GL_COLOR_ATTACHMENTn above the
|
||||
// driver's limit is INVALID_ENUM, and restricted to colour points because
|
||||
// FRONT_LEFT/BACK_LEFT and co. are not ES attachment points at all.
|
||||
const Bool isColorPoint =
|
||||
frontendType >= FramebufferAttachmentType::Color0 &&
|
||||
frontendType <= FramebufferAttachmentType::Color31 &&
|
||||
(static_cast<Int>(frontendType) - static_cast<Int>(FramebufferAttachmentType::Color0)) <
|
||||
g_GLESCapabilities.MaxColorAttachments;
|
||||
// P5e (fb, §5.4): ON THE RECORD ARM THE EMPTY POINT IS THE RECORD'S, and it
|
||||
// is the SAME test SyncAttachmentSurface attaches on - `Kind == None ||
|
||||
// Res null`. Asking the frontend here and the record there is what left
|
||||
// review N-6's one-directional hole; one test closes it by construction.
|
||||
const Bool pointIsEmpty =
|
||||
pushedRecord != nullptr
|
||||
? [&] {
|
||||
const MG_Pipe::MGPSurface* s =
|
||||
PushedSurfaceForAttachment(*pushedRecord, frontendType);
|
||||
return s == nullptr || s->Kind == MG_Pipe::kMGPipeSurfaceKindNone ||
|
||||
MG_Pipe::MGPipeHandleIsNull(s->Res);
|
||||
}()
|
||||
: attachmentObject.IsEmpty();
|
||||
if (isColorPoint && pointIsEmpty && glBackendAttachment != GL_NONE) {
|
||||
g_GLESFuncs.glFramebufferRenderbuffer(glFBOTarget, glBackendAttachment, GL_RENDERBUFFER, 0);
|
||||
}
|
||||
// M-3: the ATTACHMENT RESOLUTION is the record's on the handle arm. The walk
|
||||
// itself still runs over the frontend's 41 points, because that is what says
|
||||
// which points EXIST and it is also what carries the per-attachment version
|
||||
// memo underneath the record hash; what the record answers is WHICH object
|
||||
// each point holds and in what shape.
|
||||
//
|
||||
// A point the record does not describe (Color8..Color31; the FRONT/BACK
|
||||
// tokens) is only reachable with a non-empty attachment if D-C3's refusal
|
||||
// failed to fire, so an empty one is silently fine and a live one is loud.
|
||||
Bool attachmentSynced;
|
||||
if (pushedRecord != nullptr) {
|
||||
const MG_Pipe::MGPSurface* pushedSurface =
|
||||
PushedSurfaceForAttachment(*pushedRecord, frontendType);
|
||||
if (pushedSurface == nullptr) {
|
||||
if (attachmentObject.IsEmpty()) {
|
||||
attachmentSynced = true;
|
||||
} else {
|
||||
MGLOG_E_ONCE("MGPipe: framebuffer %u holds an attachment at point %s, which "
|
||||
"its record does not describe - refusing to attach it",
|
||||
stateFBOObject->GetExternalIndex(),
|
||||
MG_Util::ConvertFramebufferAttachmentTypeToString(frontendType).c_str());
|
||||
attachmentSynced = false;
|
||||
}
|
||||
} else {
|
||||
attachmentSynced =
|
||||
SyncAttachmentSurface(glFBOTarget, *pushedSurface, glBackendAttachment,
|
||||
&attachmentObject);
|
||||
}
|
||||
} else {
|
||||
attachmentSynced = SyncAttachmentObject(glFBOTarget, attachmentObject, glBackendAttachment);
|
||||
}
|
||||
if (attachmentSynced) {
|
||||
m_syncedFrontendAttachmentVersions[i] = attachmentVersions[i];
|
||||
}
|
||||
}
|
||||
#if MOBILEGL_LOG_ACTIVE_LEVEL <= MOBILEGL_LOG_LEVEL_DEBUG
|
||||
else {
|
||||
MGLOG_D("%s: Skipped SyncAttachmentObject(target=%s, frontendObj=(%dx%dx%d, %s), backendAtt=%s), "
|
||||
"version = %u",
|
||||
__func__, MG_Util::ConvertGLEnumToString(glFBOTarget).c_str(),
|
||||
attachmentObject.GetSize().x(), attachmentObject.GetSize().y(),
|
||||
attachmentObject.GetSize().z(),
|
||||
MG_Util::ConvertFramebufferAttachmentTypeToString(frontendType).c_str(),
|
||||
MG_Util::ConvertGLEnumToString(glBackendAttachment).c_str(),
|
||||
m_syncedFrontendAttachmentVersions[i]);
|
||||
if (!attachmentObject.IsTexture() && !attachmentObject.IsRenderbuffer()) {
|
||||
continue;
|
||||
}
|
||||
GLint objectType = GL_NONE;
|
||||
g_GLESFuncs.glGetFramebufferAttachmentParameteriv(
|
||||
glFBOTarget, glBackendAttachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &objectType);
|
||||
MOBILEGL_ASSERT((objectType == GL_NONE) ||
|
||||
(attachmentObject.IsTexture() && objectType == GL_TEXTURE) ||
|
||||
(attachmentObject.IsRenderbuffer() && objectType == GL_RENDERBUFFER),
|
||||
"Attachment type not match!");
|
||||
GLint objectName = 0;
|
||||
g_GLESFuncs.glGetFramebufferAttachmentParameteriv(
|
||||
glFBOTarget, glBackendAttachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &objectName);
|
||||
// Verify that the backend object's name and parameters match the frontend attachment state
|
||||
if (attachmentObject.IsTexture()) {
|
||||
const auto& textureObject = attachmentObject.GetTexture();
|
||||
// P5c (G6, CONTRACT-P5C §5.4): frontend-keyed twin resolution, named
|
||||
// debt inside the scope - P3b/P4b rekeys the registry.
|
||||
const MG_Pipe::MGPipeFrontendKeyedRegistryScope frontendKeyedRegistry;
|
||||
auto* backendTextureSlot = TextureImpl::g_backendTextureObjects.Find(textureObject.get());
|
||||
MOBILEGL_ASSERT(backendTextureSlot != nullptr && *backendTextureSlot != nullptr,
|
||||
"No backend texture found while framebuffer reports texture attachment.");
|
||||
GLuint backendTexId = (*backendTextureSlot)->GetBackendTextureId();
|
||||
MOBILEGL_ASSERT(static_cast<GLint>(backendTexId) == objectName,
|
||||
"Attachment texture name mismatch between GLES (%d) and backend texture object "
|
||||
"(%d), frontend texture object ID=%d.",
|
||||
objectName, backendTexId, textureObject->GetExternalIndex());
|
||||
|
||||
GLint texLevel = 0;
|
||||
g_GLESFuncs.glGetFramebufferAttachmentParameteriv(
|
||||
glFBOTarget, glBackendAttachment, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL, &texLevel);
|
||||
MOBILEGL_ASSERT(texLevel == static_cast<GLint>(attachmentObject.GetTextureLevel()),
|
||||
"Attachment texture level mismatch between GLES and state object.");
|
||||
} else if (attachmentObject.IsRenderbuffer()) {
|
||||
const auto& renderbufferObject = attachmentObject.GetRenderbuffer();
|
||||
// P5c (G6, CONTRACT-P5C §5.4): frontend-keyed twin resolution, named
|
||||
// debt inside the scope - P3b/P4b rekeys the registry.
|
||||
const MG_Pipe::MGPipeFrontendKeyedRegistryScope frontendKeyedRegistry;
|
||||
auto* backendRboSlot =
|
||||
RenderbufferImpl::g_backendRenderbufferObjects.Find(renderbufferObject.get());
|
||||
MOBILEGL_ASSERT(
|
||||
backendRboSlot != nullptr && *backendRboSlot != nullptr,
|
||||
"No backend renderbuffer found while framebuffer reports renderbuffer attachment.");
|
||||
GLuint backendRboId = (*backendRboSlot)->GetBackendRenderbufferId();
|
||||
MOBILEGL_ASSERT(static_cast<GLint>(backendRboId) == objectName,
|
||||
"Attachment renderbuffer name mismatch between GLES and state object.");
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
// The walk itself can re-mint an id (SyncAttachmentObject ->
|
||||
// SyncMipmapsToBackend -> RecreateBackendTexture), invalidating points this
|
||||
// walk already attached or version-skipped - e.g. one texture attached at two
|
||||
// points. Re-enter until the generation is quiescent: every pass syncs each
|
||||
// dirty texture clean, so each repeat finds strictly fewer re-mints and the
|
||||
// common case (no re-mint) never takes a second pass. The head's draw/read-
|
||||
// buffer syncs are memoized against their own shadows, so a repeat re-walks
|
||||
// only the attachments.
|
||||
if (m_syncedBackendIdGeneration != g_attachmentBackendIdGeneration) {
|
||||
SyncToBackend(stateFBOObject, asTarget);
|
||||
}
|
||||
}
|
||||
|
||||
// ---- P5e (fb, CONTRACT-P5E.md §5.4): the reverse index, texture -> framebuffers ------
|
||||
//
|
||||
// WHY IT EXISTS. ScopedDetachedTextureFramebufferAttachments used to answer "which
|
||||
|
||||
Reference in New Issue
Block a user