fillFrameBufferNoise()

FL_OPTIMIZATION_LEVEL_O0_END void fillFrameBufferNoise

(

)

Definition at line 446 of file curr.h.

                            {
    // Get current UI values
    uint8_t noise_scale = noiseScale.value();
    uint8_t noise_speed = noiseSpeed.value();
    
    // Derive noise coordinates from current time instead of forward iteration
    uint32_t now = millis();
    uint16_t noise_z = now * noise_speed / 10;  // Primary time dimension
    uint16_t noise_x = now * noise_speed / 80;  // Slow drift in x
    uint16_t noise_y = now * noise_speed / 160; // Even slower drift in y (opposite direction)
    
    int width = frameBufferPtr->width();
    int height = frameBufferPtr->height();
    
    // Data smoothing for low speeds (from NoisePlusPalette example)
    uint8_t dataSmoothing = 0;
    if(noise_speed < 50) {
        dataSmoothing = 200 - (noise_speed * 4);
    }
    
    // Generate noise for each pixel in the frame buffer using cylindrical mapping
    for(int x = 0; x < width; x++) {
        for(int y = 0; y < height; y++) {
            // Convert rectangular coordinates to cylindrical coordinates
            // Map x to angle (0 to 2*PI), y remains as height
            float angle = (float(x) / float(width)) * 2.0f * PI;
            
            // Convert cylindrical coordinates to cartesian for noise sampling
            // Use the noise_scale to control the cylinder size in noise space
            float cylinder_radius = noise_scale; // Use the existing noise_scale parameter
            
            // Calculate cartesian coordinates on the cylinder surface
            float noise_x_cyl = cos(angle) * cylinder_radius;
            float noise_y_cyl = sin(angle) * cylinder_radius;
            float noise_z_height = float(y) * noise_scale; // Height component
            
            // Apply time-based offsets
            int xoffset = int(noise_x_cyl) + noise_x;
            int yoffset = int(noise_y_cyl) + noise_y;
            int zoffset = int(noise_z_height) + noise_z;
            
            // Generate 8-bit noise value using 3D Perlin noise with cylindrical coordinates
            uint8_t data = inoise8(xoffset, yoffset, zoffset);
            
            // Expand the range from ~16-238 to 0-255 (from NoisePlusPalette)
            data = qsub8(data, 16);
            data = qadd8(data, scale8(data, 39));
            
            // Apply data smoothing if enabled
            if(dataSmoothing) {
                CRGB oldColor = frameBufferPtr->at(x, y);
                uint8_t olddata = (oldColor.r + oldColor.g + oldColor.b) / 3; // Simple brightness extraction
                uint8_t newdata = scale8(olddata, dataSmoothing) + scale8(data, 256 - dataSmoothing);
                data = newdata;
            }
            
            // Map noise to color using palette (adapted from NoisePlusPalette)
            uint8_t index = data;
            uint8_t bri = data;
            
            // Add color cycling if enabled - also derive from time
            uint8_t ihue = 0;
            if(colorLoop) {
                ihue = (now / 100) % 256;  // Derive hue from time instead of incrementing
                index += ihue;
            }
            
            // Enhance brightness (from NoisePlusPalette example)
            // if(bri > 127) {
            //     //bri = 255;
            // } else {
            //     //bri = dim8_raw(bri * 2);
            // }
            
            // Get color from palette and set pixel
            CRGB color = ColorFromPalette(noisePalette, index, bri);
            
            // Apply color boost using ease functions
            EaseType sat_ease = getEaseType(saturationFunction.value());
            EaseType lum_ease = getEaseType(luminanceFunction.value());
            color = color.colorBoost(sat_ease, lum_ease);
            
            frameBufferPtr->at(x, y) = color;
        }
    }
}

References CRGB::colorBoost(), fl::ColorFromPalette(), colorLoop, frameBufferPtr, getEaseType(), inoise8(), luminanceFunction(), noisePalette, noiseScale(), noiseSpeed(), PI, qadd8(), qsub8(), saturationFunction(), scale8(), x, and y.

Referenced by drawNoise().

Here is the call graph for this function:

Here is the caller graph for this function: