Function rasterizeMeshTriangle

src/rendering/raster_rendering_engine.cpp:1421–1492

        }

        void rasterizeMeshTriangle(std::vector<float>& image,
                                   std::vector<float>& depth,
                                   const int width,
                                   const int height,
                                   const lfs::core::MeshData& mesh,
                                   const size_t material_index,
                                   const MeshRenderOptions& options,
                                   const std::array<glm::vec3, 3>& screen,
                                   const std::array<glm::vec3, 3>& world,
                                   const std::array<glm::vec3, 3>& normals,
                                   const std::array<glm::vec3, 3>& tangents,
                                   const std::array<float, 3>& tangent_handedness,
                                   const std::array<glm::vec2, 3>& texcoords,
                                   const std::array<glm::vec4, 3>& colors,
                                   const glm::vec3& camera_position,
                                   const glm::vec3& light_dir,
                                   const SoftwareShadowMap& shadow_map) {
            const glm::vec2 p0(screen[0]);
            const glm::vec2 p1(screen[1]);
            const glm::vec2 p2(screen[2]);
            const float area = edgeFunction(p0, p1, p2);
            if (std::abs(area) <= 1e-6f) {
                return;
            }

            const int min_x = std::clamp(
                static_cast<int>(std::floor(std::min({p0.x, p1.x, p2.x}))), 0, width - 1);
            const int max_x = std::clamp(
                static_cast<int>(std::ceil(std::max({p0.x, p1.x, p2.x}))), 0, width - 1);
            const int min_y = std::clamp(
                static_cast<int>(std::floor(std::min({p0.y, p1.y, p2.y}))), 0, height - 1);
            const int max_y = std::clamp(
                static_cast<int>(std::ceil(std::max({p0.y, p1.y, p2.y}))), 0, height - 1);
            const size_t pixel_count = static_cast<size_t>(width) * height;

            for (int y = min_y; y <= max_y; ++y) {
                for (int x = min_x; x <= max_x; ++x) {
                    const glm::vec2 p(static_cast<float>(x) + 0.5f, static_cast<float>(y) + 0.5f);
                    const float w0 = edgeFunction(p1, p2, p) / area;
                    const float w1 = edgeFunction(p2, p0, p) / area;
                    const float w2 = edgeFunction(p0, p1, p) / area;
                    if (w0 < 0.0f || w1 < 0.0f || w2 < 0.0f) {
                        continue;
                    }
                    const float z = w0 * screen[0].z + w1 * screen[1].z + w2 * screen[2].z;
                    const size_t pixel = static_cast<size_t>(y) * width + x;
                    if (z >= depth[pixel]) {
                        continue;
                    }
                    const glm::vec3 world_position = w0 * world[0] + w1 * world[1] + w2 * world[2];
                    const glm::vec3 normal = safeNormalize(w0 * normals[0] + w1 * normals[1] + w2 * normals[2],
                                                           glm::normalize(glm::cross(world[1] - world[0],
                                                                                     world[2] - world[0])));
                    const glm::vec3 tangent = safeNormalize(w0 * tangents[0] + w1 * tangents[1] + w2 * tangents[2],
                                                            glm::vec3(1.0f, 0.0f, 0.0f));
                    const float handedness = w0 * tangent_handedness[0] +
                                             w1 * tangent_handedness[1] +
                                             w2 * tangent_handedness[2];