draw()

void fl::Chasing_Spirals_Float::draw ( Context & ctx )

overridevirtual

Implements fl::IAnimartrix2Viz.

Definition at line 292 of file chasing_spirals.cpp.hpp.

                                             {
    auto *e = ctx.mEngine.get();
    e->get_ready();
 
    // Perlin noise is periodic with period 256 at integer coordinates.
    // scale_x = 0.1, so the effective period for offset_x is 256/0.1 = 2560.
    // Reducing move.linear[i] modulo this period before use keeps float32
    // coordinate arithmetic precise even at extreme uptime values.
    // Without this, float32 loses per-pixel precision when adding a small
    // per-pixel term (~0.1) to a large offset (e.g. 200,000), since float32
    // ULP at that magnitude (~0.024) is coarser than the per-pixel step.
    // This matches the reduction already applied in setupChasingSpiralFrame
    // for the Q31 path, keeping both paths in agreement at all time values.
    static constexpr float perlin_period = 2560.0f; // 256.0f / scale_x(0.1f)
 
    e->timings.master_speed = 0.01;
    e->timings.ratio[0] = 0.1;
    e->timings.ratio[1] = 0.13;
    e->timings.ratio[2] = 0.16;
    e->timings.offset[1] = 10;
    e->timings.offset[2] = 20;
    e->timings.offset[3] = 30;
    e->calculate_oscillators(e->timings);
 
    for (int x = 0; x < e->num_x; x++) {
        for (int y = 0; y < e->num_y; y++) {
            e->animation.angle =
                3 * e->polar_theta[x][y] + e->move.radial[0] -
                e->distance[x][y] / 3;
            e->animation.dist = e->distance[x][y];
            e->animation.scale_z = 0.1;
            e->animation.scale_y = 0.1;
            e->animation.scale_x = 0.1;
            e->animation.offset_x = fl::fmodf(e->move.linear[0], perlin_period);
            e->animation.offset_y = 0;
            e->animation.offset_z = 0;
            e->animation.z = 0;
            float show1 = e->render_value(e->animation);
 
            e->animation.angle =
                3 * e->polar_theta[x][y] + e->move.radial[1] -
                e->distance[x][y] / 3;
            e->animation.dist = e->distance[x][y];
            e->animation.offset_x = fl::fmodf(e->move.linear[1], perlin_period);
            float show2 = e->render_value(e->animation);
 
            e->animation.angle =
                3 * e->polar_theta[x][y] + e->move.radial[2] -
                e->distance[x][y] / 3;
            e->animation.dist = e->distance[x][y];
            e->animation.offset_x = fl::fmodf(e->move.linear[2], perlin_period);
            float show3 = e->render_value(e->animation);
 
            float radius = e->radial_filter_radius;
            float radial_filter = (radius - e->distance[x][y]) / radius;
 
            e->pixel.red = 3 * show1 * radial_filter;
            e->pixel.green = show2 * radial_filter / 2;
            e->pixel.blue = show3 * radial_filter / 4;
 
            e->pixel = e->rgb_sanity_check(e->pixel);
            e->setPixelColorInternal(x, y, e->pixel);
        }
    }
}

References fl::fmodf(), fl::Context::mEngine, fl::x, and fl::y.

Here is the call graph for this function: