From 4a86a5c8f8dd94baaf88c79acb51d45d103f00c1 Mon Sep 17 00:00:00 2001 From: Eliza Velasquez Date: Thu, 30 Jan 2025 15:43:59 -0800 Subject: [PATCH] matdbg: add support for essl1 shader debugging Fixes #8261 --- .../backend/include/private/backend/Driver.h | 10 ++++ filament/backend/src/metal/MetalDriver.h | 1 + filament/backend/src/metal/MetalDriver.mm | 4 ++ filament/backend/src/noop/NoopDriver.cpp | 4 ++ filament/backend/src/noop/NoopDriver.h | 1 + filament/backend/src/opengl/OpenGLDriver.cpp | 4 ++ filament/backend/src/opengl/OpenGLDriver.h | 1 + filament/backend/src/vulkan/VulkanDriver.cpp | 5 ++ filament/backend/src/vulkan/VulkanDriver.h | 1 + filament/src/details/Engine.cpp | 44 ++++++++--------- filament/src/details/Engine.h | 12 +---- libs/matdbg/include/matdbg/DebugServer.h | 3 +- libs/matdbg/include/matdbg/JsonWriter.h | 4 +- libs/matdbg/include/matdbg/ShaderReplacer.h | 5 +- libs/matdbg/src/ApiHandler.cpp | 22 ++++++--- libs/matdbg/src/DebugServer.cpp | 49 +++++-------------- libs/matdbg/src/JsonWriter.cpp | 49 +++++++++++++------ libs/matdbg/src/ShaderReplacer.cpp | 33 ++++++++++--- libs/matdbg/web/api.js | 6 ++- libs/matdbg/web/app.js | 15 ++++-- tools/matinfo/src/main.cpp | 3 +- 21 files changed, 168 insertions(+), 108 deletions(-) diff --git a/filament/backend/include/private/backend/Driver.h b/filament/backend/include/private/backend/Driver.h index 1fe16446813..a00d8e13db7 100644 --- a/filament/backend/include/private/backend/Driver.h +++ b/filament/backend/include/private/backend/Driver.h @@ -69,6 +69,16 @@ class Driver { virtual ShaderModel getShaderModel() const noexcept = 0; + // The shader language used for shaders for this driver, used to inform matdbg. + // + // For OpenGL, this distinguishes whether the driver's shaders are powered by ESSL1 or ESSL3. + // This information is used by matdbg to display the correct shader code to the web UI and patch + // the correct chunk when rebuilding shaders live. + // + // Metal shaders can either be MSL or Metal libraries, but at time of writing, matdbg can only + // interface with MSL. + virtual ShaderLanguage getShaderLanguage() const noexcept = 0; + // Returns the dispatcher. This is only called once during initialization of the CommandStream, // so it doesn't matter that it's virtual. virtual Dispatcher getDispatcher() const noexcept = 0; diff --git a/filament/backend/src/metal/MetalDriver.h b/filament/backend/src/metal/MetalDriver.h index ca14adf9741..562bafb4aa8 100644 --- a/filament/backend/src/metal/MetalDriver.h +++ b/filament/backend/src/metal/MetalDriver.h @@ -67,6 +67,7 @@ class MetalDriver final : public DriverBase { MetalContext* mContext; ShaderModel getShaderModel() const noexcept final; + ShaderLanguage getShaderLanguage() const noexcept final; // Overrides the default implementation by wrapping the call to fn in an @autoreleasepool block. void execute(std::function const& fn) noexcept final; diff --git a/filament/backend/src/metal/MetalDriver.mm b/filament/backend/src/metal/MetalDriver.mm index a8eee36dcb7..dff03106b43 100644 --- a/filament/backend/src/metal/MetalDriver.mm +++ b/filament/backend/src/metal/MetalDriver.mm @@ -946,6 +946,10 @@ #endif } +ShaderLanguage MetalDriver::getShaderLanguage() const noexcept { + return ShaderLanguage::MSL; +} + Handle MetalDriver::createStreamNative(void* stream) { return {}; } diff --git a/filament/backend/src/noop/NoopDriver.cpp b/filament/backend/src/noop/NoopDriver.cpp index af3ad70fbb6..a77200c6fbf 100644 --- a/filament/backend/src/noop/NoopDriver.cpp +++ b/filament/backend/src/noop/NoopDriver.cpp @@ -39,6 +39,10 @@ ShaderModel NoopDriver::getShaderModel() const noexcept { #endif } +ShaderLanguage NoopDriver::getShaderLanguage() const noexcept { + return ShaderLanguage::ESSL3; +} + // explicit instantiation of the Dispatcher template class ConcreteDispatcher; diff --git a/filament/backend/src/noop/NoopDriver.h b/filament/backend/src/noop/NoopDriver.h index 5b4037f657e..8b522304cc8 100644 --- a/filament/backend/src/noop/NoopDriver.h +++ b/filament/backend/src/noop/NoopDriver.h @@ -34,6 +34,7 @@ class NoopDriver final : public DriverBase { private: ShaderModel getShaderModel() const noexcept final; + ShaderLanguage getShaderLanguage() const noexcept final; uint64_t nextFakeHandle = 1; diff --git a/filament/backend/src/opengl/OpenGLDriver.cpp b/filament/backend/src/opengl/OpenGLDriver.cpp index 736fa0d6769..8714bacba26 100644 --- a/filament/backend/src/opengl/OpenGLDriver.cpp +++ b/filament/backend/src/opengl/OpenGLDriver.cpp @@ -349,6 +349,10 @@ ShaderModel OpenGLDriver::getShaderModel() const noexcept { return mContext.getShaderModel(); } +ShaderLanguage OpenGLDriver::getShaderLanguage() const noexcept { + return mContext.isES2() ? ShaderLanguage::ESSL1 : ShaderLanguage::ESSL3; +} + // ------------------------------------------------------------------------------------------------ // Change and track GL state // ------------------------------------------------------------------------------------------------ diff --git a/filament/backend/src/opengl/OpenGLDriver.h b/filament/backend/src/opengl/OpenGLDriver.h index 29ea32c776d..22dc76a2e74 100644 --- a/filament/backend/src/opengl/OpenGLDriver.h +++ b/filament/backend/src/opengl/OpenGLDriver.h @@ -204,6 +204,7 @@ class OpenGLDriver final : public DriverBase { } ShaderModel getShaderModel() const noexcept final; + ShaderLanguage getShaderLanguage() const noexcept final; /* * Driver interface diff --git a/filament/backend/src/vulkan/VulkanDriver.cpp b/filament/backend/src/vulkan/VulkanDriver.cpp index 56c4a7a2964..48719c53973 100644 --- a/filament/backend/src/vulkan/VulkanDriver.cpp +++ b/filament/backend/src/vulkan/VulkanDriver.cpp @@ -26,6 +26,7 @@ #include "VulkanHandles.h" #include "VulkanMemory.h" #include "VulkanTexture.h" +#include "backend/DriverEnums.h" #include "memory/ResourceManager.h" #include "memory/ResourcePointer.h" @@ -295,6 +296,10 @@ ShaderModel VulkanDriver::getShaderModel() const noexcept { #endif } +ShaderLanguage VulkanDriver::getShaderLanguage() const noexcept { + return ShaderLanguage::SPIRV; +} + void VulkanDriver::terminate() { // Flush and wait here to make sure all queued commands are executed and resources that are tied // to those commands are no longer referenced. diff --git a/filament/backend/src/vulkan/VulkanDriver.h b/filament/backend/src/vulkan/VulkanDriver.h index 83215a2ce50..0d826fca48a 100644 --- a/filament/backend/src/vulkan/VulkanDriver.h +++ b/filament/backend/src/vulkan/VulkanDriver.h @@ -93,6 +93,7 @@ class VulkanDriver final : public DriverBase { Dispatcher getDispatcher() const noexcept final; ShaderModel getShaderModel() const noexcept final; + ShaderLanguage getShaderLanguage() const noexcept final; template friend class ConcreteDispatcher; diff --git a/filament/src/details/Engine.cpp b/filament/src/details/Engine.cpp index 1cc9a951be1..a3fcf962b18 100644 --- a/filament/src/details/Engine.cpp +++ b/filament/src/details/Engine.cpp @@ -728,28 +728,6 @@ int FEngine::loop() { } } -#if FILAMENT_ENABLE_MATDBG - #ifdef __ANDROID__ - const char* portString = "8081"; - #else - const char* portString = getenv("FILAMENT_MATDBG_PORT"); - #endif - if (portString != nullptr) { - const int port = atoi(portString); - debug.server = new matdbg::DebugServer(mBackend, port); - - // Sometimes the server can fail to spin up (e.g. if the above port is already in use). - // When this occurs, carry onward, developers can look at civetweb.txt for details. - if (!debug.server->isReady()) { - delete debug.server; - debug.server = nullptr; - } else { - debug.server->setEditCallback(FMaterial::onEditCallback); - debug.server->setQueryCallback(FMaterial::onQueryCallback); - } - } -#endif - JobSystem::setThreadName("FEngine::loop"); JobSystem::setThreadPriority(JobSystem::Priority::DISPLAY); @@ -771,6 +749,28 @@ int FEngine::loop() { return 0; } +#if FILAMENT_ENABLE_MATDBG + #ifdef __ANDROID__ + const char* portString = "8081"; + #else + const char* portString = getenv("FILAMENT_MATDBG_PORT"); + #endif + if (portString != nullptr) { + const int port = atoi(portString); + debug.server = new matdbg::DebugServer(mBackend, mDriver->getShaderLanguage(), port); + + // Sometimes the server can fail to spin up (e.g. if the above port is already in use). + // When this occurs, carry onward, developers can look at civetweb.txt for details. + if (!debug.server->isReady()) { + delete debug.server; + debug.server = nullptr; + } else { + debug.server->setEditCallback(FMaterial::onEditCallback); + debug.server->setQueryCallback(FMaterial::onQueryCallback); + } + } +#endif + while (true) { if (!execute()) { break; diff --git a/filament/src/details/Engine.h b/filament/src/details/Engine.h index d52907dc760..9e184f1f462 100644 --- a/filament/src/details/Engine.h +++ b/filament/src/details/Engine.h @@ -252,20 +252,12 @@ class FEngine : public Engine { // Return a vector of shader languages, in order of preference. utils::FixedCapacityVector getShaderLanguage() const noexcept { switch (mBackend) { - case Backend::DEFAULT: - case Backend::NOOP: default: - return { backend::ShaderLanguage::ESSL3 }; - case Backend::OPENGL: - return { getDriver().getFeatureLevel() == FeatureLevel::FEATURE_LEVEL_0 - ? backend::ShaderLanguage::ESSL1 - : backend::ShaderLanguage::ESSL3 }; - case Backend::VULKAN: - return { backend::ShaderLanguage::SPIRV }; + return { getDriver().getShaderLanguage() }; case Backend::METAL: const auto& lang = mConfig.preferredShaderLanguage; if (lang == Config::ShaderLanguage::MSL) { - return { backend::ShaderLanguage::MSL, backend::ShaderLanguage::METAL_LIBRARY }; + return { backend::ShaderLanguage::MSL, backend::ShaderLanguage::METAL_LIBRARY}; } return { backend::ShaderLanguage::METAL_LIBRARY, backend::ShaderLanguage::MSL }; } diff --git a/libs/matdbg/include/matdbg/DebugServer.h b/libs/matdbg/include/matdbg/DebugServer.h index 4340001d661..86aaa79bd10 100644 --- a/libs/matdbg/include/matdbg/DebugServer.h +++ b/libs/matdbg/include/matdbg/DebugServer.h @@ -52,7 +52,7 @@ class DebugServer { static std::string_view const kSuccessHeader; static std::string_view const kErrorHeader; - DebugServer(backend::Backend backend, int port); + DebugServer(backend::Backend backend, backend::ShaderLanguage shaderLanguage, int port); ~DebugServer(); /** @@ -97,6 +97,7 @@ class DebugServer { const char* newShaderContent, size_t newShaderLength); const backend::Backend mBackend; + const backend::ShaderLanguage mShaderLanguage; CivetServer* mServer; diff --git a/libs/matdbg/include/matdbg/JsonWriter.h b/libs/matdbg/include/matdbg/JsonWriter.h index 8cfbebd1bee..4291f6f7492 100644 --- a/libs/matdbg/include/matdbg/JsonWriter.h +++ b/libs/matdbg/include/matdbg/JsonWriter.h @@ -46,8 +46,8 @@ class JsonWriter { // The array is of the form [ backend, shaderIndex0, shaderIndex1, ... ] where each // shader index is an active variant. Each bit in the activeVariants bitmask // represents one of the possible variant combinations. - bool writeActiveInfo(const filaflat::ChunkContainer& package, backend::Backend backend, - VariantList activeVariants); + bool writeActiveInfo(const filaflat::ChunkContainer& package, + backend::ShaderLanguage shaderLanguage, VariantList activeVariants); private: utils::CString mJsonString; diff --git a/libs/matdbg/include/matdbg/ShaderReplacer.h b/libs/matdbg/include/matdbg/ShaderReplacer.h index 36b0c536ec7..ab6f49e33db 100644 --- a/libs/matdbg/include/matdbg/ShaderReplacer.h +++ b/libs/matdbg/include/matdbg/ShaderReplacer.h @@ -29,11 +29,13 @@ namespace matdbg { // in a manner similar to ShaderExtractor. class ShaderReplacer { public: - ShaderReplacer(backend::Backend backend, const void* data, size_t size); + ShaderReplacer(backend::Backend backend, backend::ShaderLanguage language, + const void* data, size_t size); ~ShaderReplacer(); bool replaceShaderSource(backend::ShaderModel shaderModel, Variant variant, backend::ShaderStage stage, const char* sourceString, size_t stringLength); const uint8_t* getEditedPackage() const; + filamat::ChunkType getMaterialTag() const noexcept; size_t getEditedSize() const; private: bool replaceSpirv(backend::ShaderModel shaderModel, Variant variant, @@ -42,6 +44,7 @@ class ShaderReplacer { filaflat::ChunkContainer mOriginalPackage; filaflat::ChunkContainer* mEditedPackage = nullptr; filamat::ChunkType mMaterialTag = filamat::ChunkType::Unknown; + filamat::ChunkType mDeleteTag = filamat::ChunkType::Unknown; filamat::ChunkType mDictionaryTag = filamat::ChunkType::Unknown; }; diff --git a/libs/matdbg/src/ApiHandler.cpp b/libs/matdbg/src/ApiHandler.cpp index c9ef42c0ee0..d13161eeacb 100644 --- a/libs/matdbg/src/ApiHandler.cpp +++ b/libs/matdbg/src/ApiHandler.cpp @@ -86,6 +86,8 @@ bool ApiHandler::handleGetApiShader(struct mg_connection* conn, } std::string_view const glsl("glsl"); + std::string_view const essl3("essl3"); + std::string_view const essl1("essl1"); std::string_view const msl("msl"); std::string_view const spirv("spirv"); size_t const qlength = strlen(request->query_string); @@ -109,12 +111,20 @@ bool ApiHandler::handleGetApiShader(struct mg_connection* conn, } if (glindex[0]) { - if (language != glsl) { - return softError("Only GLSL is supported."); + ChunkType chunkType; + ShaderLanguage shaderLanguage; + if (language == essl3) { + chunkType = ChunkType::MaterialGlsl; + shaderLanguage = ShaderLanguage::ESSL3; + } else if (language == essl1) { + chunkType = ChunkType::MaterialEssl1; + shaderLanguage = ShaderLanguage::ESSL1; + } else { + return softError("Only essl3 and essl1 are supported."); } - FixedCapacityVector info(getShaderCount(package, ChunkType::MaterialGlsl)); - if (!getShaderInfo(package, info.data(), ChunkType::MaterialGlsl)) { + FixedCapacityVector info(getShaderCount(package, chunkType)); + if (!getShaderInfo(package, info.data(), chunkType)) { return error(__LINE__, uri); } @@ -123,7 +133,7 @@ bool ApiHandler::handleGetApiShader(struct mg_connection* conn, return error(__LINE__, uri); } - ShaderExtractor extractor(ShaderLanguage::ESSL3, result->package, result->packageSize); + ShaderExtractor extractor(shaderLanguage, result->package, result->packageSize); if (!extractor.parse()) { return error(__LINE__, uri); } @@ -314,7 +324,7 @@ bool ApiHandler::handleGet(CivetServer* server, struct mg_connection* conn) { return error(__LINE__, uri); } JsonWriter writer; - if (!writer.writeActiveInfo(package, mServer->mBackend, record.activeVariants)) { + if (!writer.writeActiveInfo(package, mServer->mShaderLanguage, record.activeVariants)) { return error(__LINE__, uri); } bool const last = (++index) == mServer->mMaterialRecords.size(); diff --git a/libs/matdbg/src/DebugServer.cpp b/libs/matdbg/src/DebugServer.cpp index e8efb0b2274..d75952728b8 100644 --- a/libs/matdbg/src/DebugServer.cpp +++ b/libs/matdbg/src/DebugServer.cpp @@ -122,7 +122,8 @@ class FileRequestHandler : public CivetHandler { DebugServer* mServer; }; -DebugServer::DebugServer(Backend backend, int port) : mBackend(backend) { +DebugServer::DebugServer(Backend backend, ShaderLanguage shaderLanguage, int port) + : mBackend(backend), mShaderLanguage(shaderLanguage) { #if !SERVE_FROM_SOURCE_TREE ASSET_MAP["/index.html"] = { @@ -254,47 +255,23 @@ bool DebugServer::handleEditCommand(const MaterialKey& key, backend::Backend api return error(__LINE__); } - FixedCapacityVector infos; - size_t shaderCount; - switch (api) { - case backend::Backend::OPENGL: { - shaderCount = getShaderCount(package, ChunkType::MaterialGlsl); - infos.reserve(shaderCount); - infos.resize(shaderCount); - if (!getShaderInfo(package, infos.data(), ChunkType::MaterialGlsl)) { - return error(__LINE__); - } - break; - } - case backend::Backend::VULKAN: { - shaderCount = getShaderCount(package, ChunkType::MaterialSpirv); - infos.reserve(shaderCount); - infos.resize(shaderCount); - if (!getShaderInfo(package, infos.data(), ChunkType::MaterialSpirv)) { - return error(__LINE__); - } - break; - } - case backend::Backend::METAL: { - shaderCount = getShaderCount(package, ChunkType::MaterialMetal); - infos.reserve(shaderCount); - infos.resize(shaderCount); - if (!getShaderInfo(package, infos.data(), ChunkType::MaterialMetal)) { - return error(__LINE__); - } - break; - } - default: - error(__LINE__); - } + ShaderReplacer editor(api, mShaderLanguage, package.getData(), package.getSize()); + size_t shaderCount = getShaderCount(package, editor.getMaterialTag()); if (shaderIndex < 0 || shaderIndex >= shaderCount) { return error(__LINE__); } + FixedCapacityVector infos; + infos.reserve(shaderCount); + infos.resize(shaderCount); + if (!getShaderInfo(package, infos.data(), editor.getMaterialTag())) { + return error(__LINE__); + } + const ShaderInfo info = infos[shaderIndex]; - ShaderReplacer editor(api, package.getData(), package.getSize()); - if (!editor.replaceShaderSource(info.shaderModel, info.variant, info.pipelineStage, source, size)) { + if (!editor.replaceShaderSource(info.shaderModel, info.variant, info.pipelineStage, source, + size)) { return error(__LINE__); } diff --git a/libs/matdbg/src/JsonWriter.cpp b/libs/matdbg/src/JsonWriter.cpp index c9e94c8143d..2a22eaeae2e 100644 --- a/libs/matdbg/src/JsonWriter.cpp +++ b/libs/matdbg/src/JsonWriter.cpp @@ -136,13 +136,22 @@ static void printShaderInfo(ostream& json, const vector& info, const } } -static bool printGlslInfo(ostream& json, const ChunkContainer& container) { +static bool printGlslInfo(ostream& json, const ChunkContainer& container, ChunkType chunkType) { std::vector info; - info.resize(getShaderCount(container, ChunkType::MaterialGlsl)); - if (!getShaderInfo(container, info.data(), ChunkType::MaterialGlsl)) { + info.resize(getShaderCount(container, chunkType)); + if (!getShaderInfo(container, info.data(), chunkType)) { return false; } - json << "\"opengl\": [\n"; + switch (chunkType) { + case ChunkType::MaterialEssl1: + json << "\"essl1\": [\n"; + break; + case ChunkType::MaterialGlsl: + json << "\"opengl\": [\n"; + break; + default: + assert(false); // unreachable + } printShaderInfo(json, info, container); json << "],\n"; return true; @@ -180,7 +189,10 @@ bool JsonWriter::writeMaterialInfo(const filaflat::ChunkContainer& container) { if (!printParametersInfo(json, container)) { return false; } - if (!printGlslInfo(json, container)) { + if (!printGlslInfo(json, container, ChunkType::MaterialGlsl)) { + return false; + } + if (!printGlslInfo(json, container, ChunkType::MaterialEssl1)) { return false; } if (!printVkInfo(json, container)) { @@ -220,29 +232,34 @@ size_t JsonWriter::getJsonSize() const { } bool JsonWriter::writeActiveInfo(const filaflat::ChunkContainer& package, - Backend backend, VariantList activeVariants) { + ShaderLanguage shaderLanguage, VariantList activeVariants) { vector shaders; ostringstream json; json << "[\""; - switch (backend) { - case Backend::OPENGL: - shaders.resize(getShaderCount(package, ChunkType::MaterialGlsl)); - getShaderInfo(package, shaders.data(), ChunkType::MaterialGlsl); + ChunkType chunkType; + switch (shaderLanguage) { + case ShaderLanguage::ESSL1: + json << "essl1"; + chunkType = ChunkType::MaterialEssl1; + break; + case ShaderLanguage::ESSL3: json << "opengl"; + chunkType = ChunkType::MaterialGlsl; break; - case Backend::VULKAN: - shaders.resize(getShaderCount(package, ChunkType::MaterialSpirv)); - getShaderInfo(package, shaders.data(), ChunkType::MaterialSpirv); + case ShaderLanguage::SPIRV: json << "vulkan"; + chunkType = ChunkType::MaterialSpirv; break; - case Backend::METAL: - shaders.resize(getShaderCount(package, ChunkType::MaterialMetal)); - getShaderInfo(package, shaders.data(), ChunkType::MaterialMetal); + case ShaderLanguage::MSL: json << "metal"; + chunkType = ChunkType::MaterialMetal; break; default: return false; } + shaders.resize(getShaderCount(package, chunkType)); + getShaderInfo(package, shaders.data(), chunkType); + json << "\""; for (size_t variant = 0; variant < activeVariants.size(); variant++) { if (activeVariants[variant]) { diff --git a/libs/matdbg/src/ShaderReplacer.cpp b/libs/matdbg/src/ShaderReplacer.cpp index 8a457e598c9..38e4b582296 100644 --- a/libs/matdbg/src/ShaderReplacer.cpp +++ b/libs/matdbg/src/ShaderReplacer.cpp @@ -94,22 +94,33 @@ class BlobIndex { filaflat::BlobDictionary mDataBlobs; }; -ShaderReplacer::ShaderReplacer(Backend backend, const void* data, size_t size) : +ShaderReplacer::ShaderReplacer(Backend backend, ShaderLanguage language, + const void* data, size_t size) : mBackend(backend), mOriginalPackage(data, size) { - switch (backend) { - case Backend::OPENGL: + switch (language) { + // ESSL1 and ESSL3 share the same dictionary, and replacing either will corrupt the other. + // If replacing one, delete both. + case backend::ShaderLanguage::ESSL1: + mMaterialTag = ChunkType::MaterialEssl1; + mDeleteTag = ChunkType::MaterialGlsl; + mDictionaryTag = ChunkType::DictionaryText; + break; + case backend::ShaderLanguage::ESSL3: mMaterialTag = ChunkType::MaterialGlsl; + mDeleteTag = ChunkType::MaterialEssl1; mDictionaryTag = ChunkType::DictionaryText; break; - case Backend::METAL: + case backend::ShaderLanguage::MSL: mMaterialTag = ChunkType::MaterialMetal; mDictionaryTag = ChunkType::DictionaryText; break; - case Backend::VULKAN: + case backend::ShaderLanguage::SPIRV: mMaterialTag = ChunkType::MaterialSpirv; mDictionaryTag = ChunkType::DictionarySpirv; break; - default: + case backend::ShaderLanguage::METAL_LIBRARY: + mMaterialTag = ChunkType::MaterialMetalLibrary; + mDictionaryTag = ChunkType::DictionaryMetalLibrary; break; } } @@ -133,7 +144,7 @@ bool ShaderReplacer::replaceShaderSource(ShaderModel shaderModel, Variant varian return replaceSpirv(shaderModel, variant, stage, sourceString, stringLength); } - // Clone all chunks except Dictionary* and Material*. + // Clone (almost) all chunks except Dictionary* and Material*. stringstream sstream(std::string((const char*) cc.getData(), cc.getSize())); stringstream tstream; { @@ -145,7 +156,9 @@ bool ShaderReplacer::replaceShaderSource(ShaderModel shaderModel, Variant varian sstream.read((char*) &size, sizeof(size)); content.resize(size); sstream.read((char*) content.data(), size); - if (ChunkType(type) == mDictionaryTag|| ChunkType(type) == mMaterialTag) { + if (ChunkType(type) == mDictionaryTag + || ChunkType(type) == mDeleteTag + || ChunkType(type) == mMaterialTag) { continue; } tstream.write((char*) &type, sizeof(type)); @@ -297,6 +310,10 @@ size_t ShaderReplacer::getEditedSize() const { return mEditedPackage->getSize(); } +filamat::ChunkType ShaderReplacer::getMaterialTag() const noexcept { + return mMaterialTag; +} + ShaderIndex::ShaderIndex(ChunkType dictTag, ChunkType matTag, const filaflat::ChunkContainer& cc) : mDictTag(dictTag), mMatTag(matTag) { diff --git a/libs/matdbg/web/api.js b/libs/matdbg/web/api.js index 3a580fcacfe..f16fec3a90e 100644 --- a/libs/matdbg/web/api.js +++ b/libs/matdbg/web/api.js @@ -30,6 +30,7 @@ async function fetchShaderCode(matid, backend, language, index) { let query; switch (backend) { case "opengl": + case "essl1": query = `type=${language}&glindex=${index}`; break; case "vulkan": @@ -82,7 +83,10 @@ async function queryActiveShaders() { function rebuildMaterial(materialId, backend, shaderIndex, editedText) { let api = 0; switch (backend) { - case "opengl": api = 1; break; + case "opengl": + case "essl1": + api = 1; + break; case "vulkan": api = 2; break; case "metal": api = 3; break; } diff --git a/libs/matdbg/web/app.js b/libs/matdbg/web/app.js index 325d47487fd..58858daa3c9 100644 --- a/libs/matdbg/web/app.js +++ b/libs/matdbg/web/app.js @@ -20,11 +20,19 @@ const kUntitledPlaceholder = "untitled"; // Maps to backend to the languages allowed for that backend. const LANGUAGE_CHOICES = { - 'opengl': ['glsl'], + 'opengl': ['essl3', 'essl1'], + 'essl1': ['essl3', 'essl1'], 'vulkan': ['glsl', 'spirv'], 'metal': ['msl'], }; +const DEFAULT_LANGUAGE_FOR_BACKEND = { + 'opengl': 'essl3', + 'essl1': 'essl1', + 'vulkan': 'glsl', + 'metal': 'msl', +}; + const BACKENDS = Object.keys(LANGUAGE_CHOICES); const MATERIAL_INFO_KEY_TO_STRING = { @@ -1051,9 +1059,8 @@ class MatdbgViewer extends LitElement { updated(props) { // Set a language if there hasn't been one set. if (props.has('currentBackend') && this.currentBackend) { - const choices = LANGUAGE_CHOICES[this.currentBackend]; - if (choices.indexOf(this.currentLanguage) < 0) { - this.currentLanguage = choices[0]; + if (LANGUAGE_CHOICES[this.currentBackend].indexOf(this.currentLanguage) < 0) { + this.currentLanguage = DEFAULT_LANGUAGE_FOR_BACKEND[this.currentBackend]; } } if (props.has('currentMaterial')) { diff --git a/tools/matinfo/src/main.cpp b/tools/matinfo/src/main.cpp index ea2d1a01412..cf59f7bb69f 100644 --- a/tools/matinfo/src/main.cpp +++ b/tools/matinfo/src/main.cpp @@ -422,7 +422,8 @@ static bool parseChunks(Config config, void* data, size_t size) { if (config.serverPort) { // Spin up a web server on a secondary thread. - DebugServer server(Backend::DEFAULT, config.serverPort); + DebugServer server(Backend::DEFAULT, filament::backend::ShaderLanguage::ESSL3, + config.serverPort); if (!server.isReady()) { return false; }