#include "Animations.h" #include "Graphics.h" #include "Config.h" #include "Renderer.h" #include #ifndef TWO_PI #define TWO_PI 6.28318530717958647692528676655900576f #endif enum AnimType { ANIM_SINEWAVE = 0, ANIM_BOUNCING_BALL, ANIM_LINES, ANIM_ZONE_TRANSFORM, ANIM_SPECTRUM2, ANIM_TEXT, ANIM_COUNT }; static uint8_t currentAnim = ANIM_SINEWAVE; static bool isAnimInitialized = false; static char* textPointers[MAX_ZONES]; bool isAnimationEnabled(uint8_t animIndex) { switch (animIndex) { case ANIM_SINEWAVE: return appConfig.enableSinewave; case ANIM_BOUNCING_BALL: return appConfig.enableBouncingBall; case ANIM_LINES: return appConfig.enableLines; case ANIM_ZONE_TRANSFORM: return appConfig.enableZoneTransform; case ANIM_SPECTRUM2: return appConfig.enableSpectrum2; case ANIM_TEXT: return appConfig.enableText; default: return false; } } void nextAnimation() { uint8_t attempts = 0; uint8_t nextAnim = currentAnim; do { nextAnim = (nextAnim + 1) % ANIM_COUNT; attempts++; } while (!isAnimationEnabled(nextAnim) && attempts < ANIM_COUNT); if (isAnimationEnabled(nextAnim)) { currentAnim = nextAnim; isAnimInitialized = false; // Reset setup state Graphics::clear(); Renderer::clearHardware(); } } // ------------------------------------------------------------------- // 1. ANIMASI SINEWAVE // ------------------------------------------------------------------- void animSinewave() { #define SW_DATA_WIDTH 11 // Pola gelombang asli versi legacy static const uint8_t waves[][SW_DATA_WIDTH] = { { 9, 8, 6, 1, 6, 24, 96, 128, 96, 16, 0 }, { 6, 12, 2, 12, 48, 64, 48, 0, 0, 0, 0 }, { 10, 12, 2, 1, 2, 12, 48, 64, 128, 64, 48 } }; static const uint8_t WAVE_COUNT = sizeof(waves) / (SW_DATA_WIDTH * sizeof(uint8_t)); static uint8_t curWave = 0; static uint8_t idx = 1; uint16_t width = Graphics::getWidth(); uint16_t height = Graphics::getHeight(); // Buffer internal animasi untuk menyimpan riwayat byte per kolom // Ukuran dinamis/fleksibel mengikuti lebar layar static uint8_t historyBuffer[MAX_TOTAL_MODULES * 8] = {0}; // 1. Geser riwayat kolom ke kiri (Shift Left internal animasi) for (uint16_t x = 0; x < width - 1; x++) { historyBuffer[x] = historyBuffer[x + 1]; } // 2. Masukkan byte pola legacy baru di ujung kanan historyBuffer[width - 1] = waves[curWave][idx++]; // 3. Render ke Graphics Core Generik Graphics::clear(); for (uint16_t x = 0; x < width; x++) { uint8_t columnByte = historyBuffer[x]; if (columnByte == 0) continue; // Optimasi skip kolom kosong // Gambar bitwise piksel sesuai tinggi layar yang aktif for (uint8_t y = 0; y < height && y < 8; y++) { if (columnByte & (1 << y)) { Graphics::setPixel(x, y, true); } } } // 4. Pilih pola acak baru jika siklus wave selesai if (idx > waves[curWave][0]) { curWave = random(WAVE_COUNT); idx = 1; } // Kirim buffer ke display via Renderer Renderer::renderGraphics(appConfig.brightness); } // ------------------------------------------------------------------- // 2. ANIMASI HORIZONTAL LINES // ------------------------------------------------------------------- void animDrawLines() { Graphics::clear(); Graphics::drawHorizontalLine(2, true); Graphics::drawHorizontalLine(5, true); Renderer::renderGraphics(appConfig.brightness); } // ------------------------------------------------------------------- // 3. ANIMASI BOUNCING BALL (Presisi Bouncing Ter-mitigasi) // ------------------------------------------------------------------- void animBouncingBall() { static float posX = 2.0f, posY = 2.0f; static float velX = 0.8f, velY = 0.4f; Graphics::clear(); float maxX = (float)(Graphics::getWidth() - 1); float maxY = (float)(Graphics::getHeight() - 1); posX += velX; posY += velY; // Evaluasi Bouncing Setelah Posisi Terupdate if (posY <= 0.0f) { posY = 0.0f; velY = -velY; } else if (posY >= maxY) { posY = maxY; velY = -velY; } if (posX <= 0.0f) { posX = 0.0f; velX = -velX; } else if (posX >= maxX) { posX = maxX; velX = -velX; } Graphics::setPixel((int16_t)roundf(posX), (int16_t)roundf(posY), true); Renderer::renderGraphics(appConfig.brightness); } // ------------------------------------------------------------------- // 4. ANIMASI ZONE TRANSFORMATION // ------------------------------------------------------------------- // Font Bitmap Mini 5x7 khusus untuk Panah (ASCII 24, 25, 26, 27) static const uint8_t PROGMEM ARROW_FONTS[][5] = { { 0x08, 0x0C, 0xFE, 0x0C, 0x08 }, // ASCII 24: Panah Atas (Up) { 0x10, 0x30, 0x7F, 0x30, 0x10 }, // ASCII 25: Panah Bawah (Down) { 0x10, 0x28, 0x44, 0xFE, 0x00 }, // ASCII 26: Panah Kanan (Right) { 0x00, 0xFE, 0x44, 0x28, 0x10 } // ASCII 27: Panah Kiri (Left) }; // Tipe Transformasi Zona enum ZoneTransformType { ZONE_TSR, // Transform Shift Right ZONE_TSL, // Transform Shift Left ZONE_TSU, // Transform Shift Up ZONE_TSD // Transform Shift Down }; // Helper: Menggambar Karakter Panah ke Graphics Canvas static void drawArrowChar(uint16_t startX, uint8_t arrowIdx) { if (arrowIdx > 3) return; uint16_t h = Graphics::getHeight(); uint8_t startY = (h > 7) ? (h - 7) / 2 : 0; // Center vertikal for (uint8_t col = 0; col < 5; col++) { uint8_t line = pgm_read_byte(&ARROW_FONTS[arrowIdx][col]); for (uint8_t row = 0; row < 7; row++) { if (line & (1 << row)) { Graphics::setPixel(startX + col, startY + row, true); } } } } // Helper: Melakukan Pergeseran (Shift + Wraparound) pada Area Zona Tertentu static void transformZoneArea(uint16_t startX, uint16_t endX, ZoneTransformType tt) { uint16_t height = Graphics::getHeight(); uint16_t zoneWidth = endX - startX + 1; switch (tt) { case ZONE_TSR: { // Shift Right (Geser ke Kanan + Wraparound) for (uint16_t y = 0; y < height; y++) { bool lastPixel = Graphics::getPixel(endX, y); for (uint16_t x = endX; x > startX; x--) { Graphics::setPixel(x, y, Graphics::getPixel(x - 1, y)); } Graphics::setPixel(startX, y, lastPixel); // Wraparound ke paling kiri zona } break; } case ZONE_TSL: { // Shift Left (Geser ke Kiri + Wraparound) for (uint16_t y = 0; y < height; y++) { bool firstPixel = Graphics::getPixel(startX, y); for (uint16_t x = startX; x < endX; x++) { Graphics::setPixel(x, y, Graphics::getPixel(x + 1, y)); } Graphics::setPixel(endX, y, firstPixel); // Wraparound ke paling kanan zona } break; } case ZONE_TSU: { // Shift Up (Geser ke Atas + Wraparound) for (uint16_t x = startX; x <= endX; x++) { bool topPixel = Graphics::getPixel(x, 0); for (uint16_t y = 0; y < height - 1; y++) { Graphics::setPixel(x, y, Graphics::getPixel(x, y + 1)); } Graphics::setPixel(x, height - 1, topPixel); // Wraparound ke paling bawah zona } break; } case ZONE_TSD: { // Shift Down (Geser ke Bawah + Wraparound) for (uint16_t x = startX; x <= endX; x++) { bool bottomPixel = Graphics::getPixel(x, height - 1); for (uint16_t y = height - 1; y > 0; y--) { Graphics::setPixel(x, y, Graphics::getPixel(x, y - 1)); } Graphics::setPixel(x, 0, bottomPixel); // Wraparound ke paling atas zona } break; } } } // ------------------------------------------------------------------- // ANIMASI ZONE TRANSFORM (Refactored untuk Graphics Core Generik) // ------------------------------------------------------------------- void animZoneTransform() { static bool initialized = false; // Ambil parameter konfigurasi aktif uint8_t totalZones = appConfig.activeZones; uint8_t modulesPerZone = appConfig.modulesPerZone; uint16_t totalWidth = Graphics::getWidth(); // Mapping Arah Transformasi per Zona (Right, Down, Up, Left) static const ZoneTransformType zoneDirections[4] = { ZONE_TSR, // Zona 1: Shift Right ZONE_TSD, // Zona 2: Shift Down ZONE_TSU, // Zona 3: Shift Up ZONE_TSL // Zona 4: Shift Left }; // 1. INITIALIZATION: Inisialisasi Teks/Karakter Panah di Awal Animasi if (!initialized) { Graphics::clear(); for (uint8_t z = 0; z < totalZones; z++) { uint16_t startX = z * (modulesPerZone * 8); uint16_t endX = startX + (modulesPerZone * 8) - 1; if (endX >= totalWidth) endX = totalWidth - 1; // Tempatkan panah di tengah-tengah setiap modul dalam zona tersebut for (uint8_t m = 0; m < modulesPerZone; m++) { uint16_t modStartX = startX + (m * 8); if (modStartX + 5 <= totalWidth) { drawArrowChar(modStartX + 1, z % 4); // Gambarkan panah } } } initialized = true; } // 2. RUN TRANSFORMATION: Eksekusi Transformasi Pergeseran per Zona for (uint8_t z = 0; z < totalZones; z++) { uint16_t startX = z * (modulesPerZone * 8); uint16_t endX = startX + (modulesPerZone * 8) - 1; if (startX >= totalWidth) break; if (endX >= totalWidth) endX = totalWidth - 1; // Eksekusi arah geser sesuai indeks zona transformZoneArea(startX, endX, zoneDirections[z % 4]); } // Render ke layar fisik Renderer::renderGraphics(appConfig.brightness); } // Helper untuk reset state saat animasi diganti void resetAnimZoneTransform() { // Dipanggil saat switch animasi agar re-init karakter panah } // ------------------------------------------------------------------- // 5. ANIMASI SPECTRUM 2 // ------------------------------------------------------------------- // ------------------------------------------------------------------- // 5. ANIMASI SPECTRUM 2 (Sudah Dirapikan & Konsisten) // ------------------------------------------------------------------- void animSpectrum2() { uint16_t width = Graphics::getWidth(); Graphics::clear(); // Bersihkan framebuffer untuk frame baru for (uint16_t x = 0; x < width; x++) { // Ambil tinggi grafik acak (0 - 8 piksel) uint8_t h = random(0, 9); // Gambar piksel dari bawah (y = 7) ke atas setinggi h for (uint8_t y = 0; y < h; y++) { Graphics::setPixel(x, 7 - y, true); } } Renderer::renderGraphics(appConfig.brightness); } // ------------------------------------------------------------------- // 6. ANIMASI TEXT (PAROLA) // ------------------------------------------------------------------- void animText() { if (!isAnimInitialized) { for (uint8_t i = 0; i < appConfig.activeZones; i++) { textPointers[i] = appConfig.textLines[i]; } isAnimInitialized = true; } TextConfig textCfg = { .activeZones = appConfig.activeZones, .modulesPerZone = appConfig.modulesPerZone, .textInFx = appConfig.textInFx, .textOutFx = appConfig.textOutFx, .textAlign = appConfig.textAlign, .animationSpeed = appConfig.animationSpeed, .textPause = appConfig.textPause, .brightness = appConfig.brightness, .textLines = textPointers }; Renderer::renderText(textCfg); } // ------------------------------------------------------------------- // EXECUTION ROUTINE // ------------------------------------------------------------------- void runCurrentAnimation() { if (!isAnimationEnabled(currentAnim)) { nextAnimation(); if (!isAnimationEnabled(currentAnim)) { Graphics::clear(); Renderer::clearHardware(); return; } } switch (currentAnim) { case ANIM_SINEWAVE: animSinewave(); break; case ANIM_BOUNCING_BALL: animBouncingBall(); break; case ANIM_LINES: animDrawLines(); break; case ANIM_ZONE_TRANSFORM: animZoneTransform(); break; case ANIM_SPECTRUM2: animSpectrum2(); break; case ANIM_TEXT: animText(); break; } }