Function shadeMeshPixel

src/rendering/raster_rendering_engine.cpp:1329–1419

        }

        [[nodiscard]] glm::vec3 shadeMeshPixel(const lfs::core::MeshData& mesh,
                                               const size_t material_index,
                                               const MeshRenderOptions& options,
                                               const glm::vec3& world_position,
                                               glm::vec3 normal,
                                               const glm::vec3& tangent,
                                               const float tangent_handedness,
                                               const glm::vec2& texcoord,
                                               const glm::vec4& vertex_color,
                                               const glm::vec3& camera_position,
                                               const glm::vec3& light_dir,
                                               const SoftwareShadowMap& shadow_map) {
            const auto& material = meshMaterialOrDefault(mesh, material_index);

            glm::vec4 albedo = material.base_color;
            if (mesh.has_texcoords() &&
                material.has_albedo_texture() &&
                material.albedo_tex > 0 &&
                material.albedo_tex <= mesh.texture_images.size()) {
                const auto sample = sampleTextureBilinear(mesh.texture_images[material.albedo_tex - 1u],
                                                          texcoord.x, texcoord.y);
                albedo *= glm::vec4(srgbToLinear(glm::vec3(sample)), sample.a);
            }
            albedo *= vertex_color;

            float metallic = material.metallic;
            float roughness = material.roughness;
            float ao = material.ao;
            if (mesh.has_texcoords() &&
                material.has_metallic_roughness_texture() &&
                material.metallic_roughness_tex > 0 &&
                material.metallic_roughness_tex <= mesh.texture_images.size()) {
                const glm::vec3 orm = glm::vec3(sampleTextureBilinear(
                    mesh.texture_images[material.metallic_roughness_tex - 1u],
                    texcoord.x, texcoord.y));
                ao *= orm.r;
                roughness *= orm.g;
                metallic *= orm.b;
            }
            roughness = std::max(roughness, 0.04f);

            normal = safeNormalize(normal, glm::vec3(0.0f, 1.0f, 0.0f));
            if (mesh.has_texcoords() &&
                material.has_normal_texture() &&
                material.normal_tex > 0 &&
                material.normal_tex <= mesh.texture_images.size()) {
                const glm::vec3 normal_sample = glm::vec3(sampleTextureBilinear(
                                                    mesh.texture_images[material.normal_tex - 1u],
                                                    texcoord.x, texcoord.y)) *
                                                    2.0f -
                                                glm::vec3(1.0f);
                const glm::vec3 t = safeNormalize(tangent, glm::vec3(1.0f, 0.0f, 0.0f));
                const glm::vec3 b = safeNormalize(glm::cross(normal, t) * tangent_handedness,
                                                  glm::vec3(0.0f, 1.0f, 0.0f));
                normal = safeNormalize(glm::mat3(t, b, normal) * normal_sample, normal);
            }

            const glm::vec3 view_dir = safeNormalize(camera_position - world_position, glm::vec3(0.0f, 0.0f, 1.0f));