From 3496f3a8baa067dc545fb6d8668d17183ad5bec2 Mon Sep 17 00:00:00 2001 From: Mathias Agopian Date: Mon, 12 Sep 2022 14:02:06 -0700 Subject: [PATCH] rename ShaderType to ShaderStage --- .../backend/include/backend/DriverEnums.h | 8 +- filament/backend/include/backend/Program.h | 2 +- filament/backend/src/Program.cpp | 2 +- filament/backend/src/metal/MetalDriver.h | 2 +- filament/backend/src/metal/MetalDriver.mm | 10 +- filament/backend/src/metal/MetalHandles.mm | 10 +- filament/backend/src/opengl/OpenGLProgram.cpp | 18 +-- filament/backend/test/ShaderGenerator.cpp | 4 +- filament/backend/test/ShaderGenerator.h | 2 +- filament/src/MaterialParser.cpp | 2 +- filament/src/MaterialParser.h | 2 +- filament/src/details/Material.cpp | 8 +- .../filamat/include/filamat/MaterialBuilder.h | 4 +- libs/filamat/src/GLSLPostProcessor.cpp | 6 +- libs/filamat/src/GLSLPostProcessor.h | 2 +- libs/filamat/src/MaterialBuilder.cpp | 32 ++--- libs/filamat/src/MaterialVariants.cpp | 8 +- libs/filamat/src/MaterialVariants.h | 2 +- libs/filamat/src/sca/GLSLTools.cpp | 10 +- libs/filamat/src/sca/GLSLTools.h | 2 +- libs/filamat/src/sca/GLSLToolsLite.cpp | 2 +- libs/filamat/src/sca/GLSLToolsLite.h | 2 +- libs/filamat/src/shaders/CodeGenerator.cpp | 110 ++++++++-------- libs/filamat/src/shaders/CodeGenerator.h | 42 +++--- libs/filamat/src/shaders/ShaderGenerator.cpp | 96 +++++++------- libs/filamat/tests/test_filamat.cpp | 122 +++++++++--------- libs/filamat/tests/test_filamat_lite.cpp | 22 ++-- libs/matdbg/include/matdbg/ShaderExtractor.h | 2 +- libs/matdbg/include/matdbg/ShaderInfo.h | 2 +- libs/matdbg/include/matdbg/ShaderReplacer.h | 4 +- libs/matdbg/src/CommonWriter.h | 6 +- libs/matdbg/src/JsonWriter.cpp | 2 +- libs/matdbg/src/ShaderExtractor.cpp | 2 +- libs/matdbg/src/ShaderInfo.cpp | 6 +- libs/matdbg/src/ShaderReplacer.cpp | 18 +-- 35 files changed, 287 insertions(+), 287 deletions(-) diff --git a/filament/backend/include/backend/DriverEnums.h b/filament/backend/include/backend/DriverEnums.h index c56bf24df3..075863da8d 100644 --- a/filament/backend/include/backend/DriverEnums.h +++ b/filament/backend/include/backend/DriverEnums.h @@ -893,7 +893,7 @@ struct RasterState { * \privatesection */ -enum class ShaderType : uint8_t { +enum class ShaderStage : uint8_t { VERTEX = 0, FRAGMENT = 1 }; @@ -906,11 +906,11 @@ enum class ShaderStageFlags : uint8_t { ALL_SHADER_STAGE_FLAGS = VERTEX | FRAGMENT }; -static inline constexpr bool hasShaderType(ShaderStageFlags flags, ShaderType type) noexcept { +static inline constexpr bool hasShaderType(ShaderStageFlags flags, ShaderStage type) noexcept { switch (type) { - case ShaderType::VERTEX: + case ShaderStage::VERTEX: return bool(uint8_t(flags) & uint8_t(ShaderStageFlags::VERTEX)); - case ShaderType::FRAGMENT: + case ShaderStage::FRAGMENT: return bool(uint8_t(flags) & uint8_t(ShaderStageFlags::FRAGMENT)); } } diff --git a/filament/backend/include/backend/Program.h b/filament/backend/include/backend/Program.h index 79e4f271eb..1301c2f78d 100644 --- a/filament/backend/include/backend/Program.h +++ b/filament/backend/include/backend/Program.h @@ -70,7 +70,7 @@ public: // sets one of the program's shader (e.g. vertex, fragment) // string-based shaders are null terminated, consequently the size parameter must include the // null terminating character. - Program& shader(ShaderType shader, void const* data, size_t size); + Program& shader(ShaderStage shader, void const* data, size_t size); // Note: This is only needed for GLES3.0 backends, because the layout(binding=) syntax is // not permitted in glsl. The backend needs a way to associate a uniform block diff --git a/filament/backend/src/Program.cpp b/filament/backend/src/Program.cpp index 3d2b63f7c5..2e04067050 100644 --- a/filament/backend/src/Program.cpp +++ b/filament/backend/src/Program.cpp @@ -44,7 +44,7 @@ Program& Program::diagnostics(CString const& name, return *this; } -Program& Program::shader(ShaderType shader, void const* data, size_t size) { +Program& Program::shader(ShaderStage shader, void const* data, size_t size) { ShaderBlob blob(size); std::copy_n((const uint8_t *)data, size, blob.data()); mShadersSource[size_t(shader)] = std::move(blob); diff --git a/filament/backend/src/metal/MetalDriver.h b/filament/backend/src/metal/MetalDriver.h index 96f8e3bf6d..ad95e119c2 100644 --- a/filament/backend/src/metal/MetalDriver.h +++ b/filament/backend/src/metal/MetalDriver.h @@ -126,7 +126,7 @@ private: inline void setRenderPrimitiveRange(Handle rph, PrimitiveType pt, uint32_t offset, uint32_t minIndex, uint32_t maxIndex, uint32_t count); - void enumerateSamplerGroups(const MetalProgram* program, ShaderType shaderType, + void enumerateSamplerGroups(const MetalProgram* program, ShaderStage shaderType, const std::function& f); void enumerateBoundUniformBuffers(const std::function& f); diff --git a/filament/backend/src/metal/MetalDriver.mm b/filament/backend/src/metal/MetalDriver.mm index 0f31e31175..9be17348a7 100644 --- a/filament/backend/src/metal/MetalDriver.mm +++ b/filament/backend/src/metal/MetalDriver.mm @@ -1387,7 +1387,7 @@ void MetalDriver::draw(PipelineState ps, Handle rph, uint32_t id texturesToBindVertex[FEATURE_LEVEL_CAPS[+FeatureLevel::FEATURE_LEVEL_1].MAX_VERTEX_SAMPLER_COUNT] = {}; id samplersToBindVertex[FEATURE_LEVEL_CAPS[+FeatureLevel::FEATURE_LEVEL_1].MAX_VERTEX_SAMPLER_COUNT] = {}; - enumerateSamplerGroups(program, ShaderType::VERTEX, + enumerateSamplerGroups(program, ShaderStage::VERTEX, [this, &getTextureToBind, &getSamplerToBind, &texturesToBindVertex, &samplersToBindVertex]( const SamplerDescriptor* sampler, uint8_t binding) { // We currently only support a max of MAX_VERTEX_SAMPLER_COUNT samplers. Ignore any additional @@ -1425,7 +1425,7 @@ void MetalDriver::draw(PipelineState ps, Handle rph, uint32_t id texturesToBindFragment[FEATURE_LEVEL_CAPS[+FeatureLevel::FEATURE_LEVEL_1].MAX_FRAGMENT_SAMPLER_COUNT] = {}; id samplersToBindFragment[FEATURE_LEVEL_CAPS[+FeatureLevel::FEATURE_LEVEL_1].MAX_FRAGMENT_SAMPLER_COUNT] = {}; - enumerateSamplerGroups(program, ShaderType::FRAGMENT, + enumerateSamplerGroups(program, ShaderStage::FRAGMENT, [this, &getTextureToBind, &getSamplerToBind, &texturesToBindFragment, &samplersToBindFragment]( const SamplerDescriptor* sampler, uint8_t binding) { // We currently only support a max of MAX_FRAGMENT_SAMPLER_COUNT samplers. Ignore any additional @@ -1517,11 +1517,11 @@ void MetalDriver::endTimerQuery(Handle tqh) { } void MetalDriver::enumerateSamplerGroups( - const MetalProgram* program, ShaderType shaderType, + const MetalProgram* program, ShaderStage shaderType, const std::function& f) { - auto& samplerBlockInfo = (shaderType == ShaderType::VERTEX) ? + auto& samplerBlockInfo = (shaderType == ShaderStage::VERTEX) ? program->vertexSamplerBlockInfo : program->fragmentSamplerBlockInfo; - auto maxSamplerCount = (shaderType == ShaderType::VERTEX) ? + auto maxSamplerCount = (shaderType == ShaderStage::VERTEX) ? FEATURE_LEVEL_CAPS[+FeatureLevel::FEATURE_LEVEL_1].MAX_VERTEX_SAMPLER_COUNT : FEATURE_LEVEL_CAPS[+FeatureLevel::FEATURE_LEVEL_1].MAX_FRAGMENT_SAMPLER_COUNT; for (size_t bindingIdx = 0; bindingIdx != maxSamplerCount; ++bindingIdx) { diff --git a/filament/backend/src/metal/MetalHandles.mm b/filament/backend/src/metal/MetalHandles.mm index b40e25bbb7..b56c8813ca 100644 --- a/filament/backend/src/metal/MetalHandles.mm +++ b/filament/backend/src/metal/MetalHandles.mm @@ -415,13 +415,13 @@ MetalProgram::MetalProgram(id device, const Program& program) noexcep // 3 depth auto& samplerGroupInfo = program.getSamplerGroupInfo(); for (size_t shaderType = 0; shaderType != PIPELINE_STAGE_COUNT; ++shaderType) { - ShaderType stage = (ShaderType)shaderType; + ShaderStage stage = (ShaderStage)shaderType; size_t bindingIdx = 0; - auto getShaderStage = [this](ShaderType type) -> auto& { + auto getShaderStage = [this](ShaderStage type) -> auto& { switch (type) { - case ShaderType::VERTEX: return vertexSamplerBlockInfo; - case ShaderType::FRAGMENT: return fragmentSamplerBlockInfo; + case ShaderStage::VERTEX: return vertexSamplerBlockInfo; + case ShaderStage::FRAGMENT: return fragmentSamplerBlockInfo; } }; @@ -430,7 +430,7 @@ MetalProgram::MetalProgram(id device, const Program& program) noexcep for (size_t samplerGroupIdx = 0; samplerGroupIdx != SAMPLER_GROUP_COUNT; ++samplerGroupIdx) { auto& groupData = samplerGroupInfo[samplerGroupIdx]; auto stageFlags = groupData.stageFlags; - if (!hasShaderType(stageFlags, static_cast(shaderType))) { + if (!hasShaderType(stageFlags, static_cast(shaderType))) { continue; } auto& samplers = groupData.samplers; diff --git a/filament/backend/src/opengl/OpenGLProgram.cpp b/filament/backend/src/opengl/OpenGLProgram.cpp index 9af1475a9d..2add0f571d 100644 --- a/filament/backend/src/opengl/OpenGLProgram.cpp +++ b/filament/backend/src/opengl/OpenGLProgram.cpp @@ -34,7 +34,7 @@ using namespace utils; using namespace backend; static void logCompilationError(utils::io::ostream& out, - ShaderType shaderType, const char* name, + ShaderStage shaderType, const char* name, GLuint shaderId, CString const& sourceCode) noexcept; static void logProgramLinkError(utils::io::ostream& out, @@ -120,13 +120,13 @@ void OpenGLProgram::compileShaders(OpenGLContext& context, // build all shaders UTILS_NOUNROLL for (size_t i = 0; i < Program::SHADER_TYPE_COUNT; i++) { - ShaderType type = static_cast(i); + ShaderStage type = static_cast(i); GLenum glShaderType; switch (type) { - case ShaderType::VERTEX: + case ShaderStage::VERTEX: glShaderType = GL_VERTEX_SHADER; break; - case ShaderType::FRAGMENT: + case ShaderStage::FRAGMENT: glShaderType = GL_FRAGMENT_SHADER; break; } @@ -287,7 +287,7 @@ bool OpenGLProgram::checkProgramStatus(const char* name, // only if the link fails, we check the compilation status UTILS_NOUNROLL for (size_t i = 0; i < Program::SHADER_TYPE_COUNT; i++) { - const ShaderType type = static_cast(i); + const ShaderStage type = static_cast(i); const GLuint shader = shaderIds[i]; glGetShaderiv(shader, GL_COMPILE_STATUS, &status); if (status != GL_TRUE) { @@ -421,13 +421,13 @@ void OpenGLProgram::updateSamplers(OpenGLDriver* gld) const noexcept { } UTILS_NOINLINE -void logCompilationError(io::ostream& out, ShaderType shaderType, +void logCompilationError(io::ostream& out, ShaderStage shaderType, const char* name, GLuint shaderId, CString const& sourceCode) noexcept { - auto to_string = [](ShaderType type) -> const char* { + auto to_string = [](ShaderStage type) -> const char* { switch (type) { - case ShaderType::VERTEX: return "vertex"; - case ShaderType::FRAGMENT: return "fragment"; + case ShaderStage::VERTEX: return "vertex"; + case ShaderStage::FRAGMENT: return "fragment"; } }; diff --git a/filament/backend/test/ShaderGenerator.cpp b/filament/backend/test/ShaderGenerator.cpp index 70068910ad..f44c093587 100644 --- a/filament/backend/test/ShaderGenerator.cpp +++ b/filament/backend/test/ShaderGenerator.cpp @@ -184,8 +184,8 @@ ShaderGenerator::Blob ShaderGenerator::transpileShader( Program ShaderGenerator::getProgram(filament::backend::DriverApi&) noexcept { Program program; - program.shader(ShaderType::VERTEX, mVertexBlob.data(), mVertexBlob.size()); - program.shader(ShaderType::FRAGMENT, mFragmentBlob.data(), mFragmentBlob.size()); + program.shader(ShaderStage::VERTEX, mVertexBlob.data(), mVertexBlob.size()); + program.shader(ShaderStage::FRAGMENT, mFragmentBlob.data(), mFragmentBlob.size()); return program; } diff --git a/filament/backend/test/ShaderGenerator.h b/filament/backend/test/ShaderGenerator.h index 6de2b7481f..25f8bdfd2a 100644 --- a/filament/backend/test/ShaderGenerator.h +++ b/filament/backend/test/ShaderGenerator.h @@ -46,7 +46,7 @@ public: filament::backend::Program getProgram(filament::backend::DriverApi&) noexcept; private: - using ShaderStage = filament::backend::ShaderType; + using ShaderStage = filament::backend::ShaderStage; using Blob = std::vector; static Blob transpileShader(ShaderStage stage, std::string shader, Backend backend, diff --git a/filament/src/MaterialParser.cpp b/filament/src/MaterialParser.cpp index 2cc9c855ce..7de7a5d845 100644 --- a/filament/src/MaterialParser.cpp +++ b/filament/src/MaterialParser.cpp @@ -307,7 +307,7 @@ bool MaterialParser::getReflectionMode(ReflectionMode* value) const noexcept { } bool MaterialParser::getShader(ShaderContent& shader, - ShaderModel shaderModel, Variant variant, ShaderType stage) noexcept { + ShaderModel shaderModel, Variant variant, ShaderStage stage) noexcept { return mImpl.mMaterialChunk.getShader(shader, mImpl.mBlobDictionary, uint8_t(shaderModel), variant, uint8_t(stage)); } diff --git a/filament/src/MaterialParser.h b/filament/src/MaterialParser.h index 48080d7bd6..29d6e6449a 100644 --- a/filament/src/MaterialParser.h +++ b/filament/src/MaterialParser.h @@ -99,7 +99,7 @@ public: bool getSpecularAntiAliasingThreshold(float* value) const noexcept; bool getShader(filaflat::ShaderContent& shader, backend::ShaderModel shaderModel, - Variant variant, backend::ShaderType stage) noexcept; + Variant variant, backend::ShaderStage stage) noexcept; private: struct MaterialParserDetails { diff --git a/filament/src/details/Material.cpp b/filament/src/details/Material.cpp index 52c9253526..cec62f3812 100644 --- a/filament/src/details/Material.cpp +++ b/filament/src/details/Material.cpp @@ -388,7 +388,7 @@ Program FMaterial::getProgramBuilderWithVariants( ShaderContent& vsBuilder = mEngine.getVertexShaderContent(); UTILS_UNUSED_IN_RELEASE bool vsOK = mMaterialParser->getShader(vsBuilder, sm, - vertexVariant, ShaderType::VERTEX); + vertexVariant, ShaderStage::VERTEX); ASSERT_POSTCONDITION(isNoop || (vsOK && !vsBuilder.empty()), "The material '%s' has not been compiled to include the required " @@ -402,7 +402,7 @@ Program FMaterial::getProgramBuilderWithVariants( ShaderContent& fsBuilder = mEngine.getFragmentShaderContent(); UTILS_UNUSED_IN_RELEASE bool fsOK = mMaterialParser->getShader(fsBuilder, sm, - fragmentVariant, ShaderType::FRAGMENT); + fragmentVariant, ShaderStage::FRAGMENT); ASSERT_POSTCONDITION(isNoop || (fsOK && !fsBuilder.empty()), "The material '%s' has not been compiled to include the required " @@ -410,8 +410,8 @@ Program FMaterial::getProgramBuilderWithVariants( mName.c_str(), variant.key, fragmentVariant.key); Program program; - program.shader(ShaderType::VERTEX, vsBuilder.data(), vsBuilder.size()) - .shader(ShaderType::FRAGMENT, fsBuilder.data(), fsBuilder.size()) + program.shader(ShaderStage::VERTEX, vsBuilder.data(), vsBuilder.size()) + .shader(ShaderStage::FRAGMENT, fsBuilder.data(), fsBuilder.size()) .uniformBlockBindings(mUniformBlockBindings) .diagnostics(mName, [this, variant](io::ostream& out) -> io::ostream& { diff --git a/libs/filamat/include/filamat/MaterialBuilder.h b/libs/filamat/include/filamat/MaterialBuilder.h index 7847330888..776a67ffe9 100644 --- a/libs/filamat/include/filamat/MaterialBuilder.h +++ b/libs/filamat/include/filamat/MaterialBuilder.h @@ -647,7 +647,7 @@ public: // Preview the first shader generated by the given CodeGenParams. // This is used to run Static Code Analysis before generating a package. - std::string peek(filament::backend::ShaderType type, + std::string peek(filament::backend::ShaderStage type, const CodeGenParams& params, const PropertyList& properties) noexcept; // Returns true if any of the parameter samplers is of type samplerExternal @@ -677,7 +677,7 @@ private: // Multiple calls to findProperties accumulate the property sets across fragment // and vertex shaders in mProperties. - bool findProperties(filament::backend::ShaderType type, + bool findProperties(filament::backend::ShaderStage type, MaterialBuilder::PropertyList& p) noexcept; bool runSemanticAnalysis(MaterialInfo const& info) noexcept; diff --git a/libs/filamat/src/GLSLPostProcessor.cpp b/libs/filamat/src/GLSLPostProcessor.cpp index caba1c669d..c822fe8307 100644 --- a/libs/filamat/src/GLSLPostProcessor.cpp +++ b/libs/filamat/src/GLSLPostProcessor.cpp @@ -232,10 +232,10 @@ bool GLSLPostProcessor::process(const std::string& inputShader, Config const& co }; switch (config.shaderType) { - case ShaderType::VERTEX: + case ShaderStage::VERTEX: internalConfig.shLang = EShLangVertex; break; - case ShaderType::FRAGMENT: + case ShaderStage::FRAGMENT: internalConfig.shLang = EShLangFragment; break; } @@ -269,7 +269,7 @@ bool GLSLPostProcessor::process(const std::string& inputShader, Config const& co } // add texture lod bias - if (config.shaderType == backend::ShaderType::FRAGMENT && + if (config.shaderType == backend::ShaderStage::FRAGMENT && config.domain == MaterialDomain::SURFACE) { GLSLTools::textureLodBias(tShader); } diff --git a/libs/filamat/src/GLSLPostProcessor.h b/libs/filamat/src/GLSLPostProcessor.h index 75888ebdd1..f32946a5c1 100644 --- a/libs/filamat/src/GLSLPostProcessor.h +++ b/libs/filamat/src/GLSLPostProcessor.h @@ -53,7 +53,7 @@ public: filament::Variant variant; MaterialBuilder::TargetApi targetApi; MaterialBuilder::TargetLanguage targetLanguage; - filament::backend::ShaderType shaderType; + filament::backend::ShaderStage shaderType; filament::backend::ShaderModel shaderModel; filament::MaterialDomain domain; const filamat::MaterialInfo* materialInfo; diff --git a/libs/filamat/src/MaterialBuilder.cpp b/libs/filamat/src/MaterialBuilder.cpp index 064ab37523..a44ca80d25 100644 --- a/libs/filamat/src/MaterialBuilder.cpp +++ b/libs/filamat/src/MaterialBuilder.cpp @@ -514,7 +514,7 @@ void MaterialBuilder::prepareToBuild(MaterialInfo& info) noexcept { info.featureLevel = mFeatureLevel; } -bool MaterialBuilder::findProperties(backend::ShaderType type, +bool MaterialBuilder::findProperties(backend::ShaderStage type, MaterialBuilder::PropertyList& allProperties) noexcept { #ifndef FILAMAT_LITE GLSLTools glslTools; @@ -545,18 +545,18 @@ bool MaterialBuilder::findAllProperties() noexcept { // static code analyse the AST. MaterialBuilder::PropertyList allProperties; std::fill_n(allProperties, MATERIAL_PROPERTIES_COUNT, true); - if (!findProperties(ShaderType::FRAGMENT, allProperties)) { + if (!findProperties(ShaderStage::FRAGMENT, allProperties)) { return false; } - if (!findProperties(ShaderType::VERTEX, allProperties)) { + if (!findProperties(ShaderStage::VERTEX, allProperties)) { return false; } return true; #else GLSLToolsLite glslTools; - if (glslTools.findProperties(ShaderType::FRAGMENT, mMaterialFragmentCode.getResolved(), mProperties)) { + if (glslTools.findProperties(ShaderStage::FRAGMENT, mMaterialFragmentCode.getResolved(), mProperties)) { return glslTools.findProperties( - ShaderType::VERTEX, mMaterialVertexCode.getResolved(), mProperties); + ShaderStage::VERTEX, mMaterialVertexCode.getResolved(), mProperties); } return false; #endif @@ -577,12 +577,12 @@ bool MaterialBuilder::runSemanticAnalysis(MaterialInfo const& info) noexcept { } ShaderModel model = static_cast(mSemanticCodeGenParams.shaderModel); - std::string shaderCode = peek(ShaderType::VERTEX, mSemanticCodeGenParams, mProperties); + std::string shaderCode = peek(ShaderStage::VERTEX, mSemanticCodeGenParams, mProperties); bool result = GLSLTools::analyzeVertexShader(shaderCode, model, mMaterialDomain, targetApi, targetLanguage, info); if (!result) return false; - shaderCode = peek(ShaderType::FRAGMENT, mSemanticCodeGenParams, mProperties); + shaderCode = peek(ShaderStage::FRAGMENT, mSemanticCodeGenParams, mProperties); result = GLSLTools::analyzeFragmentShader(shaderCode, model, mMaterialDomain, targetApi, targetLanguage, mCustomSurfaceShading, info); return result; @@ -634,9 +634,9 @@ bool MaterialBuilder::ShaderCode::resolveIncludes(IncludeCallback callback, } static void showErrorMessage(const char* materialName, filament::Variant variant, - MaterialBuilder::TargetApi targetApi, backend::ShaderType shaderType, + MaterialBuilder::TargetApi targetApi, backend::ShaderStage shaderType, const std::string& shaderCode) { - using ShaderType = backend::ShaderType; + using ShaderStage = backend::ShaderStage; using TargetApi = MaterialBuilder::TargetApi; slog.e << "Error in \"" << materialName << "\"" @@ -644,7 +644,7 @@ static void showErrorMessage(const char* materialName, filament::Variant variant << (targetApi == TargetApi::VULKAN ? ", Vulkan.\n" : ", OpenGL.\n") << "=========================\n" << "Generated " - << (shaderType == ShaderType::VERTEX ? "Vertex Shader\n" : "Fragment Shader\n") + << (shaderType == ShaderStage::VERTEX ? "Vertex Shader\n" : "Fragment Shader\n") << "=========================\n" << shaderCode; } @@ -730,7 +730,7 @@ bool MaterialBuilder::generateShaders(JobSystem& jobSystem, const std::vector lock(entriesLock); - // below we rely on casting ShaderType to uint8_t - static_assert(sizeof(filament::backend::ShaderType) == 1); + // below we rely on casting ShaderStage to uint8_t + static_assert(sizeof(filament::backend::ShaderStage) == 1); switch (targetApi) { @@ -1115,7 +1115,7 @@ bool MaterialBuilder::needsStandardDepthProgram() const noexcept { mBlendingMode == BlendingMode::FADE)); } -std::string MaterialBuilder::peek(backend::ShaderType type, +std::string MaterialBuilder::peek(backend::ShaderStage type, const CodeGenParams& params, const PropertyList& properties) noexcept { ShaderGenerator sg(properties, mVariables, mOutputs, mDefines, mMaterialFragmentCode.getResolved(), @@ -1126,7 +1126,7 @@ std::string MaterialBuilder::peek(backend::ShaderType type, prepareToBuild(info); info.samplerBindings.init(mMaterialDomain, info.sib); - if (type == backend::ShaderType::VERTEX) { + if (type == backend::ShaderStage::VERTEX) { return sg.createVertexProgram(ShaderModel(params.shaderModel), params.targetApi, params.targetLanguage, info, {}, mInterpolation, mVertexDomain); } else { diff --git a/libs/filamat/src/MaterialVariants.cpp b/libs/filamat/src/MaterialVariants.cpp index 101887d3fc..4b081ebe28 100644 --- a/libs/filamat/src/MaterialVariants.cpp +++ b/libs/filamat/src/MaterialVariants.cpp @@ -37,11 +37,11 @@ std::vector determineSurfaceVariants( filteredVariant, isLit || shadowMultiplier); if (filament::Variant::filterVariantVertex(filteredVariant) == variant) { - variants.emplace_back(variant, filament::backend::ShaderType::VERTEX); + variants.emplace_back(variant, filament::backend::ShaderStage::VERTEX); } if (filament::Variant::filterVariantFragment(filteredVariant) == variant) { - variants.emplace_back(variant, filament::backend::ShaderType::FRAGMENT); + variants.emplace_back(variant, filament::backend::ShaderStage::FRAGMENT); } } return variants; @@ -53,8 +53,8 @@ std::vector determinePostProcessVariants() { // opaque is needed) for (filament::Variant::type_t k = 0; k < filament::POST_PROCESS_VARIANT_COUNT; k++) { filament::Variant variant(k); - variants.emplace_back(variant, filament::backend::ShaderType::VERTEX); - variants.emplace_back(variant, filament::backend::ShaderType::FRAGMENT); + variants.emplace_back(variant, filament::backend::ShaderStage::VERTEX); + variants.emplace_back(variant, filament::backend::ShaderStage::FRAGMENT); } return variants; } diff --git a/libs/filamat/src/MaterialVariants.h b/libs/filamat/src/MaterialVariants.h index 3e6ea5711d..939357e4e2 100644 --- a/libs/filamat/src/MaterialVariants.h +++ b/libs/filamat/src/MaterialVariants.h @@ -26,7 +26,7 @@ namespace filamat { struct Variant { - using Stage = filament::backend::ShaderType; + using Stage = filament::backend::ShaderStage; Variant(filament::Variant v, Stage s) noexcept : variant(v), stage(s) {} filament::Variant variant; Stage stage; diff --git a/libs/filamat/src/sca/GLSLTools.cpp b/libs/filamat/src/sca/GLSLTools.cpp index fa9c1f1751..622d648d27 100644 --- a/libs/filamat/src/sca/GLSLTools.cpp +++ b/libs/filamat/src/sca/GLSLTools.cpp @@ -173,7 +173,7 @@ void GLSLTools::shutdown() { } bool GLSLTools::findProperties( - filament::backend::ShaderType type, + filament::backend::ShaderStage type, const std::string& shaderCode, MaterialBuilder::PropertyList& properties, MaterialBuilder::TargetApi targetApi, @@ -181,10 +181,10 @@ bool GLSLTools::findProperties( ShaderModel model) const noexcept { const char* shaderCString = shaderCode.c_str(); - auto getShaderStage = [](ShaderType type) { + auto getShaderStage = [](ShaderStage type) { switch (type) { - case ShaderType::VERTEX: return EShLanguage::EShLangVertex; - case ShaderType::FRAGMENT: return EShLanguage::EShLangFragment; + case ShaderStage::VERTEX: return EShLanguage::EShLangVertex; + case ShaderStage::FRAGMENT: return EShLanguage::EShLangFragment; } }; @@ -205,7 +205,7 @@ bool GLSLTools::findProperties( TIntermNode* rootNode = tShader.getIntermediate()->getTreeRoot(); - std::string mainFunction(type == ShaderType::FRAGMENT ? + std::string mainFunction(type == ShaderStage::FRAGMENT ? "material" : "materialVertex"); TIntermAggregate* functionMaterialDef = ASTUtils::getFunctionByNameOnly(mainFunction, *rootNode); diff --git a/libs/filamat/src/sca/GLSLTools.h b/libs/filamat/src/sca/GLSLTools.h index 9e27869a07..faa6340503 100644 --- a/libs/filamat/src/sca/GLSLTools.h +++ b/libs/filamat/src/sca/GLSLTools.h @@ -139,7 +139,7 @@ public: // Use static code analysis on the fragment shader AST to guess properties used in user provided // glgl code. Populate properties accordingly. bool findProperties( - filament::backend::ShaderType type, + filament::backend::ShaderStage type, const std::string& shaderCode, MaterialBuilder::PropertyList& properties, MaterialBuilder::TargetApi targetApi = MaterialBuilder::TargetApi::OPENGL, diff --git a/libs/filamat/src/sca/GLSLToolsLite.cpp b/libs/filamat/src/sca/GLSLToolsLite.cpp index e2b1914466..2d3b421322 100644 --- a/libs/filamat/src/sca/GLSLToolsLite.cpp +++ b/libs/filamat/src/sca/GLSLToolsLite.cpp @@ -76,7 +76,7 @@ static std::string stripComments(const std::string& code) { } bool GLSLToolsLite::findProperties( - filament::backend::ShaderType type, + filament::backend::ShaderStage type, const utils::CString& material, MaterialBuilder::PropertyList& properties) const noexcept { if (material.empty()) { diff --git a/libs/filamat/src/sca/GLSLToolsLite.h b/libs/filamat/src/sca/GLSLToolsLite.h index a76fb73790..3e8a260200 100644 --- a/libs/filamat/src/sca/GLSLToolsLite.h +++ b/libs/filamat/src/sca/GLSLToolsLite.h @@ -40,7 +40,7 @@ public: * function is also named "material"). */ bool findProperties( - filament::backend::ShaderType type, + filament::backend::ShaderStage type, const utils::CString& material, MaterialBuilder::PropertyList& properties) const noexcept; diff --git a/libs/filamat/src/shaders/CodeGenerator.cpp b/libs/filamat/src/shaders/CodeGenerator.cpp index 075ac3f219..4d321a22d2 100644 --- a/libs/filamat/src/shaders/CodeGenerator.cpp +++ b/libs/filamat/src/shaders/CodeGenerator.cpp @@ -39,7 +39,7 @@ io::sstream& CodeGenerator::generateSeparator(io::sstream& out) { return out; } -utils::io::sstream& CodeGenerator::generateProlog(utils::io::sstream& out, ShaderType type, +utils::io::sstream& CodeGenerator::generateProlog(utils::io::sstream& out, ShaderStage type, MaterialInfo const& material) const { switch (mShaderModel) { case ShaderModel::MOBILE: @@ -124,10 +124,10 @@ utils::io::sstream& CodeGenerator::generateProlog(utils::io::sstream& out, Shade return out; } -Precision CodeGenerator::getDefaultPrecision(ShaderType type) const { - if (type == ShaderType::VERTEX) { +Precision CodeGenerator::getDefaultPrecision(ShaderStage type) const { + if (type == ShaderStage::VERTEX) { return Precision::HIGH; - } else if (type == ShaderType::FRAGMENT) { + } else if (type == ShaderStage::FRAGMENT) { if (mShaderModel < ShaderModel::DESKTOP) { return Precision::MEDIUM; } else { @@ -150,40 +150,40 @@ io::sstream& CodeGenerator::generateEpilog(io::sstream& out) { return out; } -io::sstream& CodeGenerator::generateShaderMain(io::sstream& out, ShaderType type) { - if (type == ShaderType::VERTEX) { +io::sstream& CodeGenerator::generateShaderMain(io::sstream& out, ShaderStage type) { + if (type == ShaderStage::VERTEX) { out << SHADERS_MAIN_VS_DATA; - } else if (type == ShaderType::FRAGMENT) { + } else if (type == ShaderStage::FRAGMENT) { out << SHADERS_MAIN_FS_DATA; } return out; } -io::sstream& CodeGenerator::generatePostProcessMain(io::sstream& out, ShaderType type) { - if (type == ShaderType::VERTEX) { +io::sstream& CodeGenerator::generatePostProcessMain(io::sstream& out, ShaderStage type) { + if (type == ShaderStage::VERTEX) { out << SHADERS_POST_PROCESS_VS_DATA; - } else if (type == ShaderType::FRAGMENT) { + } else if (type == ShaderStage::FRAGMENT) { out << SHADERS_POST_PROCESS_FS_DATA; } return out; } -io::sstream& CodeGenerator::generateVariable(io::sstream& out, ShaderType type, +io::sstream& CodeGenerator::generateVariable(io::sstream& out, ShaderStage type, const CString& name, size_t index) { if (!name.empty()) { - if (type == ShaderType::VERTEX) { + if (type == ShaderStage::VERTEX) { out << "\n#define VARIABLE_CUSTOM" << index << " " << name.c_str() << "\n"; out << "\n#define VARIABLE_CUSTOM_AT" << index << " variable_" << name.c_str() << "\n"; out << "LAYOUT_LOCATION(" << index << ") out vec4 variable_" << name.c_str() << ";\n"; - } else if (type == ShaderType::FRAGMENT) { + } else if (type == ShaderStage::FRAGMENT) { out << "\nLAYOUT_LOCATION(" << index << ") in highp vec4 variable_" << name.c_str() << ";\n"; } } return out; } -io::sstream& CodeGenerator::generateShaderInputs(io::sstream& out, ShaderType type, +io::sstream& CodeGenerator::generateShaderInputs(io::sstream& out, ShaderStage type, const AttributeBitset& attributes, Interpolation interpolation) { const char* shading = getInterpolationQualifier(interpolation); @@ -214,7 +214,7 @@ io::sstream& CodeGenerator::generateShaderInputs(io::sstream& out, ShaderType ty } } - if (type == ShaderType::VERTEX) { + if (type == ShaderStage::VERTEX) { out << "\n"; generateDefine(out, "LOCATION_POSITION", uint32_t(VertexAttribute::POSITION)); if (hasTangents) { @@ -246,18 +246,18 @@ io::sstream& CodeGenerator::generateShaderInputs(io::sstream& out, ShaderType ty out << SHADERS_ATTRIBUTES_VS_DATA; generateDefine(out, "VARYING", "out"); - } else if (type == ShaderType::FRAGMENT) { + } else if (type == ShaderStage::FRAGMENT) { generateDefine(out, "VARYING", "in"); } out << SHADERS_VARYINGS_GLSL_DATA; return out; } -io::sstream& CodeGenerator::generateOutput(io::sstream& out, ShaderType type, +io::sstream& CodeGenerator::generateOutput(io::sstream& out, ShaderStage type, const CString& name, size_t index, MaterialBuilder::VariableQualifier qualifier, MaterialBuilder::OutputType outputType) const { - if (name.empty() || type == ShaderType::VERTEX) { + if (name.empty() || type == ShaderStage::VERTEX) { return out; } @@ -296,9 +296,9 @@ io::sstream& CodeGenerator::generateOutput(io::sstream& out, ShaderType type, } -io::sstream& CodeGenerator::generateDepthShaderMain(io::sstream& out, ShaderType type) { - assert(type != ShaderType::VERTEX); - if (type == ShaderType::FRAGMENT) { +io::sstream& CodeGenerator::generateDepthShaderMain(io::sstream& out, ShaderStage type) { + assert(type != ShaderStage::VERTEX); + if (type == ShaderStage::FRAGMENT) { out << SHADERS_DEPTH_MAIN_FS_DATA; } return out; @@ -315,7 +315,7 @@ const char* CodeGenerator::getUniformPrecisionQualifier(UniformType type, Precis return getPrecisionQualifier(precision, defaultPrecision); } -io::sstream& CodeGenerator::generateUniforms(io::sstream& out, ShaderType type, +io::sstream& CodeGenerator::generateUniforms(io::sstream& out, ShaderStage type, UniformBindingPoints binding, const UniformInterfaceBlock& uib) const { auto const& infos = uib.getUniformInfoList(); if (infos.empty()) { @@ -556,11 +556,11 @@ io::sstream& CodeGenerator::generateQualityDefine(io::sstream& out, ShaderQualit return out; } -io::sstream& CodeGenerator::generateCommon(io::sstream& out, ShaderType type) { +io::sstream& CodeGenerator::generateCommon(io::sstream& out, ShaderStage type) { out << SHADERS_COMMON_MATH_GLSL_DATA; out << SHADERS_COMMON_SHADOWING_GLSL_DATA; - if (type == ShaderType::VERTEX) { - } else if (type == ShaderType::FRAGMENT) { + if (type == ShaderStage::VERTEX) { + } else if (type == ShaderStage::FRAGMENT) { out << SHADERS_COMMON_SHADING_FS_DATA; out << SHADERS_COMMON_GRAPHICS_FS_DATA; out << SHADERS_COMMON_MATERIAL_FS_DATA; @@ -568,74 +568,74 @@ io::sstream& CodeGenerator::generateCommon(io::sstream& out, ShaderType type) { return out; } -io::sstream& CodeGenerator::generatePostProcessCommon(io::sstream& out, ShaderType type) { +io::sstream& CodeGenerator::generatePostProcessCommon(io::sstream& out, ShaderStage type) { out << SHADERS_COMMON_MATH_GLSL_DATA; - if (type == ShaderType::VERTEX) { - } else if (type == ShaderType::FRAGMENT) { + if (type == ShaderStage::VERTEX) { + } else if (type == ShaderStage::FRAGMENT) { out << SHADERS_COMMON_SHADING_FS_DATA; out << SHADERS_COMMON_GRAPHICS_FS_DATA; } return out; } -io::sstream& CodeGenerator::generateFog(io::sstream& out, ShaderType type) { - if (type == ShaderType::VERTEX) { - } else if (type == ShaderType::FRAGMENT) { +io::sstream& CodeGenerator::generateFog(io::sstream& out, ShaderStage type) { + if (type == ShaderStage::VERTEX) { + } else if (type == ShaderStage::FRAGMENT) { out << SHADERS_FOG_FS_DATA; } return out; } -io::sstream& CodeGenerator::generateCommonMaterial(io::sstream& out, ShaderType type) { - if (type == ShaderType::VERTEX) { +io::sstream& CodeGenerator::generateCommonMaterial(io::sstream& out, ShaderStage type) { + if (type == ShaderStage::VERTEX) { out << SHADERS_MATERIAL_INPUTS_VS_DATA; - } else if (type == ShaderType::FRAGMENT) { + } else if (type == ShaderStage::FRAGMENT) { out << SHADERS_MATERIAL_INPUTS_FS_DATA; } return out; } -io::sstream& CodeGenerator::generatePostProcessInputs(io::sstream& out, ShaderType type) { - if (type == ShaderType::VERTEX) { +io::sstream& CodeGenerator::generatePostProcessInputs(io::sstream& out, ShaderStage type) { + if (type == ShaderStage::VERTEX) { out << SHADERS_POST_PROCESS_INPUTS_VS_DATA; - } else if (type == ShaderType::FRAGMENT) { + } else if (type == ShaderStage::FRAGMENT) { out << SHADERS_POST_PROCESS_INPUTS_FS_DATA; } return out; } io::sstream& CodeGenerator::generatePostProcessGetters(io::sstream& out, - ShaderType type) { + ShaderStage type) { out << SHADERS_COMMON_GETTERS_GLSL_DATA; - if (type == ShaderType::VERTEX) { + if (type == ShaderStage::VERTEX) { out << SHADERS_POST_PROCESS_GETTERS_VS_DATA; - } else if (type == ShaderType::FRAGMENT) { + } else if (type == ShaderStage::FRAGMENT) { } return out; } -io::sstream& CodeGenerator::generateGetters(io::sstream& out, ShaderType type) { +io::sstream& CodeGenerator::generateGetters(io::sstream& out, ShaderStage type) { out << SHADERS_COMMON_GETTERS_GLSL_DATA; - if (type == ShaderType::VERTEX) { + if (type == ShaderStage::VERTEX) { out << SHADERS_GETTERS_VS_DATA; - } else if (type == ShaderType::FRAGMENT) { + } else if (type == ShaderStage::FRAGMENT) { out << SHADERS_GETTERS_FS_DATA; } return out; } -io::sstream& CodeGenerator::generateParameters(io::sstream& out, ShaderType type) { - if (type == ShaderType::VERTEX) { - } else if (type == ShaderType::FRAGMENT) { +io::sstream& CodeGenerator::generateParameters(io::sstream& out, ShaderStage type) { + if (type == ShaderStage::VERTEX) { + } else if (type == ShaderStage::FRAGMENT) { out << SHADERS_SHADING_PARAMETERS_FS_DATA; } return out; } -io::sstream& CodeGenerator::generateShaderLit(io::sstream& out, ShaderType type, +io::sstream& CodeGenerator::generateShaderLit(io::sstream& out, ShaderStage type, filament::Variant variant, Shading shading, bool customSurfaceShading) { - if (type == ShaderType::VERTEX) { - } else if (type == ShaderType::FRAGMENT) { + if (type == ShaderStage::VERTEX) { + } else if (type == ShaderStage::FRAGMENT) { out << SHADERS_COMMON_LIGHTING_FS_DATA; if (filament::Variant::isShadowReceiverVariant(variant)) { out << SHADERS_SHADOWING_FS_DATA; @@ -681,10 +681,10 @@ io::sstream& CodeGenerator::generateShaderLit(io::sstream& out, ShaderType type, return out; } -io::sstream& CodeGenerator::generateShaderUnlit(io::sstream& out, ShaderType type, +io::sstream& CodeGenerator::generateShaderUnlit(io::sstream& out, ShaderStage type, filament::Variant variant, bool hasShadowMultiplier) { - if (type == ShaderType::VERTEX) { - } else if (type == ShaderType::FRAGMENT) { + if (type == ShaderStage::VERTEX) { + } else if (type == ShaderStage::FRAGMENT) { if (hasShadowMultiplier) { if (filament::Variant::isShadowReceiverVariant(variant)) { out << SHADERS_SHADOWING_FS_DATA; @@ -695,10 +695,10 @@ io::sstream& CodeGenerator::generateShaderUnlit(io::sstream& out, ShaderType typ return out; } -io::sstream& CodeGenerator::generateShaderReflections(utils::io::sstream& out, ShaderType type, +io::sstream& CodeGenerator::generateShaderReflections(utils::io::sstream& out, ShaderStage type, filament::Variant variant) { - if (type == ShaderType::VERTEX) { - } else if (type == ShaderType::FRAGMENT) { + if (type == ShaderStage::VERTEX) { + } else if (type == ShaderStage::FRAGMENT) { out << SHADERS_COMMON_LIGHTING_FS_DATA; out << SHADERS_LIGHT_REFLECTIONS_FS_DATA; out << SHADERS_SHADING_REFLECTIONS_FS_DATA; diff --git a/libs/filamat/src/shaders/CodeGenerator.h b/libs/filamat/src/shaders/CodeGenerator.h index 3127359fe0..2cfbd5e67c 100644 --- a/libs/filamat/src/shaders/CodeGenerator.h +++ b/libs/filamat/src/shaders/CodeGenerator.h @@ -42,7 +42,7 @@ namespace filamat { class UTILS_PRIVATE CodeGenerator { - using ShaderType = filament::backend::ShaderType; + using ShaderStage = filament::backend::ShaderStage; using TargetApi = MaterialBuilder::TargetApi; using TargetLanguage = MaterialBuilder::TargetLanguage; using ShaderQuality = MaterialBuilder::ShaderQuality; @@ -62,54 +62,54 @@ public: static utils::io::sstream& generateSeparator(utils::io::sstream& out); // generate prolog for the given shader - utils::io::sstream& generateProlog(utils::io::sstream& out, ShaderType type, + utils::io::sstream& generateProlog(utils::io::sstream& out, ShaderStage type, MaterialInfo const& material) const; static utils::io::sstream& generateEpilog(utils::io::sstream& out); // generate common functions for the given shader - static utils::io::sstream& generateCommon(utils::io::sstream& out, ShaderType type); - static utils::io::sstream& generatePostProcessCommon(utils::io::sstream& out, ShaderType type); - static utils::io::sstream& generateCommonMaterial(utils::io::sstream& out, ShaderType type); + static utils::io::sstream& generateCommon(utils::io::sstream& out, ShaderStage type); + static utils::io::sstream& generatePostProcessCommon(utils::io::sstream& out, ShaderStage type); + static utils::io::sstream& generateCommonMaterial(utils::io::sstream& out, ShaderStage type); - static utils::io::sstream& generateFog(utils::io::sstream& out, ShaderType type); + static utils::io::sstream& generateFog(utils::io::sstream& out, ShaderStage type); // generate the shader's main() - static utils::io::sstream& generateShaderMain(utils::io::sstream& out, ShaderType type); - static utils::io::sstream& generatePostProcessMain(utils::io::sstream& out, ShaderType type); + static utils::io::sstream& generateShaderMain(utils::io::sstream& out, ShaderStage type); + static utils::io::sstream& generatePostProcessMain(utils::io::sstream& out, ShaderStage type); // generate the shader's code for the lit shading model - static utils::io::sstream& generateShaderLit(utils::io::sstream& out, ShaderType type, + static utils::io::sstream& generateShaderLit(utils::io::sstream& out, ShaderStage type, filament::Variant variant, filament::Shading shading, bool customSurfaceShading); // generate the shader's code for the unlit shading model - static utils::io::sstream& generateShaderUnlit(utils::io::sstream& out, ShaderType type, + static utils::io::sstream& generateShaderUnlit(utils::io::sstream& out, ShaderStage type, filament::Variant variant, bool hasShadowMultiplier); // generate the shader's code for the screen-space reflections - static utils::io::sstream& generateShaderReflections(utils::io::sstream& out, ShaderType type, + static utils::io::sstream& generateShaderReflections(utils::io::sstream& out, ShaderStage type, filament::Variant variant); // generate declarations for custom interpolants - static utils::io::sstream& generateVariable(utils::io::sstream& out, ShaderType type, + static utils::io::sstream& generateVariable(utils::io::sstream& out, ShaderStage type, const utils::CString& name, size_t index); // generate declarations for non-custom "in" variables - static utils::io::sstream& generateShaderInputs(utils::io::sstream& out, ShaderType type, + static utils::io::sstream& generateShaderInputs(utils::io::sstream& out, ShaderStage type, const filament::AttributeBitset& attributes, filament::Interpolation interpolation); - static utils::io::sstream& generatePostProcessInputs(utils::io::sstream& out, ShaderType type); + static utils::io::sstream& generatePostProcessInputs(utils::io::sstream& out, ShaderStage type); // generate declarations for custom output variables - utils::io::sstream& generateOutput(utils::io::sstream& out, ShaderType type, + utils::io::sstream& generateOutput(utils::io::sstream& out, ShaderStage type, const utils::CString& name, size_t index, MaterialBuilder::VariableQualifier qualifier, MaterialBuilder::OutputType outputType) const; // generate no-op shader for depth prepass - static utils::io::sstream& generateDepthShaderMain(utils::io::sstream& out, ShaderType type); + static utils::io::sstream& generateDepthShaderMain(utils::io::sstream& out, ShaderStage type); // generate uniforms - utils::io::sstream& generateUniforms(utils::io::sstream& out, ShaderType type, + utils::io::sstream& generateUniforms(utils::io::sstream& out, ShaderStage type, filament::UniformBindingPoints binding, const filament::UniformInterfaceBlock& uib) const; // generate samplers @@ -135,15 +135,15 @@ public: utils::io::sstream& generateSpecificationConstant(utils::io::sstream& out, const char* name, uint32_t id, std::variant value) const; - static utils::io::sstream& generatePostProcessGetters(utils::io::sstream& out, ShaderType type); - static utils::io::sstream& generateGetters(utils::io::sstream& out, ShaderType type); - static utils::io::sstream& generateParameters(utils::io::sstream& out, ShaderType type); + static utils::io::sstream& generatePostProcessGetters(utils::io::sstream& out, ShaderStage type); + static utils::io::sstream& generateGetters(utils::io::sstream& out, ShaderStage type); + static utils::io::sstream& generateParameters(utils::io::sstream& out, ShaderStage type); static void fixupExternalSamplers( std::string& shader, filament::SamplerInterfaceBlock const& sib) noexcept; private: - filament::backend::Precision getDefaultPrecision(ShaderType type) const; + filament::backend::Precision getDefaultPrecision(ShaderStage type) const; filament::backend::Precision getDefaultUniformPrecision() const; static const char* getUniformPrecisionQualifier(filament::backend::UniformType type, diff --git a/libs/filamat/src/shaders/ShaderGenerator.cpp b/libs/filamat/src/shaders/ShaderGenerator.cpp index d06ee29850..6f0b860e7c 100644 --- a/libs/filamat/src/shaders/ShaderGenerator.cpp +++ b/libs/filamat/src/shaders/ShaderGenerator.cpp @@ -181,7 +181,7 @@ std::string ShaderGenerator::createVertexProgram(ShaderModel shaderModel, const CodeGenerator cg(shaderModel, targetApi, targetLanguage); const bool lit = material.isLit; - cg.generateProlog(vs, ShaderType::VERTEX, material); + cg.generateProlog(vs, ShaderStage::VERTEX, material); cg.generateQualityDefine(vs, material.quality); @@ -253,34 +253,34 @@ std::string ShaderGenerator::createVertexProgram(ShaderModel shaderModel, attributes.set(VertexAttribute::MORPH_TANGENTS_3); } } - CodeGenerator::generateShaderInputs(vs, ShaderType::VERTEX, attributes, interpolation); + CodeGenerator::generateShaderInputs(vs, ShaderStage::VERTEX, attributes, interpolation); // custom material variables size_t variableIndex = 0; for (const auto& variable : mVariables) { - CodeGenerator::generateVariable(vs, ShaderType::VERTEX, variable, variableIndex++); + CodeGenerator::generateVariable(vs, ShaderStage::VERTEX, variable, variableIndex++); } // materials defines generateVertexDomain(vs, vertexDomain); // uniforms - cg.generateUniforms(vs, ShaderType::VERTEX, + cg.generateUniforms(vs, ShaderStage::VERTEX, UniformBindingPoints::PER_VIEW, UibGenerator::getPerViewUib()); - cg.generateUniforms(vs, ShaderType::VERTEX, + cg.generateUniforms(vs, ShaderStage::VERTEX, UniformBindingPoints::PER_RENDERABLE, UibGenerator::getPerRenderableUib()); if (variant.hasSkinningOrMorphing()) { - cg.generateUniforms(vs, ShaderType::VERTEX, + cg.generateUniforms(vs, ShaderStage::VERTEX, UniformBindingPoints::PER_RENDERABLE_BONES, UibGenerator::getPerRenderableBonesUib()); - cg.generateUniforms(vs, ShaderType::VERTEX, + cg.generateUniforms(vs, ShaderStage::VERTEX, UniformBindingPoints::PER_RENDERABLE_MORPHING, UibGenerator::getPerRenderableMorphingUib()); cg.generateSamplers(vs, material.samplerBindings.getBlockOffset(SamplerBindingPoints::PER_RENDERABLE_MORPHING), SibGenerator::getPerRenderPrimitiveMorphingSib(variant)); } - cg.generateUniforms(vs, ShaderType::VERTEX, + cg.generateUniforms(vs, ShaderStage::VERTEX, UniformBindingPoints::PER_MATERIAL_INSTANCE, material.uib); CodeGenerator::generateSeparator(vs); // TODO: should we generate per-view SIB in the vertex shader? @@ -289,13 +289,13 @@ std::string ShaderGenerator::createVertexProgram(ShaderModel shaderModel, material.sib); // shader code - CodeGenerator::generateCommon(vs, ShaderType::VERTEX); - CodeGenerator::generateGetters(vs, ShaderType::VERTEX); - CodeGenerator::generateCommonMaterial(vs, ShaderType::VERTEX); + CodeGenerator::generateCommon(vs, ShaderStage::VERTEX); + CodeGenerator::generateGetters(vs, ShaderStage::VERTEX); + CodeGenerator::generateCommonMaterial(vs, ShaderStage::VERTEX); // main entry point appendShader(vs, mMaterialVertexCode, mMaterialVertexLineOffset); - CodeGenerator::generateShaderMain(vs, ShaderType::VERTEX); + CodeGenerator::generateShaderMain(vs, ShaderStage::VERTEX); CodeGenerator::generateEpilog(vs); @@ -315,7 +315,7 @@ std::string ShaderGenerator::createFragmentProgram(ShaderModel shaderModel, const bool lit = material.isLit; io::sstream fs; - cg.generateProlog(fs, ShaderType::FRAGMENT, material); + cg.generateProlog(fs, ShaderStage::FRAGMENT, material); cg.generateQualityDefine(fs, material.quality); @@ -451,28 +451,28 @@ std::string ShaderGenerator::createFragmentProgram(ShaderModel shaderModel, CodeGenerator::generateDefine(fs, "MATERIAL_HAS_CUSTOM_SURFACE_SHADING", material.hasCustomSurfaceShading); - CodeGenerator::generateShaderInputs(fs, ShaderType::FRAGMENT, material.requiredAttributes, interpolation); + CodeGenerator::generateShaderInputs(fs, ShaderStage::FRAGMENT, material.requiredAttributes, interpolation); // custom material variables size_t variableIndex = 0; for (const auto& variable : mVariables) { - CodeGenerator::generateVariable(fs, ShaderType::FRAGMENT, variable, variableIndex++); + CodeGenerator::generateVariable(fs, ShaderStage::FRAGMENT, variable, variableIndex++); } // uniforms and samplers - cg.generateUniforms(fs, ShaderType::FRAGMENT, + cg.generateUniforms(fs, ShaderStage::FRAGMENT, UniformBindingPoints::PER_VIEW, UibGenerator::getPerViewUib()); - cg.generateUniforms(fs, ShaderType::FRAGMENT, + cg.generateUniforms(fs, ShaderStage::FRAGMENT, UniformBindingPoints::PER_RENDERABLE, UibGenerator::getPerRenderableUib()); - cg.generateUniforms(fs, ShaderType::FRAGMENT, + cg.generateUniforms(fs, ShaderStage::FRAGMENT, UniformBindingPoints::LIGHTS, UibGenerator::getLightsUib()); if (litVariants && filament::Variant::isShadowReceiverVariant(variant)) { - cg.generateUniforms(fs, ShaderType::FRAGMENT, + cg.generateUniforms(fs, ShaderStage::FRAGMENT, UniformBindingPoints::SHADOW, UibGenerator::getShadowUib()); } - cg.generateUniforms(fs, ShaderType::FRAGMENT, + cg.generateUniforms(fs, ShaderStage::FRAGMENT, UniformBindingPoints::FROXEL_RECORDS, UibGenerator::getFroxelRecordUib()); - cg.generateUniforms(fs, ShaderType::FRAGMENT, + cg.generateUniforms(fs, ShaderStage::FRAGMENT, UniformBindingPoints::PER_MATERIAL_INSTANCE, material.uib); CodeGenerator::generateSeparator(fs); cg.generateSamplers(fs, @@ -485,11 +485,11 @@ std::string ShaderGenerator::createFragmentProgram(ShaderModel shaderModel, fs << "float filament_lodBias;\n"; // shading code - CodeGenerator::generateCommon(fs, ShaderType::FRAGMENT); - CodeGenerator::generateGetters(fs, ShaderType::FRAGMENT); - CodeGenerator::generateCommonMaterial(fs, ShaderType::FRAGMENT); - CodeGenerator::generateParameters(fs, ShaderType::FRAGMENT); - CodeGenerator::generateFog(fs, ShaderType::FRAGMENT); + CodeGenerator::generateCommon(fs, ShaderStage::FRAGMENT); + CodeGenerator::generateGetters(fs, ShaderStage::FRAGMENT); + CodeGenerator::generateCommonMaterial(fs, ShaderStage::FRAGMENT); + CodeGenerator::generateParameters(fs, ShaderStage::FRAGMENT); + CodeGenerator::generateFog(fs, ShaderStage::FRAGMENT); // shading model if (filament::Variant::isValidDepthVariant(variant)) { @@ -500,20 +500,20 @@ std::string ShaderGenerator::createFragmentProgram(ShaderModel shaderModel, } // these variants are special and are treated as DEPTH variants. Filament will never // request that variant for the color pass. - CodeGenerator::generateDepthShaderMain(fs, ShaderType::FRAGMENT); + CodeGenerator::generateDepthShaderMain(fs, ShaderStage::FRAGMENT); } else { appendShader(fs, mMaterialFragmentCode, mMaterialLineOffset); if (filament::Variant::isSSRVariant(variant)) { - CodeGenerator::generateShaderReflections(fs, ShaderType::FRAGMENT, variant); + CodeGenerator::generateShaderReflections(fs, ShaderStage::FRAGMENT, variant); } else if (material.isLit) { - CodeGenerator::generateShaderLit(fs, ShaderType::FRAGMENT, variant, + CodeGenerator::generateShaderLit(fs, ShaderStage::FRAGMENT, variant, material.shading,material.hasCustomSurfaceShading); } else { - CodeGenerator::generateShaderUnlit(fs, ShaderType::FRAGMENT, variant, + CodeGenerator::generateShaderUnlit(fs, ShaderStage::FRAGMENT, variant, material.hasShadowMultiplier); } // entry point - CodeGenerator::generateShaderMain(fs, ShaderType::FRAGMENT); + CodeGenerator::generateShaderMain(fs, ShaderStage::FRAGMENT); } CodeGenerator::generateEpilog(fs); @@ -535,7 +535,7 @@ std::string ShaderGenerator::createPostProcessVertexProgram(ShaderModel sm, MaterialInfo const& material, const filament::Variant::type_t variantKey) const noexcept { const CodeGenerator cg(sm, targetApi, targetLanguage); io::sstream vs; - cg.generateProlog(vs, ShaderType::VERTEX, material); + cg.generateProlog(vs, ShaderStage::VERTEX, material); cg.generateQualityDefine(vs, material.quality); @@ -544,27 +544,27 @@ std::string ShaderGenerator::createPostProcessVertexProgram(ShaderModel sm, // custom material variables size_t variableIndex = 0; for (const auto& variable : mVariables) { - CodeGenerator::generateVariable(vs, ShaderType::VERTEX, variable, variableIndex++); + CodeGenerator::generateVariable(vs, ShaderStage::VERTEX, variable, variableIndex++); } - CodeGenerator::generatePostProcessInputs(vs, ShaderType::VERTEX); + CodeGenerator::generatePostProcessInputs(vs, ShaderStage::VERTEX); generatePostProcessMaterialVariantDefines(vs, PostProcessVariant(variantKey)); - cg.generateUniforms(vs, ShaderType::VERTEX, + cg.generateUniforms(vs, ShaderStage::VERTEX, UniformBindingPoints::PER_VIEW, UibGenerator::getPerViewUib()); - cg.generateUniforms(vs, ShaderType::VERTEX, + cg.generateUniforms(vs, ShaderStage::VERTEX, UniformBindingPoints::PER_MATERIAL_INSTANCE, material.uib); cg.generateSamplers(vs, material.samplerBindings.getBlockOffset(SamplerBindingPoints::PER_MATERIAL_INSTANCE), material.sib); - CodeGenerator::generatePostProcessCommon(vs, ShaderType::VERTEX); - CodeGenerator::generatePostProcessGetters(vs, ShaderType::VERTEX); + CodeGenerator::generatePostProcessCommon(vs, ShaderStage::VERTEX); + CodeGenerator::generatePostProcessGetters(vs, ShaderStage::VERTEX); appendShader(vs, mMaterialVertexCode, mMaterialVertexLineOffset); - CodeGenerator::generatePostProcessMain(vs, ShaderType::VERTEX); + CodeGenerator::generatePostProcessMain(vs, ShaderStage::VERTEX); CodeGenerator::generateEpilog(vs); return vs.c_str(); @@ -575,7 +575,7 @@ std::string ShaderGenerator::createPostProcessFragmentProgram(ShaderModel sm, MaterialInfo const& material, uint8_t variant) const noexcept { const CodeGenerator cg(sm, targetApi, targetLanguage); io::sstream fs; - cg.generateProlog(fs, ShaderType::FRAGMENT, material); + cg.generateProlog(fs, ShaderStage::FRAGMENT, material); cg.generateQualityDefine(fs, material.quality); @@ -584,12 +584,12 @@ std::string ShaderGenerator::createPostProcessFragmentProgram(ShaderModel sm, // custom material variables size_t variableIndex = 0; for (const auto& variable : mVariables) { - CodeGenerator::generateVariable(fs, ShaderType::FRAGMENT, variable, variableIndex++); + CodeGenerator::generateVariable(fs, ShaderStage::FRAGMENT, variable, variableIndex++); } - cg.generateUniforms(fs, ShaderType::FRAGMENT, + cg.generateUniforms(fs, ShaderStage::FRAGMENT, UniformBindingPoints::PER_VIEW, UibGenerator::getPerViewUib()); - cg.generateUniforms(fs, ShaderType::FRAGMENT, + cg.generateUniforms(fs, ShaderStage::FRAGMENT, UniformBindingPoints::PER_MATERIAL_INSTANCE, material.uib); cg.generateSamplers(fs, @@ -599,13 +599,13 @@ std::string ShaderGenerator::createPostProcessFragmentProgram(ShaderModel sm, // subpass CodeGenerator::generateSubpass(fs, material.subpass); - CodeGenerator::generatePostProcessCommon(fs, ShaderType::FRAGMENT); - CodeGenerator::generatePostProcessGetters(fs, ShaderType::FRAGMENT); + CodeGenerator::generatePostProcessCommon(fs, ShaderStage::FRAGMENT); + CodeGenerator::generatePostProcessGetters(fs, ShaderStage::FRAGMENT); // Generate post-process outputs. for (const auto& output : mOutputs) { if (output.target == MaterialBuilder::OutputTarget::COLOR) { - cg.generateOutput(fs, ShaderType::FRAGMENT, output.name, output.location, + cg.generateOutput(fs, ShaderStage::FRAGMENT, output.name, output.location, output.qualifier, output.type); } if (output.target == MaterialBuilder::OutputTarget::DEPTH) { @@ -613,11 +613,11 @@ std::string ShaderGenerator::createPostProcessFragmentProgram(ShaderModel sm, } } - CodeGenerator::generatePostProcessInputs(fs, ShaderType::FRAGMENT); + CodeGenerator::generatePostProcessInputs(fs, ShaderStage::FRAGMENT); appendShader(fs, mMaterialFragmentCode, mMaterialLineOffset); - CodeGenerator::generatePostProcessMain(fs, ShaderType::FRAGMENT); + CodeGenerator::generatePostProcessMain(fs, ShaderStage::FRAGMENT); CodeGenerator::generateEpilog(fs); return fs.c_str(); } diff --git a/libs/filamat/tests/test_filamat.cpp b/libs/filamat/tests/test_filamat.cpp index 5f88ba050b..d25cca1a8c 100644 --- a/libs/filamat/tests/test_filamat.cpp +++ b/libs/filamat/tests/test_filamat.cpp @@ -44,7 +44,7 @@ static ::testing::AssertionResult PropertyListsMatch(const MaterialBuilder::Prop return ::testing::AssertionSuccess(); } -std::string shaderWithAllProperties(JobSystem& jobSystem, ShaderType type, +std::string shaderWithAllProperties(JobSystem& jobSystem, ShaderStage type, const std::string& fragmentCode, const std::string& vertexCode = "", filamat::MaterialBuilder::Shading shadingModel = filamat::MaterialBuilder::Shading::LIT, filamat::MaterialBuilder::RefractionMode refractionMode = filamat::MaterialBuilder::RefractionMode::NONE, @@ -114,12 +114,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerNothingDetected) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; EXPECT_TRUE(PropertyListsMatch(expected, properties)); } @@ -135,12 +135,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerNothingDetectedVertex) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::VERTEX, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::VERTEX, fragmentCode, vertexCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::VERTEX, shaderCode, properties); + glslTools.findProperties(ShaderStage::VERTEX, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; EXPECT_TRUE(PropertyListsMatch(expected, properties)); } @@ -157,12 +157,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerNotFollowingINParameters) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; EXPECT_TRUE(PropertyListsMatch(expected, properties)); } @@ -175,12 +175,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerDirectAssign) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::BASE_COLOR)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -198,7 +198,7 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerDirectAssignVertex) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::VERTEX, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::VERTEX, fragmentCode, vertexCode, MaterialBuilder::Shading::LIT, MaterialBuilder::RefractionMode::NONE, @@ -206,7 +206,7 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerDirectAssignVertex) { GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::VERTEX, shaderCode, properties); + glslTools.findProperties(ShaderStage::VERTEX, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::CLIP_SPACE_TRANSFORM)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -220,12 +220,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerDirectAssignWithSwizzling) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::BASE_COLOR)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -244,12 +244,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerSymbolAsOutParameterWithAliasing) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::BASE_COLOR)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -268,12 +268,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerSymbolAsOutParameterWithAliasingAndSw } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::BASE_COLOR)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -297,12 +297,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerSymbolInOutInChainWithDirectIndexInto } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::BASE_COLOR)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -326,12 +326,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerSymbolInOutInChain) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::BASE_COLOR)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -346,12 +346,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerBaseColor) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::BASE_COLOR)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -365,12 +365,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerRoughness) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::ROUGHNESS)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -384,12 +384,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerMetallic) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::METALLIC)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -403,12 +403,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerReflectance) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::REFLECTANCE)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -422,12 +422,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerAmbientOcclusion) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::AMBIENT_OCCLUSION)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -441,12 +441,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerClearCoat) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::CLEAR_COAT)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -462,14 +462,14 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerTransmission) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, fragmentCode, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode, "", filamat::MaterialBuilder::Shading::LIT, filamat::MaterialBuilder::RefractionMode::CUBEMAP); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::ABSORPTION)] = true; expected[size_t(filamat::MaterialBuilder::Property::TRANSMISSION)] = true; @@ -485,12 +485,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerClearCoatRoughness) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, fragmentCode, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode, ""); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::CLEAR_COAT_ROUGHNESS)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -505,12 +505,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerClearCoatNormal) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, fragmentCode, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode, ""); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::CLEAR_COAT)] = true; expected[size_t(filamat::MaterialBuilder::Property::CLEAR_COAT_NORMAL)] = true; @@ -525,13 +525,13 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerThickness) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, fragmentCode, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode, "", filamat::MaterialBuilder::Shading::SUBSURFACE); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::THICKNESS)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -545,13 +545,13 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerSubsurfacePower) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, fragmentCode, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode, "", filamat::MaterialBuilder::Shading::SUBSURFACE); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::SUBSURFACE_POWER)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -565,13 +565,13 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerSubsurfaceColor) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, fragmentCode, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode, "", filamat::MaterialBuilder::Shading::SUBSURFACE); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::SUBSURFACE_COLOR)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -585,12 +585,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerAnisotropicDirection) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::ANISOTROPY_DIRECTION)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -604,12 +604,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerAnisotropic) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::ANISOTROPY)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -623,13 +623,13 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerSheenColor) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, fragmentCode, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode, "", filamat::MaterialBuilder::Shading::CLOTH); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::SHEEN_COLOR)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -643,12 +643,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerSheenRoughness) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::SHEEN_ROUGHNESS)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -662,12 +662,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerNormal) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::NORMAL)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -681,12 +681,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerBentNormal) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::BENT_NORMAL)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -700,12 +700,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerOutputFactor) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::POST_LIGHTING_COLOR)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -719,12 +719,12 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerWithinInclude) { } )"); - std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderType::FRAGMENT, + std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT, fragmentCode); GLSLTools glslTools; MaterialBuilder::PropertyList properties{ false }; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected{ false }; expected[size_t(filamat::MaterialBuilder::Property::NORMAL)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); diff --git a/libs/filamat/tests/test_filamat_lite.cpp b/libs/filamat/tests/test_filamat_lite.cpp index 0d784f85d4..82c1d71f57 100644 --- a/libs/filamat/tests/test_filamat_lite.cpp +++ b/libs/filamat/tests/test_filamat_lite.cpp @@ -57,7 +57,7 @@ TEST_F(FilamatLite, StaticCodeAnalyzerNothingDetected) { GLSLToolsLite glslTools; MaterialBuilder::PropertyList properties {false}; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected {false}; EXPECT_TRUE(PropertyListsMatch(expected, properties)); } @@ -70,7 +70,7 @@ TEST_F(FilamatLite, StaticCodeAnalyzerNothingDetectedinVertex) { GLSLToolsLite glslTools; MaterialBuilder::PropertyList properties {false}; - glslTools.findProperties(ShaderType::VERTEX, shaderCode, properties); + glslTools.findProperties(ShaderStage::VERTEX, shaderCode, properties); MaterialBuilder::PropertyList expected {false}; EXPECT_TRUE(PropertyListsMatch(expected, properties)); } @@ -85,7 +85,7 @@ TEST_F(FilamatLite, StaticCodeAnalyzerDirectAssign) { GLSLToolsLite glslTools; MaterialBuilder::PropertyList properties {false}; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected {false}; expected[size_t(MaterialBuilder::Property::BASE_COLOR)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -100,7 +100,7 @@ TEST_F(FilamatLite, StaticCodeAnalyzerDirectAssignVertex) { GLSLToolsLite glslTools; MaterialBuilder::PropertyList properties {false}; - glslTools.findProperties(ShaderType::VERTEX, shaderCode, properties); + glslTools.findProperties(ShaderStage::VERTEX, shaderCode, properties); MaterialBuilder::PropertyList expected {false}; expected[size_t(MaterialBuilder::Property::CLIP_SPACE_TRANSFORM)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -118,7 +118,7 @@ TEST_F(FilamatLite, StaticCodeAnalyzerAssignMultiple) { GLSLToolsLite glslTools; MaterialBuilder::PropertyList properties {false}; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected {false}; expected[size_t(MaterialBuilder::Property::CLEAR_COAT)] = true; expected[size_t(MaterialBuilder::Property::BASE_COLOR)] = true; @@ -136,7 +136,7 @@ TEST_F(FilamatLite, StaticCodeAnalyzerDirectAssignWithSwizzling) { GLSLToolsLite glslTools; MaterialBuilder::PropertyList properties {false}; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected {false}; expected[size_t(MaterialBuilder::Property::SUBSURFACE_COLOR)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -152,7 +152,7 @@ TEST_F(FilamatLite, StaticCodeAnalyzerNoSpace) { GLSLToolsLite glslTools; MaterialBuilder::PropertyList properties {false}; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected {false}; expected[size_t(MaterialBuilder::Property::AMBIENT_OCCLUSION)] = true; EXPECT_TRUE(PropertyListsMatch(expected, properties)); @@ -171,7 +171,7 @@ TEST_F(FilamatLite, StaticCodeAnalyzerWhitespace) { GLSLToolsLite glslTools; MaterialBuilder::PropertyList properties {false}; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected {false}; expected[size_t(MaterialBuilder::Property::SUBSURFACE_COLOR)] = true; expected[size_t(MaterialBuilder::Property::AMBIENT_OCCLUSION)] = true; @@ -186,7 +186,7 @@ TEST_F(FilamatLite, StaticCodeAnalyzerEndOfShader) { GLSLToolsLite glslTools; MaterialBuilder::PropertyList properties {false}; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected {false}; EXPECT_TRUE(PropertyListsMatch(expected, properties)); } @@ -205,7 +205,7 @@ TEST_F(FilamatLite, StaticCodeAnalyzerSlashComments) { GLSLToolsLite glslTools; MaterialBuilder::PropertyList properties {false}; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected {false}; expected[size_t(MaterialBuilder::Property::METALLIC)] = true; expected[size_t(MaterialBuilder::Property::CLEAR_COAT)] = true; @@ -228,7 +228,7 @@ TEST_F(FilamatLite, StaticCodeAnalyzerMultilineComments) { GLSLToolsLite glslTools; MaterialBuilder::PropertyList properties {false}; - glslTools.findProperties(ShaderType::FRAGMENT, shaderCode, properties); + glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties); MaterialBuilder::PropertyList expected {false}; expected[size_t(MaterialBuilder::Property::METALLIC)] = true; expected[size_t(MaterialBuilder::Property::CLEAR_COAT)] = true; diff --git a/libs/matdbg/include/matdbg/ShaderExtractor.h b/libs/matdbg/include/matdbg/ShaderExtractor.h index 4dc79d2168..76503c42d2 100644 --- a/libs/matdbg/include/matdbg/ShaderExtractor.h +++ b/libs/matdbg/include/matdbg/ShaderExtractor.h @@ -34,7 +34,7 @@ public: ShaderExtractor(backend::Backend backend, const void* data, size_t size); bool parse() noexcept; bool getShader(backend::ShaderModel shaderModel, - Variant variant, backend::ShaderType stage, filaflat::ShaderContent& shader) noexcept; + Variant variant, backend::ShaderStage stage, filaflat::ShaderContent& shader) noexcept; bool getDictionary(filaflat::BlobDictionary& dictionary) noexcept; static utils::CString spirvToGLSL(const uint32_t* data, size_t wordCount); diff --git a/libs/matdbg/include/matdbg/ShaderInfo.h b/libs/matdbg/include/matdbg/ShaderInfo.h index 98b2d1f226..015025d911 100644 --- a/libs/matdbg/include/matdbg/ShaderInfo.h +++ b/libs/matdbg/include/matdbg/ShaderInfo.h @@ -30,7 +30,7 @@ namespace matdbg { struct ShaderInfo { backend::ShaderModel shaderModel; Variant variant; - backend::ShaderType pipelineStage; + backend::ShaderStage pipelineStage; uint32_t offset; }; diff --git a/libs/matdbg/include/matdbg/ShaderReplacer.h b/libs/matdbg/include/matdbg/ShaderReplacer.h index aaf2d7fc18..36b0c536ec 100644 --- a/libs/matdbg/include/matdbg/ShaderReplacer.h +++ b/libs/matdbg/include/matdbg/ShaderReplacer.h @@ -32,12 +32,12 @@ public: ShaderReplacer(backend::Backend backend, const void* data, size_t size); ~ShaderReplacer(); bool replaceShaderSource(backend::ShaderModel shaderModel, Variant variant, - backend::ShaderType stage, const char* sourceString, size_t stringLength); + backend::ShaderStage stage, const char* sourceString, size_t stringLength); const uint8_t* getEditedPackage() const; size_t getEditedSize() const; private: bool replaceSpirv(backend::ShaderModel shaderModel, Variant variant, - backend::ShaderType stage, const char* source, size_t sourceLength); + backend::ShaderStage stage, const char* source, size_t sourceLength); const backend::Backend mBackend; filaflat::ChunkContainer mOriginalPackage; filaflat::ChunkContainer* mEditedPackage = nullptr; diff --git a/libs/matdbg/src/CommonWriter.h b/libs/matdbg/src/CommonWriter.h index 3a121a0a47..d996774714 100644 --- a/libs/matdbg/src/CommonWriter.h +++ b/libs/matdbg/src/CommonWriter.h @@ -141,10 +141,10 @@ const char* toString(bool value) { } inline -const char* toString(backend::ShaderType stage) noexcept { +const char* toString(backend::ShaderStage stage) noexcept { switch (stage) { - case backend::ShaderType::VERTEX: return "vs"; - case backend::ShaderType::FRAGMENT: return "fs"; + case backend::ShaderStage::VERTEX: return "vs"; + case backend::ShaderStage::FRAGMENT: return "fs"; default: break; } return "--"; diff --git a/libs/matdbg/src/JsonWriter.cpp b/libs/matdbg/src/JsonWriter.cpp index 13ff2d413b..dfe5e3d970 100644 --- a/libs/matdbg/src/JsonWriter.cpp +++ b/libs/matdbg/src/JsonWriter.cpp @@ -123,7 +123,7 @@ static void printShaderInfo(ostream& json, const vector& info, const for (uint64_t i = 0; i < info.size(); ++i) { const auto& item = info[i]; string variantString = formatVariantString(item.variant, domain); - string ps = (item.pipelineStage == backend::ShaderType::VERTEX) ? "vertex " : "fragment"; + string ps = (item.pipelineStage == backend::ShaderStage::VERTEX) ? "vertex " : "fragment"; json << " {" << "\"index\": \"" << std::setw(2) << i << "\", " diff --git a/libs/matdbg/src/ShaderExtractor.cpp b/libs/matdbg/src/ShaderExtractor.cpp index 7ecb41b8bb..c89175ac85 100644 --- a/libs/matdbg/src/ShaderExtractor.cpp +++ b/libs/matdbg/src/ShaderExtractor.cpp @@ -70,7 +70,7 @@ bool ShaderExtractor::getDictionary(BlobDictionary& dictionary) noexcept { } bool ShaderExtractor::getShader(ShaderModel shaderModel, - Variant variant, ShaderType stage, ShaderContent& shader) noexcept { + Variant variant, ShaderStage stage, ShaderContent& shader) noexcept { ChunkContainer const& cc = mChunkContainer; if (!cc.hasChunk(mMaterialTag) || !cc.hasChunk(mDictionaryTag)) { diff --git a/libs/matdbg/src/ShaderInfo.cpp b/libs/matdbg/src/ShaderInfo.cpp index 4333727542..bb394f4de5 100644 --- a/libs/matdbg/src/ShaderInfo.cpp +++ b/libs/matdbg/src/ShaderInfo.cpp @@ -89,7 +89,7 @@ bool getMetalShaderInfo(ChunkContainer container, ShaderInfo* info) { *info++ = { .shaderModel = ShaderModel(shaderModelValue), .variant = variant, - .pipelineStage = ShaderType(pipelineStageValue), + .pipelineStage = ShaderStage(pipelineStageValue), .offset = offsetValue }; } @@ -136,7 +136,7 @@ bool getGlShaderInfo(ChunkContainer container, ShaderInfo* info) { *info++ = { .shaderModel = ShaderModel(shaderModelValue), .variant = variant, - .pipelineStage = ShaderType(pipelineStageValue), + .pipelineStage = ShaderStage(pipelineStageValue), .offset = offsetValue }; } @@ -182,7 +182,7 @@ bool getVkShaderInfo(ChunkContainer container, ShaderInfo* info) { *info++ = { .shaderModel = ShaderModel(shaderModelValue), .variant = variant, - .pipelineStage = ShaderType(pipelineStageValue), + .pipelineStage = ShaderStage(pipelineStageValue), .offset = dictionaryIndex }; } diff --git a/libs/matdbg/src/ShaderReplacer.cpp b/libs/matdbg/src/ShaderReplacer.cpp index f634e61130..940a7f5d83 100644 --- a/libs/matdbg/src/ShaderReplacer.cpp +++ b/libs/matdbg/src/ShaderReplacer.cpp @@ -61,7 +61,7 @@ public: // Replaces the specified shader text with new content. void replaceShader(backend::ShaderModel shaderModel, Variant variant, - ShaderType stage, const char* source, size_t sourceLength); + ShaderStage stage, const char* source, size_t sourceLength); bool isEmpty() const { return mShaderRecords.size() == 0; } @@ -81,7 +81,7 @@ public: // Replaces the specified shader with new content. void replaceShader(backend::ShaderModel shaderModel, Variant variant, - ShaderType stage, const char* source, size_t sourceLength); + ShaderStage stage, const char* source, size_t sourceLength); bool isEmpty() const { return mDataBlobs.size() == 0 && mShaderRecords.size() == 0; } @@ -117,7 +117,7 @@ ShaderReplacer::~ShaderReplacer() { } bool ShaderReplacer::replaceShaderSource(ShaderModel shaderModel, Variant variant, - ShaderType stage, const char* sourceString, size_t stringLength) { + ShaderStage stage, const char* sourceString, size_t stringLength) { if (!mOriginalPackage.parse()) { return false; } @@ -171,13 +171,13 @@ bool ShaderReplacer::replaceShaderSource(ShaderModel shaderModel, Variant varian } bool ShaderReplacer::replaceSpirv(ShaderModel shaderModel, Variant variant, - ShaderType stage, const char* source, size_t sourceLength) { + ShaderStage stage, const char* source, size_t sourceLength) { assert_invariant(mMaterialTag == ChunkType::MaterialSpirv); - auto getShaderStage = [](ShaderType type) { + auto getShaderStage = [](ShaderStage type) { switch (type) { - case ShaderType::VERTEX: return EShLanguage::EShLangVertex; - case ShaderType::FRAGMENT: return EShLanguage::EShLangFragment; + case ShaderStage::VERTEX: return EShLanguage::EShLangVertex; + case ShaderStage::FRAGMENT: return EShLanguage::EShLangFragment; } }; @@ -311,7 +311,7 @@ void ShaderIndex::writeChunks(ostream& stream) { } void ShaderIndex::replaceShader(backend::ShaderModel shaderModel, Variant variant, - backend::ShaderType stage, const char* source, size_t sourceLength) { + backend::ShaderStage stage, const char* source, size_t sourceLength) { const uint8_t model = uint8_t(shaderModel); for (auto& record : mShaderRecords) { if (record.shaderModel == model && record.variantKey == variant.key && @@ -381,7 +381,7 @@ void BlobIndex::writeChunks(ostream& stream) { } void BlobIndex::replaceShader(ShaderModel shaderModel, Variant variant, - ShaderType stage, const char* source, size_t sourceLength) { + ShaderStage stage, const char* source, size_t sourceLength) { const uint8_t model = (uint8_t) shaderModel; for (auto& record : mShaderRecords) { if (record.shaderModel == model && record.variantKey == variant.key &&