◆ render_value_fp()

FASTLED_FORCE_INLINE fl::i32 fl::render_value_fp	(	const render_parameters_fp &	p,
		const fl::i32 *	fade_lut,
		const fl::u8 *	perm )

Definition at line 53 of file render_value_fp.h.

                          {
 
    using FP = fl::s16x16;
    constexpr fl::i32 FP_ONE = static_cast<fl::i32>(1) << FP::FRAC_BITS;
 
    // sincos32 for angle
    fl::u32 a24 = radiansToA24_fp(p.angle_raw);
    SinCos32 sc = sincos32(a24);
 
    // sincos32 output is in [-2147418112, 2147418112] (Q0.31 range).
    // To multiply with s16x16 dist, we use:
    //   result_s16x16 = (sc_val * dist_raw) >> 31
    // This gives us the product in s16x16 format.
    fl::i32 cos_dist = static_cast<fl::i32>(
        (static_cast<fl::i64>(sc.cos_val) * p.dist_raw) >> 31);
    fl::i32 sin_dist = static_cast<fl::i32>(
        (static_cast<fl::i64>(sc.sin_val) * p.dist_raw) >> 31);
 
    // newx = (offset_x + center_x - cos*dist) * scale_x
    // newy = (offset_y + center_y - sin*dist) * scale_y
    fl::i32 pre_x = p.offset_x_raw + p.center_x_raw - cos_dist;
    fl::i32 pre_y = p.offset_y_raw + p.center_y_raw - sin_dist;
 
    fl::i32 nx = static_cast<fl::i32>(
        (static_cast<fl::i64>(pre_x) * p.scale_x_raw) >> FP::FRAC_BITS);
    fl::i32 ny = static_cast<fl::i32>(
        (static_cast<fl::i64>(pre_y) * p.scale_y_raw) >> FP::FRAC_BITS);
 
    // Compute z coordinate: newz = (offset_z + z) * scale_z
    fl::i32 nz = static_cast<fl::i32>(
        (static_cast<fl::i64>(p.offset_z_raw + p.z_raw) * p.scale_z_raw) >> FP::FRAC_BITS);
 
    // Perlin noise: 2D when z==0, 3D otherwise
    fl::i32 raw_noise;
    if (nz == 0) {
        raw_noise = perlin_s16x16::pnoise2d_raw(nx, ny, fade_lut, perm);
    } else {
        raw_noise = perlin_s16x16::pnoise3d_raw(nx, ny, nz, fade_lut, perm);
    }
 
    // Clamp to [low_limit, high_limit]
    if (raw_noise < p.low_limit_raw) raw_noise = p.low_limit_raw;
    if (raw_noise > p.high_limit_raw) raw_noise = p.high_limit_raw;
 
    // Map from [low_limit, high_limit] to [0, 255]
    // map_float(x, low, high, 0, 255) = (x - low) * 255 / (high - low)
    fl::i32 range = p.high_limit_raw - p.low_limit_raw;
    fl::i32 shifted = raw_noise - p.low_limit_raw;
 
    // shifted is in [0, range], we want (shifted * 255) / range
    // For the common case where low=0, high=1: range = FP_ONE
    //   result = (shifted * 255) >> FRAC_BITS  (since shifted is in [0, FP_ONE])
    // For low=-1, high=1: range = 2*FP_ONE
    //   result = (shifted * 255) / (2*FP_ONE)
    fl::i32 result;
    if (range == FP_ONE) {
        // Optimized path: low_limit=0, high_limit=1
        result = static_cast<fl::i32>(
            (static_cast<fl::i64>(shifted) * 255) >> FP::FRAC_BITS);
    } else if (range == 2 * FP_ONE) {
        // Optimized path: low_limit=-1, high_limit=1
        result = static_cast<fl::i32>(
            (static_cast<fl::i64>(shifted) * 255) >> (FP::FRAC_BITS + 1));
    } else {
        // General path
        result = static_cast<fl::i32>(
            (static_cast<fl::i64>(shifted) * 255) / range);
    }
 
    // Final clamp to [0, 255]
    if (result < 0) result = 0;
    if (result > 255) result = 255;
 
    return result;
}

Referenced by fl::Center_Field_FP::draw(), fl::Complex_Kaleido_5_FP::draw(), fl::Module_Experiment10_FP::draw(), fl::Module_Experiment2_FP::draw(), fl::Module_Experiment3_FP::draw(), fl::Scaledemo1_FP::draw(), fl::SpiralMatrix4_FP::draw(), and render_value_fp_from_float().

Here is the call graph for this function:

Here is the caller graph for this function: