683 lines
26 KiB
C++
683 lines
26 KiB
C++
/// @file FxNoiseRing.ino
|
|
/// @brief Noise effect on circular ring with ScreenMap
|
|
/// @example FxNoiseRing.ino
|
|
///
|
|
/// This sketch is fully compatible with the FastLED web compiler. To use it do the following:
|
|
/// 1. Install Fastled: `pip install fastled`
|
|
/// 2. cd into this examples page.
|
|
/// 3. Run the FastLED web compiler at root: `fastled`
|
|
/// 4. When the compiler is done a web page will open.
|
|
|
|
#include <Arduino.h>
|
|
#include <FastLED.h>
|
|
|
|
|
|
#include "fl/json.h"
|
|
#include "fl/math_macros.h"
|
|
#include "fl/warn.h"
|
|
#include "noisegen.h"
|
|
#include "fl/screenmap.h"
|
|
#include "fl/slice.h"
|
|
#include "fl/ui.h"
|
|
|
|
#include "sensors/pir.h"
|
|
#include "./simple_timer.h"
|
|
#include "fl/sstream.h"
|
|
#include "fl/assert.h"
|
|
|
|
|
|
|
|
|
|
|
|
#define LED_PIN 2
|
|
#define COLOR_ORDER GRB // Color order matters for a real device, web-compiler will ignore this.
|
|
#define NUM_LEDS 250
|
|
#define PIN_PIR 0
|
|
|
|
#define PIR_LATCH_MS 60000 // how long to keep the PIR sensor active after a trigger
|
|
#define PIR_RISING_TIME 1000 // how long to fade in the PIR sensor
|
|
#define PIR_FALLING_TIME 1000 // how long to fade out the PIR sensor
|
|
|
|
using namespace fl;
|
|
|
|
CRGB leds[NUM_LEDS];
|
|
|
|
// Enhanced coordinate system for ring-based effects
|
|
struct RingCoord {
|
|
float angle; // Position on ring (0 to 2π)
|
|
float radius; // Distance from center (normalized 0-1)
|
|
float x, y; // Cartesian coordinates
|
|
int led_index; // LED position on strip
|
|
};
|
|
|
|
// Convert LED index to ring coordinates
|
|
RingCoord calculateRingCoord(int led_index, int num_leds, float time_offset = 0.0f) {
|
|
RingCoord coord;
|
|
coord.led_index = led_index;
|
|
coord.angle = (led_index * 2.0f * M_PI / num_leds) + time_offset;
|
|
coord.radius = 1.0f; // Fixed radius for ring
|
|
coord.x = cos(coord.angle);
|
|
coord.y = sin(coord.angle);
|
|
return coord;
|
|
}
|
|
|
|
// Performance optimization with lookup tables
|
|
class RingLUT {
|
|
private:
|
|
float cos_table[NUM_LEDS];
|
|
float sin_table[NUM_LEDS];
|
|
|
|
public:
|
|
void initialize() {
|
|
for(int i = 0; i < NUM_LEDS; i++) {
|
|
float angle = i * 2.0f * M_PI / NUM_LEDS;
|
|
cos_table[i] = cos(angle);
|
|
sin_table[i] = sin(angle);
|
|
}
|
|
}
|
|
|
|
RingCoord fastRingCoord(int led_index, float time_offset = 0.0f) {
|
|
RingCoord coord;
|
|
coord.led_index = led_index;
|
|
coord.angle = (led_index * 2.0f * M_PI / NUM_LEDS) + time_offset;
|
|
coord.x = cos_table[led_index];
|
|
coord.y = sin_table[led_index];
|
|
coord.radius = 1.0f;
|
|
return coord;
|
|
}
|
|
};
|
|
|
|
// Plasma wave parameters
|
|
struct PlasmaParams {
|
|
float time_scale = 1.0f;
|
|
float noise_intensity = 0.5f;
|
|
float noise_amplitude = 0.8f;
|
|
uint8_t time_bitshift = 5;
|
|
uint8_t hue_offset = 0;
|
|
float brightness = 1.0f;
|
|
};
|
|
|
|
// Plasma wave generator - Featured Implementation
|
|
class PlasmaWaveGenerator {
|
|
private:
|
|
struct WaveSource {
|
|
float x, y; // Source position
|
|
float frequency; // Wave frequency
|
|
float amplitude; // Wave strength
|
|
float phase_speed; // Phase evolution rate
|
|
};
|
|
|
|
WaveSource sources[4] = {
|
|
{0.5f, 0.5f, 1.0f, 1.0f, 0.8f}, // Center source
|
|
{0.0f, 0.0f, 1.5f, 0.8f, 1.2f}, // Corner source
|
|
{1.0f, 1.0f, 0.8f, 1.2f, 0.6f}, // Opposite corner
|
|
{0.5f, 0.0f, 1.2f, 0.9f, 1.0f} // Edge source
|
|
};
|
|
|
|
public:
|
|
CRGB calculatePlasmaPixel(const RingCoord& coord, uint32_t time_ms, const PlasmaParams& params) {
|
|
float time_scaled = time_ms * params.time_scale * 0.001f;
|
|
|
|
// Calculate wave interference
|
|
float wave_sum = 0.0f;
|
|
for (int i = 0; i < 4; i++) {
|
|
float dx = coord.x - sources[i].x;
|
|
float dy = coord.y - sources[i].y;
|
|
float distance = sqrt(dx*dx + dy*dy);
|
|
|
|
float wave_phase = distance * sources[i].frequency + time_scaled * sources[i].phase_speed;
|
|
wave_sum += sin(wave_phase) * sources[i].amplitude;
|
|
}
|
|
|
|
// Add noise modulation for organic feel
|
|
float noise_scale = params.noise_intensity;
|
|
float noise_x = coord.x * 0xffff * noise_scale;
|
|
float noise_y = coord.y * 0xffff * noise_scale;
|
|
uint32_t noise_time = time_ms << params.time_bitshift;
|
|
|
|
float noise_mod = (inoise16(noise_x, noise_y, noise_time) - 32768) / 65536.0f;
|
|
wave_sum += noise_mod * params.noise_amplitude;
|
|
|
|
// Map to color space
|
|
return mapWaveToColor(wave_sum, params);
|
|
}
|
|
|
|
private:
|
|
CRGB mapWaveToColor(float wave_value, const PlasmaParams& params) {
|
|
// Normalize wave to 0-1 range
|
|
float normalized = (wave_value + 4.0f) / 8.0f; // Assuming max amplitude ~4
|
|
normalized = constrain(normalized, 0.0f, 1.0f);
|
|
|
|
// Create flowing hue based on wave phase
|
|
uint8_t hue = (uint8_t)(normalized * 255.0f + params.hue_offset) % 256;
|
|
|
|
// Dynamic saturation based on wave intensity
|
|
float intensity = abs(wave_value);
|
|
uint8_t sat = (uint8_t)(192 + intensity * 63); // High saturation with variation
|
|
|
|
// Brightness modulation
|
|
uint8_t val = (uint8_t)(normalized * 255.0f * params.brightness);
|
|
|
|
return CHSV(hue, sat, val);
|
|
}
|
|
};
|
|
|
|
// Advanced Color Palette System
|
|
class ColorPaletteManager {
|
|
private:
|
|
uint8_t current_palette = 0;
|
|
uint32_t last_palette_change = 0;
|
|
static const uint32_t PALETTE_CHANGE_INTERVAL = 5000; // 5 seconds
|
|
|
|
public:
|
|
void update(uint32_t now, bool auto_cycle_enabled, uint8_t manual_palette) {
|
|
if (auto_cycle_enabled) {
|
|
if (now - last_palette_change > PALETTE_CHANGE_INTERVAL) {
|
|
current_palette = (current_palette + 1) % 5;
|
|
last_palette_change = now;
|
|
}
|
|
} else {
|
|
current_palette = manual_palette;
|
|
}
|
|
}
|
|
|
|
CRGB mapColor(float hue_norm, float intensity, float special_param = 0.0f) {
|
|
switch(current_palette) {
|
|
case 0: return mapSunsetBoulevard(hue_norm, intensity, special_param);
|
|
case 1: return mapOceanBreeze(hue_norm, intensity, special_param);
|
|
case 2: return mapNeonNights(hue_norm, intensity, special_param);
|
|
case 3: return mapForestWhisper(hue_norm, intensity, special_param);
|
|
case 4: return mapGalaxyExpress(hue_norm, intensity, special_param);
|
|
default: return mapSunsetBoulevard(hue_norm, intensity, special_param);
|
|
}
|
|
}
|
|
|
|
private:
|
|
CRGB mapSunsetBoulevard(float hue_norm, float intensity, float special_param) {
|
|
// Warm oranges, deep reds, golden yellows (Hue 0-45)
|
|
uint8_t hue = (uint8_t)(hue_norm * 45);
|
|
uint8_t sat = 200 + (uint8_t)(intensity * 55);
|
|
uint8_t val = 150 + (uint8_t)(intensity * 105);
|
|
return CHSV(hue, sat, val);
|
|
}
|
|
|
|
CRGB mapOceanBreeze(float hue_norm, float intensity, float special_param) {
|
|
// Deep blues, aqua, seafoam green (Hue 120-210)
|
|
uint8_t hue = 120 + (uint8_t)(hue_norm * 90);
|
|
uint8_t sat = 180 + (uint8_t)(intensity * 75);
|
|
uint8_t val = 120 + (uint8_t)(intensity * 135);
|
|
return CHSV(hue, sat, val);
|
|
}
|
|
|
|
CRGB mapNeonNights(float hue_norm, float intensity, float special_param) {
|
|
// Electric pink, cyan, purple, lime green - high contrast
|
|
uint8_t base_hues[] = {0, 85, 128, 192}; // Red, Cyan, Pink, Purple
|
|
uint8_t selected_hue = base_hues[(int)(hue_norm * 4) % 4];
|
|
uint8_t sat = 255; // Maximum saturation for neon effect
|
|
uint8_t val = 100 + (uint8_t)(intensity * 155);
|
|
return CHSV(selected_hue, sat, val);
|
|
}
|
|
|
|
CRGB mapForestWhisper(float hue_norm, float intensity, float special_param) {
|
|
// Deep greens, earth browns, golden highlights (Hue 60-150)
|
|
uint8_t hue = 60 + (uint8_t)(hue_norm * 90);
|
|
uint8_t sat = 150 + (uint8_t)(intensity * 105);
|
|
uint8_t val = 100 + (uint8_t)(intensity * 155);
|
|
return CHSV(hue, sat, val);
|
|
}
|
|
|
|
CRGB mapGalaxyExpress(float hue_norm, float intensity, float special_param) {
|
|
// Deep purples, cosmic blues, silver stars (Hue 200-300)
|
|
if (special_param > 0.8f) {
|
|
// Silver/white stars
|
|
uint8_t brightness = 200 + (uint8_t)(intensity * 55);
|
|
return CRGB(brightness, brightness, brightness);
|
|
} else {
|
|
uint8_t hue = 200 + (uint8_t)(hue_norm * 100);
|
|
uint8_t sat = 180 + (uint8_t)(intensity * 75);
|
|
uint8_t val = 80 + (uint8_t)(intensity * 175);
|
|
return CHSV(hue, sat, val);
|
|
}
|
|
}
|
|
};
|
|
|
|
// ALL 10 ALGORITHM IMPLEMENTATIONS
|
|
CRGB drawCosmicSwirl(const RingCoord& coord, uint32_t time_ms, ColorPaletteManager& palette) {
|
|
float time_factor = time_ms * 0.0008f;
|
|
|
|
// Multi-octave noise for organic complexity
|
|
float noise1 = inoise16(coord.x * 2000, coord.y * 2000, time_factor * 1000) / 65536.0f;
|
|
float noise2 = inoise16(coord.x * 1000, coord.y * 1000, time_factor * 2000) / 65536.0f * 0.5f;
|
|
float noise3 = inoise16(coord.x * 4000, coord.y * 4000, time_factor * 500) / 65536.0f * 0.25f;
|
|
|
|
float combined_noise = noise1 + noise2 + noise3;
|
|
float hue_norm = (combined_noise + coord.angle / (2*M_PI) + 1.0f) * 0.5f;
|
|
float intensity = (combined_noise + 1.0f) * 0.5f;
|
|
|
|
return palette.mapColor(hue_norm, intensity);
|
|
}
|
|
|
|
CRGB drawElectricStorm(const RingCoord& coord, uint32_t time_ms, ColorPaletteManager& palette) {
|
|
uint32_t fast_time = time_ms << 3; // 8x time acceleration
|
|
|
|
float x_noise = coord.x * 8000;
|
|
float y_noise = coord.y * 8000;
|
|
|
|
uint16_t noise1 = inoise16(x_noise, y_noise, fast_time);
|
|
uint16_t noise2 = inoise16(x_noise + 10000, y_noise + 10000, fast_time + 5000);
|
|
|
|
uint8_t threshold = 200;
|
|
bool lightning = (noise1 >> 8) > threshold || (noise2 >> 8) > threshold;
|
|
|
|
if (lightning) {
|
|
float lightning_intensity = max((noise1 >> 8) - threshold, (noise2 >> 8) - threshold) / 55.0f;
|
|
return palette.mapColor(0.7f, lightning_intensity, 1.0f); // Special lightning effect
|
|
} else {
|
|
float storm_intensity = (noise1 >> 8) / 1020.0f; // Very low intensity for background
|
|
return palette.mapColor(0.6f, storm_intensity);
|
|
}
|
|
}
|
|
|
|
CRGB drawLavaLamp(const RingCoord& coord, uint32_t time_ms, ColorPaletteManager& palette) {
|
|
float slow_time = time_ms * 0.0002f;
|
|
|
|
float blob_scale = 800;
|
|
uint16_t primary_noise = inoise16(coord.x * blob_scale, coord.y * blob_scale, slow_time * 1000);
|
|
uint16_t secondary_noise = inoise16(coord.x * blob_scale * 0.5f, coord.y * blob_scale * 0.5f, slow_time * 1500);
|
|
|
|
float blob_value = (primary_noise + secondary_noise * 0.3f) / 65536.0f;
|
|
|
|
if (blob_value > 0.6f) {
|
|
// Hot blob center
|
|
float intensity = (blob_value - 0.6f) / 0.4f;
|
|
return palette.mapColor(0.1f, intensity); // Warm colors
|
|
} else if (blob_value > 0.3f) {
|
|
// Blob edge gradient
|
|
float edge_factor = (blob_value - 0.3f) / 0.3f;
|
|
return palette.mapColor(0.2f, edge_factor);
|
|
} else {
|
|
// Background
|
|
return palette.mapColor(0.8f, 0.2f); // Cool background
|
|
}
|
|
}
|
|
|
|
CRGB drawDigitalRain(const RingCoord& coord, uint32_t time_ms, ColorPaletteManager& palette) {
|
|
float vertical_pos = sin(coord.angle) * 0.5f + 0.5f;
|
|
float cascade_speed = 0.002f;
|
|
float time_offset = time_ms * cascade_speed;
|
|
|
|
int stream_id = (int)(coord.angle * 10) % 8;
|
|
float stream_phase = fmod(vertical_pos + time_offset + stream_id * 0.125f, 1.0f);
|
|
|
|
uint16_t noise = inoise16(stream_id * 1000, stream_phase * 10000, time_ms / 4);
|
|
uint8_t digital_value = (noise >> 8) > 128 ? 255 : 0;
|
|
|
|
if (digital_value > 0) {
|
|
float intensity = 1.0f - stream_phase * 0.8f; // Fade trailing
|
|
return palette.mapColor(0.4f, intensity); // Matrix green area
|
|
} else {
|
|
return CRGB::Black;
|
|
}
|
|
}
|
|
|
|
CRGB drawGlitchCity(const RingCoord& coord, uint32_t time_ms, ColorPaletteManager& palette) {
|
|
uint32_t glitch_time = (time_ms / 100) * 100; // Quantize time
|
|
|
|
uint16_t noise1 = inoise16(coord.x * 3000, coord.y * 3000, glitch_time);
|
|
uint16_t noise2 = inoise16(coord.x * 5000, coord.y * 5000, glitch_time + 1000);
|
|
|
|
uint16_t glitch_value = noise1 ^ noise2; // XOR for harsh digital effects
|
|
|
|
if ((glitch_value & 0xF000) == 0xF000) {
|
|
return CRGB(255, 255, 255); // Full-bright glitch flash
|
|
}
|
|
|
|
float intensity = (glitch_value & 0xFF) / 255.0f;
|
|
float hue_chaos = ((glitch_value >> 8) & 0xFF) / 255.0f;
|
|
|
|
return palette.mapColor(hue_chaos, intensity, 0.5f);
|
|
}
|
|
|
|
CRGB drawOceanDepths(const RingCoord& coord, uint32_t time_ms, ColorPaletteManager& palette) {
|
|
float ocean_time = time_ms * 0.0005f;
|
|
|
|
float current1 = inoise16(coord.x * 1200, coord.y * 1200, ocean_time * 800) / 65536.0f;
|
|
float current2 = inoise16(coord.x * 2400, coord.y * 2400, ocean_time * 600) / 65536.0f * 0.5f;
|
|
float current3 = inoise16(coord.x * 600, coord.y * 600, ocean_time * 1000) / 65536.0f * 0.3f;
|
|
|
|
float depth_factor = (current1 + current2 + current3 + 1.5f) / 3.0f;
|
|
float hue_variation = (current2 + 0.5f);
|
|
|
|
return palette.mapColor(hue_variation, depth_factor);
|
|
}
|
|
|
|
CRGB drawFireDance(const RingCoord& coord, uint32_t time_ms, ColorPaletteManager& palette) {
|
|
float vertical_component = sin(coord.angle) * 0.5f + 0.5f;
|
|
|
|
float flame_x = coord.x * 1500;
|
|
float flame_y = coord.y * 1500 + time_ms * 0.003f;
|
|
|
|
uint16_t turbulence = inoise16(flame_x, flame_y, time_ms);
|
|
float flame_intensity = (turbulence / 65536.0f) * (1.0f - vertical_component * 0.3f);
|
|
|
|
float fire_hue = flame_intensity * 0.15f; // Red to orange range
|
|
return palette.mapColor(fire_hue, flame_intensity);
|
|
}
|
|
|
|
CRGB drawNebulaDrift(const RingCoord& coord, uint32_t time_ms, ColorPaletteManager& palette) {
|
|
float nebula_time = time_ms * 0.0003f;
|
|
|
|
float cloud1 = inoise16(coord.x * 800, coord.y * 800, nebula_time * 1000) / 65536.0f;
|
|
float cloud2 = inoise16(coord.x * 1600, coord.y * 1600, nebula_time * 700) / 65536.0f * 0.5f;
|
|
float cloud3 = inoise16(coord.x * 400, coord.y * 400, nebula_time * 1200) / 65536.0f * 0.25f;
|
|
|
|
float nebula_density = cloud1 + cloud2 + cloud3;
|
|
|
|
uint16_t star_noise = inoise16(coord.x * 4000, coord.y * 4000, nebula_time * 200);
|
|
bool is_star = (star_noise > 60000);
|
|
|
|
if (is_star) {
|
|
float star_intensity = (star_noise - 60000) / 5536.0f;
|
|
return palette.mapColor(0.0f, star_intensity, 1.0f); // Stars
|
|
} else {
|
|
float hue_drift = (nebula_density + 1.0f) * 0.5f;
|
|
float intensity = (nebula_density + 1.0f) * 0.4f;
|
|
return palette.mapColor(hue_drift, intensity);
|
|
}
|
|
}
|
|
|
|
CRGB drawBinaryPulse(const RingCoord& coord, uint32_t time_ms, ColorPaletteManager& palette) {
|
|
float pulse_period = 2000.0f;
|
|
float pulse_phase = fmod(time_ms, pulse_period) / pulse_period;
|
|
|
|
float distance_from_center = sqrt(coord.x * coord.x + coord.y * coord.y);
|
|
|
|
float ring_frequency = 5.0f;
|
|
float pulse_offset = pulse_phase * 2.0f;
|
|
float ring_value = sin((distance_from_center * ring_frequency - pulse_offset) * 2 * M_PI);
|
|
|
|
uint16_t noise = inoise16(coord.x * 2000, coord.y * 2000, time_ms / 8);
|
|
float digital_mod = ((noise >> 8) > 128) ? 1.0f : -0.5f;
|
|
|
|
float final_value = ring_value * digital_mod;
|
|
|
|
if (final_value > 0.3f) {
|
|
return palette.mapColor(0.8f, final_value, 0.8f); // Active pulse
|
|
} else if (final_value > -0.2f) {
|
|
float transition_intensity = (final_value + 0.2f) * 2.0f;
|
|
return palette.mapColor(0.3f, transition_intensity); // Transition zones
|
|
} else {
|
|
return palette.mapColor(0.7f, 0.1f); // Background
|
|
}
|
|
}
|
|
|
|
// Enhanced variant manager with ALL 10 ALGORITHMS and smooth transitions
|
|
class NoiseVariantManager {
|
|
private:
|
|
uint8_t current_variant = 0;
|
|
uint8_t target_variant = 0;
|
|
float transition_progress = 1.0f; // 0.0 = old, 1.0 = new
|
|
uint32_t transition_start = 0;
|
|
static const uint32_t TRANSITION_DURATION = 1500; // 1.5 second fade for smoother transitions
|
|
|
|
// Algorithm instances
|
|
PlasmaWaveGenerator plasma_gen;
|
|
PlasmaParams plasma_params;
|
|
ColorPaletteManager& palette_manager;
|
|
|
|
public:
|
|
NoiseVariantManager(ColorPaletteManager& palette_mgr) : palette_manager(palette_mgr) {}
|
|
|
|
void update(uint32_t now, bool auto_cycle_enabled, uint8_t manual_variant, const PlasmaParams& params) {
|
|
plasma_params = params;
|
|
|
|
// Handle automatic cycling vs manual override
|
|
if (auto_cycle_enabled) {
|
|
EVERY_N_MILLISECONDS(12000) { // Slightly longer for each variant
|
|
startTransition((current_variant + 1) % 10, now); // ALL 10 variants
|
|
}
|
|
} else if (manual_variant != target_variant && transition_progress >= 1.0f) {
|
|
// Manual override
|
|
startTransition(manual_variant, now);
|
|
}
|
|
|
|
// Update transition progress
|
|
if (transition_progress < 1.0f) {
|
|
uint32_t elapsed = now - transition_start;
|
|
transition_progress = min(1.0f, elapsed / (float)TRANSITION_DURATION);
|
|
|
|
if (transition_progress >= 1.0f) {
|
|
current_variant = target_variant;
|
|
}
|
|
}
|
|
}
|
|
|
|
CRGB renderPixel(const RingCoord& coord, uint32_t time_ms) {
|
|
if (transition_progress >= 1.0f) {
|
|
// No transition, render current variant
|
|
return renderVariant(current_variant, coord, time_ms);
|
|
} else {
|
|
// Advanced cross-fade with brightness preservation
|
|
CRGB old_color = renderVariant(current_variant, coord, time_ms);
|
|
CRGB new_color = renderVariant(target_variant, coord, time_ms);
|
|
return smoothLerpCRGB(old_color, new_color, transition_progress);
|
|
}
|
|
}
|
|
|
|
uint8_t getCurrentVariant() const { return current_variant; }
|
|
const char* getCurrentVariantName() const {
|
|
const char* names[] = {
|
|
"Cosmic Swirl", "Electric Storm", "Lava Lamp", "Digital Rain", "Plasma Waves",
|
|
"Glitch City", "Ocean Depths", "Fire Dance", "Nebula Drift", "Binary Pulse"
|
|
};
|
|
return names[current_variant % 10];
|
|
}
|
|
|
|
private:
|
|
void startTransition(uint8_t new_variant, uint32_t now) {
|
|
target_variant = new_variant % 10; // Ensure valid range
|
|
transition_start = now;
|
|
transition_progress = 0.0f;
|
|
}
|
|
|
|
CRGB renderVariant(uint8_t variant, const RingCoord& coord, uint32_t time_ms) {
|
|
switch(variant % 10) {
|
|
case 0: return drawCosmicSwirl(coord, time_ms, palette_manager);
|
|
case 1: return drawElectricStorm(coord, time_ms, palette_manager);
|
|
case 2: return drawLavaLamp(coord, time_ms, palette_manager);
|
|
case 3: return drawDigitalRain(coord, time_ms, palette_manager);
|
|
case 4: return drawPlasmaWithPalette(coord, time_ms, palette_manager);
|
|
case 5: return drawGlitchCity(coord, time_ms, palette_manager);
|
|
case 6: return drawOceanDepths(coord, time_ms, palette_manager);
|
|
case 7: return drawFireDance(coord, time_ms, palette_manager);
|
|
case 8: return drawNebulaDrift(coord, time_ms, palette_manager);
|
|
case 9: return drawBinaryPulse(coord, time_ms, palette_manager);
|
|
default: return drawCosmicSwirl(coord, time_ms, palette_manager);
|
|
}
|
|
}
|
|
|
|
// Enhanced Plasma Waves with palette integration
|
|
CRGB drawPlasmaWithPalette(const RingCoord& coord, uint32_t time_ms, ColorPaletteManager& palette) {
|
|
// Generate base plasma waves
|
|
CRGB plasma_color = plasma_gen.calculatePlasmaPixel(coord, time_ms, plasma_params);
|
|
|
|
// Extract intensity and hue information from plasma
|
|
float intensity = (plasma_color.r + plasma_color.g + plasma_color.b) / 765.0f;
|
|
|
|
// Calculate wave interference for hue mapping
|
|
float time_scaled = time_ms * plasma_params.time_scale * 0.001f;
|
|
float wave_sum = 0.0f;
|
|
|
|
// Simplified wave calculation for hue determination
|
|
float dx = coord.x - 0.5f;
|
|
float dy = coord.y - 0.5f;
|
|
float distance = sqrt(dx*dx + dy*dy);
|
|
float wave_phase = distance * 2.0f + time_scaled * 1.5f;
|
|
wave_sum = sin(wave_phase);
|
|
|
|
float hue_norm = (wave_sum + 1.0f) * 0.5f; // Normalize to 0-1
|
|
|
|
// Use palette system for consistent color theming
|
|
return palette.mapColor(hue_norm, intensity, intensity > 0.8f ? 1.0f : 0.0f);
|
|
}
|
|
|
|
// Enhanced interpolation with brightness preservation and smooth curves
|
|
CRGB smoothLerpCRGB(const CRGB& a, const CRGB& b, float t) {
|
|
// Apply smooth curve to transition
|
|
float smooth_t = t * t * (3.0f - 2.0f * t); // Smoothstep function
|
|
|
|
// Preserve brightness during transition to avoid flickering
|
|
float brightness_a = (a.r + a.g + a.b) / 765.0f;
|
|
float brightness_b = (b.r + b.g + b.b) / 765.0f;
|
|
float target_brightness = brightness_a + (brightness_b - brightness_a) * smooth_t;
|
|
|
|
CRGB result = CRGB(
|
|
a.r + (int)((b.r - a.r) * smooth_t),
|
|
a.g + (int)((b.g - a.g) * smooth_t),
|
|
a.b + (int)((b.b - a.b) * smooth_t)
|
|
);
|
|
|
|
// Brightness compensation
|
|
float current_brightness = (result.r + result.g + result.b) / 765.0f;
|
|
if (current_brightness > 0.01f) {
|
|
float compensation = target_brightness / current_brightness;
|
|
compensation = min(compensation, 2.0f); // Limit boost
|
|
result.r = min(255, (int)(result.r * compensation));
|
|
result.g = min(255, (int)(result.g * compensation));
|
|
result.b = min(255, (int)(result.b * compensation));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
};
|
|
|
|
// ALL 10 Variant names for UI
|
|
fl::string variant_names[10] = {
|
|
"Cosmic Swirl", "Electric Storm", "Lava Lamp", "Digital Rain", "Plasma Waves",
|
|
"Glitch City", "Ocean Depths", "Fire Dance", "Nebula Drift", "Binary Pulse"
|
|
};
|
|
|
|
// 5 Color Palette names for UI
|
|
fl::string palette_names[5] = {
|
|
"Sunset Boulevard", "Ocean Breeze", "Neon Nights", "Forest Whisper", "Galaxy Express"
|
|
};
|
|
|
|
// Helper functions to get indices from names
|
|
uint8_t getVariantIndex(const fl::string& name) {
|
|
for (int i = 0; i < 10; i++) {
|
|
if (variant_names[i] == name) {
|
|
return i;
|
|
}
|
|
}
|
|
return 0; // Default to first variant
|
|
}
|
|
|
|
uint8_t getPaletteIndex(const fl::string& name) {
|
|
for (int i = 0; i < 5; i++) {
|
|
if (palette_names[i] == name) {
|
|
return i;
|
|
}
|
|
}
|
|
return 0; // Default to first palette
|
|
}
|
|
|
|
// Global instances - order matters for initialization
|
|
ColorPaletteManager palette_manager;
|
|
NoiseVariantManager variant_manager(palette_manager);
|
|
RingLUT ring_lut;
|
|
|
|
// KICKASS UI controls - comprehensive control suite
|
|
UISlider brightness("Brightness", 1, 0, 1);
|
|
UISlider scale("Scale", 4, .1, 4, .1);
|
|
UISlider timeBitshift("Time Bitshift", 5, 0, 16, 1);
|
|
UISlider timescale("Time Scale", 1, .1, 10, .1);
|
|
|
|
// Advanced variant and palette controls
|
|
UIDropdown variants("Noise Variants", variant_names);
|
|
UIDropdown palettes("Color Palettes", palette_names);
|
|
UICheckbox autoCycle("Auto Cycle Effects", true);
|
|
UICheckbox autoPalette("Auto Cycle Palettes", true);
|
|
// This PIR type is special because it will bind to a pin for a real device,
|
|
// but also provides a UIButton when run in the simulator.
|
|
Pir pir(PIN_PIR, PIR_LATCH_MS, PIR_RISING_TIME, PIR_FALLING_TIME);
|
|
UICheckbox useDither("Use Binary Dither", true);
|
|
|
|
Timer timer;
|
|
float current_brightness = 0;
|
|
|
|
// Save a pointer to the controller so that we can modify the dither in real time.
|
|
CLEDController* controller = nullptr;
|
|
|
|
void setup() {
|
|
Serial.begin(115200);
|
|
// ScreenMap is purely something that is needed for the sketch to correctly
|
|
// show on the web display. For deployements to real devices, this essentially
|
|
// becomes a no-op.
|
|
ScreenMap xyMap = ScreenMap::Circle(NUM_LEDS, 2.0, 2.0);
|
|
controller = &FastLED.addLeds<WS2811, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS)
|
|
.setCorrection(TypicalLEDStrip)
|
|
.setDither(DISABLE_DITHER)
|
|
.setScreenMap(xyMap);
|
|
FastLED.setBrightness(brightness);
|
|
pir.activate(millis()); // Activate the PIR sensor on startup.
|
|
|
|
// Initialize performance optimizations
|
|
ring_lut.initialize();
|
|
}
|
|
|
|
void draw(uint32_t now) {
|
|
// Configure plasma parameters from UI controls with enhanced scaling
|
|
PlasmaParams plasma_params;
|
|
plasma_params.time_scale = timescale.as<float>();
|
|
plasma_params.noise_intensity = scale.as<float>() * 0.8f; // Slightly reduce for better visual balance
|
|
plasma_params.brightness = brightness.as<float>();
|
|
plasma_params.time_bitshift = timeBitshift.as<int>();
|
|
plasma_params.hue_offset = (now / 100) % 256; // Slow hue rotation for extra dynamism
|
|
plasma_params.noise_amplitude = 0.6f + 0.4f * sin(now * 0.001f); // Breathing noise effect
|
|
|
|
// Update palette manager with auto-cycling and manual control
|
|
palette_manager.update(now, autoPalette.value(), getPaletteIndex(palettes.value()));
|
|
|
|
// Update variant manager with enhanced parameters
|
|
variant_manager.update(now, autoCycle.value(), getVariantIndex(variants.value()), plasma_params);
|
|
|
|
// KICKASS rendering with performance optimizations
|
|
for (int i = 0; i < NUM_LEDS; i++) {
|
|
RingCoord coord = ring_lut.fastRingCoord(i);
|
|
CRGB pixel_color = variant_manager.renderPixel(coord, now);
|
|
|
|
// Apply global brightness and gamma correction for better visual quality
|
|
float global_brightness = brightness.as<float>();
|
|
pixel_color.r = (uint8_t)(pixel_color.r * global_brightness);
|
|
pixel_color.g = (uint8_t)(pixel_color.g * global_brightness);
|
|
pixel_color.b = (uint8_t)(pixel_color.b * global_brightness);
|
|
|
|
leds[i] = pixel_color;
|
|
}
|
|
|
|
// Optional: Add subtle sparkle overlay for extra visual interest
|
|
EVERY_N_MILLISECONDS(50) {
|
|
// Add random sparkles to 1% of LEDs
|
|
int sparkle_count = NUM_LEDS / 100 + 1;
|
|
for (int s = 0; s < sparkle_count; s++) {
|
|
int sparkle_pos = random16() % NUM_LEDS;
|
|
if (random8() > 250) { // Very rare sparkles
|
|
leds[sparkle_pos] = blend(leds[sparkle_pos], CRGB::White, 128);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void loop() {
|
|
// Allow the dither to be enabled and disabled.
|
|
controller->setDither(useDither ? BINARY_DITHER : DISABLE_DITHER);
|
|
uint32_t now = millis();
|
|
uint8_t bri = pir.transition(now);
|
|
FastLED.setBrightness(bri * brightness.as<float>());
|
|
// Apply leds generation to the leds.
|
|
draw(now);
|
|
|
|
|
|
FastLED.show();
|
|
}
|