swung0x48/MobileGL
1
0
Fork 0
mirror of https://github.com/MobileGL-Dev/MobileGL synced 2026-09-12 06:08:30 +09:00
Code Issues Packages Projects Releases Wiki Activity
Files
cc34d347062b34121bc14acfc5f8166a0bd5927a
MobileGL/MobileGL/MG_Test/Program/AsyncSpirvPhaseTest.cpp
T

1558 lines
73 KiB
C++
Raw Blame History

// MobileGL - MobileGL/MG_Test/Program/AsyncSpirvPhaseTest.cpp
// Copyright (c) 2025-2026 MobileGL-Dev
// Licensed under the GNU Lesser General Public License v3.0:
// https://www.gnu.org/licenses/gpl-3.0.txt
// https://www.gnu.org/licenses/lgpl-3.0.txt
// SPDX-License-Identifier: LGPL-3.0-only
// End of Source File Header
// The two-phase link: ProgramLinkTask (phase A - everything GL can be asked about the
// program) publishes through the existing join gate, and a chained ProgramSpirvTask (phase B -
// GlslangToSpv, spirv-opt, the global-UBO routing tables) publishes through a second gate that
// only five getters use.
//
// Four properties are under test, and they are the four the split can get wrong:
// * phase A really is complete - LINK_STATUS, the info log and the WHOLE reflection surface
// answer while phase B is still outstanding, and answering them does not settle it;
// * a link that FAILS never posts phase B at all, and a phase B that never produced SPIR-V
// leaves a program that is linked and queryable but not drawable;
// * glUniform* writes taken inside the A->B window are replayed byte-for-byte at the phase-B
// publish, with the UBO content version moving exactly when a direct write would have
// moved it;
// * both publishes bump the link-observable version counters, or a backend memo taken inside
// the window survives the arrival of the SPIR-V.
//
// Like the other async suites, every case drives the real GL entry points and flips
// MG_Config::Features.AsyncShaderCompile itself, so the file behaves identically however the
// suite was launched.
#include <gtest/gtest.h>
#include <chrono>
#include <map>
#include <set>
#include <string>
#include <vector>
#include <spirv-tools/libspirv.hpp>
#include "Config.h"
#include "Includes.h"
#include "Init.h"
#include "MG_Impl/GLImpl/Getter/GL_Getter.h"
#include "MG_Impl/GLImpl/Program/GL_Program.h"
#include "MG_State/GLState/Core.h"
#include "MG_Util/Async/ShaderCompilePool.h"
using namespace MobileGL;
using namespace MobileGL::MG_Impl::GLImpl;
namespace {
class AsyncModeScope {
public:
explicit AsyncModeScope(const Bool async) : m_saved(MG_Config::Features.AsyncShaderCompile) {
MG_Config::Features.AsyncShaderCompile =
async ? MG_Config::QuirkOverride::ForceOn : MG_Config::QuirkOverride::ForceOff;
}
~AsyncModeScope() { MG_Config::Features.AsyncShaderCompile = m_saved; }
AsyncModeScope(const AsyncModeScope&) = delete;
AsyncModeScope& operator=(const AsyncModeScope&) = delete;
private:
const MG_Config::QuirkOverride m_saved;
};
// One worker, restored on the way out. With a single worker a batch of links leaves phase-B
// jobs queued behind each other, which is the whole window this suite needs to observe.
class SingleWorkerScope {
public:
SingleWorkerScope() : m_saved(MG_Util::Async::ShaderCompilePool::Get().GetThreadCount()) {
MG_Util::Async::ShaderCompilePool::Get().SetMaxConcurrency(1);
}
~SingleWorkerScope() { MG_Util::Async::ShaderCompilePool::Get().SetMaxConcurrency(m_saved); }
SingleWorkerScope(const SingleWorkerScope&) = delete;
SingleWorkerScope& operator=(const SingleWorkerScope&) = delete;
private:
const Uint m_saved;
};
const char* kVs = R"(#version 460
layout(location = 0) in vec3 aPos;
out vec3 vPos;
void main() {
vPos = aPos;
gl_Position = vec4(aPos, 1.0);
}
)";
// Heavy enough that neither the compile nor either link phase is instantaneous, and it
// READS every uniform it declares so the optimizer cannot delete the global UBO out from
// under the routing tables. Templated on an index so every instance is distinct source
// text (no preprocess-memo hit).
String MakeUniformSource(const int index) {
const String n = std::to_string(index);
String source = "#version 460\n";
source += "in vec3 vPos;\n";
source += "layout(location = 0) out vec4 fragColor;\n";
source += "uniform mat4 uModel" + n + ";\n";
source += "uniform vec3 uTint" + n + ";\n";
source += "uniform float uArr" + n + "[4];\n";
source += "uniform float uSeed" + n + ";\n";
// An OPAQUE uniform, so the window cases can pin the "glUniform1i(samplerLoc, unit)
// right after a link is a zero-join operation" claim the split is built around.
source += "uniform sampler2D uTex" + n + ";\n";
source += "void main() {\n";
source += " float acc = uSeed" + n + ";\n";
for (int i = 0; i < 200; ++i) {
source += " acc = acc * 1.0001 + sin(acc + " + std::to_string(i) + ".0) * cos(acc);\n";
}
source += " vec4 p = uModel" + n + " * vec4(vPos, 1.0);\n";
source += " acc += p.x + p.y + p.z + p.w;\n";
source += " acc += uArr" + n + "[0] + uArr" + n + "[1] + uArr" + n + "[2] + uArr" + n + "[3];\n";
source += " vec4 t = texture(uTex" + n + ", vPos.xy);\n";
source += " fragColor = vec4(uTint" + n + " * acc, 1.0) * t;\n";
source += "}\n";
return source;
}
GLuint MakeShader(const GLenum type, const char* source) {
const GLuint shader = CreateShader(type);
ShaderSource(shader, 1, &source, nullptr);
CompileShader(shader);
return shader;
}
GLint QueryLinkStatus(const GLuint program) {
GLint status = GL_FALSE;
GetProgramiv(program, GL_LINK_STATUS, &status);
return status;
}
String QueryProgramInfoLog(const GLuint program) {
GLint length = 0;
GetProgramiv(program, GL_INFO_LOG_LENGTH, &length);
if (length <= 0) return String();
std::vector<GLchar> buffer(static_cast<size_t>(length));
GLsizei written = 0;
GetProgramInfoLog(program, length, &written, buffer.data());
return String(buffer.data(), static_cast<size_t>(written));
}
const SharedPtr<MG_State::GLState::ProgramObject>& Object(const GLuint program) {
return MG_State::pGLContext->GetProgramObject(program);
}
Bool SpirvIsSettled(const GLuint program) {
const auto& object = Object(program);
return object == nullptr || object->IsSpirvComplete();
}
Vector<Uint64> SpirvDigest(const GLuint program) {
Vector<Uint64> digest;
const auto& object = Object(program);
if (!object) return digest;
for (const auto& module : object->GetGeneratedSpirv()) {
Uint64 hash = 1469598103934665603ull;
for (const unsigned word : module) {
hash = (hash ^ static_cast<Uint64>(word)) * 1099511628211ull;
}
digest.push_back(hash);
}
return digest;
}
// A batch of linked programs, all with phase A joined and (for most of them) phase B still
// outstanding. Returns the GL names in link order; `indices` receives the source index used
// for each, so uniform names can be reconstructed.
Vector<GLuint> LinkBatch(const int count, const int firstIndex, Vector<String>& sourceStorage) {
const GLuint vs = MakeShader(GL_VERTEX_SHADER, kVs);
Vector<GLuint> programs;
programs.reserve(static_cast<SizeT>(count));
for (int i = 0; i < count; ++i) {
sourceStorage.push_back(MakeUniformSource(firstIndex + i));
const char* text = sourceStorage.back().c_str();
const GLuint fs = CreateShader(GL_FRAGMENT_SHADER);
ShaderSource(fs, 1, &text, nullptr);
CompileShader(fs);
const GLuint program = CreateProgram();
AttachShader(program, vs);
AttachShader(program, fs);
LinkProgram(program);
programs.push_back(program);
}
return programs;
}
class AsyncSpirvPhaseTest : public ::testing::Test {
protected:
void SetUp() override { MobileGL::Initialize(); }
};
} // namespace
// ---------------------------------------------------------------------------------------
// Phase A is complete on its own
// ---------------------------------------------------------------------------------------
// The headline property: the whole GL query surface is answerable out of phase A. Every query
// below is asked while phase-B jobs are still queued, and none of them may settle one.
TEST_F(AsyncSpirvPhaseTest, EveryReflectionQueryAnswersWhileTheSpirvJobIsOutstanding) {
const AsyncModeScope async(true);
const SingleWorkerScope oneWorker;
constexpr int kPrograms = 24;
constexpr int kFirst = 31000;
Vector<String> sources;
const Vector<GLuint> programs = LinkBatch(kPrograms, kFirst, sources);
int outstanding = 0;
for (int i = 0; i < kPrograms; ++i) {
const GLuint program = programs[static_cast<SizeT>(i)];
const String n = std::to_string(kFirst + i);
// LINK_STATUS and the info log: phase A.
EXPECT_EQ(QueryLinkStatus(program), GL_TRUE) << QueryProgramInfoLog(program);
// Uniform locations, including the array's element slots.
const GLint locModel = GetUniformLocation(program, ("uModel" + n).c_str());
const GLint locTint = GetUniformLocation(program, ("uTint" + n).c_str());
const GLint locArr = GetUniformLocation(program, ("uArr" + n + "[0]").c_str());
const GLint locArr2 = GetUniformLocation(program, ("uArr" + n + "[2]").c_str());
EXPECT_GE(locModel, 0);
EXPECT_GE(locTint, 0);
EXPECT_GE(locArr, 0);
EXPECT_EQ(locArr2, locArr + 2);
// Counts and name lengths.
GLint activeUniforms = 0;
GLint maxNameLength = 0;
GLint activeAttributes = 0;
GLint activeBlocks = 0;
GetProgramiv(program, GL_ACTIVE_UNIFORMS, &activeUniforms);
GetProgramiv(program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxNameLength);
GetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &activeAttributes);
GetProgramiv(program, GL_ACTIVE_UNIFORM_BLOCKS, &activeBlocks);
EXPECT_GE(activeUniforms, 4);
EXPECT_GT(maxNameLength, 0);
EXPECT_GE(activeAttributes, 1);
EXPECT_EQ(activeBlocks, 0); // the synthesized global UBO is not GL-visible
// Per-uniform reflection.
std::vector<GLchar> nameBuffer(static_cast<size_t>(maxNameLength) + 1);
GLsizei written = 0;
GLint size = 0;
GLenum type = 0;
GetActiveUniform(program, 0, maxNameLength, &written, &size, &type, nameBuffer.data());
EXPECT_GT(written, 0);
// Attributes and fragment outputs.
EXPECT_GE(GetAttribLocation(program, "aPos"), 0);
EXPECT_GE(GetFragDataLocation(program, "fragColor"), 0);
// Transform feedback and the geometry input type, both phase A.
GLint xfbVaryings = -1;
GetProgramiv(program, GL_TRANSFORM_FEEDBACK_VARYINGS, &xfbVaryings);
EXPECT_EQ(xfbVaryings, 0);
EXPECT_EQ(GetError(), GL_NO_ERROR);
if (!SpirvIsSettled(program)) ++outstanding;
}
EXPECT_GT(outstanding, 0) << "every phase-B job had already drained while the whole query surface was being "
"read - one of those queries is joining phase B";
}
// ---------------------------------------------------------------------------------------
// A failed link never posts phase B
// ---------------------------------------------------------------------------------------
TEST_F(AsyncSpirvPhaseTest, ALinkThatFailsNeverProducesSpirv) {
for (const Bool async : {false, true}) {
const AsyncModeScope scope(async);
const char* brokenFs = R"(#version 460
layout(location = 0) out vec4 fragColor;
void main() { fragColor = thisIdentifierWasNeverDeclared; }
)";
const GLuint vs = MakeShader(GL_VERTEX_SHADER, kVs);
const GLuint fs = MakeShader(GL_FRAGMENT_SHADER, brokenFs);
const GLuint program = CreateProgram();
AttachShader(program, vs);
AttachShader(program, fs);
LinkProgram(program);
EXPECT_EQ(QueryLinkStatus(program), GL_FALSE);
EXPECT_FALSE(QueryProgramInfoLog(program).empty());
const auto& object = Object(program);
ASSERT_NE(object, nullptr);
// GetSpirvStatus() FIRST, and the order is load-bearing rather than stylistic: phase B
// is settled by a continuation that runs on whichever worker drove phase A terminal,
// and JobNode::TryTransition releases waiters (notify_all) BEFORE it runs its
// continuation list - so the GL thread can be back here with phase A published while
// that one-line lambda has not run yet. GetSpirvStatus() goes through the phase-B
// gate, which Waits; only after it has can IsSpirvComplete() be asserted without a
// race. Asserting the other way round is a rare CI flake, not a red.
EXPECT_FALSE(object->GetSpirvStatus());
EXPECT_TRUE(object->IsSpirvComplete());
EXPECT_TRUE(object->GetGeneratedSpirv().empty());
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
}
// A fragment output past GL_MAX_DRAW_BUFFERS fails the link inside phase A, and it is the
// check that used to run AFTER 68 s of SPIR-V work per pack load.
TEST_F(AsyncSpirvPhaseTest, AFragmentOutputRangeFailureIsDecidedInPhaseA) {
const AsyncModeScope async(true);
const char* fs = R"(#version 460
layout(location = 4096) out vec4 fragColor;
void main() { fragColor = vec4(1.0); }
)";
const GLuint vs = MakeShader(GL_VERTEX_SHADER, kVs);
const GLuint fsId = MakeShader(GL_FRAGMENT_SHADER, fs);
const GLuint program = CreateProgram();
AttachShader(program, vs);
AttachShader(program, fsId);
LinkProgram(program);
EXPECT_EQ(QueryLinkStatus(program), GL_FALSE) << "a fragment output past GL_MAX_DRAW_BUFFERS must fail the link";
const auto& object = Object(program);
ASSERT_NE(object, nullptr);
// GetSpirvStatus() before IsSpirvComplete(); see ALinkThatFailsNeverProducesSpirv.
EXPECT_FALSE(object->GetSpirvStatus());
EXPECT_TRUE(object->IsSpirvComplete());
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
// ---------------------------------------------------------------------------------------
// Linked, but the SPIR-V never arrived
// ---------------------------------------------------------------------------------------
// The state the split invented and GL gives no way out of: phase A published LINK_STATUS
// GL_TRUE, and phase B then settled CANCELLED rather than Complete - its body threw
// (bad_alloc out of GlslangToSpv/spirv-opt under pack-load memory pressure), the pool failed
// to enqueue it, or teardown cancelled it while it was queued. The shadow is then a
// default-constructed SpirvArtifacts: empty uniformOffsets, null scratch, spirvStatus false -
// while the whole phase-A query surface, IsValidUniformLocation() included, keeps answering.
//
// Every getter and every entry point on that surface must degrade, not fault. Before the
// bounds check in GetUniformOffset this was a null dereference on the first glUniform* or
// glGetUniform* the application made.
//
// The state is produced deterministically rather than by racing a cancel: after the
// LINK_STATUS read has published phase A (m_pendingLink is null), CancelLink() can only reach
// the SPIR-V job - which is exactly the shape StopAndDrain produces for a phase B queued
// behind an already-complete phase A.
TEST_F(AsyncSpirvPhaseTest, ALinkedProgramWhoseSpirvJobWasCancelledDegradesInsteadOfFaulting) {
const AsyncModeScope async(true);
const SingleWorkerScope oneWorker;
constexpr int kPrograms = 12;
constexpr int kFirst = 38000;
Vector<String> sources;
const Vector<GLuint> programs = LinkBatch(kPrograms, kFirst, sources);
int cancelled = 0;
for (int i = 0; i < kPrograms; ++i) {
const GLuint program = programs[static_cast<SizeT>(i)];
const String n = std::to_string(kFirst + i);
ASSERT_EQ(QueryLinkStatus(program), GL_TRUE) << QueryProgramInfoLog(program);
const auto& object = Object(program);
ASSERT_NE(object, nullptr);
if (object->IsSpirvComplete()) continue; // already published; not the state under test
object->CancelLink(); // phase A is published, so this reaches only the SPIR-V job
++cancelled;
// ---- the contract: linked, fully queryable, not drawable ----
EXPECT_TRUE(object->GetLinkStatus()) << "a cancelled phase B must not retract LINK_STATUS";
EXPECT_EQ(QueryLinkStatus(program), GL_TRUE);
EXPECT_FALSE(object->GetSpirvStatus());
EXPECT_TRUE(object->IsSpirvComplete());
// This is the expression both backends' bind gates evaluate.
EXPECT_FALSE(object->GetLinkStatus() && object->GetSpirvStatus())
<< "the backends must refuse to bind a program with no SPIR-V";
EXPECT_TRUE(object->GetGeneratedSpirv().empty());
EXPECT_EQ(object->GetUBOSize(), 0u);
EXPECT_EQ(object->GetUBOData(), nullptr);
// ---- the reflection surface still answers ----
const GLint locModel = GetUniformLocation(program, ("uModel" + n).c_str());
const GLint locTint = GetUniformLocation(program, ("uTint" + n).c_str());
const GLint locTex = GetUniformLocation(program, ("uTex" + n).c_str());
ASSERT_GE(locModel, 0);
ASSERT_GE(locTint, 0);
ASSERT_GE(locTex, 0);
EXPECT_TRUE(object->IsValidUniformLocation(locTint));
// ---- and every write/read path degrades ----
// Direct getter first: kInvalidUniformOffset, not an out-of-bounds index.
EXPECT_EQ(object->GetUniformOffset(static_cast<Uint>(locTint)),
MG_State::GLState::ProgramObject::kInvalidUniformOffset);
EXPECT_EQ(object->GetUniformOffset(object->GetMaxUniformLocation()),
MG_State::GLState::ProgramObject::kInvalidUniformOffset);
const GLfloat tint[3] = {1.0f, 2.0f, 3.0f};
GLfloat model[16] = {};
for (int c = 0; c < 16; ++c) model[c] = static_cast<GLfloat>(c);
ProgramUniform3fv(program, locTint, 1, tint); // dropped, not faulted
ProgramUniformMatrix4fv(program, locModel, 1, GL_FALSE, model); // ditto
UseProgram(program);
Uniform3fv(locTint, 1, tint); // the glUseProgram + glUniform* entry, same verdict
UseProgram(0);
// The opaque branch never touches phase B, so it keeps working in full.
ProgramUniform1i(program, locTex, 3);
GLint unit = -1;
GetUniformiv(program, locTex, &unit);
EXPECT_EQ(unit, 3) << "sampler units are phase-A state and must survive a lost phase B";
// Reads leave the caller's buffer alone rather than faulting.
GLfloat readback[16] = {};
for (int c = 0; c < 16; ++c) readback[c] = -1.0f;
GetUniformfv(program, locModel, readback);
for (int c = 0; c < 16; ++c) {
EXPECT_FLOAT_EQ(readback[c], -1.0f) << "a program with no shadow must not write the query buffer";
}
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
EXPECT_GT(cancelled, 0) << "no phase B was ever cancelled; this case proved nothing";
}
// The mirror image: with async off the state is not reachable at all, because both bodies run
// inline before glLinkProgram returns. Worth pinning - it is what makes the async-off mode a
// usable fallback for a device where the state above would be a problem.
TEST_F(AsyncSpirvPhaseTest, AsyncOffNeverProducesALinkedProgramWithoutSpirv) {
const AsyncModeScope async(false);
Vector<String> sources;
const Vector<GLuint> programs = LinkBatch(4, 39000, sources);
for (const GLuint program : programs) {
const auto& object = Object(program);
ASSERT_NE(object, nullptr);
EXPECT_EQ(QueryLinkStatus(program), GL_TRUE) << QueryProgramInfoLog(program);
EXPECT_TRUE(object->IsSpirvComplete()) << "nothing may be outstanding when async is off";
EXPECT_TRUE(object->GetSpirvStatus());
EXPECT_GT(object->GetUBOSize(), 0u);
}
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
// ---------------------------------------------------------------------------------------
// glUniform* across the window
// ---------------------------------------------------------------------------------------
// The write path's half of the split: a non-opaque glUniform* inside the A->B window is
// recorded rather than joined, and the bytes that come back afterwards are the bytes that
// went in. Writes are made through glProgramUniform* so no program has to be current.
TEST_F(AsyncSpirvPhaseTest, UniformWritesInsideTheWindowReplayExactly) {
const AsyncModeScope async(true);
const SingleWorkerScope oneWorker;
constexpr int kPrograms = 24;
constexpr int kFirst = 32000;
Vector<String> sources;
const Vector<GLuint> programs = LinkBatch(kPrograms, kFirst, sources);
struct Expectation {
GLuint program = 0;
GLint locModel = -1;
GLint locTint = -1;
GLint locArr = -1;
GLint locTex = -1;
GLfloat model[16] = {};
GLfloat tint[3] = {};
GLfloat arr1 = 0.0f;
GLint texUnit = 0;
Bool wasBuffered = false;
};
Vector<Expectation> expectations;
int buffered = 0;
for (int i = 0; i < kPrograms; ++i) {
Expectation e;
e.program = programs[static_cast<SizeT>(i)];
const String n = std::to_string(kFirst + i);
ASSERT_EQ(QueryLinkStatus(e.program), GL_TRUE) << QueryProgramInfoLog(e.program);
// Sampled straight after the LINK_STATUS read: phase A is settled, phase B usually is
// not, and this is exactly the window an application writes its uniforms in.
e.wasBuffered = !SpirvIsSettled(e.program);
if (e.wasBuffered) ++buffered;
e.locModel = GetUniformLocation(e.program, ("uModel" + n).c_str());
e.locTint = GetUniformLocation(e.program, ("uTint" + n).c_str());
e.locArr = GetUniformLocation(e.program, ("uArr" + n + "[0]").c_str());
e.locTex = GetUniformLocation(e.program, ("uTex" + n).c_str());
ASSERT_GE(e.locModel, 0);
ASSERT_GE(e.locTint, 0);
ASSERT_GE(e.locArr, 0);
ASSERT_GE(e.locTex, 0);
for (int c = 0; c < 16; ++c) e.model[c] = static_cast<GLfloat>(i) + static_cast<GLfloat>(c) * 0.25f;
e.tint[0] = 0.125f * static_cast<GLfloat>(i);
e.tint[1] = 0.25f * static_cast<GLfloat>(i);
e.tint[2] = 0.5f * static_cast<GLfloat>(i);
e.arr1 = 7.5f + static_cast<GLfloat>(i);
e.texUnit = i % 8;
// An OPAQUE write inside the window. The design's load-bearing claim is that this is a
// ZERO-JOIN operation - a sampler unit is phase-A state - and it is what Iris does
// immediately after every glLinkProgram, so it is asserted rather than assumed.
ProgramUniform1i(e.program, e.locTex, e.texUnit);
if (e.wasBuffered) {
EXPECT_FALSE(SpirvIsSettled(e.program))
<< "glUniform1i on a sampler must not settle phase B (program " << e.program << ")";
}
ProgramUniformMatrix4fv(e.program, e.locModel, 1, GL_FALSE, e.model);
ProgramUniform3fv(e.program, e.locTint, 1, e.tint);
// An element in the middle of an array, addressed by its own location.
ProgramUniform1fv(e.program, e.locArr + 1, 1, &e.arr1);
// Last write wins, and through the OTHER entry point for half the programs: the
// Minecraft/Iris shape is glUseProgram + glUniform*, which reaches Uniform_State
// through Uniformv_State/GetProgramForUniform rather than through the by-name form.
e.tint[1] = 0.75f;
if ((i % 2) == 0) {
ProgramUniform3fv(e.program, e.locTint, 1, e.tint);
} else {
UseProgram(e.program);
Uniform3fv(e.locTint, 1, e.tint);
UseProgram(0);
}
if (e.wasBuffered) {
EXPECT_FALSE(SpirvIsSettled(e.program))
<< "no glUniform* entry point may settle phase B (program " << e.program << ")";
}
expectations.push_back(e);
}
EXPECT_GT(buffered, 0) << "no write ever landed inside the A->B window; this case proved nothing";
for (const Expectation& e : expectations) {
GLfloat model[16] = {};
GLfloat tint[3] = {};
GLfloat arr1 = 0.0f;
GetUniformfv(e.program, e.locModel, model);
GetUniformfv(e.program, e.locTint, tint);
GetUniformfv(e.program, e.locArr + 1, &arr1);
for (int c = 0; c < 16; ++c) {
EXPECT_FLOAT_EQ(model[c], e.model[c]) << "program " << e.program << " matrix component " << c;
}
for (int c = 0; c < 3; ++c) {
EXPECT_FLOAT_EQ(tint[c], e.tint[c]) << "program " << e.program << " tint component " << c;
}
EXPECT_FLOAT_EQ(arr1, e.arr1) << "program " << e.program << " array element 1";
GLint unit = -1;
GetUniformiv(e.program, e.locTex, &unit);
EXPECT_EQ(unit, e.texUnit) << "program " << e.program << " sampler unit";
// Reading them settled phase B, so the program is drawable now.
const auto& object = Object(e.program);
ASSERT_NE(object, nullptr);
EXPECT_TRUE(object->GetSpirvStatus());
}
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
// The overflow valve. BufferUniformWrite declines past kMaxBufferedUniformBytes and the
// caller falls through to the direct path - which JOINS, and therefore has to replay
// everything already buffered BEFORE performing its own write, or last-write-wins breaks for
// every uniform touched after the valve trips.
TEST_F(AsyncSpirvPhaseTest, TheBufferedWriteValveFallsThroughToADirectWriteWithoutLosingOrder) {
const AsyncModeScope async(true);
const SingleWorkerScope oneWorker;
constexpr int kPrograms = 8;
constexpr int kFirst = 40000;
// kMaxBufferedUniformBytes is 4 MiB and one mat4 write buffers 4 columns x 16 bytes, so
// this many calls is comfortably past the valve.
constexpr int kFloodWrites = 80000;
Vector<String> sources;
const Vector<GLuint> programs = LinkBatch(kPrograms, kFirst, sources);
int flooded = 0;
for (int i = 0; i < kPrograms; ++i) {
const GLuint program = programs[static_cast<SizeT>(i)];
const String n = std::to_string(kFirst + i);
ASSERT_EQ(QueryLinkStatus(program), GL_TRUE) << QueryProgramInfoLog(program);
if (SpirvIsSettled(program)) continue;
++flooded;
const GLint locModel = GetUniformLocation(program, ("uModel" + n).c_str());
const GLint locTint = GetUniformLocation(program, ("uTint" + n).c_str());
ASSERT_GE(locModel, 0);
ASSERT_GE(locTint, 0);
// A distinctive early value that must survive the valve: it is buffered, and the
// fall-through write has to replay it before writing its own bytes.
const GLfloat earlyTint[3] = {11.0f, 22.0f, 33.0f};
ProgramUniform3fv(program, locTint, 1, earlyTint);
GLfloat model[16] = {};
for (int w = 0; w < kFloodWrites; ++w) {
for (int c = 0; c < 16; ++c) model[c] = static_cast<GLfloat>(w) + static_cast<GLfloat>(c);
ProgramUniformMatrix4fv(program, locModel, 1, GL_FALSE, model);
}
// Falling through joined, so the shadow is live and holds BOTH the buffered early
// write and the last direct one.
EXPECT_TRUE(SpirvIsSettled(program)) << "the valve must have fallen through to a joining write";
GLfloat tintReadback[3] = {};
GLfloat modelReadback[16] = {};
GetUniformfv(program, locTint, tintReadback);
GetUniformfv(program, locModel, modelReadback);
for (int c = 0; c < 3; ++c) {
EXPECT_FLOAT_EQ(tintReadback[c], earlyTint[c])
<< "the pre-valve buffered write was lost at component " << c;
}
for (int c = 0; c < 16; ++c) {
EXPECT_FLOAT_EQ(modelReadback[c], static_cast<GLfloat>(kFloodWrites - 1) + static_cast<GLfloat>(c))
<< "last-write-wins broke across the valve at component " << c;
}
}
EXPECT_GT(flooded, 0) << "no program was ever observed inside the A->B window";
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
// The dedupe property the live write path has, preserved across the detour: replaying a record
// that really changes bytes moves the UBO content version, and a bytes-identical write made
// AFTER the replay does not move it. Both matter - the first is what makes a backend re-upload
// a UBO it cached during the window, the second is what stops Minecraft's per-frame re-set of
// identical matrices from re-uploading every frame.
TEST_F(AsyncSpirvPhaseTest, TheReplayMovesTheUboContentVersionExactlyLikeADirectWrite) {
const AsyncModeScope async(true);
const SingleWorkerScope oneWorker;
constexpr int kPrograms = 24;
constexpr int kFirst = 33000;
Vector<String> sources;
const Vector<GLuint> programs = LinkBatch(kPrograms, kFirst, sources);
int checked = 0;
for (int i = 0; i < kPrograms; ++i) {
const GLuint program = programs[static_cast<SizeT>(i)];
const String n = std::to_string(kFirst + i);
ASSERT_EQ(QueryLinkStatus(program), GL_TRUE) << QueryProgramInfoLog(program);
if (SpirvIsSettled(program)) continue; // phase B already landed; nothing to buffer
const auto& object = Object(program);
ASSERT_NE(object, nullptr);
const GLint locTint = GetUniformLocation(program, ("uTint" + n).c_str());
ASSERT_GE(locTint, 0);
const Uint32 versionBeforeWrite = object->GetUBOContentVersion();
const GLfloat tint[3] = {0.5f, 0.25f, 0.125f};
ProgramUniform3fv(program, locTint, 1, tint);
// Still buffered: nothing has been written into the shadow yet, so the content version
// cannot have moved.
EXPECT_EQ(object->GetUBOContentVersion(), versionBeforeWrite)
<< "a buffered write must not move the content version before it is replayed";
// The join replays it - and the replay writes real bytes, so it moves.
object->JoinLinkAndSpirv();
EXPECT_NE(object->GetUBOContentVersion(), versionBeforeWrite)
<< "the replayed write changed bytes, so the content version had to move";
// And now the ordinary dedupe applies again.
const Uint32 versionAfterReplay = object->GetUBOContentVersion();
ProgramUniform3fv(program, locTint, 1, tint);
EXPECT_EQ(object->GetUBOContentVersion(), versionAfterReplay)
<< "a bytes-identical rewrite after the replay must not move the content version";
++checked;
}
EXPECT_GT(checked, 0) << "no program was ever observed inside the A->B window";
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
// ---------------------------------------------------------------------------------------
// Version counters
// ---------------------------------------------------------------------------------------
// Both publishes bump the link-observable versions. Without the second bump, a backend memo
// taken inside the A->B window - when the program already answers as linked but has no SPIR-V
// and no uniform shadow - would survive the arrival of both.
TEST_F(AsyncSpirvPhaseTest, TheSpirvPublishBumpsTheLinkObservableVersions) {
const AsyncModeScope async(true);
const SingleWorkerScope oneWorker;
constexpr int kPrograms = 24;
constexpr int kFirst = 34000;
Vector<String> sources;
const Vector<GLuint> programs = LinkBatch(kPrograms, kFirst, sources);
int checked = 0;
for (int i = 0; i < kPrograms; ++i) {
const GLuint program = programs[static_cast<SizeT>(i)];
ASSERT_EQ(QueryLinkStatus(program), GL_TRUE) << QueryProgramInfoLog(program);
if (SpirvIsSettled(program)) continue;
const auto& object = Object(program);
ASSERT_NE(object, nullptr);
const Uint32 backendVersionInWindow = object->GetBackendStateVersion();
const Uint32 linkVersionInWindow = object->GetLinkVersion();
object->JoinLinkAndSpirv();
EXPECT_NE(object->GetBackendStateVersion(), backendVersionInWindow)
<< "a memo keyed on backendStateVersion inside the window would have survived the SPIR-V publish";
EXPECT_NE(object->GetLinkVersion(), linkVersionInWindow);
++checked;
}
EXPECT_GT(checked, 0) << "no program was ever observed inside the A->B window";
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
// ---------------------------------------------------------------------------------------
// Cancel
// ---------------------------------------------------------------------------------------
// A relink over a program whose phase B is still in flight drops that phase B where it stands
// and the new link answers for itself. The half-published program the old one-handler-per-link
// comment warned about is structurally impossible: the relink resets BOTH halves.
TEST_F(AsyncSpirvPhaseTest, RelinkingOverAPendingSpirvJobIsClean) {
const AsyncModeScope async(true);
const SingleWorkerScope oneWorker;
constexpr int kPrograms = 16;
constexpr int kFirst = 35000;
constexpr int kRelinkOffset = 500; // distinct uniform names for the second link
// Built by hand rather than through LinkBatch, because the relink has to use DIFFERENT
// source: relinking byte-identical source cannot tell the second link's artifacts from
// the first's, so it would pass even if Link()'s prologue stopped resetting m_spirv.
const GLuint vs = MakeShader(GL_VERTEX_SHADER, kVs);
Vector<String> firstSources;
Vector<String> secondSources;
Vector<GLuint> programs;
Vector<GLuint> fragmentShaders;
for (int i = 0; i < kPrograms; ++i) {
firstSources.push_back(MakeUniformSource(kFirst + i));
const char* text = firstSources.back().c_str();
const GLuint fs = CreateShader(GL_FRAGMENT_SHADER);
ShaderSource(fs, 1, &text, nullptr);
CompileShader(fs);
const GLuint program = CreateProgram();
AttachShader(program, vs);
AttachShader(program, fs);
LinkProgram(program);
programs.push_back(program);
fragmentShaders.push_back(fs);
}
int relinked = 0;
for (int i = 0; i < kPrograms; ++i) {
const GLuint program = programs[static_cast<SizeT>(i)];
const String firstName = "uTint" + std::to_string(kFirst + i);
ASSERT_EQ(QueryLinkStatus(program), GL_TRUE) << QueryProgramInfoLog(program);
if (SpirvIsSettled(program)) continue;
// A write buffered against link #1, which the relink must DROP. If CancelLink stopped
// clearing the buffers, these bytes would be replayed into link #2's shadow at
// whatever offset its own routing tables assigned - silently overwriting a uniform
// GL 4.6 core 7.6 requires a relink to have reset to zero.
const GLint firstTint = GetUniformLocation(program, firstName.c_str());
ASSERT_GE(firstTint, 0);
const GLfloat poison[3] = {123.0f, 456.0f, 789.0f};
ProgramUniform3fv(program, firstTint, 1, poison);
ASSERT_FALSE(SpirvIsSettled(program)) << "the poison write should have been buffered, not applied";
// Relink, with different source, while phase B is queued.
secondSources.push_back(MakeUniformSource(kFirst + kRelinkOffset + i));
const char* secondText = secondSources.back().c_str();
ShaderSource(fragmentShaders[static_cast<SizeT>(i)], 1, &secondText, nullptr);
CompileShader(fragmentShaders[static_cast<SizeT>(i)]);
LinkProgram(program);
++relinked;
EXPECT_EQ(QueryLinkStatus(program), GL_TRUE) << QueryProgramInfoLog(program);
// The artifacts really are the SECOND link's: the first link's uniform is gone.
EXPECT_EQ(GetUniformLocation(program, firstName.c_str()), -1)
<< "the relink is still answering out of the previous link's reflection";
const String secondName = "uTint" + std::to_string(kFirst + kRelinkOffset + i);
const GLint secondTint = GetUniformLocation(program, secondName.c_str());
ASSERT_GE(secondTint, 0) << secondName;
const auto& object = Object(program);
ASSERT_NE(object, nullptr);
object->JoinLinkAndSpirv();
EXPECT_TRUE(object->GetSpirvStatus()) << "the relink's own phase B must have produced SPIR-V";
EXPECT_FALSE(object->GetGeneratedSpirv().empty());
// And the dropped buffer really was dropped: a freshly linked program's uniforms read
// back as zero.
GLfloat tint[3] = {-1.0f, -1.0f, -1.0f};
GetUniformfv(program, secondTint, tint);
for (int c = 0; c < 3; ++c) {
EXPECT_FLOAT_EQ(tint[c], 0.0f)
<< "a uniform write buffered against the cancelled link leaked into the relink, component " << c;
}
}
EXPECT_GT(relinked, 0) << "no relink ever landed inside the A->B window";
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
// Destroying a program whose phase B is still queued must ABANDON it, not wait for it. The
// property is timed rather than asserted structurally, and self-calibrated: deleting a whole
// batch of programs with outstanding SPIR-V jobs has to cost a small fraction of what draining
// the same number of jobs costs. Replacing CancelLink's cooperative Cancel() with a Wait()
// would make the two times equal - which is precisely the GL-thread stall the design forbids,
// and which the previous shape of this case could not see.
TEST_F(AsyncSpirvPhaseTest, DeletingAProgramWithAPendingSpirvJobDoesNotBlock) {
const AsyncModeScope async(true);
const SingleWorkerScope oneWorker;
constexpr int kPrograms = 24;
constexpr int kHalf = kPrograms / 2;
constexpr int kFirst = 36000;
Vector<String> sources;
const Vector<GLuint> programs = LinkBatch(kPrograms, kFirst, sources);
// Settle phase A for every program without touching phase B.
for (int i = 0; i < kPrograms; ++i) {
ASSERT_EQ(QueryLinkStatus(programs[static_cast<SizeT>(i)]), GL_TRUE)
<< QueryProgramInfoLog(programs[static_cast<SizeT>(i)]);
}
int outstandingBeforeDelete = 0;
for (int i = 0; i < kHalf; ++i) {
const GLuint program = programs[static_cast<SizeT>(i)];
if (!SpirvIsSettled(program)) ++outstandingBeforeDelete;
// Buffered writes on the destruction path, so CancelLink's drop of
// m_pendingUniformWrites/m_pendingUniformBytes is exercised rather than assumed.
const String n = std::to_string(kFirst + i);
const GLint locTint = GetUniformLocation(program, ("uTint" + n).c_str());
if (locTint >= 0) {
const GLfloat tint[3] = {1.0f, 2.0f, 3.0f};
ProgramUniform3fv(program, locTint, 1, tint);
}
}
const auto deleteStart = std::chrono::steady_clock::now();
for (int i = 0; i < kHalf; ++i) {
DeleteProgram(programs[static_cast<SizeT>(i)]);
}
const auto deleteEnd = std::chrono::steady_clock::now();
// The calibration run: the same number of phase-B jobs, actually drained. Counted first,
// so a machine that drained everything in the background cannot turn the bound below into
// a comparison between two zeroes without saying so.
int outstandingBeforeDrain = 0;
for (int i = kHalf; i < kPrograms; ++i) {
if (!SpirvIsSettled(programs[static_cast<SizeT>(i)])) ++outstandingBeforeDrain;
}
const auto drainStart = std::chrono::steady_clock::now();
for (int i = kHalf; i < kPrograms; ++i) {
const auto& object = Object(programs[static_cast<SizeT>(i)]);
ASSERT_NE(object, nullptr);
object->JoinLinkAndSpirv();
}
const auto drainEnd = std::chrono::steady_clock::now();
const auto deleteUs =
std::chrono::duration_cast<std::chrono::microseconds>(deleteEnd - deleteStart).count();
const auto drainUs = std::chrono::duration_cast<std::chrono::microseconds>(drainEnd - drainStart).count();
EXPECT_GT(outstandingBeforeDelete, 0) << "no program was deleted inside the A->B window";
EXPECT_GT(outstandingBeforeDrain, 0) << "nothing was left to drain, so the timing bound has no calibration";
if (outstandingBeforeDelete > 0 && outstandingBeforeDrain > 0 && drainUs > 2000) {
EXPECT_LT(deleteUs, drainUs / 4)
<< "deleting " << kHalf << " programs with outstanding SPIR-V jobs took " << deleteUs
<< " us against " << drainUs << " us to drain the same number - glDeleteProgram is waiting for them";
}
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
// ---------------------------------------------------------------------------------------
// Inline equivalence
// ---------------------------------------------------------------------------------------
// The contract the async-off path has always had: it is byte-identical to the synchronous
// implementation. The split runs two bodies instead of one, in order, on the calling thread -
// and the artifacts it produces must equal what the asynchronous path produces.
TEST_F(AsyncSpirvPhaseTest, AsyncOffAndAsyncOnProduceIdenticalSpirvAndShadow) {
// The ASYNC arm runs FIRST, deliberately. Both arms must compile the same source text for
// their SPIR-V to be comparable, and the first arm to run is the one that pays for the
// cold path: it misses the per-context ShaderPreprocessCache and therefore executes
// PreprocessShaderSource, the reserved-identifier scan and both lexical extractions. Run
// the sync arm first and the async arm becomes a cache hit that never runs any of that on
// a worker - which is exactly the half this case exists to compare.
const SingleWorkerScope oneWorker;
Vector<Uint64> asyncDigest;
Uint asyncUboSize = 0;
Vector<Uint> asyncOffsets;
Vector<Uint64> syncDigest;
Uint syncUboSize = 0;
Vector<Uint> syncOffsets;
const auto buildOnce = [&](const Bool async, Vector<Uint64>& digest, Uint& uboSize, Vector<Uint>& offsets) {
const AsyncModeScope scope(async);
// A witness that this arm really ran in the mode it claims: without it, any ambient
// reason for AsyncShaderCompileActive() to be false degrades the case to sync-vs-sync
// and it still passes.
ASSERT_EQ(MG_Util::Async::AsyncShaderCompileActive(), async)
<< "the arm did not run in the mode it was asked for";
// Give the single worker a backlog to chew on, so "was it actually asynchronous" is a
// deterministic observation rather than a race with a fast pool.
Vector<String> backlogSources;
Vector<GLuint> backlog;
if (async) {
backlog = LinkBatch(6, 37500, backlogSources);
}
const String source = MakeUniformSource(37000);
const char* text = source.c_str();
const GLuint vs = MakeShader(GL_VERTEX_SHADER, kVs);
const GLuint fs = CreateShader(GL_FRAGMENT_SHADER);
ShaderSource(fs, 1, &text, nullptr);
CompileShader(fs);
const GLuint program = CreateProgram();
AttachShader(program, vs);
AttachShader(program, fs);
LinkProgram(program);
const auto& object = Object(program);
ASSERT_NE(object, nullptr);
if (async) {
// Nothing has been read yet, and the worker is busy with the backlog: the link
// must genuinely still be outstanding.
EXPECT_FALSE(object->IsLinkComplete()) << "the async arm settled before anything read it";
} else {
// The whole point of the mode: nothing is outstanding when glLinkProgram returns.
EXPECT_TRUE(object->IsLinkComplete());
}
ASSERT_EQ(QueryLinkStatus(program), GL_TRUE) << QueryProgramInfoLog(program);
digest = SpirvDigest(program);
uboSize = object->GetUBOSize();
for (Uint location = 0; location <= object->GetMaxUniformLocation(); ++location) {
offsets.push_back(object->GetUniformOffset(location));
}
EXPECT_TRUE(object->GetSpirvStatus());
for (const GLuint backlogProgram : backlog) {
DeleteProgram(backlogProgram);
}
};
buildOnce(true, asyncDigest, asyncUboSize, asyncOffsets);
ASSERT_FALSE(asyncDigest.empty());
buildOnce(false, syncDigest, syncUboSize, syncOffsets);
EXPECT_EQ(asyncDigest, syncDigest) << "the two modes produced different SPIR-V";
EXPECT_EQ(asyncUboSize, syncUboSize);
EXPECT_EQ(asyncOffsets, syncOffsets);
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
// ---------------------------------------------------------------------------------------
// The program that crashed the device, replayed end to end through the async frontend
// ---------------------------------------------------------------------------------------
//
// This is the shape that killed DirectVulkan on an Adreno 830: an Iris-transformed shader
// pair whose vertex stage declares inputs that Iris does not bind through
// glBindAttribLocation and that the shader itself never reads. Before the io-resolver fix
// such an input reached SPIR-V with no Location decoration, which is invalid
// (VUID-StandaloneSpirv-Location-04916); Adreno rejected the whole pipeline with
// VK_ERROR_UNKNOWN at the first rainy-world draw while lavapipe accepted it, so no desktop
// gate could see it.
//
// The sources are the real thing, lifted verbatim from the extracted BSL corpus: a vertex
// shader carrying the victim's condition - it DECLARES mc_Entity and mc_midTexCoord without
// reading either, and Iris binds neither - paired with the iris_FragData0 fragment shader
// that consumes its varyings. It is not the device's exact pack revision (that build is not
// in the corpus), but it is a real Iris-transformed program with the same partial-binding
// shape, driven through the same call sequence.
//
// FRONTEND ONLY, deliberately: nothing here touches a backend or a driver. The replay stops
// at the SPIR-V the frontend hands over, and validates it with the same validator whose VUID
// the driver enforces.
namespace {
const char* kIrisWeatherVs = R"GLSL(#version 330 core
// Generated by glsl-transformer
uniform mat4 iris_ProjMat;
in vec3 iris_Position;
uniform mat4 iris_ModelViewMatInverse;
uniform mat4 iris_ProjMatInverse;
uniform mat3 iris_NormalMat;
uniform mat4 iris_LightmapTextureMatrix;
uniform mat4 iris_TextureMat;
uniform mat4 iris_ModelViewMat;
in vec4 iris_Color;
uniform vec4 iris_ColorModulator;
in ivec2 iris_UV2;
in vec2 iris_UV0;
uniform float iris_FogDensity;
uniform float iris_FogStart;
uniform float iris_FogEnd;
uniform vec4 iris_FogColor;
struct iris_FogParameters {
vec4 color;
float density;
float start;
float end;
float scale;
};
iris_FogParameters iris_Fog = iris_FogParameters(iris_FogColor, iris_FogDensity, iris_FogStart, iris_FogEnd, 1.0f / (iris_FogEnd - iris_FogStart));
vec4 iris_FrontColor;
out float iris_FogFragCoord;
const int shadowMapResolution = 2048;
const float shadowDistance = 256.0f;
const float shadowMapBias = 1.0f - 25.6f / shadowDistance;
const float sunPathRotation = -40.0f;
const float ambientOcclusionLevel = 1.0f;
out vec2 texCoord, lmCoord;
out vec3 normal;
out vec3 sunVec, upVec, eastVec;
out vec4 color;
uniform int worldTime;
uniform float frameTimeCounter;
uniform float timeAngle;
uniform vec3 cameraPosition;
uniform mat4 gbufferModelView, gbufferModelViewInverse;
uniform int frameCounter;
uniform float viewWidth, viewHeight;
in vec4 mc_Entity;
in vec4 mc_midTexCoord;
float time = frameTimeCounter * 1.0f;
uniform float framemod8;
uniform float framemod2;
vec2 jitterOffsets8[8] = vec2[8](vec2(0.125f, -0.375f), vec2(-0.125f, 0.375f), vec2(0.625f, 0.125f), vec2(0.375f, -0.625f), vec2(-0.625f, 0.625f), vec2(-0.875f, -0.125f), vec2(0.375f, -0.875f), vec2(0.875f, 0.875f));
vec2 jitterOffsets2[2] = vec2[2](vec2(1.0f, 0.0f), vec2(0.0f, 1.0f));
uniform vec3 iris_ChunkOffset;
mat4 _iris_internal_translate(vec3 offset) {
return mat4(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, offset.x, offset.y, offset.z, 1.0f);
}
vec4 ftransform() {
return (iris_ProjMat * (iris_ModelViewMat * _iris_internal_translate(iris_ChunkOffset))) * vec4(iris_Position, 1.0f);
}
vec2 TAAJitter(vec2 coord, float w) {
vec2 offset = jitterOffsets8[int(framemod8)] * (w / vec2(viewWidth, viewHeight));
return coord + offset;
}
void main() {
iris_FogFragCoord = 0.0f;
texCoord = (iris_TextureMat * vec4(iris_UV0, 0.0f, 1.0f)).xy;
lmCoord = (iris_LightmapTextureMatrix * vec4(iris_UV2, 0.0f, 1.0f)).xy;
lmCoord = clamp((lmCoord - 0.03125f) * 1.06667f, vec2(0.0f), vec2(0.9333f, 1.0f));
normal = normalize(iris_NormalMat * vec3(0.0f, 0.0f, 1.0f));
color = (iris_Color * iris_ColorModulator);
const vec2 sunRotationData = vec2(cos(sunPathRotation * 0.01745329251994f), -sin(sunPathRotation * 0.01745329251994f));
float ang = fract(timeAngle - 0.25f);
ang = (ang + (cos(ang * 3.14159265358979f) * -0.5f + 0.5f - ang) / 3.0f) * 6.28318530717959f;
sunVec = normalize((gbufferModelView * vec4(vec3(-sin(ang), cos(ang) * sunRotationData) * 2000.0f, 1.0f)).xyz);
upVec = normalize(gbufferModelView[1].xyz);
eastVec = normalize(gbufferModelView[0].xyz);
gl_Position = ftransform();
gl_Position.xy = TAAJitter(gl_Position.xy, gl_Position.w);
}
)GLSL";
const char* kIrisWeatherFs = R"GLSL(#version 330 core
// Generated by glsl-transformer
uniform mat4 iris_ProjMat;
uniform mat4 iris_ModelViewMatInverse;
uniform mat4 iris_ProjMatInverse;
uniform mat3 iris_NormalMat;
uniform mat4 iris_LightmapTextureMatrix;
uniform mat4 iris_TextureMat;
uniform mat4 iris_ModelViewMat;
uniform vec4 iris_ColorModulator;
uniform float iris_FogDensity;
uniform float iris_FogStart;
uniform float iris_FogEnd;
uniform vec4 iris_FogColor;
struct iris_FogParameters {
vec4 color;
float density;
float start;
float end;
float scale;
};
iris_FogParameters iris_Fog = iris_FogParameters(iris_FogColor, iris_FogDensity, iris_FogStart, iris_FogEnd, 1.0f / (iris_FogEnd - iris_FogStart));
uniform float iris_currentAlphaTest;
layout(location = 0) out vec4 iris_FragData0;
in float iris_FogFragCoord;
const int shadowMapResolution = 2048;
const float shadowDistance = 256.0f;
const float shadowMapBias = 1.0f - 25.6f / shadowDistance;
const float sunPathRotation = -40.0f;
const float ambientOcclusionLevel = 1.0f;
in vec2 texCoord, lmCoord;
in vec3 normal;
in vec3 sunVec, upVec, eastVec;
in vec4 color;
uniform int bedrockLevel;
uniform int frameCounter;
uniform int isEyeInWater;
uniform int moonPhase;
uniform int worldTime;
uniform float blindFactor, darknessFactor, nightVision;
uniform float cloudHeight;
uniform float endFlashIntensity;
uniform float far, near;
uniform float frameTimeCounter;
uniform float rainStrength;
uniform float screenBrightness;
uniform float shadowFade;
uniform float timeAngle, timeBrightness;
uniform float viewWidth, viewHeight;
uniform ivec2 eyeBrightnessSmooth;
uniform vec3 cameraPosition;
uniform vec3 relativeEyePosition;
uniform mat4 gbufferProjectionInverse;
uniform mat4 gbufferModelViewInverse;
uniform mat4 shadowProjection;
uniform mat4 shadowModelView;
uniform sampler2D gtexture;
uniform sampler2D noisetex;
uniform int heldBlockLightValue, heldBlockLightValue2;
float eBS = eyeBrightnessSmooth.y / 240.0f;
float sunVisibility = clamp(dot(sunVec, upVec) * 10.0f + 0.5f, 0.0f, 1.0f);
float moonVisibility = clamp(dot(-sunVec, upVec) * 10.0f + 0.5f, 0.0f, 1.0f);
float time = frameTimeCounter * 1.0f;
vec3 lightVec = sunVec * ((timeAngle < 0.5325f || timeAngle > 0.9675f) ? 1.0f : -1.0f);
float GetLuminance(vec3 color) {
return dot(color, vec3(0.299f, 0.587f, 0.114f));
}
vec3 blocklightColSqrt = vec3(255, 212, 160) * 0.85f / 255.0f;
vec3 blocklightCol = blocklightColSqrt * blocklightColSqrt;
vec3 lightMorning = vec3(255, 160, 80) * 1.2f / 255.0f;
vec3 lightDay = vec3(196, 220, 255) * 1.4f / 255.0f;
vec3 lightEvening = vec3(255, 160, 80) * 1.2f / 255.0f;
vec3 ambientMorning = vec3(255, 204, 144) * 0.35f / 255.0f;
vec3 ambientDay = vec3(120, 172, 255) * 0.6f / 255.0f;
vec3 ambientEvening = vec3(255, 204, 144) * 0.35f / 255.0f;
float moonPhaseMultiplier[8] = float[8](1.0f, 0.875f, 0.75f, 0.625f, 0.5f, 0.625f, 0.75f, 0.875f);
float nightMult = 0.3f * moonPhaseMultiplier[moonPhase];
vec3 lightNight = vec3(96, 192, 255) * 1.0f * nightMult / 255.0f;
vec3 ambientNight = vec3(96, 192, 255) * 0.6f * nightMult / 255.0f;
uniform float isDesert, isMesa, isCold, isSwamp, isMushroom, isSavanna, isJungle;
vec4 weatherRain = vec4(vec3(176, 224, 255) / 255.0f, 1.0f) * 1.2f;
vec4 weatherCold = vec4(vec3(216, 240, 255) / 255.0f, 1.0f) * 1.2f;
vec4 weatherDesert = vec4(vec3(255, 232, 180) / 255.0f, 1.0f) * 1.2f;
vec4 weatherBadlands = vec4(vec3(255, 216, 176) / 255.0f, 1.0f) * 1.2f;
vec4 weatherSwamp = vec4(vec3(200, 224, 160) / 255.0f, 1.0f) * 1.2f;
vec4 weatherMushroom = vec4(vec3(216, 216, 255) / 255.0f, 1.0f) * 1.2f;
vec4 weatherSavanna = vec4(vec3(224, 224, 224) / 255.0f, 1.0f) * 1.2f;
vec4 weatherJungle = vec4(vec3(176, 232, 232) / 255.0f, 1.0f) * 1.2f;
float weatherWeight = clamp(isCold + isDesert + isMesa + isSwamp + isMushroom + isSavanna + isJungle, 0.0f, 1.0f);
vec4 weatherCol = mix(weatherRain, (weatherCold * isCold + weatherDesert * isDesert + weatherBadlands * isMesa + weatherSwamp * isSwamp + weatherMushroom * isMushroom + weatherSavanna * isSavanna + weatherJungle * isJungle) / max(weatherWeight, 1.0E-4f), weatherWeight);
float mefade = 1.0f - clamp(abs(timeAngle - 0.5f) * 8.0f - 1.5f, 0.0f, 1.0f);
float dfade = 1.0f - pow(1.0f - timeBrightness, 1.5f);
vec3 lightSun = mix(mix(lightMorning, lightEvening, mefade), lightDay, dfade);
vec3 ambientSun = mix(mix(ambientMorning, ambientEvening, mefade), ambientDay, dfade);
vec3 lightColRaw = mix(lightNight, lightSun, sunVisibility);
vec3 lightColSqrt = mix(lightColRaw, dot(lightColRaw, vec3(0.299f, 0.587f, 0.114f)) * weatherCol.rgb, rainStrength);
vec3 lightCol = lightColSqrt * lightColSqrt;
vec3 ambientColRaw = mix(ambientNight, ambientSun, sunVisibility);
vec3 ambientColSqrt = mix(ambientColRaw, dot(ambientColRaw, vec3(0.299f, 0.587f, 0.114f)) * weatherCol.rgb, rainStrength);
vec3 ambientCol = ambientColSqrt * ambientColSqrt;
vec3 minLightColSqrt = vec3(128, 128, 128) * 0.5f / 255.0f;
vec3 minLightCol = minLightColSqrt * minLightColSqrt * 0.04f;
float sunSkyVisibility = clamp(dot(sunVec, upVec) * 2.0f + 0.5f, 0.0f, 1.0f);
vec3 lightSkyColRaw = mix(lightNight, lightSun, sunSkyVisibility);
vec3 lightSkyColSqrt = mix(lightSkyColRaw, dot(lightSkyColRaw, vec3(0.299f, 0.587f, 0.114f)) * weatherCol.rgb, rainStrength);
vec3 lightSkyCol = lightSkyColSqrt * lightSkyColSqrt;
vec3 skyColSqrt = vec3(96, 160, 255) * 1.0f / 255.0f;
vec3 fogColSqrt = vec3(96, 160, 255) * 1.0f / 255.0f;
vec3 skyCol = skyColSqrt * skyColSqrt;
vec3 fogCol = fogColSqrt * fogColSqrt;
vec3 ToNDC(vec3 pos) {
vec4 iProjDiag = vec4(gbufferProjectionInverse[0].x, gbufferProjectionInverse[1].y, gbufferProjectionInverse[2].zw);
vec3 p3 = pos * 2.0f - 1.0f;
vec4 viewPos = iProjDiag * p3.xyzz + gbufferProjectionInverse[3];
return viewPos.xyz / viewPos.w;
}
vec3 ToWorld(vec3 pos) {
return mat3(gbufferModelViewInverse) * pos + gbufferModelViewInverse[3].xyz;
}
vec3 ToShadow(vec3 pos) {
vec3 shadowpos = mat3(shadowModelView) * pos + shadowModelView[3].xyz;
return (vec3((shadowProjection)[0].x, (shadowProjection)[1].y, shadowProjection[2].z) * (shadowpos) + (shadowProjection)[3].xyz);
}
float fogDensity = 1.0f * mix(1.0f, (1.0f * isCold + 1.0f * (isDesert + isMesa + isSavanna) + 1.0f * (isSwamp + isMushroom + isJungle)) / max(weatherWeight, 1.0E-4f), weatherWeight);
vec3 GetFogColor(vec3 viewPos) {
vec3 nViewPos = normalize(viewPos);
float lViewPos = length(viewPos) / 64.0f;
lViewPos = 1.0f - exp(-lViewPos * lViewPos);
float VoU = clamp(dot(nViewPos, upVec), -1.0f, 1.0f);
float VoL = clamp(dot(nViewPos, sunVec), -1.0f, 1.0f);
float density = 0.4f;
float nightDensity = 1.0f;
float weatherDensity = 1.5f;
float groundDensity = 0.08f * (4.0f - 3.0f * sunSkyVisibility) * (10.0f * rainStrength * rainStrength + 1.0f);
float exposure = exp2(timeBrightness * 0.75f - 0.75f);
float nightExposure = exp2(-3.5f);
float baseGradient = exp(-(VoU * 0.5f + 0.5f) * 0.5f / density);
float groundVoU = clamp(-VoU * 0.5f + 0.5f, 0.0f, 1.0f);
float ground = 1.0f - exp(-groundDensity / groundVoU);
vec3 fog = skyCol;
fog *= baseGradient / (1.0f * 1.0f);
fog = fog / sqrt(fog * fog + 1.0f) * exposure * sunSkyVisibility * (1.0f * 1.0f);
float sunMix = pow((VoL * 0.5f + 0.5f) * clamp(1.0f - VoU, 0.0f, 1.0f), 2.0f - sunSkyVisibility) * pow(1.0f - timeBrightness * 0.6f, 3.0f);
float horizonMix = pow(1.0f - abs(VoU), 2.5f) * 0.125f;
float lightMix = (1.0f - (1.0f - sunMix) * (1.0f - horizonMix)) * lViewPos;
vec3 lightFog = pow(lightSun, vec3(4.0f - sunSkyVisibility)) * baseGradient;
lightFog = lightFog / (1.0f + lightFog * rainStrength);
fog = mix(sqrt(fog * (1.0f - lightMix)), sqrt(lightFog), lightMix);
fog *= fog;
float nightGradient = exp(-(VoU * 0.5f + 0.5f) * 0.35f / nightDensity);
vec3 nightFog = lightNight * lightNight * nightGradient * nightExposure;
fog = mix(nightFog, fog, sunSkyVisibility * sunSkyVisibility);
float rainGradient = exp(-(VoU * 0.5f + 0.5f) * 0.125f / weatherDensity);
vec3 weatherFog = weatherCol.rgb * weatherCol.rgb;
weatherFog *= GetLuminance(ambientCol / (weatherFog)) * (0.2f * sunSkyVisibility + 0.2f);
fog = mix(fog, weatherFog * rainGradient, rainStrength);
float exteriorFactor = eBS;
fog = mix(minLightCol * 0.5f, fog * exteriorFactor, exteriorFactor);
fog *= clamp((cameraPosition.y - bedrockLevel + 6.0f) / 8.0f, 0.0f, 1.0f);
return fog;
}
void NormalFog(inout vec3 color, vec3 viewPos) {
float viewLength = length(viewPos);
vec4 worldPos = gbufferModelViewInverse * vec4(viewPos, 1.0f);
worldPos.xyz /= worldPos.w;
float fogFactor = viewLength;
float fog = viewLength * fogDensity / 1024.0f;
float clearDay = sunSkyVisibility * (1.0f - rainStrength);
float exteriorFactor = eBS;
float fogDensityMult = mix(1.0f, 1.5f, rainStrength) / mix(1.0f / 4.0f, 1.0f, clearDay);
fogDensityMult = mix(1.0f, fogDensityMult * exteriorFactor, exteriorFactor);
fog *= fogDensityMult;
float fogDampen = 0.3f * rainStrength + 0.5f;
fog = min(fog, (fog - fogDampen) * 0.25f + fogDampen);
fog *= exp2(-max(worldPos.y + cameraPosition.y - 62, 0.0f) / exp2(7.0f));
fog = 1.0f - exp(-2.0f * pow(fog, 0.35f * clearDay * exteriorFactor + 1.25f));
vec3 fogColor = GetFogColor(viewPos);
color = mix(color, fogColor, fog);
}
void BlindFog(inout vec3 color, vec3 viewPos) {
float fog = length(viewPos) * max(blindFactor * 0.2f, darknessFactor * 0.075f);
fog = (1.0f - exp(-6.0f * fog * fog * fog)) * max(blindFactor, darknessFactor);
color = mix(color, vec3(0.0f), fog);
}
vec3 denseFogColor[2] = vec3[2](vec3(1.0f, 0.3f, 0.01f), vec3(0.1f, 0.16f, 0.2f));
void DenseFog(inout vec3 color, vec3 viewPos) {
float fog = length(viewPos) * 0.5f;
fog = (1.0f - exp(-4.0f * fog * fog * fog));
color = mix(color, denseFogColor[isEyeInWater - 2], fog);
}
vec2 ApplyDynamicHandlight(vec2 lightmap, vec3 worldPos) {
float heldLightValue = max(float(heldBlockLightValue), float(heldBlockLightValue2));
if (heldLightValue == 0.0f) return lightmap;
vec3 heldLightPos = worldPos + relativeEyePosition + vec3(0.0f, 0.5f, 0.0f);
float handlight = min((heldLightValue - 2.0f * length(heldLightPos)) / 15.0f, 0.9333f);
lightmap.x = log2(exp2(lightmap.x * 32.0f) + exp2(handlight * 32.0f)) / 32.0f;
return lightmap;
}
uniform sampler2DShadow shadowtex0;
uniform sampler2DShadow shadowtex1;
uniform sampler2D shadowcolor0;
vec2 shadowOffsets[9] = vec2[9](vec2(0.0f, 0.0f), vec2(0.0f, 1.0f), vec2(0.7f, 0.7f), vec2(1.0f, 0.0f), vec2(0.7f, -0.7f), vec2(0.0f, -1.0f), vec2(-0.7f, -0.7f), vec2(-1.0f, 0.0f), vec2(-0.7f, 0.7f));
float texture2DShadow(sampler2DShadow shadowtex, vec3 shadowPos) {
return vec4(texture(shadowtex, shadowPos)).x;
}
vec3 DistortShadow(vec3 shadowPos, float distortFactor) {
shadowPos.xy /= distortFactor;
shadowPos.z *= 0.2f;
shadowPos = shadowPos * 0.5f + 0.5f;
return shadowPos;
}
float InterleavedGradientNoise() {
float n = 52.9829189f * fract(0.06711056f * gl_FragCoord.x + 0.00583715f * gl_FragCoord.y);
return fract(n + frameCounter * 1.618f);
}
vec3 SampleFilteredShadow(vec3 shadowPos, float offset, float subsurface) {
float shadow0 = 0.0f;
for (int i = 0; i < 9; i++) {
vec2 shadowOffset = shadowOffsets[i] * offset;
shadow0 += texture2DShadow(shadowtex0, vec3(shadowPos.st + shadowOffset, shadowPos.z));
}
shadow0 /= 9.0f;
vec3 shadowCol = vec3(0.0f);
if (shadow0 < 0.999f) {
for (int i = 0; i < 9; i++) {
vec2 shadowOffset = shadowOffsets[i] * offset;
vec3 shadowColSample = texture(shadowcolor0, shadowPos.st + shadowOffset).rgb * texture2DShadow(shadowtex1, vec3(shadowPos.st + shadowOffset, shadowPos.z));
shadowCol += shadowColSample;
}
shadowCol /= 9.0f;
}
shadow0 *= mix(shadow0, 1.0f, subsurface);
shadowCol *= shadowCol;
return clamp(shadowCol * (1.0f - shadow0) + shadow0, vec3(0.0f), vec3(16.0f));
}
vec3 GetShadow(vec3 worldPos, vec3 normal, float NoL, float subsurface, float skylight) {
vec3 rawShadowPos = ToShadow(worldPos);
float distb = sqrt(dot(rawShadowPos.xy, rawShadowPos.xy));
float distortFactor = distb * shadowMapBias + (1.0f - shadowMapBias);
vec3 shadowPos = DistortShadow(rawShadowPos, distortFactor);
float shadowFade = clamp(100.0f - 100.0f * max(abs(rawShadowPos.x), abs(rawShadowPos.y)), 0.0f, 1.0f);
shadowFade *= clamp(skylight * 1000.0f - 1.0f, 0.0f, 1.0f);
if (shadowFade < 1.0E-5f) return vec3(1.0f);
float bias = 0.0f;
float offset = 1.0f / shadowMapResolution;
float biasFactor = sqrt(1.0f - NoL * NoL) / NoL;
float distortBias = distortFactor * shadowDistance / 256.0f;
distortBias *= 8.0f * distortBias;
float distanceBias = sqrt(dot(worldPos.xyz, worldPos.xyz)) * 0.005f;
bias = (distortBias * biasFactor + distanceBias + 0.05f) / shadowMapResolution;
if (subsurface > 0.0f) {
float blurFadeIn = clamp(distb * 20.0f, 0.0f, 1.0f);
float blurFadeOut = 1.0f - clamp(distb * 10.0f - 2.0f, 0.0f, 1.0f);
float blurMult = blurFadeIn * blurFadeOut * (1.0f - NoL);
blurMult = blurMult * 1.5f + 1.0f;
offset = 7.0E-4f * blurMult;
bias = 2.0E-4f;
}
shadowPos.z -= bias;
vec3 shadow = SampleFilteredShadow(shadowPos, offset, subsurface);
shadow = mix(vec3(1.0f), shadow, shadowFade);
return shadow;
}
void GetLighting(
inout vec3 albedo,
out vec3 shadow,
vec3 viewPos,
vec3 worldPos,
vec3 normal,
vec2 lightmap,
float smoothLighting,
float NoL,
float vanillaDiffuse,
float parallaxShadow,
float emission,
float subsurface,
float basicSubsurface
) {
float skylightSqr = lightmap.y * lightmap.y;
if (NoL > 0.0f || basicSubsurface > 0.0f) {
shadow = GetShadow(worldPos, normal, NoL, basicSubsurface, lightmap.y);
}
shadow *= parallaxShadow;
shadow = max(shadow, vec3(0.0f));
NoL = clamp(NoL * 1.01f - 0.01f, 0.0f, 1.0f);
float scattering = 0.0f;
if (basicSubsurface > 0.0f) {
float VoL = clamp(dot(normalize(viewPos.xyz), lightVec) * 0.5f + 0.5f, 0.0f, 1.0f);
scattering = pow(VoL, 16.0f) * (1.0f - rainStrength) * basicSubsurface * shadowFade;
NoL = mix(NoL, 1.0f, sqrt(basicSubsurface) * 0.7f);
NoL = mix(NoL, 1.0f, scattering);
}
vec3 fullShadow = max(shadow * NoL, vec3(0.0f));
float shadowMult = (1.0f - 0.95f * rainStrength) * shadowFade;
vec3 sceneLighting = mix(ambientCol * lightmap.y, lightCol, fullShadow * shadowMult);
sceneLighting *= skylightSqr * (1.0f + scattering * shadow);
float newLightmap = pow(lightmap.x, 10.0f) * 1.6f + lightmap.x * 0.6f;
vec3 blockLighting = blocklightCol * newLightmap * newLightmap;
vec3 minLighting = minLightCol * (1.0f - skylightSqr);
vec3 albedoNormalized = normalize(albedo.rgb + 1.0E-5f);
emission = pow(emission, max(1.0f, 1.0f));
vec3 emissiveLighting = mix(albedoNormalized, vec3(1.0f), emission * 0.5f);
emissiveLighting *= emission * 4.0f;
float lightFlatten = clamp(1.0f - pow(1.0f - emission, 128.0f), 0.0f, 1.0f);
vanillaDiffuse = mix(vanillaDiffuse, 1.0f, lightFlatten);
smoothLighting = mix(smoothLighting, 1.0f, lightFlatten);
float nightVisionLighting = nightVision * 0.25f;
float albedoBrightness = max(max(albedo.r, albedo.g), albedo.b);
albedo.rgb /= 1.0f + albedoBrightness * 0.25f * (1.0f - lightFlatten);
albedo *= max(sceneLighting + blockLighting + emissiveLighting + nightVisionLighting + minLighting, vec3(0.0f));
albedo *= vanillaDiffuse * smoothLighting * smoothLighting;
float desatAmount = 1.0f - sqrt(max(sqrt(length(fullShadow / 3.0f)) * lightmap.y, lightmap.y)) * sunVisibility * (1.0f - rainStrength * 0.7f);
desatAmount *= smoothstep(0.25f, 1.0f, (1.0f - lightmap.x) * (1.0f - lightmap.x)) * (1.0f - lightFlatten);
desatAmount = 1.0f - desatAmount;
vec3 desatNight = normalize(lightNight * lightNight + 1.0E-6f);
vec3 desatWeather = normalize(weatherCol.rgb * weatherCol.rgb + 1.0E-6f);
float desatNWMix = (1.0f - sunVisibility) * (1.0f - rainStrength);
vec3 desatColor = mix(desatWeather, desatNight, desatNWMix);
desatColor = mix(vec3(0.4f), desatColor, sqrt(lightmap.y)) * 1.7f;
vec3 desatAlbedo = mix(albedo, GetLuminance(albedo) * desatColor, 1.0f - 1.5f * 0.4f);
albedo = mix(desatAlbedo, albedo, desatAmount);
}
uniform float framemod8;
uniform float framemod2;
vec2 jitterOffsets8[8] = vec2[8](vec2(0.125f, -0.375f), vec2(-0.125f, 0.375f), vec2(0.625f, 0.125f), vec2(0.375f, -0.625f), vec2(-0.625f, 0.625f), vec2(-0.875f, -0.125f), vec2(0.375f, -0.875f), vec2(0.875f, 0.875f));
vec2 jitterOffsets2[2] = vec2[2](vec2(1.0f, 0.0f), vec2(0.0f, 1.0f));
vec2 TAAJitter(vec2 coord, float w) {
vec2 offset = jitterOffsets8[int(framemod8)] * (w / vec2(viewWidth, viewHeight));
return coord + offset;
}
void main() {
vec4 albedo = texture(gtexture, texCoord) * color;
{
vec2 lightmap = clamp(lmCoord, vec2(0.0f), vec2(1.0f));
vec3 screenPos = vec3(gl_FragCoord.xy / vec2(viewWidth, viewHeight), gl_FragCoord.z);
vec3 viewPos = ToNDC(vec3(TAAJitter(screenPos.xy, -0.5f), screenPos.z));
vec3 worldPos = ToWorld(viewPos);
lightmap = ApplyDynamicHandlight(lightmap, worldPos);
albedo.rgb = pow(albedo.rgb, vec3(2.2f));
float NoL = 1.0f;
float NoU = clamp(dot(normal, upVec), -1.0f, 1.0f);
float NoE = clamp(dot(normal, eastVec), -1.0f, 1.0f);
float vanillaDiffuse = (0.25f * NoU + 0.75f) + (0.667f - abs(NoE)) * (1.0f - abs(NoU)) * 0.15f;
vanillaDiffuse *= vanillaDiffuse;
vec3 shadow = vec3(0.0f);
GetLighting(albedo.rgb, shadow, viewPos, worldPos, normal, lightmap, 1.0f, NoL, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f);
albedo.rgb = sqrt(max(albedo.rgb, vec3(0.0f)));
}
iris_FragData0 = albedo;
if (!(iris_FragData0.a > iris_currentAlphaTest)) {
discard;
}
}
)GLSL";
// Iris's partial pattern: it binds the vanilla attributes and leaves the pack's extras
// (mc_Entity, mc_midTexCoord) unbound - which, with neither of them read by the shader, is
// exactly the inactive-and-unbound case that reached SPIR-V undecorated.
struct BoundAttribute {
const char* name;
GLint location;
};
const BoundAttribute kIrisWeatherBindings[] = {
{"iris_Position", 0}, {"iris_Color", 1}, {"iris_UV0", 2}, {"iris_UV2", 3},
};
// Drives Iris's own call sequence and returns the linked program name.
GLuint ReplayIrisWeatherProgram() {
const GLuint vs = CreateShader(GL_VERTEX_SHADER);
ShaderSource(vs, 1, &kIrisWeatherVs, nullptr);
CompileShader(vs);
const GLuint fs = CreateShader(GL_FRAGMENT_SHADER);
ShaderSource(fs, 1, &kIrisWeatherFs, nullptr);
CompileShader(fs);
// Iris reads the log and the status for every shader, in that order.
for (const GLuint shader : {vs, fs}) {
GLint logLength = 0;
GetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLength);
if (logLength > 0) {
std::vector<GLchar> log(static_cast<size_t>(logLength));
GLsizei written = 0;
GetShaderInfoLog(shader, logLength, &written, log.data());
}
GLint compileStatus = GL_FALSE;
GetShaderiv(shader, GL_COMPILE_STATUS, &compileStatus);
EXPECT_EQ(compileStatus, GL_TRUE) << "shader " << shader << " failed to compile";
}
const GLuint program = CreateProgram();
AttachShader(program, vs);
AttachShader(program, fs);
for (const BoundAttribute& binding : kIrisWeatherBindings) {
BindAttribLocation(program, static_cast<GLuint>(binding.location), binding.name);
}
LinkProgram(program);
return program;
}
} // namespace
TEST_F(AsyncSpirvPhaseTest, IrisWeatherProgramReplaysCleanlyThroughBothPhases) {
for (const Bool optimisticQuirk : {false, true}) {
const AsyncModeScope async(true);
const MG_Config::QuirkOverride savedQuirk = MG_Config::Features.AsyncOptimisticShaderStatus;
MG_Config::Features.AsyncOptimisticShaderStatus =
optimisticQuirk ? MG_Config::QuirkOverride::ForceOn : MG_Config::QuirkOverride::ForceOff;
const GLuint program = ReplayIrisWeatherProgram();
// ---- phase A: LINK_STATUS is the join, and it must be truthful ----
GLint linkStatus = GL_FALSE;
GetProgramiv(program, GL_LINK_STATUS, &linkStatus);
ASSERT_EQ(linkStatus, GL_TRUE) << QueryProgramInfoLog(program)
<< " (optimistic quirk " << (optimisticQuirk ? "on" : "off") << ")";
// Iris queries uniforms straight after the status read; these are phase-A answers.
EXPECT_GE(GetUniformLocation(program, "iris_ModelViewMatrix"), -1);
EXPECT_GE(GetUniformLocation(program, "iris_ProjectionMatrix"), -1);
EXPECT_GE(GetUniformLocation(program, "texture"), -1);
// ---- the API bindings survived exactly ----
for (const BoundAttribute& binding : kIrisWeatherBindings) {
EXPECT_EQ(GetAttribLocation(program, binding.name), binding.location) << binding.name;
}
// ---- settle phase B through a gated getter and check what it published ----
const auto& object = Object(program);
ASSERT_NE(object, nullptr);
const auto& modules = object->GetGeneratedSpirv(); // joins phase B
EXPECT_TRUE(object->IsSpirvComplete());
EXPECT_TRUE(object->GetSpirvStatus());
ASSERT_FALSE(modules.empty());
EXPECT_GT(object->GetUBOSize(), 0u) << "the uniform shadow should have been allocated";
EXPECT_NE(object->GetUniformOffset(0), MG_State::GLState::ProgramObject::kInvalidUniformOffset);
// ---- every module the frontend hands over must be valid SPIR-V ----
// NOTE ON WHAT THIS DOES AND DOES NOT CATCH. It validates the modules AFTER spirv-opt,
// which is what a backend actually receives - but AggressiveDCE deletes an input that
// nothing reads, so for a merely-unused attribute this assertion cannot fail even with
// the io-resolver bug reinstated (verified by mutation). The discriminating gate for
// VUID-StandaloneSpirv-Location-04916 is
// ProgramUtilTest.PartiallyBoundVertexInputsAllReceiveALocation, which validates the
// RAW GlslangToSpv output before the optimizer can hide the defect. This assertion is
// still worth having: it is the end-to-end guarantee that whatever the frontend ships
// to a driver is valid, and it would catch a regression whose variable SURVIVES DCE -
// which is precisely what the device victim did.
spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_1);
String validatorMessages;
tools.SetMessageConsumer([&validatorMessages](spv_message_level_t, const char*, const spv_position_t&,
const char* message) {
if (message != nullptr) validatorMessages += String(message) + "\n";
});
for (SizeT i = 0; i < modules.size(); ++i) {
validatorMessages.clear();
EXPECT_TRUE(tools.Validate(modules[i]))
<< "module " << i << " is not valid SPIR-V - Adreno rejects the pipeline for this while "
<< "lavapipe tolerates it:\n" << validatorMessages;
}
// ---- every vertex input carries a unique Location ----
const Int vsIndex = object->GetShaderIndexByStage(ShaderStage::Vertex);
ASSERT_GE(vsIndex, 0);
const auto& vsModule = modules[static_cast<SizeT>(vsIndex)];
constexpr unsigned kOpDecorate = 71, kOpVariable = 59;
constexpr unsigned kDecorationBuiltIn = 11, kDecorationLocation = 30;
constexpr unsigned kStorageClassInput = 1;
std::map<unsigned, unsigned> locationById;
std::set<unsigned> builtInIds;
std::vector<unsigned> inputIds;
for (SizeT i = 5; i < vsModule.size();) {
const unsigned wordCount = vsModule[i] >> 16;
const unsigned opcode = vsModule[i] & 0xFFFFu;
ASSERT_GT(wordCount, 0u);
if (i + wordCount > vsModule.size()) break;
if (opcode == kOpDecorate && wordCount >= 4 && vsModule[i + 2] == kDecorationLocation) {
locationById[vsModule[i + 1]] = vsModule[i + 3];
} else if (opcode == kOpDecorate && wordCount >= 3 && vsModule[i + 2] == kDecorationBuiltIn) {
builtInIds.insert(vsModule[i + 1]);
} else if (opcode == kOpVariable && wordCount >= 4 && vsModule[i + 3] == kStorageClassInput) {
inputIds.push_back(vsModule[i + 2]);
}
i += wordCount;
}
std::set<unsigned> usedLocations;
SizeT checkedInputs = 0;
for (const unsigned id : inputIds) {
if (builtInIds.count(id) != 0) continue;
const auto it = locationById.find(id);
ASSERT_NE(it, locationById.end())
<< "a vertex input reached SPIR-V with no Location decoration (optimistic quirk "
<< (optimisticQuirk ? "on" : "off") << ")";
EXPECT_TRUE(usedLocations.insert(it->second).second)
<< "two vertex inputs share location " << it->second;
++checkedInputs;
}
EXPECT_GT(checkedInputs, 0u) << "no vertex inputs found; the scan proved nothing";
EXPECT_EQ(GetError(), GL_NO_ERROR);
MG_Config::Features.AsyncOptimisticShaderStatus = savedQuirk;
}
}
Reference in New Issue View Git Blame Copy Permalink