Updated version to work on Apple Silicon Macs - tested on MacOS Tahoe

[tribblecoder]

Hi all — I updated the source files to work with modern Macs (with the help of ChatGPT). I was struggling to get it working on my machine, and thankfully @lh84 posted a snippet of code that got me in the right direction.

This version does two big things:

• Adds a dropdown selector for audio input source so you can pick BlackHole / Loopback / etc.
• Moves the Stage output to its own fullscreen PApplet on the external display, which brings back true fullscreen on macOS and hides the menu bar on the projector.

How to use this:

1. Install the Processing framework (follow the instructions in the repo README).
2. Download / clone the project and open it in Processing.
3. Replace the entire contents of the MusicBeam tab with the code below.
4. Replace the entire contents of the Stage tab with the code below.
5. Press Run in Processing.

After that:
The control window will stay on your main display.
The Stage window will go fullscreen on the external display (and hide the menu bar).
You can choose live audio input / loopback from the dropdown.

MusicBeam.pde

import java.util.LinkedList;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import java.awt.GraphicsEnvironment;
import java.awt.GraphicsDevice;

import controlP5.*;

import ddf.minim.*;
import ddf.minim.analysis.*;

import javax.sound.sampled.*; // for Mixer, TargetDataLine, etc.

String version = "2.8.1";

public Boolean debugMode = false;

Stage stage = null;

Strobe_Effect strobo;

ControlP5 cp5;

Minim minim;

AudioSource in;

BeatDetect bdFreq, bdSound;

PImage[] randomImg;

LinkedList<Beat> beatHistory = new LinkedList<Beat>();

Effect[] effectArray;

DropdownList displays;
DropdownList mixerDropdown; // dropdown for audio input device

Toggle projectorToggle, randomToggle;
Slider randomTimeSlider, beatDelaySlider, minLevelSlider;
Button nextButton;
RadioButton activeEffect, activeSetting;

// === Mixer management ===
Mixer.Info[] mixerInfoAll;          // full list from JavaSound
ArrayList<Integer> candidateMixerMap = new ArrayList<Integer>();
// candidateMixerMap[n] = index into mixerInfoAll for dropdown row n
int currentMixerInfoIdx = -1;       // index into mixerInfoAll we are actually using

float randomTimer = 0;

int randomEffect = 0;
int width = 775;
int height = 670;

float maxLevel = 0;
float goalMaxLevel=0;

void settings() {
  if (! debugMode)
    checkForUpdate();
  
  pixelDensity(displayDensity());
  initAudioInput(); // populates mixers + opens an input

  if(!hasEnoughScreenDevices()) {
    String msg = "No second screen device detected!\n"
      +"Please make sure to attach your video projector before you launch MusicBeam.\n"
      +"Do you want to launch MusicBeam anyway?";
    int close = JOptionPane.showConfirmDialog(null, msg, "Device detection", JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);
    if (close == JOptionPane.NO_OPTION)
      System.exit(1);
  }

  size(width, height);
}

void setup() {
  surface.setTitle("MusicBeam v"+version);
  
  colorMode(HSB, 360, 100, 100);

  initControls();
}

void draw() {
  if (stage==null)
    beatDetect();
  background(25);

  noStroke();

  drawBeatBoard();

  if (effectArray!=null) {
    // hide all settings panes
    for (Effect e : effectArray) {
      e.hideControls();
    }
    // then show the one currently selected (if any)
    if (int(activeSetting.getValue())>=0) {
      effectArray[int(activeSetting.getValue())].showControls();
    }
  }

  if (randomToggle!=null) {
    if (randomToggle.getState() && randomTimer>=randomTimeSlider.getValue()*60) {
      nextRandom();
    } else if (randomToggle.getState()) {
      randomTimer++;
    }
  }
}

// Graceful shutdown so Stage / audio don't explode when the main window closes
@Override
void exit() {
  println("MusicBeam shutting down...");

  // stop the stage window if it exists
  try {
    if (stage != null) {
      stage.noLoop();        // stop its draw()
      stage.exit();          // ask Stage PApplet to close its own window
      stage = null;
    }
  } catch (Exception e) {
    println("Error while closing stage: " + e.getMessage());
  }

  // release audio safely
  try {
    if (in != null) {
      in.close();
      in = null;
    }
  } catch (Exception e) {
    println("Error while closing audio input: " + e.getMessage());
  }

  try {
    if (minim != null) {
      minim.stop();          // tells Minim to release the mixer
      minim = null;
    }
  } catch (Exception e) {
    println("Error while stopping Minim: " + e.getMessage());
  }

  // now let Processing actually quit
  super.exit();
}

void nextRandom()
{
  int k = randomEffect;
  while (randomEffect==k || !effectArray[k].randomToggle.getState())
    k = int(random(effectArray.length));
  randomEffect = k;
  activeEffect.activate(randomEffect);
  randomTimer = 0;
}

void controlEvent(ControlEvent event)
{
  // "Next Effect"
  if (event.getName()=="next")
    nextRandom();

  // Mixer dropdown changed
  if (mixerDropdown != null && event.isFrom(mixerDropdown)) {
    int dropdownIdx = int(event.getValue());   // row in dropdown
    if (dropdownIdx >= 0 && dropdownIdx < candidateMixerMap.size()) {
      int mixerInfoIdx = candidateMixerMap.get(dropdownIdx);
      println("User selected dropdown row " + dropdownIdx + " -> mixer " + mixerInfoAll[mixerInfoIdx].getName());
      boolean ok = setAudioInputByMixerInfoIndex(mixerInfoIdx);
      if (ok) {
        mixerDropdown.setCaptionLabel(mixerInfoAll[mixerInfoIdx].getName());
      } else {
        // if it failed, keep old caption
        println("Failed to open that mixer, staying on previous input.");
      }
    }
  }
}

void drawBeatBoard()
{
  fill(200, 100, 20);
  rect(10, 10, 354, 122);
  fill(120, 100, getLevel()>minLevelSlider.getValue()&&bdFreq.isHat() ? 100 : 20);
  rect(365, 10, 40, 40);
  fill(220, 100, getLevel()>minLevelSlider.getValue()&&bdFreq.isSnare() ? 100 : 20);
  rect(365, 51, 40, 40);
  fill(320, 100, getLevel()>minLevelSlider.getValue()&&bdFreq.isKick() ? 100 : 20);
  rect(365, 92, 40, 40);
  fill(0);

  textSize(32);
  textAlign(CENTER, CENTER);
  text("H", 385, 26);
  text("S", 385, 67);
  text("K", 385, 108);
  textAlign(LEFT, BOTTOM);
  drawBeatHistory(beatHistory, 10, 110);
}

/** Draws a beat Visualisation.
 */
void drawBeatHistory(LinkedList<Beat> history, int x, int y)
{
  history.add(new Beat(isHat(), isSnare(), isKick(), isOnset(), getLevel()));
  goalMaxLevel=0;
  for (int i=0; i < history.size(); i++) {
    Beat b = history.get(i);
    if (b.level>goalMaxLevel)
      goalMaxLevel=b.level;
  }
  if (maxLevel<goalMaxLevel)maxLevel+=(goalMaxLevel-maxLevel)/2;
  for (int i=0; i < history.size(); i++) {
    Beat b = history.get(i);

    if (b.hat)
      stroke(120, 100, 100);
    else if (b.snare)
      stroke(220, 100, 100);
    else if (b.kick)
      stroke(320, 100, 100);
    else if (b.onset)
      stroke(0, 0, 100);
    else
      stroke(200, 100, 50);

    float d = 95*b.level/maxLevel;
    line(x+i, y-d, x+i, y);

    if (b.hat)
      stroke(120, 100, 30);
    else if (b.snare)
      stroke(220, 100, 30);
    else if (b.kick)
      stroke(320, 100, 30);
    else if (b.onset)
      stroke(0, 0, 30);
    else
      stroke(200, 100, 30);

    float e = 20*b.level/maxLevel;
    line(x+i, y+e, x+i, y);
  }
  if (history.size()>= 343)
    history.removeFirst();
  stroke(50, 20, 60);
  float n = (minLevelSlider.getValue()/maxLevel*95);
  float level = minLevelSlider.getValue();
  if (level*5 > maxLevel*4) {
    minLevelSlider.setValue(level*0.99);
  } else if (level*5 < maxLevel) {
    minLevelSlider.setValue(level*1.01);
  }
  if (n>98)
  {
    stroke(50, 20, 30);
    n=98;
  }
  line(x, y-n, x+343, y-n);
  stroke(0);
  maxLevel*=0.99;
}

int projectorDisplayNumber() {
  GraphicsDevice[] gs =
    GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices();

  if (gs != null && gs.length > 1) {
    // If you have more than one display,
    // choose the LAST one as the projector target.
    // Processing's fullScreen(display) is 1-based, so last display = gs.length
    return gs.length;
  } else {
    // Only one display, just use display #1
    return 1;
  }
}

void initControls()
{
  cp5 = new ControlP5(this);
  cp5.setFont(createFont("Monospaced", 12 / displayDensity()));

  beatDelaySlider = cp5.addSlider("beatDelay").setSize(395, 20).setPosition(10, 134).setRange(10, 1000);
  beatDelaySlider.getCaptionLabel().set("Beat Delay (ms)").align(ControlP5.CENTER, ControlP5.CENTER);
  beatDelaySlider.setValue(200);

  minLevelSlider = cp5.addSlider("minLevel").setSize(10, 122).setPosition(354, 10).setRange(0, 1);
  minLevelSlider.setLabelVisible(false);
  minLevelSlider.setValue(0.1);

  // === Mixer dropdown ===
  mixerDropdown = cp5.addDropdownList("mixerSelect")
    .setPosition(10, 170)
    .setSize(300, 200);

  mixerDropdown.setBarHeight(18);
  mixerDropdown.setItemHeight(16);
  mixerDropdown.setOpen(false);

  mixerDropdown.getCaptionLabel().set("Audio Input / Mixer");

  // populate dropdown from candidateMixerMap
  for (int ddIdx = 0; ddIdx < candidateMixerMap.size(); ddIdx++) {
    int infoIdx = candidateMixerMap.get(ddIdx);
    String label = mixerInfoAll[infoIdx].getName();
    mixerDropdown.addItem(label, ddIdx);
  }

  // caption = whichever we ended up using
  if (currentMixerInfoIdx >= 0 && currentMixerInfoIdx < mixerInfoAll.length) {
    mixerDropdown.setCaptionLabel(mixerInfoAll[currentMixerInfoIdx].getName());
  } else {
    mixerDropdown.setCaptionLabel("Default Input (System)");
  }

  stage = new Stage(this, projectorDisplayNumber());
  String[] args = {"Stage"};
  PApplet.runSketch(args, stage);
  stage.noLoop();
  initEffects();
  initSettings();
  stage.loop();
}

void initRandomControls() {
  randomToggle = cp5.addToggle("random")
    .setSize(135, 45)
    .setPosition(415, 10);
  randomToggle.getCaptionLabel().set("Play Random").align(ControlP5.CENTER, ControlP5.CENTER);

  randomTimeSlider = cp5.addSlider("randomTime")
    .setSize(210, 45)
    .setPosition(555, 10)
    .setRange(1, 60);
  randomTimeSlider.getCaptionLabel().set("Random Time (s)").align(ControlP5.CENTER, ControlP5.CENTER);
  randomTimeSlider.setValue(20);

  nextButton = cp5.addButton("next")
    .setSize(350, 45)
    .setPosition(415, 60);
  nextButton.getCaptionLabel().set("Next Effect").align(ControlP5.CENTER, ControlP5.CENTER);

  activeEffect = cp5.addRadioButton("activeEffects")
    .setPosition(415, 115)
    .setSize(250, 45)
    .setItemsPerRow(1)
    .setSpacingRow(5)
    .setNoneSelectedAllowed(true);  // allow none selected at startup

  activeSetting = cp5.addRadioButton("activeSettings")
    .setPosition(720, 115)
    .setSize(45, 45)
    .setItemsPerRow(1)
    .setSpacingRow(5)
    .setNoneSelectedAllowed(true);  // allow hiding the edit panel
}

void initEffects() {
  initRandomControls();

  effectArray = new Effect[11];
  effectArray[0]  = new Blackout_Effect(this, 0);
  effectArray[1]  = new Strobe_Effect(this, 1);
  effectArray[2]  = new Scanner_Effect(this, 2);
  effectArray[3]  = new Moonflower_Effect(this, 3);
  effectArray[4]  = new RGBSpot_Effect(this, 4);
  effectArray[5]  = new Derby_Effect(this, 5);
  effectArray[6]  = new Snowstorm_Effect(this, 6);
  effectArray[7]  = new LaserBurst_Effect(this, 7);
  effectArray[8]  = new Polygon_Effect(this, 8);
  effectArray[9]  = new Vortex_Effect(this, 9);
  effectArray[10] = new Raindrops_Effect(this, 10);

  // DO NOT call activeSetting.activate(0);  // we want no panel open by default

  // label alignment like before
  for (Toggle t : activeEffect.getItems()) {
    t.getCaptionLabel().align(LEFT, CENTER);
  }

  for (Toggle t : activeSetting.getItems()) {
    t.getCaptionLabel().set("EDIT").align(CENTER, CENTER);
  }

  // --- ensure nothing is "editing" on startup ---

  // 1. turn every EDIT toggle off using public API
  for (Toggle t : activeSetting.getItems()) {
    t.setState(false); // instead of t.deactivate(); fixes visibility error
  }

  // 2. tell ControlP5 that no setting is selected
  activeSetting.setValue(-1);

  // 3. hide ALL effect control groups so nothing shows at launch
  for (Effect e : effectArray) {
    e.hideControls();
  }
}

void beatDetect()
{
  if (bdSound != null && bdFreq != null && in != null) {
    bdSound.setSensitivity(int(beatDelaySlider.getValue()));
    bdFreq.setSensitivity(int(beatDelaySlider.getValue()));
    bdSound.detect(in.mix);
    bdFreq.detect(in.mix);
  }
}

void checkForUpdate() {
  String[] lines = loadStrings("https://api.github.com/repos/codingjoe/musicbeam/releases/latest");
  if (lines == null) return;

  // build one JSON string
  String jsonString = "";
  for (int i = 0; i < lines.length; i++) {
    jsonString += lines[i];
  }

  JSONObject json = parseJSONObject(jsonString);
  String remoteTag = json.getString("tag_name");   // e.g. "v2.7.0"
  String localTag  = version;                      // e.g. "2.8.1"

  // normalize (strip leading "v" or "V")
  remoteTag = stripLeadingV(remoteTag);
  localTag  = stripLeadingV(localTag);

  // if remote is actually newer than local, THEN prompt
  if (isRemoteNewer(remoteTag, localTag)) {
    int choice = JOptionPane.showConfirmDialog(
      null,
      "A newer version of MusicBeam is available. Do you want to download it now?",
      "Update available",
      JOptionPane.YES_NO_OPTION,
      JOptionPane.WARNING_MESSAGE
    );
    if (choice == JOptionPane.YES_OPTION) {
      launch("https://github.com/codingjoe/MusicBeam/releases/latest");
    }
  }
}

// remove "v" prefix like "v2.7.0"
String stripLeadingV(String s) {
  if (s == null) return "";
  if (s.startsWith("v") || s.startsWith("V")) {
    return s.substring(1);
  }
  return s;
}

// compare "a.b.c" style versions.
// return true if remote > local
boolean isRemoteNewer(String remoteVer, String localVer) {
  int[] r = parseVer(remoteVer);
  int[] l = parseVer(localVer);

  // compare major, minor, patch in order
  if (r[0] != l[0]) return r[0] > l[0];
  if (r[1] != l[1]) return r[1] > l[1];
  if (r[2] != l[2]) return r[2] > l[2];
  return false; // equal or older
}

int[] parseVer(String v) {
  // default [0,0,0] if weird
  int[] out = {0, 0, 0};
  if (v == null) return out;

  String[] parts = v.split("\\.");
  for (int i = 0; i < parts.length && i < 3; i++) {
    try {
      out[i] = Integer.parseInt(parts[i].trim());
    } catch (Exception e) {
      out[i] = 0;
    }
  }
  return out;
}

void keyPressed()
{
  if (effectArray!=null)
    for (int i = 0; i < effectArray.length; i++)
    {
      if (key == effectArray[i].triggeredByKey())
        effectArray[i].activate();
      if (effectArray[i].isActive())
        effectArray[i].keyPressed(key, keyCode);
    }
}

void keyReleased()
{
  if (effectArray!=null)
    for (int i = 0; i < effectArray.length; i++)
      if (effectArray[i].isActive())
        effectArray[i].keyReleased(key, keyCode);
}

boolean isHat()
{
  return getLevel()>minLevelSlider.getValue()?bdFreq.isHat():false;
}

boolean isSnare()
{
  return getLevel()>minLevelSlider.getValue()?bdFreq.isSnare():false;
}

boolean isKick()
{
  return getLevel()>minLevelSlider.getValue()?bdFreq.isKick():false;
}

boolean isOnset()
{
  return getLevel()>minLevelSlider.getValue()?bdSound.isOnset():false;
}

float getLevel()
{
  if (in == null || in.mix == null) return 0;
  if (in.mix.level()<0.0001)return 0;
  return in.mix.level();
}

private boolean hasEnoughScreenDevices()
{
  GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
  GraphicsDevice[] gs = ge.getScreenDevices();
  return gs.length > 1;
}

/* ================================
   AUDIO / MIXER LOGIC
   ================================ */

// try to actually open audio on a given Mixer.Info index.
// returns true if we succeeded.

@SuppressWarnings("deprecation")  // Minim.setInputMixer is deprecated in the API but still required.
boolean setAudioInputByMixerInfoIndex(int mixerInfoIdx) {
  if (mixerInfoAll == null) return false;
  if (mixerInfoIdx < 0 || mixerInfoIdx >= mixerInfoAll.length) return false;

  Mixer.Info mi = mixerInfoAll[mixerInfoIdx];
  Mixer m = AudioSystem.getMixer(mi);

  println("Attempting mixer: " + mi.getName());

  // close old input first
  if (in != null) {
    try {
      in.close();
    } catch (Exception e) {
      println("Couldn't close previous input: " + e.getMessage());
    }
  }

  // tell Minim to use this mixer
  minim.setInputMixer(m);

  // now try to open with formats that BlackHole / loopback devices actually allow
  AudioInput newIn = tryOpenInputForMixer();
  if (newIn == null) {
    println("Mixer " + mi.getName() + " did not return an input.");
    return false;
  }

  in = newIn;

  // rebuild beat detectors
  bdFreq = new BeatDetect(in.bufferSize(), in.sampleRate());
  bdSound = new BeatDetect();

  currentMixerInfoIdx = mixerInfoIdx;
  return true;
}

// helper that tries several getLineIn() signatures
AudioInput tryOpenInputForMixer() {
  AudioInput attempt = null;

  // 1. The most compatible for loopback devices is usually stereo @ 48000
  try {
    attempt = minim.getLineIn(Minim.STEREO, 512, 48000);
    if (attempt != null) return attempt;
  } catch (Exception e) {
    // swallow and try next
    println("tryOpenInputForMixer: stereo/48k failed: " + e.getMessage());
  }

  // 2. stereo @ 44100
  try {
    attempt = minim.getLineIn(Minim.STEREO, 512, 44100);
    if (attempt != null) return attempt;
  } catch (Exception e) {
    println("tryOpenInputForMixer: stereo/44.1k failed: " + e.getMessage());
  }

  // 3. mono @ 44100 (original behavior)
  try {
    attempt = minim.getLineIn(Minim.MONO, 512, 44100);
    if (attempt != null) return attempt;
  } catch (Exception e) {
    println("tryOpenInputForMixer: mono/44.1k failed: " + e.getMessage());
  }

  // If all fail, return null so we don't break.
  return null;
}

// scan JavaSound mixers and figure out which ones are actually usable inputs.
// We skip "Port ..." mixers and mixers with no TargetDataLine capability.
void buildInputCandidateList() {
  mixerInfoAll = AudioSystem.getMixerInfo();
  candidateMixerMap.clear();

  for (int i = 0; i < mixerInfoAll.length; i++) {
    Mixer.Info mi = mixerInfoAll[i];
    String name = mi.getName();
    Mixer m = AudioSystem.getMixer(mi);

    // ignore "Port ..." mixers (those are usually gain/volume controls, not audio streams)
    if (name != null && name.startsWith("Port ")) {
      continue;
    }

    // check if mixer can actually provide a TargetDataLine (recording line)
    Line.Info[] targets = m.getTargetLineInfo();
    boolean hasInputLine = false;
    for (int t = 0; t < targets.length; t++) {
      Class<?> c = targets[t].getLineClass();
      if (TargetDataLine.class.isAssignableFrom(c)) {
        hasInputLine = true;
        break;
      }
    }

    if (hasInputLine) {
      candidateMixerMap.add(i);
    }
  }
}

// Pick a "best guess" default:
// - something named BlackHole / Loopback / Soundflower / VB first
// - otherwise, just first candidate
int choosePreferredMixerInfoIdx() {
  int fallback = -1;
  for (int ddIdx = 0; ddIdx < candidateMixerMap.size(); ddIdx++) {
    int infoIdx = candidateMixerMap.get(ddIdx);
    String lower = mixerInfoAll[infoIdx].getName().toLowerCase();
    if (fallback == -1) fallback = infoIdx;
    if (lower.contains("blackhole")
     || lower.contains("loopback")
     || lower.contains("soundflower")
     || lower.contains("vb")) {
      return infoIdx;
    }
  }
  return fallback;
}

// Initialize Minim, enumerate mixers, open something usable, build detectors.
private void initAudioInput()
{
  String msg = "No audio input found!\n\n"
             + "Please check the audio settings on your current operating system.\n"
             + "There must be at least one audio input activated.";

  minim = new Minim(this);

  buildInputCandidateList(); // fills mixerInfoAll + candidateMixerMap

  boolean opened = false;

  if (!candidateMixerMap.isEmpty()) {
    int preferredInfoIdx = choosePreferredMixerInfoIdx();
    if (preferredInfoIdx != -1) {
      opened = setAudioInputByMixerInfoIndex(preferredInfoIdx);
    }
  }

  // Fallback: use Minim's default if we still don't have 'in'
  if (!opened || in == null) {
    println("Falling back to Minim default input.");
    try {
      in = minim.getLineIn(Minim.MONO, 512);
    } catch (Exception e) {
      println("Default getLineIn failed: " + e.getMessage());
    }

    if (in == null) {
      JOptionPane.showMessageDialog(null, msg, "Device detection", JOptionPane.ERROR_MESSAGE);
      System.exit(1);
    }

    bdFreq = new BeatDetect(in.bufferSize(), in.sampleRate());
    bdSound = new BeatDetect();

    currentMixerInfoIdx = -1; // "system default"
  }
}

Stage.pde

import java.awt.GraphicsEnvironment;
import java.awt.GraphicsDevice;
import processing.core.PApplet;

class Stage extends PApplet {

  // Reference to the main MusicBeam sketch (control window)
  MusicBeam ctrl;

  // Processing-style display number (1-based: 1 = main, 2 = external, etc.)
  int displayNumber;

  Stage(MusicBeam ctrl, int displayNumber) {
    this.ctrl = ctrl;
    this.displayNumber = displayNumber;
  }

  public void settings() {
    // macOS hides the menu bar ONLY if we go fullscreen here in settings().
    // fullScreen(displayNumber) is 1-based monitor selection.
    if (!ctrl.debugMode) {
      pixelDensity(1);
      fullScreen(P2D, displayNumber);   // projector / external screen
    } else {
      pixelDensity(1);
      size(1280, 720, P2D);             // windowed debug mode
    }
  }

  public void setup() {
    surface.setTitle("MusicBeam Stage");
    surface.setAlwaysOnTop(true);
    noCursor(); // hide the mouse on the projector

    // Match control window's color model for consistent hue/white math
    colorMode(HSB, 360, 100, 100);
  }

  public void draw() {
    // Drive beat detection from Stage once per frame
    ctrl.beatDetect();

    // Clear frame
    background(0);

    // Reset render state so every effect starts predictable, like 2.7.x
    colorMode(HSB, 360, 100, 100); // don't let an effect leave us in RGB
    noStroke();                    // stop red/pink halos around shapes
    blendMode(ADD);                // stack light additively (bright output like 2.7)

    // Draw each active effect in isolation so transforms don't leak
    if (ctrl.effectArray != null) {
      for (int i = 0; i < ctrl.effectArray.length; i++) {
        Effect fx = ctrl.effectArray[i];
        if (fx != null && fx.isActive()) {

          pushMatrix();

          // Give each effect a stable origin at screen center.
          // Effects (Moonflower, Scanner, etc.) compute their own translate/rotate
          // relative to the idea that (0,0) is center of Stage.
          translate(width * 0.5f, height * 0.5f);

          fx.draw();

          popMatrix();
        }
      }
    }

    // If you ever render debug text/UI overlays here, you'd want:
    // blendMode(BLEND);
  }

  // Geometry helpers for effects.
  // These compute live from width/height so they work during initEffects(),
  // before Stage.draw() has ever run. This fixes Moonflower's radius=0 bug.
  float getMinRadius() {
    float w = width;
    float h = height;
    return min(w, h) / 2.0f;
  }

  float getMaxRadius() {
    float w = width;
    float h = height;
    return sqrt(w*w + h*h) / 2.0f;
  }

  @Override
  public void exit() {
    noLoop();
    super.exit();
  }
 }

[lh84]

Great that I could help, I don’t know where but it doesent matter ;)