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

Refactor: Rename shader snippets w/ new naming convention (see README.md) (#8402)

Browse Source 
This commit renames all shader snippet files to conform to the newly
introduced naming convention outlined in README.md.

The new naming convention uses a `prefix_name.suffix` format to clearly
indicate the purpose and target shader stage of each snippet. This
improves the overall organization and readability of the shader code,
making it easier to understand how each snippet contributes to the
shader generation process.

No functional changes were made to the shader code itself or source
code. This is purely a refactoring for clarity and maintainability.
This commit is contained in:
Sungun Park
2025-01-30 16:02:53 -08:00
committed by GitHub
parent f1c1aa155b
commit 87bdf96449
54 changed files with 262 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
filament/CMakeLists.txt
View File

@@ -385,16 +385,16 @@ endforeach()
add_custom_command(
OUTPUT "${MATERIAL_DIR}/colorGrading.filamat"
DEPENDS ../shaders/src/dithering.fs
DEPENDS ../shaders/src/vignette.fs
DEPENDS ../shaders/src/inline_dithering.fs
DEPENDS ../shaders/src/inline_vignette.fs
DEPENDS src/materials/colorGrading/colorGrading.fs
APPEND
)
add_custom_command(
OUTPUT "${MATERIAL_DIR}/colorGradingAsSubpass.filamat"
DEPENDS ../shaders/src/dithering.fs
DEPENDS ../shaders/src/vignette.fs
DEPENDS ../shaders/src/inline_dithering.fs
DEPENDS ../shaders/src/inline_vignette.fs
DEPENDS src/materials/colorGrading/colorGrading.fs
APPEND
)

2
filament/backend/include/backend/DriverEnums.h
View File

@@ -1302,7 +1302,7 @@ enum class Workaround : uint16_t {
// for some uniform arrays, it's needed to do an initialization to avoid crash on adreno gpu
ADRENO_UNIFORM_ARRAY_CRASH,
// Workaround a Metal pipeline compilation error with the message:
// "Could not statically determine the target of a texture". See light_indirect.fs
// "Could not statically determine the target of a texture". See surface_light_indirect.fs
METAL_STATIC_TEXTURE_TARGET_ERROR,
// Adreno drivers sometimes aren't able to blit into a layer of a texture array.
DISABLE_BLIT_INTO_TEXTURE_ARRAY,

4
filament/backend/src/metal/MetalDriver.mm
View File

@@ -1134,8 +1134,8 @@ FeatureLevel MetalDriver::getFeatureLevel() {
math::float2 MetalDriver::getClipSpaceParams() {
// virtual and physical z-coordinate of clip-space is in [-w, 0]
// Note: this is actually never used (see: main.vs), but it's a backend API so we implement it
// properly.
// Note: this is actually never used (see: surface_main.vs), but it's a backend API so we
// implement it properly.
return math::float2{ 1.0f, 0.0f };
}

4
filament/backend/src/vulkan/VulkanDriver.cpp
View File

@@ -1091,8 +1091,8 @@ FeatureLevel VulkanDriver::getFeatureLevel() {
math::float2 VulkanDriver::getClipSpaceParams() {
// virtual and physical z-coordinate of clip-space is in [-w, 0]
// Note: this is actually never used (see: main.vs), but it's a backend API, so we implement it
// properly.
// Note: this is actually never used (see: surface_main.vs), but it's a backend API, so we
// implement it properly.
return math::float2{ 1.0f, 0.0f };
}

2
filament/src/PostProcessManager.cpp
View File

@@ -2661,7 +2661,7 @@ void PostProcessManager::TaaJitterCamera(
// update projection matrix
inoutCameraInfo->projection[2].xy -= jitterInClipSpace;
// VERTEX_DOMAIN_DEVICE doesn't apply the projection, but it still needs this
// clip transform, so we apply it separately (see main.vs)
// clip transform, so we apply it separately (see surface_main.vs)
inoutCameraInfo->clipTransform.zw -= jitterInClipSpace;
}

6
filament/src/ShadowMap.cpp
View File

@@ -253,7 +253,7 @@ ShadowMap::ShaderParameters ShadowMap::updateDirectional(FEngine& engine,
// The model matrix below is in fact inverted to get the view matrix and passed to the
// shader as 'viewFromWorldMatrix', and is used in the VSM case to compute the depth metric.
// (see depth_main.fs). Note that in the case of VSM, 'b' below is identity.
// (see surface_depth_main.fs). Note that in the case of VSM, 'b' below is identity.
mCamera->setModelMatrix(FCamera::rigidTransformInverse(highPrecisionMultiplyd(Mv, b)));
mCamera->setCustomProjection(mat4(Mn * F * WLMp), znear, zfar);
@@ -315,7 +315,7 @@ ShadowMap::ShaderParameters ShadowMap::updatePunctual(
// The model matrix below is in fact inverted to get the view matrix and passed to the
// shader as 'viewFromWorldMatrix', and is used in the VSM case to compute the depth metric.
// (see depth_main.fs). Note that in the case of VSM, 'b' below is identity.
// (see surface_depth_main.fs). Note that in the case of VSM, 'b' below is identity.
mCamera->setModelMatrix(FCamera::rigidTransformInverse(highPrecisionMultiplyd(Mv, b)));
mCamera->setCustomProjection(highPrecisionMultiplyd(Mn, Mp), nearPlane, farPlane);
@@ -719,7 +719,7 @@ mat4f ShadowMap::computeVsmLightSpaceMatrix(const mat4f& lightSpacePcf,
// For VSM, we want to leave the z coordinate in linear light-space, normalized between [0, 1],
// i.e. remapping [near, far] to [0, 1].
// When sampling a VSM shadow map, the shader follows suit, and doesn't divide by w for the z
// coordinate. See shadowing.fs.
// coordinate. See surface_shadowing.fs.
// compute z' = -(Mv * position).z / (far - near) - (near / (far - near))
const float scale = 1.0f / (zfar - znear);
mat4f lightSpaceVsm{ lightSpacePcf };

2
filament/src/details/MorphTargetBuffer.cpp
View File

@@ -66,7 +66,7 @@ MorphTargetBuffer* MorphTargetBuffer::Builder::build(Engine& engine) {
// ------------------------------------------------------------------------------------------------
// This value is limited by ES3.0, ES3.0 only guarantees 2048.
// When you change this value, you must change MAX_MORPH_TARGET_BUFFER_WIDTH at getters.vs
// When you change this value, you must change MAX_MORPH_TARGET_BUFFER_WIDTH at surface_getters.vs
constexpr size_t MAX_MORPH_TARGET_BUFFER_WIDTH = 2048;
static inline size_t getWidth(size_t const vertexCount) noexcept {

2
filament/src/details/Renderer.cpp
View File

@@ -781,7 +781,7 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
cameraInfo.projection = highPrecisionMultiply(ts, cameraInfo.projection);
// VERTEX_DOMAIN_DEVICE doesn't apply the projection, but it still needs this
// clip transform, so we apply it separately (see main.vs)
// clip transform, so we apply it separately (see surface_main.vs)
cameraInfo.clipTransform = { ts[0][0], ts[1][1], ts[3].x, ts[3].y };
// adjust svp to the new, larger, rendering dimensions

2
filament/src/details/SkinningBuffer.cpp
View File

@@ -174,7 +174,7 @@ void FSkinningBuffer::setBones(FEngine& engine, Handle<HwBufferObject> handle,
}
// This value is limited by ES3.0, ES3.0 only guarantees 2048.
// When you change this value, you must change MAX_SKINNING_BUFFER_WIDTH at getters.vs
// When you change this value, you must change MAX_SKINNING_BUFFER_WIDTH at surface_getters.vs
constexpr size_t MAX_SKINNING_BUFFER_WIDTH = 2048;
static inline size_t getSkinningBufferWidth(size_t const pairCount) noexcept {

4
filament/src/materials/colorGrading/colorGrading.mat
View File

@@ -83,8 +83,8 @@ vertex {
fragment {
#include "../../../../shaders/src/dithering.fs"
#include "../../../../shaders/src/vignette.fs"
#include "../../../../shaders/src/inline_dithering.fs"
#include "../../../../shaders/src/inline_vignette.fs"
#include "colorGrading.fs"
void dummy(){}

4
filament/src/materials/colorGrading/colorGradingAsSubpass.mat
View File

@@ -71,8 +71,8 @@ vertex {
fragment {
#include "../../../../shaders/src/dithering.fs"
#include "../../../../shaders/src/vignette.fs"
#include "../../../../shaders/src/inline_dithering.fs"
#include "../../../../shaders/src/inline_vignette.fs"
#include "colorGrading.fs"
void dummy(){}

2
libs/filamat/include/filamat/MaterialBuilder.h
View File

@@ -727,7 +727,7 @@ public:
static constexpr size_t MAX_DEPTH_OUTPUT = 1;
static_assert(MAX_COLOR_OUTPUT == 8,
"When updating MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT, manually update post_process_inputs.fs"
" and post_process.fs");
" and post_process_main.fs");
// Preview the first shader generated by the given CodeGenParams.
// This is used to run Static Code Analysis before generating a package.

12
libs/filamat/src/MaterialBuilder.cpp
View File

@@ -937,15 +937,15 @@ bool MaterialBuilder::generateShaders(JobSystem& jobSystem, const std::vector<Va
// explicitly remove them when using filamat lite.
std::string shader;
if (v.stage == backend::ShaderStage::VERTEX) {
shader = sg.createVertexProgram(
shader = sg.createSurfaceVertexProgram(
shaderModel, targetApi, targetLanguage, featureLevel,
info, v.variant, mInterpolation, mVertexDomain);
} else if (v.stage == backend::ShaderStage::FRAGMENT) {
shader = sg.createFragmentProgram(
shader = sg.createSurfaceFragmentProgram(
shaderModel, targetApi, targetLanguage, featureLevel,
info, v.variant, mInterpolation, mVariantFilter);
} else if (v.stage == backend::ShaderStage::COMPUTE) {
shader = sg.createComputeProgram(
shader = sg.createSurfaceComputeProgram(
shaderModel, targetApi, targetLanguage, featureLevel,
info);
}
@@ -1438,15 +1438,15 @@ std::string MaterialBuilder::peek(backend::ShaderStage stage,
switch (stage) {
case backend::ShaderStage::VERTEX:
return sg.createVertexProgram(
return sg.createSurfaceVertexProgram(
params.shaderModel, params.targetApi, params.targetLanguage,
params.featureLevel, info, {}, mInterpolation, mVertexDomain);
case backend::ShaderStage::FRAGMENT:
return sg.createFragmentProgram(
return sg.createSurfaceFragmentProgram(
params.shaderModel, params.targetApi, params.targetLanguage,
params.featureLevel, info, {}, mInterpolation, mVariantFilter);
case backend::ShaderStage::COMPUTE:
return sg.createComputeProgram(
return sg.createSurfaceComputeProgram(
params.shaderModel, params.targetApi, params.targetLanguage,
params.featureLevel, info);
}

169
libs/filamat/src/shaders/CodeGenerator.cpp
View File

@@ -42,7 +42,7 @@ io::sstream& CodeGenerator::generateSeparator(io::sstream& out) {
return out;
}
utils::io::sstream& CodeGenerator::generateProlog(utils::io::sstream& out, ShaderStage stage,
utils::io::sstream& CodeGenerator::generateCommonProlog(utils::io::sstream& out, ShaderStage stage,
MaterialInfo const& material, filament::Variant v) const {
switch (mShaderModel) {
case ShaderModel::MOBILE:
@@ -324,7 +324,7 @@ utils::io::sstream& CodeGenerator::generateProlog(utils::io::sstream& out, Shade
+ReservedSpecializationConstants::CONFIG_DEBUG_FROXEL_VISUALIZATION, false);
// Workaround a Metal pipeline compilation error with the message:
// "Could not statically determine the target of a texture". See light_indirect.fs
// "Could not statically determine the target of a texture". See surface_light_indirect.fs
generateSpecializationConstant(out, "CONFIG_STATIC_TEXTURE_TARGET_WORKAROUND",
+ReservedSpecializationConstants::CONFIG_STATIC_TEXTURE_TARGET_WORKAROUND, false);
@@ -409,21 +409,21 @@ Precision CodeGenerator::getDefaultUniformPrecision() const {
}
}
io::sstream& CodeGenerator::generateEpilog(io::sstream& out) {
io::sstream& CodeGenerator::generateCommonEpilog(io::sstream& out) {
out << "\n"; // For line compression all shaders finish with a newline character.
return out;
}
io::sstream& CodeGenerator::generateCommonTypes(io::sstream& out, ShaderStage stage) {
io::sstream& CodeGenerator::generateSurfaceTypes(io::sstream& out, ShaderStage stage) {
out << '\n';
switch (stage) {
case ShaderStage::VERTEX:
out << '\n';
out << SHADERS_COMMON_TYPES_GLSL_DATA;
out << SHADERS_SURFACE_TYPES_GLSL_DATA;
break;
case ShaderStage::FRAGMENT:
out << '\n';
out << SHADERS_COMMON_TYPES_GLSL_DATA;
out << SHADERS_SURFACE_TYPES_GLSL_DATA;
break;
case ShaderStage::COMPUTE:
break;
@@ -431,31 +431,31 @@ io::sstream& CodeGenerator::generateCommonTypes(io::sstream& out, ShaderStage st
return out;
}
io::sstream& CodeGenerator::generateShaderMain(io::sstream& out, ShaderStage stage) {
io::sstream& CodeGenerator::generateSurfaceMain(io::sstream& out, ShaderStage stage) {
switch (stage) {
case ShaderStage::VERTEX:
out << SHADERS_MAIN_VS_DATA;
out << SHADERS_SURFACE_MAIN_VS_DATA;
break;
case ShaderStage::FRAGMENT:
out << SHADERS_MAIN_FS_DATA;
out << SHADERS_SURFACE_MAIN_FS_DATA;
break;
case ShaderStage::COMPUTE:
out << SHADERS_MAIN_CS_DATA;
out << SHADERS_SURFACE_MAIN_CS_DATA;
break;
}
return out;
}
io::sstream& CodeGenerator::generatePostProcessMain(io::sstream& out, ShaderStage type) {
if (type == ShaderStage::VERTEX) {
out << SHADERS_POST_PROCESS_VS_DATA;
} else if (type == ShaderStage::FRAGMENT) {
out << SHADERS_POST_PROCESS_FS_DATA;
io::sstream& CodeGenerator::generatePostProcessMain(io::sstream& out, ShaderStage stage) {
if (stage == ShaderStage::VERTEX) {
out << SHADERS_POST_PROCESS_MAIN_VS_DATA;
} else if (stage == ShaderStage::FRAGMENT) {
out << SHADERS_POST_PROCESS_MAIN_FS_DATA;
}
return out;
}
io::sstream& CodeGenerator::generateVariable(io::sstream& out, ShaderStage stage,
io::sstream& CodeGenerator::generateCommonVariable(io::sstream& out, ShaderStage stage,
const MaterialBuilder::CustomVariable& variable, size_t index) {
auto const& name = variable.name;
const char* precisionString = getPrecisionQualifier(variable.precision);
@@ -475,7 +475,7 @@ io::sstream& CodeGenerator::generateVariable(io::sstream& out, ShaderStage stage
return out;
}
io::sstream& CodeGenerator::generateShaderInputs(io::sstream& out, ShaderStage type,
io::sstream& CodeGenerator::generateSurfaceShaderInputs(io::sstream& out, ShaderStage stage,
const AttributeBitset& attributes, Interpolation interpolation,
MaterialBuilder::PushConstantList const& pushConstants) const {
auto const& attributeDatabase = MaterialBuilder::getAttributeDatabase();
@@ -488,7 +488,7 @@ io::sstream& CodeGenerator::generateShaderInputs(io::sstream& out, ShaderStage t
generateDefine(out, attributeDatabase[i].getDefineName().c_str(), true);
});
if (type == ShaderStage::VERTEX) {
if (stage == ShaderStage::VERTEX) {
out << "\n";
attributes.forEachSetBit([&out, &attributeDatabase, this](size_t i) {
auto const& attribute = attributeDatabase[i];
@@ -507,16 +507,16 @@ io::sstream& CodeGenerator::generateShaderInputs(io::sstream& out, ShaderStage t
}
out << "\n";
out << SHADERS_VARYINGS_GLSL_DATA;
out << SHADERS_SURFACE_VARYINGS_GLSL_DATA;
return out;
}
io::sstream& CodeGenerator::generateOutput(io::sstream& out, ShaderStage type,
io::sstream& CodeGenerator::generateOutput(io::sstream& out, ShaderStage stage,
const CString& name, size_t index,
MaterialBuilder::VariableQualifier qualifier,
MaterialBuilder::Precision precision,
MaterialBuilder::OutputType outputType) const {
if (name.empty() || type == ShaderStage::VERTEX) {
if (name.empty() || stage == ShaderStage::VERTEX) {
return out;
}
@@ -577,10 +577,10 @@ io::sstream& CodeGenerator::generateOutput(io::sstream& out, ShaderStage type,
}
io::sstream& CodeGenerator::generateDepthShaderMain(io::sstream& out, ShaderStage type) {
assert(type != ShaderStage::VERTEX);
if (type == ShaderStage::FRAGMENT) {
out << SHADERS_DEPTH_MAIN_FS_DATA;
io::sstream& CodeGenerator::generateSurfaceDepthMain(io::sstream& out, ShaderStage stage) {
assert(stage != ShaderStage::VERTEX);
if (stage == ShaderStage::FRAGMENT) {
out << SHADERS_SURFACE_DEPTH_MAIN_FS_DATA;
}
return out;
}
@@ -776,7 +776,7 @@ io::sstream& CodeGenerator::generateBufferInterfaceBlock(io::sstream& out, Shade
return out;
}
io::sstream& CodeGenerator::generateSamplers(utils::io::sstream& out,
io::sstream& CodeGenerator::generateCommonSamplers(utils::io::sstream& out,
filament::DescriptorSetBindingPoints set,
filament::SamplerInterfaceBlock::SamplerInfoList const& list) const {
if (list.empty()) {
@@ -825,7 +825,7 @@ io::sstream& CodeGenerator::generateSamplers(utils::io::sstream& out,
return out;
}
io::sstream& CodeGenerator::generateSubpass(io::sstream& out, SubpassInfo subpass) {
io::sstream& CodeGenerator::generatePostProcessSubpass(io::sstream& out, SubpassInfo subpass) {
if (!subpass.isValid) {
return out;
}
@@ -1013,21 +1013,19 @@ io::sstream& CodeGenerator::generateQualityDefine(io::sstream& out, ShaderQualit
return out;
}
io::sstream& CodeGenerator::generateCommon(io::sstream& out, ShaderStage stage) {
io::sstream& CodeGenerator::generateSurfaceCommon(io::sstream& out, ShaderStage stage) {
out << SHADERS_COMMON_MATH_GLSL_DATA;
switch (stage) {
case ShaderStage::VERTEX:
out << SHADERS_COMMON_INSTANCING_GLSL_DATA;
out << SHADERS_COMMON_SHADOWING_GLSL_DATA;
out << SHADERS_SURFACE_INSTANCING_GLSL_DATA;
out << SHADERS_SURFACE_SHADOWING_GLSL_DATA;
break;
case ShaderStage::FRAGMENT:
out << SHADERS_COMMON_INSTANCING_GLSL_DATA;
out << SHADERS_COMMON_SHADOWING_GLSL_DATA;
out << SHADERS_SURFACE_INSTANCING_GLSL_DATA;
out << SHADERS_SURFACE_SHADOWING_GLSL_DATA;
out << SHADERS_COMMON_SHADING_FS_DATA;
out << SHADERS_COMMON_GRAPHICS_FS_DATA;
out << SHADERS_COMMON_MATERIAL_FS_DATA;
out << SHADERS_SURFACE_MATERIAL_FS_DATA;
break;
case ShaderStage::COMPUTE:
out << '\n';
@@ -1037,89 +1035,87 @@ io::sstream& CodeGenerator::generateCommon(io::sstream& out, ShaderStage stage)
return out;
}
io::sstream& CodeGenerator::generatePostProcessCommon(io::sstream& out, ShaderStage type) {
io::sstream& CodeGenerator::generatePostProcessCommon(io::sstream& out, ShaderStage stage) {
out << SHADERS_COMMON_MATH_GLSL_DATA;
if (type == ShaderStage::VERTEX) {
} else if (type == ShaderStage::FRAGMENT) {
if (stage == ShaderStage::VERTEX) {
} else if (stage == ShaderStage::FRAGMENT) {
out << SHADERS_COMMON_SHADING_FS_DATA;
out << SHADERS_COMMON_GRAPHICS_FS_DATA;
}
return out;
}
io::sstream& CodeGenerator::generateFog(io::sstream& out, ShaderStage type) {
if (type == ShaderStage::VERTEX) {
} else if (type == ShaderStage::FRAGMENT) {
out << SHADERS_FOG_FS_DATA;
io::sstream& CodeGenerator::generateSurfaceFog(io::sstream& out, ShaderStage stage) {
if (stage == ShaderStage::VERTEX) {
} else if (stage == ShaderStage::FRAGMENT) {
out << SHADERS_SURFACE_FOG_FS_DATA;
}
return out;
}
io::sstream& CodeGenerator::generateCommonMaterial(io::sstream& out, ShaderStage type) {
if (type == ShaderStage::VERTEX) {
out << SHADERS_MATERIAL_INPUTS_VS_DATA;
} else if (type == ShaderStage::FRAGMENT) {
out << SHADERS_MATERIAL_INPUTS_FS_DATA;
io::sstream& CodeGenerator::generateSurfaceMaterial(io::sstream& out, ShaderStage stage) {
if (stage == ShaderStage::VERTEX) {
out << SHADERS_SURFACE_MATERIAL_INPUTS_VS_DATA;
} else if (stage == ShaderStage::FRAGMENT) {
out << SHADERS_SURFACE_MATERIAL_INPUTS_FS_DATA;
}
return out;
}
io::sstream& CodeGenerator::generatePostProcessInputs(io::sstream& out, ShaderStage type) {
if (type == ShaderStage::VERTEX) {
io::sstream& CodeGenerator::generatePostProcessInputs(io::sstream& out, ShaderStage stage) {
if (stage == ShaderStage::VERTEX) {
out << SHADERS_POST_PROCESS_INPUTS_VS_DATA;
} else if (type == ShaderStage::FRAGMENT) {
} else if (stage == ShaderStage::FRAGMENT) {
out << SHADERS_POST_PROCESS_INPUTS_FS_DATA;
}
return out;
}
io::sstream& CodeGenerator::generatePostProcessGetters(io::sstream& out, ShaderStage type) {
io::sstream& CodeGenerator::generatePostProcessGetters(io::sstream& out, ShaderStage stage) {
out << SHADERS_COMMON_GETTERS_GLSL_DATA;
if (type == ShaderStage::VERTEX) {
if (stage == ShaderStage::VERTEX) {
out << SHADERS_POST_PROCESS_GETTERS_VS_DATA;
} else if (type == ShaderStage::FRAGMENT) {
} else if (stage == ShaderStage::FRAGMENT) {
}
return out;
}
io::sstream& CodeGenerator::generateGetters(io::sstream& out, ShaderStage stage) {
io::sstream& CodeGenerator::generateSurfaceGetters(io::sstream& out, ShaderStage stage) {
out << SHADERS_COMMON_GETTERS_GLSL_DATA;
switch (stage) {
case ShaderStage::VERTEX:
out << SHADERS_GETTERS_VS_DATA;
out << SHADERS_SURFACE_GETTERS_VS_DATA;
break;
case ShaderStage::FRAGMENT:
out << SHADERS_GETTERS_FS_DATA;
out << SHADERS_SURFACE_GETTERS_FS_DATA;
break;
case ShaderStage::COMPUTE:
out << SHADERS_GETTERS_CS_DATA;
out << SHADERS_SURFACE_GETTERS_CS_DATA;
break;
}
return out;
}
io::sstream& CodeGenerator::generateParameters(io::sstream& out, ShaderStage type) {
if (type == ShaderStage::VERTEX) {
} else if (type == ShaderStage::FRAGMENT) {
out << SHADERS_SHADING_PARAMETERS_FS_DATA;
io::sstream& CodeGenerator::generateSurfaceParameters(io::sstream& out, ShaderStage stage) {
if (stage == ShaderStage::FRAGMENT) {
out << SHADERS_SURFACE_SHADING_PARAMETERS_FS_DATA;
}
return out;
}
io::sstream& CodeGenerator::generateShaderLit(io::sstream& out, ShaderStage type,
io::sstream& CodeGenerator::generateSurfaceLit(io::sstream& out, ShaderStage stage,
filament::Variant variant, Shading shading, bool customSurfaceShading) {
if (type == ShaderStage::VERTEX) {
} else if (type == ShaderStage::FRAGMENT) {
out << SHADERS_COMMON_LIGHTING_FS_DATA;
if (stage == ShaderStage::FRAGMENT) {
out << SHADERS_SURFACE_LIGHTING_FS_DATA;
if (filament::Variant::isShadowReceiverVariant(variant)) {
out << SHADERS_SHADOWING_FS_DATA;
out << SHADERS_SURFACE_SHADOWING_FS_DATA;
}
// the only reason we have this assert here is that we used to have a check,
// which seemed unnecessary.
assert_invariant(shading != Shading::UNLIT);
out << SHADERS_BRDF_FS_DATA;
out << SHADERS_SURFACE_BRDF_FS_DATA;
switch (shading) {
case Shading::UNLIT:
// can't happen
@@ -1127,54 +1123,53 @@ io::sstream& CodeGenerator::generateShaderLit(io::sstream& out, ShaderStage type
case Shading::SPECULAR_GLOSSINESS:
case Shading::LIT:
if (customSurfaceShading) {
out << SHADERS_SHADING_LIT_CUSTOM_FS_DATA;
out << SHADERS_SURFACE_SHADING_LIT_CUSTOM_FS_DATA;
} else {
out << SHADERS_SHADING_MODEL_STANDARD_FS_DATA;
out << SHADERS_SURFACE_SHADING_MODEL_STANDARD_FS_DATA;
}
break;
case Shading::SUBSURFACE:
out << SHADERS_SHADING_MODEL_SUBSURFACE_FS_DATA;
out << SHADERS_SURFACE_SHADING_MODEL_SUBSURFACE_FS_DATA;
break;
case Shading::CLOTH:
out << SHADERS_SHADING_MODEL_CLOTH_FS_DATA;
out << SHADERS_SURFACE_SHADING_MODEL_CLOTH_FS_DATA;
break;
}
out << SHADERS_AMBIENT_OCCLUSION_FS_DATA;
out << SHADERS_LIGHT_INDIRECT_FS_DATA;
out << SHADERS_SURFACE_AMBIENT_OCCLUSION_FS_DATA;
out << SHADERS_SURFACE_LIGHT_INDIRECT_FS_DATA;
if (variant.hasDirectionalLighting()) {
out << SHADERS_LIGHT_DIRECTIONAL_FS_DATA;
out << SHADERS_SURFACE_LIGHT_DIRECTIONAL_FS_DATA;
}
if (variant.hasDynamicLighting()) {
out << SHADERS_LIGHT_PUNCTUAL_FS_DATA;
out << SHADERS_SURFACE_LIGHT_PUNCTUAL_FS_DATA;
}
out << SHADERS_SHADING_LIT_FS_DATA;
out << SHADERS_SURFACE_SHADING_LIT_FS_DATA;
}
return out;
}
io::sstream& CodeGenerator::generateShaderUnlit(io::sstream& out, ShaderStage type,
io::sstream& CodeGenerator::generateSurfaceUnlit(io::sstream& out, ShaderStage stage,
filament::Variant variant, bool hasShadowMultiplier) {
if (type == ShaderStage::VERTEX) {
} else if (type == ShaderStage::FRAGMENT) {
if (stage == ShaderStage::FRAGMENT) {
if (hasShadowMultiplier) {
if (filament::Variant::isShadowReceiverVariant(variant)) {
out << SHADERS_SHADOWING_FS_DATA;
out << SHADERS_SURFACE_SHADOWING_FS_DATA;
}
}
out << SHADERS_SHADING_UNLIT_FS_DATA;
out << SHADERS_SURFACE_SHADING_UNLIT_FS_DATA;
}
return out;
}
io::sstream& CodeGenerator::generateShaderReflections(utils::io::sstream& out, ShaderStage type) {
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;
io::sstream& CodeGenerator::generateSurfaceReflections(utils::io::sstream& out,
ShaderStage stage) {
if (stage == ShaderStage::FRAGMENT) {
out << SHADERS_SURFACE_LIGHTING_FS_DATA;
out << SHADERS_SURFACE_LIGHT_REFLECTIONS_FS_DATA;
out << SHADERS_SURFACE_SHADING_REFLECTIONS_FS_DATA;
}
return out;
}

48
libs/filamat/src/shaders/CodeGenerator.h
View File

@@ -75,68 +75,68 @@ public:
static utils::io::sstream& generateSeparator(utils::io::sstream& out);
// generate prolog for the given shader
utils::io::sstream& generateProlog(utils::io::sstream& out, ShaderStage stage,
utils::io::sstream& generateCommonProlog(utils::io::sstream& out, ShaderStage stage,
MaterialInfo const& material, filament::Variant v) const;
static utils::io::sstream& generateEpilog(utils::io::sstream& out);
static utils::io::sstream& generateCommonEpilog(utils::io::sstream& out);
static utils::io::sstream& generateCommonTypes(utils::io::sstream& out, ShaderStage stage);
static utils::io::sstream& generateSurfaceTypes(utils::io::sstream& out, ShaderStage stage);
// generate common functions for the given shader
static utils::io::sstream& generateCommon(utils::io::sstream& out, ShaderStage stage);
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& generateSurfaceCommon(utils::io::sstream& out, ShaderStage stage);
static utils::io::sstream& generatePostProcessCommon(utils::io::sstream& out, ShaderStage stage);
static utils::io::sstream& generateSurfaceMaterial(utils::io::sstream& out, ShaderStage stage);
static utils::io::sstream& generateFog(utils::io::sstream& out, ShaderStage type);
static utils::io::sstream& generateSurfaceFog(utils::io::sstream& out, ShaderStage stage);
// generate the shader's main()
static utils::io::sstream& generateShaderMain(utils::io::sstream& out, ShaderStage stage);
static utils::io::sstream& generatePostProcessMain(utils::io::sstream& out, ShaderStage type);
static utils::io::sstream& generateSurfaceMain(utils::io::sstream& out, ShaderStage stage);
static utils::io::sstream& generatePostProcessMain(utils::io::sstream& out, ShaderStage stage);
// generate the shader's code for the lit shading model
static utils::io::sstream& generateShaderLit(utils::io::sstream& out, ShaderStage type,
static utils::io::sstream& generateSurfaceLit(utils::io::sstream& out, ShaderStage stage,
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, ShaderStage type,
static utils::io::sstream& generateSurfaceUnlit(utils::io::sstream& out, ShaderStage stage,
filament::Variant variant, bool hasShadowMultiplier);
// generate the shader's code for the screen-space reflections
static utils::io::sstream& generateShaderReflections(utils::io::sstream& out, ShaderStage type);
static utils::io::sstream& generateSurfaceReflections(utils::io::sstream& out, ShaderStage stage);
// generate declarations for custom interpolants
static utils::io::sstream& generateVariable(utils::io::sstream& out, ShaderStage stage,
static utils::io::sstream& generateCommonVariable(utils::io::sstream& out, ShaderStage stage,
const MaterialBuilder::CustomVariable& variable, size_t index);
// generate declarations for non-custom "in" variables
utils::io::sstream& generateShaderInputs(utils::io::sstream& out, ShaderStage type,
utils::io::sstream& generateSurfaceShaderInputs(utils::io::sstream& out, ShaderStage stage,
const filament::AttributeBitset& attributes, filament::Interpolation interpolation,
MaterialBuilder::PushConstantList const& pushConstants) const;
static utils::io::sstream& generatePostProcessInputs(utils::io::sstream& out, ShaderStage type);
static utils::io::sstream& generatePostProcessInputs(utils::io::sstream& out, ShaderStage stage);
// generate declarations for custom output variables
utils::io::sstream& generateOutput(utils::io::sstream& out, ShaderStage type,
utils::io::sstream& generateOutput(utils::io::sstream& out, ShaderStage stage,
const utils::CString& name, size_t index,
MaterialBuilder::VariableQualifier qualifier,
MaterialBuilder::Precision precision,
MaterialBuilder::OutputType outputType) const;
// generate no-op shader for depth prepass
static utils::io::sstream& generateDepthShaderMain(utils::io::sstream& out, ShaderStage type);
static utils::io::sstream& generateSurfaceDepthMain(utils::io::sstream& out, ShaderStage stage);
// generate samplers
utils::io::sstream& generateSamplers(utils::io::sstream& out,
utils::io::sstream& generateCommonSamplers(utils::io::sstream& out,
filament::DescriptorSetBindingPoints set,
filament::SamplerInterfaceBlock::SamplerInfoList const& list) const;
utils::io::sstream& generateSamplers(utils::io::sstream& out,
utils::io::sstream& generateCommonSamplers(utils::io::sstream& out,
filament::DescriptorSetBindingPoints set,
const filament::SamplerInterfaceBlock& sib) const {
return generateSamplers(out, set, sib.getSamplerInfoList());
return generateCommonSamplers(out, set, sib.getSamplerInfoList());
}
// generate subpass
static utils::io::sstream& generateSubpass(utils::io::sstream& out,
static utils::io::sstream& generatePostProcessSubpass(utils::io::sstream& out,
filament::SubpassInfo subpass);
// generate uniforms
@@ -174,9 +174,9 @@ public:
MaterialBuilder::PushConstantList const& pushConstants,
size_t const layoutLocation) const;
static utils::io::sstream& generatePostProcessGetters(utils::io::sstream& out, ShaderStage type);
static utils::io::sstream& generateGetters(utils::io::sstream& out, ShaderStage stage);
static utils::io::sstream& generateParameters(utils::io::sstream& out, ShaderStage type);
static utils::io::sstream& generatePostProcessGetters(utils::io::sstream& out, ShaderStage stage);
static utils::io::sstream& generateSurfaceGetters(utils::io::sstream& out, ShaderStage stage);
static utils::io::sstream& generateSurfaceParameters(utils::io::sstream& out, ShaderStage stage);
static void fixupExternalSamplers(
std::string& shader, filament::SamplerInterfaceBlock const& sib,

95
libs/filamat/src/shaders/ShaderGenerator.cpp
View File

@@ -370,7 +370,7 @@ void ShaderGenerator::fixupExternalSamplers(ShaderModel sm, std::string& shader,
}
}
std::string ShaderGenerator::createVertexProgram(ShaderModel shaderModel,
std::string ShaderGenerator::createSurfaceVertexProgram(ShaderModel shaderModel,
MaterialBuilder::TargetApi targetApi, MaterialBuilder::TargetLanguage targetLanguage,
MaterialBuilder::FeatureLevel featureLevel,
MaterialInfo const& material, const filament::Variant variant, Interpolation interpolation,
@@ -389,7 +389,7 @@ std::string ShaderGenerator::createVertexProgram(ShaderModel shaderModel,
const CodeGenerator cg(shaderModel, targetApi, targetLanguage, featureLevel);
cg.generateProlog(vs, ShaderStage::VERTEX, material, variant);
cg.generateCommonProlog(vs, ShaderStage::VERTEX, material, variant);
generateUserSpecConstants(cg, vs, mConstants);
@@ -436,15 +436,15 @@ std::string ShaderGenerator::createVertexProgram(ShaderModel shaderModel,
[](MaterialBuilder::PushConstant const& constant) {
return constant.stage == ShaderStage::VERTEX;
});
cg.generateShaderInputs(vs, ShaderStage::VERTEX, attributes, interpolation,
cg.generateSurfaceShaderInputs(vs, ShaderStage::VERTEX, attributes, interpolation,
vertexPushConstants);
CodeGenerator::generateCommonTypes(vs, ShaderStage::VERTEX);
CodeGenerator::generateSurfaceTypes(vs, ShaderStage::VERTEX);
// custom material variables
size_t variableIndex = 0;
for (const auto& variable : mVariables) {
CodeGenerator::generateVariable(vs, ShaderStage::VERTEX, variable, variableIndex++);
CodeGenerator::generateCommonVariable(vs, ShaderStage::VERTEX, variable, variableIndex++);
}
// materials defines
@@ -478,7 +478,7 @@ std::string ShaderGenerator::createVertexProgram(ShaderModel shaderModel,
DescriptorSetBindingPoints::PER_RENDERABLE,
+PerRenderableBindingPoints::MORPHING_UNIFORMS,
UibGenerator::getPerRenderableMorphingUib());
cg.generateSamplers(vs, DescriptorSetBindingPoints::PER_RENDERABLE,
cg.generateCommonSamplers(vs, DescriptorSetBindingPoints::PER_RENDERABLE,
SibGenerator::getPerRenderableSib(variant));
}
@@ -489,23 +489,23 @@ std::string ShaderGenerator::createVertexProgram(ShaderModel shaderModel,
CodeGenerator::generateSeparator(vs);
cg.generateSamplers(vs, DescriptorSetBindingPoints::PER_MATERIAL, material.sib);
cg.generateCommonSamplers(vs, DescriptorSetBindingPoints::PER_MATERIAL, material.sib);
// shader code
CodeGenerator::generateCommon(vs, ShaderStage::VERTEX);
CodeGenerator::generateGetters(vs, ShaderStage::VERTEX);
CodeGenerator::generateCommonMaterial(vs, ShaderStage::VERTEX);
CodeGenerator::generateSurfaceCommon(vs, ShaderStage::VERTEX);
CodeGenerator::generateSurfaceGetters(vs, ShaderStage::VERTEX);
CodeGenerator::generateSurfaceMaterial(vs, ShaderStage::VERTEX);
// main entry point
appendShader(vs, mMaterialVertexCode, mMaterialVertexLineOffset);
CodeGenerator::generateShaderMain(vs, ShaderStage::VERTEX);
CodeGenerator::generateSurfaceMain(vs, ShaderStage::VERTEX);
CodeGenerator::generateEpilog(vs);
CodeGenerator::generateCommonEpilog(vs);
return vs.c_str();
}
std::string ShaderGenerator::createFragmentProgram(ShaderModel shaderModel,
std::string ShaderGenerator::createSurfaceFragmentProgram(ShaderModel shaderModel,
MaterialBuilder::TargetApi targetApi, MaterialBuilder::TargetLanguage targetLanguage,
MaterialBuilder::FeatureLevel featureLevel,
MaterialInfo const& material, const filament::Variant variant,
@@ -522,7 +522,7 @@ std::string ShaderGenerator::createFragmentProgram(ShaderModel shaderModel,
const CodeGenerator cg(shaderModel, targetApi, targetLanguage, featureLevel);
io::sstream fs;
cg.generateProlog(fs, ShaderStage::FRAGMENT, material, variant);
cg.generateCommonProlog(fs, ShaderStage::FRAGMENT, material, variant);
generateUserSpecConstants(cg, fs, mConstants);
@@ -546,15 +546,15 @@ std::string ShaderGenerator::createFragmentProgram(ShaderModel shaderModel,
[](MaterialBuilder::PushConstant const& constant) {
return constant.stage == ShaderStage::FRAGMENT;
});
cg.generateShaderInputs(fs, ShaderStage::FRAGMENT, material.requiredAttributes, interpolation,
cg.generateSurfaceShaderInputs(fs, ShaderStage::FRAGMENT, material.requiredAttributes, interpolation,
fragmentPushConstants);
CodeGenerator::generateCommonTypes(fs, ShaderStage::FRAGMENT);
CodeGenerator::generateSurfaceTypes(fs, ShaderStage::FRAGMENT);
// custom material variables
size_t variableIndex = 0;
for (const auto& variable : mVariables) {
CodeGenerator::generateVariable(fs, ShaderStage::FRAGMENT, variable, variableIndex++);
CodeGenerator::generateCommonVariable(fs, ShaderStage::FRAGMENT, variable, variableIndex++);
}
// uniforms and samplers
@@ -626,21 +626,21 @@ std::string ShaderGenerator::createFragmentProgram(ShaderModel shaderModel,
return pos == perViewDescriptorSetLayout.bindings.end();
}), list.end());
cg.generateSamplers(fs, DescriptorSetBindingPoints::PER_VIEW, list);
cg.generateCommonSamplers(fs, DescriptorSetBindingPoints::PER_VIEW, list);
}
cg.generateSamplers(fs, DescriptorSetBindingPoints::PER_MATERIAL, material.sib);
cg.generateCommonSamplers(fs, DescriptorSetBindingPoints::PER_MATERIAL, material.sib);
fs << "float filament_lodBias;\n";
// shading code
CodeGenerator::generateCommon(fs, ShaderStage::FRAGMENT);
CodeGenerator::generateGetters(fs, ShaderStage::FRAGMENT);
CodeGenerator::generateCommonMaterial(fs, ShaderStage::FRAGMENT);
CodeGenerator::generateParameters(fs, ShaderStage::FRAGMENT);
CodeGenerator::generateSurfaceCommon(fs, ShaderStage::FRAGMENT);
CodeGenerator::generateSurfaceGetters(fs, ShaderStage::FRAGMENT);
CodeGenerator::generateSurfaceMaterial(fs, ShaderStage::FRAGMENT);
CodeGenerator::generateSurfaceParameters(fs, ShaderStage::FRAGMENT);
if (filament::Variant::isFogVariant(variant)) {
CodeGenerator::generateFog(fs, ShaderStage::FRAGMENT);
CodeGenerator::generateSurfaceFog(fs, ShaderStage::FRAGMENT);
}
// shading model
@@ -656,30 +656,30 @@ 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, ShaderStage::FRAGMENT);
CodeGenerator::generateSurfaceDepthMain(fs, ShaderStage::FRAGMENT);
} else {
appendShader(fs, mMaterialFragmentCode, mMaterialLineOffset);
if (material.isLit) {
if (filament::Variant::isSSRVariant(variant)) {
CodeGenerator::generateShaderReflections(fs, ShaderStage::FRAGMENT);
CodeGenerator::generateSurfaceReflections(fs, ShaderStage::FRAGMENT);
} else {
CodeGenerator::generateShaderLit(fs, ShaderStage::FRAGMENT, variant,
CodeGenerator::generateSurfaceLit(fs, ShaderStage::FRAGMENT, variant,
material.shading,material.hasCustomSurfaceShading);
}
} else {
CodeGenerator::generateShaderUnlit(fs, ShaderStage::FRAGMENT, variant,
CodeGenerator::generateSurfaceUnlit(fs, ShaderStage::FRAGMENT, variant,
material.hasShadowMultiplier);
}
// entry point
CodeGenerator::generateShaderMain(fs, ShaderStage::FRAGMENT);
CodeGenerator::generateSurfaceMain(fs, ShaderStage::FRAGMENT);
}
CodeGenerator::generateEpilog(fs);
CodeGenerator::generateCommonEpilog(fs);
return fs.c_str();
}
std::string ShaderGenerator::createComputeProgram(filament::backend::ShaderModel shaderModel,
std::string ShaderGenerator::createSurfaceComputeProgram(filament::backend::ShaderModel shaderModel,
MaterialBuilder::TargetApi targetApi, MaterialBuilder::TargetLanguage targetLanguage,
MaterialBuilder::FeatureLevel featureLevel,
MaterialInfo const& material) const noexcept {
@@ -688,11 +688,11 @@ std::string ShaderGenerator::createComputeProgram(filament::backend::ShaderModel
const CodeGenerator cg(shaderModel, targetApi, targetLanguage, featureLevel);
io::sstream s;
cg.generateProlog(s, ShaderStage::COMPUTE, material, {});
cg.generateCommonProlog(s, ShaderStage::COMPUTE, material, {});
generateUserSpecConstants(cg, s, mConstants);
CodeGenerator::generateCommonTypes(s, ShaderStage::COMPUTE);
CodeGenerator::generateSurfaceTypes(s, ShaderStage::COMPUTE);
cg.generateUniforms(s, ShaderStage::COMPUTE,
DescriptorSetBindingPoints::PER_VIEW,
@@ -704,22 +704,21 @@ std::string ShaderGenerator::createComputeProgram(filament::backend::ShaderModel
+PerMaterialBindingPoints::MATERIAL_PARAMS,
material.uib);
cg.generateSamplers(s, DescriptorSetBindingPoints::PER_MATERIAL, material.sib);
cg.generateCommonSamplers(s, DescriptorSetBindingPoints::PER_MATERIAL, material.sib);
// generate SSBO
cg.generateBuffers(s, material.buffers);
// TODO: generate images
CodeGenerator::generateCommon(s, ShaderStage::COMPUTE);
CodeGenerator::generateGetters(s, ShaderStage::COMPUTE);
CodeGenerator::generateSurfaceCommon(s, ShaderStage::COMPUTE);
CodeGenerator::generateSurfaceGetters(s, ShaderStage::COMPUTE);
appendShader(s, mMaterialFragmentCode, mMaterialLineOffset);
CodeGenerator::generateShaderMain(s, ShaderStage::COMPUTE);
CodeGenerator::generateSurfaceMain(s, ShaderStage::COMPUTE);
CodeGenerator::generateEpilog(s);
CodeGenerator::generateCommonEpilog(s);
return s.c_str();
}
@@ -729,7 +728,7 @@ std::string ShaderGenerator::createPostProcessVertexProgram(ShaderModel sm,
MaterialInfo const& material, const filament::Variant::type_t variantKey) const noexcept {
const CodeGenerator cg(sm, targetApi, targetLanguage, featureLevel);
io::sstream vs;
cg.generateProlog(vs, ShaderStage::VERTEX, material, {});
cg.generateCommonProlog(vs, ShaderStage::VERTEX, material, {});
generateUserSpecConstants(cg, vs, mConstants);
@@ -738,7 +737,7 @@ std::string ShaderGenerator::createPostProcessVertexProgram(ShaderModel sm,
// custom material variables
size_t variableIndex = 0;
for (const auto& variable : mVariables) {
CodeGenerator::generateVariable(vs, ShaderStage::VERTEX, variable, variableIndex++);
CodeGenerator::generateCommonVariable(vs, ShaderStage::VERTEX, variable, variableIndex++);
}
CodeGenerator::generatePostProcessInputs(vs, ShaderStage::VERTEX);
@@ -754,7 +753,7 @@ std::string ShaderGenerator::createPostProcessVertexProgram(ShaderModel sm,
+PerMaterialBindingPoints::MATERIAL_PARAMS,
material.uib);
cg.generateSamplers(vs, DescriptorSetBindingPoints::PER_MATERIAL, material.sib);
cg.generateCommonSamplers(vs, DescriptorSetBindingPoints::PER_MATERIAL, material.sib);
CodeGenerator::generatePostProcessCommon(vs, ShaderStage::VERTEX);
CodeGenerator::generatePostProcessGetters(vs, ShaderStage::VERTEX);
@@ -763,7 +762,7 @@ std::string ShaderGenerator::createPostProcessVertexProgram(ShaderModel sm,
CodeGenerator::generatePostProcessMain(vs, ShaderStage::VERTEX);
CodeGenerator::generateEpilog(vs);
CodeGenerator::generateCommonEpilog(vs);
return vs.c_str();
}
@@ -773,7 +772,7 @@ std::string ShaderGenerator::createPostProcessFragmentProgram(ShaderModel sm,
MaterialInfo const& material, uint8_t variant) const noexcept {
const CodeGenerator cg(sm, targetApi, targetLanguage, featureLevel);
io::sstream fs;
cg.generateProlog(fs, ShaderStage::FRAGMENT, material, {});
cg.generateCommonProlog(fs, ShaderStage::FRAGMENT, material, {});
generateUserSpecConstants(cg, fs, mConstants);
@@ -782,7 +781,7 @@ std::string ShaderGenerator::createPostProcessFragmentProgram(ShaderModel sm,
// custom material variables
size_t variableIndex = 0;
for (const auto& variable : mVariables) {
CodeGenerator::generateVariable(fs, ShaderStage::FRAGMENT, variable, variableIndex++);
CodeGenerator::generateCommonVariable(fs, ShaderStage::FRAGMENT, variable, variableIndex++);
}
cg.generateUniforms(fs, ShaderStage::FRAGMENT,
@@ -795,10 +794,10 @@ std::string ShaderGenerator::createPostProcessFragmentProgram(ShaderModel sm,
+PerMaterialBindingPoints::MATERIAL_PARAMS,
material.uib);
cg.generateSamplers(fs, DescriptorSetBindingPoints::PER_MATERIAL, material.sib);
cg.generateCommonSamplers(fs, DescriptorSetBindingPoints::PER_MATERIAL, material.sib);
// subpass
CodeGenerator::generateSubpass(fs, material.subpass);
CodeGenerator::generatePostProcessSubpass(fs, material.subpass);
CodeGenerator::generatePostProcessCommon(fs, ShaderStage::FRAGMENT);
CodeGenerator::generatePostProcessGetters(fs, ShaderStage::FRAGMENT);
@@ -819,7 +818,7 @@ std::string ShaderGenerator::createPostProcessFragmentProgram(ShaderModel sm,
appendShader(fs, mMaterialFragmentCode, mMaterialLineOffset);
CodeGenerator::generatePostProcessMain(fs, ShaderStage::FRAGMENT);
CodeGenerator::generateEpilog(fs);
CodeGenerator::generateCommonEpilog(fs);
return fs.c_str();
}

6
libs/filamat/src/shaders/ShaderGenerator.h
View File

@@ -58,21 +58,21 @@ public:
size_t vertexLineOffset,
MaterialBuilder::MaterialDomain materialDomain) noexcept;
std::string createVertexProgram(filament::backend::ShaderModel shaderModel,
std::string createSurfaceVertexProgram(filament::backend::ShaderModel shaderModel,
MaterialBuilder::TargetApi targetApi, MaterialBuilder::TargetLanguage targetLanguage,
MaterialBuilder::FeatureLevel featureLevel,
MaterialInfo const& material, filament::Variant variant,
filament::Interpolation interpolation,
filament::VertexDomain vertexDomain) const noexcept;
std::string createFragmentProgram(filament::backend::ShaderModel shaderModel,
std::string createSurfaceFragmentProgram(filament::backend::ShaderModel shaderModel,
MaterialBuilder::TargetApi targetApi, MaterialBuilder::TargetLanguage targetLanguage,
MaterialBuilder::FeatureLevel featureLevel,
MaterialInfo const& material, filament::Variant variant,
filament::Interpolation interpolation,
filament::UserVariantFilterMask variantFilter) const noexcept;
std::string createComputeProgram(filament::backend::ShaderModel shaderModel,
std::string createSurfaceComputeProgram(filament::backend::ShaderModel shaderModel,
MaterialBuilder::TargetApi targetApi, MaterialBuilder::TargetLanguage targetLanguage,
MaterialBuilder::FeatureLevel featureLevel,
MaterialInfo const& material) const noexcept;

70
shaders/CMakeLists.txt
View File

@@ -11,48 +11,48 @@ endif()
# Sources and headers
# ==================================================================================================
set(SHADERS
src/ambient_occlusion.fs
src/brdf.fs
src/surface_ambient_occlusion.fs
src/surface_brdf.fs
src/common_defines.glsl
src/common_getters.glsl
src/common_instancing.glsl
src/surface_instancing.glsl
src/common_graphics.fs
src/common_lighting.fs
src/common_material.fs
src/surface_lighting.fs
src/surface_material.fs
src/common_math.glsl
src/common_shading.fs
src/common_shadowing.glsl
src/common_types.glsl
src/depth_main.fs
src/fog.fs
src/getters.cs
src/getters.fs
src/getters.vs
src/light_directional.fs
src/light_indirect.fs
src/light_reflections.fs
src/light_punctual.fs
src/main.cs
src/main.fs
src/main.vs
src/material_inputs.fs
src/material_inputs.vs
src/post_process.fs
src/post_process.vs
src/surface_shadowing.glsl
src/surface_types.glsl
src/surface_depth_main.fs
src/surface_fog.fs
src/surface_getters.cs
src/surface_getters.fs
src/surface_getters.vs
src/surface_light_directional.fs
src/surface_light_indirect.fs
src/surface_light_reflections.fs
src/surface_light_punctual.fs
src/surface_main.cs
src/surface_main.fs
src/surface_main.vs
src/surface_material_inputs.fs
src/surface_material_inputs.vs
src/post_process_main.fs
src/post_process_main.vs
src/post_process_getters.vs
src/post_process_inputs.fs
src/post_process_inputs.vs
src/shading_lit.fs
src/shading_lit_custom.fs
src/shading_model_cloth.fs
src/shading_model_standard.fs
src/shading_model_subsurface.fs
src/shading_parameters.fs
src/shading_reflections.fs
src/shading_unlit.fs
src/shadowing.fs
src/varyings.glsl
src/vignette.fs
src/surface_shading_lit.fs
src/surface_shading_lit_custom.fs
src/surface_shading_model_cloth.fs
src/surface_shading_model_standard.fs
src/surface_shading_model_subsurface.fs
src/surface_shading_parameters.fs
src/surface_shading_reflections.fs
src/surface_shading_unlit.fs
src/surface_shadowing.fs
src/surface_varyings.glsl
src/inline_vignette.fs
)
# These files aren't part of libshaders, but are included by materials inside
@@ -60,7 +60,7 @@ set(SHADERS
#
# tone_mapping.fs
# conversion_functions.fs
# dithering.fs
# inline_dithering.fs
set(MINIFIED_DIR ${CMAKE_CURRENT_BINARY_DIR}/minified)

34
shaders/src/README.md Normal file
View File

@@ -0,0 +1,34 @@
# Shader Code Directory
This directory contains GLSL (OpenGL Shading Language) code snippets, organized by their function and stage in the graphics pipeline. These snippets are designed to be used as **building blocks** by the **Shader Generator** within this project. Instead of being compiled directly, these snippets are combined and processed to generate complete, functional shader programs for various purposes.
## File Naming Convention
Shader files within this directory follow a consistent naming convention to easily identify their purpose and usage:
`prefix_name.suffix`
### Prefixes
The prefix indicates the domain or category of the shader code:
* **`surface`:** Snippets with this prefix are intended for use in **surface shaders**. Surface shaders define the visual properties of object surfaces, handling aspects like lighting, texturing, and material properties.
* **`post_process`:** Snippets with this prefix are used in **post-processing shaders**. Post-processing shaders operate on the entire rendered image after the main rendering pass to achieve effects such as blur, bloom, color correction, and more.
* **`common`:** Snippets with this prefix contain **shared code** that can be used by **both** `surface` and `post_process` shaders. This includes utility functions, common data structures, and reusable logic, promoting modularity and reducing code duplication.
* **`inline`:** Snippets with this prefix are **specifically designed to be directly included within other shader files** during the generation process. They often contain reusable functions or macros that need to be present in the final shader code but not necessarily categorized as `surface` or `post_process`.
### Suffixes (Extensions)
The suffix (file extension) specifies the **shader stage** that the code snippet is intended for:
* **`.vs`:** Files with this extension contain code snippets for **vertex shaders**. Vertex shaders operate on individual vertices and are typically used to transform vertex positions, calculate normals, and pass data to the fragment shader.
* **`.fs`:** Files with this extension contain code snippets for **fragment shaders**. Fragment shaders, also known as pixel shaders, determine the final color of each pixel. They are used for lighting, texturing, and other per-pixel operations.
* **`.cs`:** Files with this extension contain code snippets for **compute shaders**. Compute shaders are used for general-purpose computation on the GPU, outside the traditional rendering pipeline. They can be used for tasks like physics simulations, image processing, and more. (Currently not implemented yet)
* **`.glsl`:** Files with this extension contain **reusable GLSL code snippets, including functions, structures, or constants**, that are intended to be included or linked into multiple shader stages (vertex, fragment, or compute). This is a generic extension to signify that the file does not belong exclusively to a single shader stage.
## Example
* `surface_light_directional.fs`: Fragment shader snippets for objects using the directional lighting model.
* `post_process_getters.vs`: Vertex shader snippets containing reusable getter functions for post-processing shaders.
* `common_math.glsl`: GLSL code with reusable math constants and functions shared by both surface and post-processing shaders.

0
shaders/src/dithering.fs → shaders/src/inline_dithering.fs
View File

0
shaders/src/vignette.fs → shaders/src/inline_vignette.fs
View File

0
shaders/src/post_process.fs → shaders/src/post_process_main.fs
View File

0
shaders/src/post_process.vs → shaders/src/post_process_main.vs
View File

0
shaders/src/ambient_occlusion.fs → shaders/src/surface_ambient_occlusion.fs
View File

0
shaders/src/brdf.fs → shaders/src/surface_brdf.fs
View File

4
shaders/src/depth_main.fs → shaders/src/surface_depth_main.fs
View File

@@ -40,7 +40,7 @@ void main() {
#endif
#if defined(MATERIAL_HAS_TRANSPARENT_SHADOW)
// Interleaved gradient noise, see dithering.fs
// Interleaved gradient noise, see inline_dithering.fs
float noise = interleavedGradientNoise(gl_FragCoord.xy);
if (noise >= alpha) {
discard;
@@ -49,7 +49,7 @@ void main() {
#endif
#if defined(VARIANT_HAS_VSM)
// interpolated depth is stored in vertex_worldPosition.w (see main.vs)
// interpolated depth is stored in vertex_worldPosition.w (see surface_main.vs)
// we always compute the "negative" side of ELVSM because the cost is small, and this allows
// EVSM/ELVSM choice to be done on the CPU side more easily.
highp float depth = vertex_worldPosition.w;

0
shaders/src/fog.fs → shaders/src/surface_fog.fs
View File

0
shaders/src/getters.cs → shaders/src/surface_getters.cs
View File

0
shaders/src/getters.fs → shaders/src/surface_getters.fs
View File

0
shaders/src/getters.vs → shaders/src/surface_getters.vs
View File

0
shaders/src/common_instancing.glsl → shaders/src/surface_instancing.glsl
View File

0
shaders/src/light_directional.fs → shaders/src/surface_light_directional.fs
View File

0
shaders/src/light_indirect.fs → shaders/src/surface_light_indirect.fs
View File

2
shaders/src/light_punctual.fs → shaders/src/surface_light_punctual.fs
View File

@@ -115,7 +115,7 @@ float getAngleAttenuation(const highp vec3 lightDir, const highp vec3 l, const h
}
/**
* Returns a Light structure (see common_lighting.fs) describing a point or spot light.
* Returns a Light structure (see surface_lighting.fs) describing a point or spot light.
* The colorIntensity field will store the *pre-exposed* intensity of the light
* in the w component.
*

0
shaders/src/light_reflections.fs → shaders/src/surface_light_reflections.fs
View File

0
shaders/src/common_lighting.fs → shaders/src/surface_lighting.fs
View File

0
shaders/src/main.cs → shaders/src/surface_main.cs
View File

4
shaders/src/main.fs → shaders/src/surface_main.fs
View File

@@ -43,11 +43,11 @@ void main() {
initObjectUniforms();
// See shading_parameters.fs
// See surface_shading_parameters.fs
// Computes global variables we need to evaluate material and lighting
computeShadingParams();
// Initialize the inputs to sensible default values, see material_inputs.fs
// Initialize the inputs to sensible default values, see surface_material_inputs.fs
MaterialInputs inputs;
initMaterial(inputs);

2
shaders/src/main.vs → shaders/src/surface_main.vs
View File

@@ -33,7 +33,7 @@ void main() {
initObjectUniforms();
// Initialize the inputs to sensible default values, see material_inputs.vs
// Initialize the inputs to sensible default values, see surface_material_inputs.vs
#if defined(USE_OPTIMIZED_DEPTH_VERTEX_SHADER)
// In USE_OPTIMIZED_DEPTH_VERTEX_SHADER mode, we can even skip this if we're already in

0
shaders/src/common_material.fs → shaders/src/surface_material.fs
View File

0
shaders/src/material_inputs.fs → shaders/src/surface_material_inputs.fs
View File

0
shaders/src/material_inputs.vs → shaders/src/surface_material_inputs.vs
View File

0
shaders/src/shading_lit.fs → shaders/src/surface_shading_lit.fs
View File

0
shaders/src/shading_lit_custom.fs → shaders/src/surface_shading_lit_custom.fs
View File

0
shaders/src/shading_model_cloth.fs → shaders/src/surface_shading_model_cloth.fs
View File

4
shaders/src/shading_model_standard.fs → shaders/src/surface_shading_model_standard.fs
View File

@@ -91,7 +91,7 @@ vec3 diffuseLobe(const PixelParams pixel, float NoV, float NoL, float LoH) {
* Surface BRDF
* The surface BRDF uses a diffuse lobe and a specular lobe to render both
* dielectrics and conductors. The specular lobe is based on the Cook-Torrance
* micro-facet model (see brdf.fs for more details). In addition, the specular
* micro-facet model (see surface_brdf.fs for more details). In addition, the specular
* can be either isotropic or anisotropic.
*
* Clear coat BRDF
@@ -99,7 +99,7 @@ vec3 diffuseLobe(const PixelParams pixel, float NoV, float NoL, float LoH) {
* top of the surface. Its IOR is set to 1.5 (polyutherane) to simplify
* our computations. This BRDF only contains a specular lobe and while based
* on the Cook-Torrance microfacet model, it uses cheaper terms than the surface
* BRDF's specular lobe (see brdf.fs).
* BRDF's specular lobe (see surface_brdf.fs).
*/
vec3 surfaceShading(const PixelParams pixel, const Light light, float occlusion) {
vec3 h = normalize(shading_view + light.l);

2
shaders/src/shading_model_subsurface.fs → shaders/src/surface_shading_model_subsurface.fs
View File

@@ -1,6 +1,6 @@
/**
* Evalutes lit materials with the subsurface shading model. This model is a
* combination of a BRDF (the same used in shading_model_standard.fs, refer to that
* combination of a BRDF (the same used in surface_shading_model_standard.fs, refer to that
* file for more information) and of an approximated BTDF to simulate subsurface
* scattering. The BTDF itself is not physically based and does not represent a
* correct interpretation of transmission events.

0
shaders/src/shading_parameters.fs → shaders/src/surface_shading_parameters.fs
View File

0
shaders/src/shading_reflections.fs → shaders/src/surface_shading_reflections.fs
View File

0
shaders/src/shading_unlit.fs → shaders/src/surface_shading_unlit.fs
View File

0
shaders/src/shadowing.fs → shaders/src/surface_shadowing.fs
View File

0
shaders/src/common_shadowing.glsl → shaders/src/surface_shadowing.glsl
View File

0
shaders/src/common_types.glsl → shaders/src/surface_types.glsl
View File

2
shaders/src/varyings.glsl → shaders/src/surface_varyings.glsl
View File

@@ -32,7 +32,7 @@ LAYOUT_LOCATION(10) VARYING highp vec4 vertex_uv01;
LAYOUT_LOCATION(11) VARYING highp vec4 vertex_lightSpacePosition;
#endif
// Note that fragColor is an output and is not declared here; see main.fs and depth_main.fs
// Note that fragColor is an output and is not declared here; see surface_main.fs and surface_depth_main.fs
#if defined(VARIANT_HAS_STEREO) && defined(FILAMENT_STEREO_INSTANCED)
#if defined(GL_ES) && defined(FILAMENT_GLSLANG)