Add metaball blob demo effect

With a python test script using the DDP protocol

Author: jacob toft pedersen

blobs.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+import socket
+import numpy as np
+import time
+import math
+
+# ==============================
+# Config
+# ==============================
+WIDTH, HEIGHT = 16, 16       # Display size
+SIM_SCALE = 8                # Simulation resolution multiplier
+SIM_W, SIM_H = WIDTH*SIM_SCALE, HEIGHT*SIM_SCALE
+
+NUM_BALLS = 4
+RADIUS = 3.0 * SIM_SCALE                 # Radius in simulation pixels
+SPEED = 0.6 * SIM_SCALE                 # Speed in simulation pixels/frame
+GAMMA = 1.7
+CAP_VALUE = 3.0              # Max field value before tone-mapping
+
+IP = "192.168.1.112"
+PORT = 4048
+FPS = 40
+
+# ==============================
+# DDP sender
+# ==============================
+def create_packet(pixels=None):
+    packet = bytearray([
+        0x41,  # Version 1
+        0x00,  # Flags
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    ])
+    data = bytearray([0] * (WIDTH * HEIGHT * 3))
+    if pixels:
+        for x, y, brightness in pixels:
+            if 0 <= x < WIDTH and 0 <= y < HEIGHT and 0 <= brightness <= 255:
+                idx = (y * WIDTH + x) * 3
+                data[idx:idx + 3] = [brightness] * 3
+    packet.extend(data)
+    return packet
+
+def send_ddp_packet(ip, port, packet):
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        sock.sendto(packet, (ip, port))
+    finally:
+        sock.close()
+
+# ==============================
+# Metaball simulation
+# ==============================
+balls = []
+for _ in range(NUM_BALLS):
+    x = np.random.uniform(0, SIM_W)
+    y = np.random.uniform(0, SIM_H)
+    vx = np.random.uniform(-SPEED, SPEED)
+    vy = np.random.uniform(-SPEED, SPEED)
+    balls.append([x, y, vx, vy])
+
+def attenuation_fn(d, radius=RADIUS):
+    if d > radius:
+        return 0.0
+    return (1 - (d / radius)**2)**2
+
+def tone_map(v, gamma=GAMMA):
+    v_capped = min(v, CAP_VALUE)
+    n = v_capped / CAP_VALUE
+    return int(pow(n, 1 / gamma) * 255)
+
+def update_positions():
+    for b in balls:
+        b[0] += b[2]
+        b[1] += b[3]
+        if b[0] < 0 or b[0] >= SIM_W:
+            b[2] *= -1
+        if b[1] < 0 or b[1] >= SIM_H:
+            b[3] *= -1
+
+def render_highres():
+    grid = np.zeros((SIM_H, SIM_W), dtype=float)
+    for y in range(SIM_H):
+        for x in range(SIM_W):
+            val = 0.0
+            for bx, by, _, _ in balls:
+                d = math.dist((x, y), (bx, by))
+                val += attenuation_fn(d)
+            grid[y, x] = val
+    return grid
+
+def downsample(grid):
+    """Average SIM_SCALE×SIM_SCALE blocks into one pixel"""
+    pixels = []
+    for y in range(HEIGHT):
+        for x in range(WIDTH):
+            block = grid[
+                y*SIM_SCALE:(y+1)*SIM_SCALE,
+                x*SIM_SCALE:(x+1)*SIM_SCALE
+            ]
+            avg_val = block.mean()
+            brightness = tone_map(avg_val)
+            pixels.append((x, y, brightness))
+    return pixels
+
+# ==============================
+# Main loop
+# ==============================
+def main():
+    try:
+        while True:
+            update_positions()
+            highres = render_highres()
+            pixels = downsample(highres)
+            packet = create_packet(pixels)
+            send_ddp_packet(IP, PORT, packet)
+            time.sleep(1 / FPS)
+    except KeyboardInterrupt:
+        pass
+
+if __name__ == "__main__":
+    main()

include/plugins/Blop.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "PluginManager.h"
+#include <cmath>
+#include <cstdlib>
+
+class BlobPlugin : public Plugin
+{
+public:
+    static constexpr float aspect_ratio = 1.5f;
+    static constexpr uint8_t X_MAX = 16;
+    static constexpr uint8_t Y_MAX = static_cast<uint8_t>(X_MAX * aspect_ratio);
+
+    static constexpr uint8_t NUM_BALLS = 5;
+
+    BlobPlugin();
+    virtual ~BlobPlugin() {}
+
+    void setup() override;
+    void loop() override;
+    const char* getName() const override;
+
+private:
+    struct Ball {
+        float x, y;
+        float vx, vy;
+    };
+
+    Ball balls[NUM_BALLS];
+
+    static constexpr float RADIUS = 7.0f;
+    static constexpr float SPEED = 0.2f;
+    static constexpr float CAP_VALUE = 3.0f;
+    static constexpr float GAMMA = 0.7f;
+
+    float attenuation(float d, float radius) const;
+    uint8_t toneMap(float v) const;
+    void updatePositions();
+};

src/main.cpp

@@ -32,6 +32,7 @@
 #include "plugins/StarsPlugin.h"
 #include "plugins/TickingClockPlugin.h"
 #include "plugins/ArtNet.h"
+#include "plugins/Blop.h"
 
 #ifdef ENABLE_SERVER
 #include "plugins/AnimationPlugin.h"
@@ -166,6 +167,7 @@ void baseSetup()
   pluginManager.addPlugin(new CirclePlugin());
   pluginManager.addPlugin(new RainPlugin());
   pluginManager.addPlugin(new FireworkPlugin());
+  pluginManager.addPlugin(new BlobPlugin());
 
 #ifdef ENABLE_SERVER
   pluginManager.addPlugin(new BigClockPlugin());

src/plugins/Blop.cpp

@@ -0,0 +1,76 @@
+#include "plugins/Blop.h"
+#include "screen.h"  // Uses global Screen
+
+BlobPlugin::BlobPlugin()
+{
+    // Nothing special here, setup() will handle init
+}
+
+void BlobPlugin::setup()
+{
+    Screen.clear();
+
+    for (auto &b : balls) {
+        b.x = static_cast<float>(rand() % X_MAX);
+        b.y = static_cast<float>(rand() % Y_MAX);
+        b.vx = ((rand() % 200) / 100.0f - 1.0f) * SPEED * 2;
+        b.vy = ((rand() % 200) / 100.0f - 1.0f) * SPEED * 2;
+    }
+}
+
+void BlobPlugin::loop()
+{
+    Screen.clear();
+
+    for (uint8_t y = 0; y < ROWS; ++y) {
+        for (uint8_t x = 0; x < COLS; ++x) {
+            float value = 0.0f;
+
+            for (const auto &b : balls) {
+                float dx = b.x - static_cast<float>(x);
+                float dy = b.y - static_cast<float>(y*aspect_ratio);
+                float dist = std::sqrt(dx * dx + dy * dy);
+                value += attenuation(dist, RADIUS);
+            }
+
+            uint8_t brightness = toneMap(value);
+            Screen.setPixel(x, y, 1, brightness);
+        }
+    }
+
+    updatePositions();
+    delay(50); // ~20 FPS
+}
+
+const char* BlobPlugin::getName() const
+{
+    return "Blobs";
+}
+
+float BlobPlugin::attenuation(float d, float radius) const
+{
+    if (d > radius) return 0.0f;
+    float ratio = d / radius;
+    return (1.0f - ratio * ratio) * (1.0f - ratio * ratio);
+}
+
+uint8_t BlobPlugin::toneMap(float v) const
+{
+    if (v > CAP_VALUE) v = CAP_VALUE;
+    float n = v / CAP_VALUE;
+    float corrected = std::pow(n, 1.0f / GAMMA);
+    return static_cast<uint8_t>(corrected * 255.0f);
+}
+
+void BlobPlugin::updatePositions()
+{
+    for (auto &b : balls) {
+        b.x += b.vx;
+        b.y += b.vy;
+
+        if (b.x < 0) { b.x = 0; b.vx *= -1; }
+        if (b.x >= X_MAX) { b.x = X_MAX - 1; b.vx *= -1; }
+        if (b.y < 0) { b.y = 0; b.vy *= -1; }
+        if (b.y >= Y_MAX) { b.y = Y_MAX - 1; b.vy *= -1; }
+    }
+}