Scarfski/filament
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rename ShaderType to ShaderStage

Browse Source
This commit is contained in:
Mathias Agopian
2022-09-12 15:54:07 -07:00
committed by Mathias Agopian
parent 441708ea12
commit 3496f3a8ba
35 changed files with 287 additions and 287 deletions
Download Patch File Download Diff File Expand all files Collapse all files
filament/backend/include/backend/DriverEnums.h
+4 -4
View File
@@ -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));
}
}
filament/backend/include/backend/Program.h
+1 -1
View File
@@ -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
filament/backend/src/Program.cpp
+1 -1
View File
@@ -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);
filament/backend/src/metal/MetalDriver.h
+1 -1
View File
@@ -126,7 +126,7 @@ private:
inline void setRenderPrimitiveRange(Handle<HwRenderPrimitive> 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<void(const SamplerDescriptor*, size_t)>& f);
void enumerateBoundUniformBuffers(const std::function<void(const UniformBufferState&,
MetalBuffer*, uint32_t)>& f);
filament/backend/src/metal/MetalDriver.mm
+5 -5
View File
@@ -1387,7 +1387,7 @@ void MetalDriver::draw(PipelineState ps, Handle<HwRenderPrimitive> rph, uint32_t
id<MTLTexture> texturesToBindVertex[FEATURE_LEVEL_CAPS[+FeatureLevel::FEATURE_LEVEL_1].MAX_VERTEX_SAMPLER_COUNT] = {};
id<MTLSamplerState> 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<HwRenderPrimitive> rph, uint32_t
id<MTLTexture> texturesToBindFragment[FEATURE_LEVEL_CAPS[+FeatureLevel::FEATURE_LEVEL_1].MAX_FRAGMENT_SAMPLER_COUNT] = {};
id<MTLSamplerState> 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<HwTimerQuery> tqh) {
}
void MetalDriver::enumerateSamplerGroups(
const MetalProgram* program, ShaderType shaderType,
const MetalProgram* program, ShaderStage shaderType,
const std::function<void(const SamplerDescriptor*, size_t)>& 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) {
filament/backend/src/metal/MetalHandles.mm
+5 -5
View File
@@ -415,13 +415,13 @@ MetalProgram::MetalProgram(id<MTLDevice> 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<MTLDevice> 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>(shaderType))) {
if (!hasShaderType(stageFlags, static_cast<ShaderStage>(shaderType))) {
continue;
}
auto& samplers = groupData.samplers;
filament/backend/src/opengl/OpenGLProgram.cpp
+9 -9
View File
@@ -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<ShaderType>(i);
ShaderStage type = static_cast<ShaderStage>(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<ShaderType>(i);
const ShaderStage type = static_cast<ShaderStage>(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";
}
};
filament/backend/test/ShaderGenerator.cpp
+2 -2
View File
@@ -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;
}
filament/backend/test/ShaderGenerator.h
+1 -1
View File
@@ -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<char>;
static Blob transpileShader(ShaderStage stage, std::string shader, Backend backend,
filament/src/MaterialParser.cpp
+1 -1
View File
@@ -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));
}
filament/src/MaterialParser.h
+1 -1
View File
@@ -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 {
filament/src/details/Material.cpp
+4 -4
View File
@@ -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& {
libs/filamat/include/filamat/MaterialBuilder.h
+2 -2
View File
@@ -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;
libs/filamat/src/GLSLPostProcessor.cpp
+3 -3
View File
@@ -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);
}
libs/filamat/src/GLSLPostProcessor.h
+1 -1
View File
@@ -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;
libs/filamat/src/MaterialBuilder.cpp
+16 -16
View File
@@ -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<ShaderModel>(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<Va
// directives are optimized away when using the full filamat, so down below we
// explicitly remove them when using filamat lite.
std::string shader;
if (v.stage == backend::ShaderType::VERTEX) {
if (v.stage == backend::ShaderStage::VERTEX) {
shader = sg.createVertexProgram(
shaderModel, targetApi, targetLanguage, info, v.variant,
mInterpolation, mVertexDomain);
@@ -738,7 +738,7 @@ bool MaterialBuilder::generateShaders(JobSystem& jobSystem, const std::vector<Va
GLSLToolsLite glslTools;
glslTools.removeGoogleLineDirectives(shader);
#endif
} else if (v.stage == backend::ShaderType::FRAGMENT) {
} else if (v.stage == backend::ShaderStage::FRAGMENT) {
shader = sg.createFragmentProgram(
shaderModel, targetApi, targetLanguage, info, v.variant, mInterpolation);
#ifdef FILAMAT_LITE
@@ -789,8 +789,8 @@ bool MaterialBuilder::generateShaders(JobSystem& jobSystem, const std::vector<Va
// NOTE: do not execute expensive work from here on!
std::unique_lock<Mutex> 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 {
libs/filamat/src/MaterialVariants.cpp
+4 -4
View File
@@ -37,11 +37,11 @@ std::vector<Variant> 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<Variant> 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;
}
libs/filamat/src/MaterialVariants.h
+1 -1
View File
@@ -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;
libs/filamat/src/sca/GLSLTools.cpp
+5 -5
View File
@@ -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);
libs/filamat/src/sca/GLSLTools.h
+1 -1
View File
@@ -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,
libs/filamat/src/sca/GLSLToolsLite.cpp
+1 -1
View File
@@ -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()) {
libs/filamat/src/sca/GLSLToolsLite.h
+1 -1
View File
@@ -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;
libs/filamat/src/shaders/CodeGenerator.cpp
+55 -55
View File
@@ -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;
libs/filamat/src/shaders/CodeGenerator.h
+21 -21
View File
@@ -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<int, float, bool> 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,
libs/filamat/src/shaders/ShaderGenerator.cpp
+48 -48
View File
@@ -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();
}
libs/filamat/tests/test_filamat.cpp
+61 -61
View File
@@ -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));
libs/filamat/tests/test_filamat_lite.cpp
+11 -11
View File
@@ -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;
libs/matdbg/include/matdbg/ShaderExtractor.h
+1 -1
View File
@@ -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);
libs/matdbg/include/matdbg/ShaderInfo.h
+1 -1
View File
@@ -30,7 +30,7 @@ namespace matdbg {
struct ShaderInfo {
backend::ShaderModel shaderModel;
Variant variant;
backend::ShaderType pipelineStage;
backend::ShaderStage pipelineStage;
uint32_t offset;
};
libs/matdbg/include/matdbg/ShaderReplacer.h
+2 -2
View File
@@ -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;
libs/matdbg/src/CommonWriter.h
+3 -3
View File
@@ -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 "--";
libs/matdbg/src/JsonWriter.cpp
+1 -1
View File
@@ -123,7 +123,7 @@ static void printShaderInfo(ostream& json, const vector<ShaderInfo>& 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 << "\", "
libs/matdbg/src/ShaderExtractor.cpp
+1 -1
View File
@@ -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)) {
libs/matdbg/src/ShaderInfo.cpp
+3 -3
View File
@@ -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
};
}
libs/matdbg/src/ShaderReplacer.cpp
+9 -9
View File
@@ -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 &&