mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-17 15:03:25 +09:00
[Fix] (CMakeLists.txt, MG_Backend/DirectGLES, MG_Pipe, MG_Test/Backend, MG_Test/ShaderTranspiler, MG_Util/ShaderTranspiler): give integer attributes their GL value in Espryt
- every integer array reaches the driver with its input's signedness, at the pointer, zero-stride and client-memory call sites, so each fetch is one ES defines - 8/16-bit data of the other signedness is widened back by the program's runtime-width seeds, armed on the first draw that needs them and set as two uniforms per draw - capture programs with integer inputs are armed at their first build; arming is part of the ESSL translation key - a build whose seeds cannot be verified keeps the driver's own value for narrow data; one that fails to link is rebuilt without them - the program's integer input masks are memoized on its shader record
This commit is contained in:
@@ -74,6 +74,17 @@ add_executable(SubsystemDepsTest SubsystemDepsTest.cpp)
|
||||
target_include_directories(SubsystemDepsTest PRIVATE ${MGL_ROOT}/include ${MGL_ROOT}/MobileGL)
|
||||
target_link_libraries(SubsystemDepsTest PRIVATE MobileGLTestMain ${LINK_LIBRARIES})
|
||||
gtest_discover_tests(SubsystemDepsTest DISCOVERY_TIMEOUT 30 PROPERTIES LABELS unit)
|
||||
|
||||
# DirectGLES's narrow integer attributes: the per-draw plan, and an armed vertex stage's ESSL.
|
||||
add_executable(IntegerAttributePlanTest IntegerAttributePlanTest.cpp)
|
||||
target_include_directories(IntegerAttributePlanTest PRIVATE ${MGL_ROOT}/include ${MGL_ROOT}/MobileGL)
|
||||
target_link_libraries(IntegerAttributePlanTest PRIVATE MobileGLTestMain ${LINK_LIBRARIES})
|
||||
gtest_discover_tests(IntegerAttributePlanTest DISCOVERY_TIMEOUT 30 PROPERTIES LABELS unit)
|
||||
|
||||
add_executable(NarrowIntegerEsslTest NarrowIntegerEsslTest.cpp)
|
||||
target_include_directories(NarrowIntegerEsslTest PRIVATE ${MGL_ROOT}/include ${MGL_ROOT}/MobileGL)
|
||||
target_link_libraries(NarrowIntegerEsslTest PRIVATE MobileGLTestMain glslang-default-resource-limits ${LINK_LIBRARIES})
|
||||
gtest_discover_tests(NarrowIntegerEsslTest DISCOVERY_TIMEOUT 30 PROPERTIES LABELS unit)
|
||||
gtest_discover_tests(EsslShaderPassTest DISCOVERY_TIMEOUT 30 PROPERTIES LABELS unit)
|
||||
gtest_discover_tests(BaseInstanceInjectionTest DISCOVERY_TIMEOUT 30 PROPERTIES LABELS unit)
|
||||
gtest_discover_tests(ViewportIndexRoutingTest DISCOVERY_TIMEOUT 30 PROPERTIES LABELS unit)
|
||||
|
||||
@@ -0,0 +1,114 @@
|
||||
// MobileGL - MobileGL/MG_Test/Backend/DirectGLES/IntegerAttributePlanTest.cpp
|
||||
// Copyright (c) 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
|
||||
//
|
||||
// What DirectGLES does with each (array data type, shader input type) pair. ES defines an integer
|
||||
// attribute only when the array has the input's signedness, so every integer array is issued with
|
||||
// it; 8/16-bit data of the other signedness also needs the program's seeds to put GL's value back,
|
||||
// and without working seeds such an array keeps the application's type instead.
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include <MG_Backend/DirectGLES/IntegerAttributePlan.h>
|
||||
|
||||
using namespace MobileGL;
|
||||
using MobileGL::MG_Backend::DirectGLES::HeldIntegerRetype;
|
||||
using MobileGL::MG_Backend::DirectGLES::IntegerAttribTypeForInput;
|
||||
using MobileGL::MG_Backend::DirectGLES::IntegerAttributeDataMasks;
|
||||
using MobileGL::MG_Backend::DirectGLES::IntegerAttributePlan;
|
||||
using MobileGL::MG_Backend::DirectGLES::IntegerVertexInputMasks;
|
||||
using MobileGL::MG_Backend::DirectGLES::ResolveIntegerAttributePlan;
|
||||
|
||||
namespace {
|
||||
struct DataCase {
|
||||
DataType type;
|
||||
GLenum glType;
|
||||
Uint32 bits;
|
||||
Bool isSigned;
|
||||
};
|
||||
constexpr DataCase kData[] = {
|
||||
{DataType::Int8, GL_BYTE, 8, true}, {DataType::Uint8, GL_UNSIGNED_BYTE, 8, false},
|
||||
{DataType::Int16, GL_SHORT, 16, true}, {DataType::Uint16, GL_UNSIGNED_SHORT, 16, false},
|
||||
{DataType::Int32, GL_INT, 32, true}, {DataType::Uint32, GL_UNSIGNED_INT, 32, false},
|
||||
};
|
||||
|
||||
Bool IsSignedGLType(GLenum type) {
|
||||
return type == GL_BYTE || type == GL_SHORT || type == GL_INT;
|
||||
}
|
||||
|
||||
IntegerAttributePlan PlanFor(DataType data, GLenum input, Uint32 location, Bool seedsUsable = true) {
|
||||
IntegerVertexInputMasks inputs;
|
||||
inputs.Note(location, input);
|
||||
IntegerAttributeDataMasks masks;
|
||||
masks.Note(location, data);
|
||||
return ResolveIntegerAttributePlan(inputs, masks, seedsUsable);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
TEST(IntegerAttributePlan, EveryIntegerArrayIsIssuedWithItsInputsSignedness) {
|
||||
constexpr Uint32 location = 3;
|
||||
constexpr Uint32 bit = 1u << location;
|
||||
for (const DataCase& data : kData) {
|
||||
for (const GLenum input : {GL_INT_VEC4, GL_UNSIGNED_INT_VEC2}) {
|
||||
const Bool signedInput = input == GL_INT_VEC4;
|
||||
const IntegerAttributePlan plan = PlanFor(data.type, input, location);
|
||||
const Bool mismatch = signedInput != data.isSigned;
|
||||
SCOPED_TRACE(testing::Message() << "data 0x" << std::hex << data.glType << " input 0x" << input);
|
||||
EXPECT_EQ(plan.careMask, bit);
|
||||
EXPECT_EQ(plan.retypeMask, mismatch ? bit : 0u);
|
||||
EXPECT_EQ(IsSignedGLType(IntegerAttribTypeForInput(data.glType, (plan.retypeMask & bit) != 0)),
|
||||
signedInput);
|
||||
// Only 8/16-bit data of the other signedness needs the seeds; 32-bit is the same bits.
|
||||
EXPECT_EQ(plan.widths8, mismatch && data.bits == 8 ? bit : 0u);
|
||||
EXPECT_EQ(plan.widths16, mismatch && data.bits == 16 ? bit : 0u);
|
||||
EXPECT_EQ(plan.widths8 & plan.widths16, 0u);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(IntegerAttributePlan, AFloatInputLeavesItsArrayAlone) {
|
||||
for (const DataCase& data : kData) {
|
||||
const IntegerAttributePlan plan = PlanFor(data.type, GL_FLOAT_VEC4, 5);
|
||||
EXPECT_EQ(plan, IntegerAttributePlan{}) << std::hex << data.glType;
|
||||
}
|
||||
// ...and an integer input fed float data has no integer array to issue.
|
||||
EXPECT_EQ(PlanFor(DataType::Float32, GL_INT_VEC4, 5), IntegerAttributePlan{});
|
||||
}
|
||||
|
||||
TEST(IntegerAttributePlan, WithoutWorkingSeedsANarrowArrayKeepsTheApplicationsType) {
|
||||
for (const DataCase& data : kData) {
|
||||
const GLenum input = data.isSigned ? GL_UNSIGNED_INT : GL_INT;
|
||||
const IntegerAttributePlan plan = PlanFor(data.type, input, 7, false);
|
||||
EXPECT_FALSE(plan.NeedsSeeds()) << std::hex << data.glType;
|
||||
EXPECT_EQ(plan.retypeMask, data.bits == 32 ? (1u << 7) : 0u) << std::hex << data.glType;
|
||||
EXPECT_EQ(plan, PlanFor(data.type, input, 7).WithoutSeeds());
|
||||
}
|
||||
}
|
||||
|
||||
TEST(IntegerAttributePlan, LocationsStopAt31) {
|
||||
EXPECT_EQ(PlanFor(DataType::Uint8, GL_INT, 31).widths8, 1u << 31);
|
||||
EXPECT_EQ(PlanFor(DataType::Uint8, GL_INT, 32), IntegerAttributePlan{});
|
||||
}
|
||||
|
||||
TEST(IntegerAttributePlan, AVertexArrayKeepsWhatItHoldsWhereNothingCanSeeIt) {
|
||||
IntegerAttributePlan plan;
|
||||
plan.careMask = 0b0110u;
|
||||
plan.retypeMask = 0b0100u;
|
||||
// Bit 0 is held and unobservable: kept. Bit 1 is observable and wanted plain: cleared.
|
||||
EXPECT_EQ(HeldIntegerRetype(0b0011u, plan), 0b0101u);
|
||||
EXPECT_EQ(HeldIntegerRetype(0u, IntegerAttributePlan{}), 0u);
|
||||
}
|
||||
|
||||
TEST(IntegerAttributePlan, TheIssuedTypeOnlyEverSwapsSignedness) {
|
||||
for (const DataCase& data : kData) {
|
||||
EXPECT_EQ(IntegerAttribTypeForInput(data.glType, false), data.glType);
|
||||
const GLenum swapped = IntegerAttribTypeForInput(data.glType, true);
|
||||
EXPECT_NE(IsSignedGLType(swapped), data.isSigned);
|
||||
EXPECT_EQ(IntegerAttribTypeForInput(swapped, true), data.glType);
|
||||
}
|
||||
EXPECT_EQ(IntegerAttribTypeForInput(GL_FLOAT, true), static_cast<GLenum>(GL_FLOAT));
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
// MobileGL - MobileGL/MG_Test/Backend/DirectGLES/NarrowIntegerEsslTest.cpp
|
||||
// Copyright (c) 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
|
||||
//
|
||||
// A vertex stage armed with the narrow-integer seeds, through the same steps the DirectGLES build
|
||||
// takes: the array-input split, the RuntimeWidths pass, ESSL 3.00 emission and the uniform
|
||||
// promotion. The two widths have to come out as `uniform highp uint` (anything else is read
|
||||
// uninitialised or at too low a precision) and the result has to be ESSL 3.00 a compiler accepts.
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include <MG_Backend/DirectGLES/DirectGLES.h>
|
||||
#include <MG_Backend/DirectGLES/Managers.h>
|
||||
#include <MG_Util/ShaderTranspiler/ShaderCompiler.h>
|
||||
#include <MG_Util/ShaderTranspiler/SpvcSession.h>
|
||||
#include <MG_Util/ShaderTranspiler/Types.h>
|
||||
|
||||
#include "Init.h"
|
||||
|
||||
#include <glslang/Public/ResourceLimits.h>
|
||||
#include <glslang/Public/ShaderLang.h>
|
||||
|
||||
using namespace MobileGL;
|
||||
using MobileGL::MG_Backend::DirectGLES::PromoteDrawParameterGlobalsToUniforms;
|
||||
using MobileGL::MG_Backend::DirectGLES::PromoteNarrowIntegerWidthGlobals;
|
||||
using MobileGL::MG_Util::ShaderTranspiler::kNarrowIntegerWidths16GlobalName;
|
||||
using MobileGL::MG_Util::ShaderTranspiler::kNarrowIntegerWidths8GlobalName;
|
||||
using MobileGL::MG_Util::ShaderTranspiler::SessionUsageBit;
|
||||
using MobileGL::MG_Util::ShaderTranspiler::ShaderCompiler;
|
||||
using MobileGL::MG_Util::ShaderTranspiler::SpvcSession;
|
||||
|
||||
namespace {
|
||||
constexpr const char* kVertex = R"(#version 330 core
|
||||
layout(location = 0) in vec2 pos;
|
||||
layout(location = 1) in ivec4 lightAndData;
|
||||
layout(location = 2) in uvec2 texc;
|
||||
layout(location = 3) in int packed[2];
|
||||
flat out ivec4 a;
|
||||
flat out uvec4 b;
|
||||
void main() {
|
||||
a = lightAndData + ivec4(packed[0], packed[1], 0, 0);
|
||||
b = uvec4(texc, 0u, 0u);
|
||||
gl_Position = vec4(pos, 0.0, 1.0);
|
||||
}
|
||||
)";
|
||||
constexpr const char* kFragment = R"(#version 330 core
|
||||
flat in ivec4 a;
|
||||
flat in uvec4 b;
|
||||
out vec4 color;
|
||||
void main() { color = vec4(a) + vec4(b); }
|
||||
)";
|
||||
|
||||
Vector<Uint32> CompileVertexModule() {
|
||||
using namespace MG_Util::ShaderTranspiler;
|
||||
Vector<SharedPtr<glslang::TShader>> shaders;
|
||||
for (const auto& [stage, source] :
|
||||
Vector<Pair<GLenum, const char*>>{{GL_VERTEX_SHADER, kVertex}, {GL_FRAGMENT_SHADER, kFragment}}) {
|
||||
ShaderAttrib attrib{.shaderType = stage, .sourceStr = source};
|
||||
auto shader = ShaderCompiler::CompileShader(attrib);
|
||||
EXPECT_TRUE(shader) << (shader ? String{} : shader.error().log);
|
||||
if (!shader) return {};
|
||||
shaders.push_back(shader.value());
|
||||
}
|
||||
ProgramAttrib programAttrib{.shaders = shaders};
|
||||
auto program = ShaderCompiler::LinkProgram(programAttrib);
|
||||
EXPECT_TRUE(program) << (program ? String{} : program.error().log);
|
||||
if (!program) return {};
|
||||
ProgramBinaryAttrib binaryAttrib{.shaderTypes = {GL_VERTEX_SHADER, GL_FRAGMENT_SHADER},
|
||||
.program = *program.value()};
|
||||
auto binary = ShaderCompiler::GetSpirvBinaryFromProgram(binaryAttrib);
|
||||
EXPECT_TRUE(binary) << (binary ? String{} : binary.error().log);
|
||||
if (!binary || binary->size() != 2) return {};
|
||||
Vector<Uint32> module = binary.value()[0];
|
||||
EXPECT_TRUE(ShaderCompiler::SanitizeAndOptimizeBinary(module, module, true, true));
|
||||
return module;
|
||||
}
|
||||
|
||||
String EmitEssl300(const Vector<Uint32>& spirv) {
|
||||
SpvcSession session(spirv, SessionUsageBit::Transpile);
|
||||
spvc_compiler_options options;
|
||||
session.CreateOptions(&options);
|
||||
spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_GLSL_VERSION, 300);
|
||||
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_GLSL_ES, SPVC_TRUE);
|
||||
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_GLSL_VULKAN_SEMANTICS, SPVC_FALSE);
|
||||
session.SetOptions(options);
|
||||
const char* result = nullptr;
|
||||
session.Compile(&result);
|
||||
EXPECT_NE(result, nullptr) << (session.GetLastErrorString() ? session.GetLastErrorString() : "");
|
||||
return result != nullptr ? String(result) : String{};
|
||||
}
|
||||
|
||||
String CompileErrorAsEssl300Vertex(const String& source) {
|
||||
glslang::TShader shader(EShLangVertex);
|
||||
const char* strings[] = {source.c_str()};
|
||||
shader.setStrings(strings, 1);
|
||||
if (shader.parse(GetDefaultResources(), 300, EEsProfile, false, false, EShMsgDefault)) return {};
|
||||
return shader.getInfoLog();
|
||||
}
|
||||
} // namespace
|
||||
|
||||
TEST(NarrowIntegerEssl, ArmedVertexStageDeclaresBothWidthsAsHighpUniformsInValidEssl300) {
|
||||
MobileGL::Initialize();
|
||||
const Vector<Uint32> module = CompileVertexModule();
|
||||
ASSERT_FALSE(module.empty());
|
||||
|
||||
Vector<Uint32> split;
|
||||
ASSERT_TRUE(ShaderCompiler::SplitArrayVertexInputsForEssl(module, split, true));
|
||||
Vector<Uint32> seeded;
|
||||
Bool changed = false;
|
||||
ASSERT_TRUE(
|
||||
ShaderCompiler::ExtendNarrowIntegerVertexInputsForEssl(split.empty() ? module : split, seeded, changed, true));
|
||||
ASSERT_TRUE(changed);
|
||||
|
||||
const String emitted = EmitEssl300(seeded);
|
||||
ASSERT_FALSE(emitted.empty());
|
||||
const String essl = PromoteDrawParameterGlobalsToUniforms(emitted, GL_VERTEX_SHADER);
|
||||
for (const char* name : {kNarrowIntegerWidths8GlobalName, kNarrowIntegerWidths16GlobalName}) {
|
||||
EXPECT_NE(essl.find(String("uniform highp uint ") + name + ";"), String::npos) << name << "\n" << essl;
|
||||
// Exactly one declaration, and it is the uniform.
|
||||
EXPECT_EQ(essl.find(String("uint ") + name), essl.find(String("highp uint ") + name) + 6) << essl;
|
||||
}
|
||||
for (const char* bitfield : {"bitfieldExtract", "bitfieldInsert"})
|
||||
EXPECT_EQ(essl.find(bitfield), String::npos) << essl;
|
||||
EXPECT_EQ(CompileErrorAsEssl300Vertex(essl), String{}) << essl;
|
||||
}
|
||||
|
||||
TEST(NarrowIntegerEssl, OnlyALineStartingDeclarationIsPromoted) {
|
||||
const String promoted = PromoteNarrowIntegerWidthGlobals("#version 300 es\n"
|
||||
"uint mg_NarrowIntegerWidths8 = 0u;\n"
|
||||
"highp uint mg_NarrowIntegerWidths16;\n"
|
||||
"void main() { uint x = mg_NarrowIntegerWidths8; }\n");
|
||||
EXPECT_EQ(promoted, "#version 300 es\n"
|
||||
"uniform highp uint mg_NarrowIntegerWidths8;\n"
|
||||
"uniform highp uint mg_NarrowIntegerWidths16;\n"
|
||||
"void main() { uint x = mg_NarrowIntegerWidths8; }\n");
|
||||
// Already a uniform: untouched, and a mediump spelling is promoted to highp all the same.
|
||||
EXPECT_EQ(PromoteNarrowIntegerWidthGlobals(promoted), promoted);
|
||||
EXPECT_EQ(PromoteNarrowIntegerWidthGlobals("mediump uint mg_NarrowIntegerWidths16;\n"),
|
||||
"uniform highp uint mg_NarrowIntegerWidths16;\n");
|
||||
}
|
||||
@@ -1095,6 +1095,11 @@ TEST_F(TranslationCacheTest, L2KeyMovesWithEveryGateThatSteersTheEsslChain) {
|
||||
v.stripOutputBlockLocations = true;
|
||||
variants.emplace_back("stripOutputBlockLocations", BuildEsslTranslationKey(v));
|
||||
}
|
||||
{ // arms the narrow-integer seeds of a vertex stage (ExtendNarrowIntegerVertexInputsForEssl)
|
||||
EsslTranslationKeyInputs v = base;
|
||||
v.narrowIntegerSeedsArmed = true;
|
||||
variants.emplace_back("narrowIntegerSeedsArmed", BuildEsslTranslationKey(v));
|
||||
}
|
||||
{
|
||||
EsslTranslationKeyInputs v = base;
|
||||
v.enableSpirvValidation = true;
|
||||
|
||||
Reference in New Issue
Block a user