Function sampleShadow

src/rendering/raster_rendering_engine.cpp:1288–1327

        }

        [[nodiscard]] float sampleShadow(const SoftwareShadowMap& shadow,
                                         const glm::vec3& world_position,
                                         const float bias = 0.0025f) {
            if (!shadow.active || shadow.size <= 0 || shadow.depth.empty()) {
                return 1.0f;
            }

            const glm::vec4 clip = shadow.light_vp * glm::vec4(world_position, 1.0f);
            if (std::abs(clip.w) <= 1.0e-6f) {
                return 1.0f;
            }
            glm::vec3 proj = glm::vec3(clip) / clip.w;
            proj = proj * 0.5f + 0.5f;
            if (proj.z < 0.0f || proj.z > 1.0f ||
                proj.x < 0.0f || proj.x > 1.0f ||
                proj.y < 0.0f || proj.y > 1.0f) {
                return 1.0f;
            }

            const float sx = proj.x * static_cast<float>(shadow.size - 1);
            const float sy = proj.y * static_cast<float>(shadow.size - 1);
            const int ix = static_cast<int>(std::round(sx));
            const int iy = static_cast<int>(std::round(sy));
            float lit = 0.0f;
            int samples = 0;
            for (int dy = -1; dy <= 1; ++dy) {
                for (int dx = -1; dx <= 1; ++dx) {
                    const int x = ix + dx;
                    const int y = iy + dy;
                    if (x < 0 || y < 0 || x >= shadow.size || y >= shadow.size) {
                        lit += 1.0f;
                    } else {
                        const float depth = shadow.depth[static_cast<size_t>(y) * shadow.size + x];
                        lit += (proj.z - bias <= depth) ? 1.0f : 0.0f;
                    }
                    ++samples;
                }
            }
            return samples > 0 ? lit / static_cast<float>(samples) : 1.0f;
        }

        [[nodiscard]] glm::vec3 shadeMeshPixel(const lfs::core::MeshData& mesh,
                                               const size_t material_index,