Category: Integrated FX

Looking to add an impressive, glowing effect to your tabletop terrain or D&D scenery? With just a few affordable components, some simple wiring, and a touch of code (provided), you can create a 3D printed terrain piece that lights up like arcane magic!

This glowing ritual circle is perfect for fantasy or sci-fi settings, whether you’re summoning eldritch horrors or powering up ancient tech.

🧙‍♂️ What You’ll Need to build this terrain

Here’s a list of materials I used to create the glowing ritual circle:

• 3D printed ritual circle – You can grab the STL file from Saucermen Studios
• Neo-Pixel LED ring – I used a 16 LED ring
• Microcontroller – Arduino, ESP32, or any similar board will do
• A few wires
• 5V power source – A USB battery pack or phone charger works great

⚙️ Where to Get the Parts

I sourced the electronics cheaply through AliExpress, but similar components can be found on Amazon, eBay, or your local electronics supplier. Altogether, this build cost less than $10.

🧠 Coding the Magic (With Help from ChatGPT)

To animate the LEDs, I used ChatGPT to help generate the code. I asked:

“Create two sequences for the ring on pin 13 of Arduino and 16 LED nano pixel ring. First: a symmetrical blue sparkle effect lasting 3 seconds. Second: a popping green magical explosion lasting 6 seconds.”

It responded with perfectly usable Arduino code, which I uploaded to the microcontroller. You can customize this code to match the tone of your game—be it eerie, chaotic, or divine.

You can also use the code below:

#include <Adafruit_NeoPixel.h>

#define PIN         13
#define NUM_LEDS    16

#define SEQ_ONE_DURATION  3000   // 3 seconds
#define SEQ_TWO_DURATION  6000   // 6 seconds
#define TOTAL_DURATION    (SEQ_ONE_DURATION + SEQ_TWO_DURATION)

#define FADE_SPEED        20
#define SPARK_CHANCE      30

Adafruit_NeoPixel ring = Adafruit_NeoPixel(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);

// For sparkle logic
uint8_t sparkle_brightness[NUM_LEDS];

// For timing
unsigned long startTime = 0;

void setup() {
  ring.begin();
  ring.setBrightness(255); // Full brightness, we control individual pixel brightness
  ring.show();

  for (int i = 0; i < NUM_LEDS; i++) {
    sparkle_brightness[i] = 0;
  }

  startTime = millis();
}

void loop() {
  unsigned long currentTime = millis();
  unsigned long elapsed = (currentTime - startTime) % TOTAL_DURATION;

  ring.clear();

  if (elapsed < SEQ_ONE_DURATION) {
    runSequenceOne(elapsed);
  } else {
    runSequenceTwo();
  }

  ring.show();
  delay(30); // Control update speed
}

// --- Sequence ONE: 4-way mirrored faint blue rotation ---
void runSequenceOne(unsigned long elapsed) {
  static unsigned long lastStep = 0;
  static int step = 0;

  if (millis() - lastStep > 100) {
    step = (step + 1) % 4; // 4 steps per quarter rotation
    lastStep = millis();
  }

  for (int offset = -1; offset <= 1; offset++) {
    int pos = (step + offset + 4) % 4;
    uint8_t brightness = 10;
    if (offset == 0) brightness = 50;
    else if (abs(offset) == 1) brightness = 20;

    for (int q = 0; q < 4; q++) {
      int idx = (pos + q * 4) % NUM_LEDS;
      ring.setPixelColor(idx, ring.Color(0, 0, brightness));
    }
  }
}

// --- Sequence TWO: Green magical sparkles ---
void runSequenceTwo() {
  for (int i = 0; i < NUM_LEDS; i++) {
    if (sparkle_brightness[i] == 0 && random(0, SPARK_CHANCE) == 0) {
      sparkle_brightness[i] = 255; // Start sparkle
    }

    if (sparkle_brightness[i] > 0) {
      sparkle_brightness[i] = max(sparkle_brightness[i] - FADE_SPEED, 0);
    }

    ring.setPixelColor(i, ring.Color(0, sparkle_brightness[i], 0));
  }
}

🔌 Wiring It All Up

• 5V from the LED ring to the 5V pin on your board
• GND to GND
• Data Input to Pin 13 on your microcontroller

Once wired, upload the code via the Arduino IDE, and your 3D printed terrain will burst to life with a dramatic glow.

✨ Assembly Tips for your terrain

I recommend dry-fitting everything first. Once you’re happy with the positioning, use a bit of hot glue or superglue to secure the LED ring inside the ritual circle. You can diffuse the lights further with parchment paper or resin for a mystical glow.

🧪 Use Cases for Glowing Terrain

• Highlight key objectives in a dungeon crawl
• Mark teleportation circles or magical wards
• Bring life to cyberpunk terminals or sci-fi consoles
• Upgrade your D&D scenery with animated lighting effects

This is a great way to bring your 3D printed terrain to life and impress players with interactive tabletop elements.

📦 STL Download & More Info

You can download the STL for the ritual circle here:
👉 Darkmyth Dungeon Ritual Circle with LED Integration – Saucermen Studios

I’ll post the exact Arduino code and links to components in an upcoming blog update.

🧙‍♂️ Miniature Credit

The wizard mini featured in the video/photos is the Thalmor Mage by Marco R Sassi.

Lighting can bring your tabletop terrain to life, especially when it comes to sci-fi vehicles. In this quick guide, I’ll walk you through how I added working red and blue emergency lights to a cyberpunk police cruiser model with just a few cheap components.

What You’ll Need:

• ESP32 development board
• Red and blue 5mm LEDs (optional extra warn lights for headlights)
• Some basic wiring (use Dupont wires for no soldering)
• Soldering gear (optional, but recommended)
• Power source of choice

Step 1: Wiring It Up

Start by connecting the long legs (positive) of the red and blue LEDs to pins 18 and 19 on the ESP32 board. The short legs (negative) go to ground. That’s your basic circuit done!

Next, plug the board into your computer and open the free Arduino IDE software. If coding isn’t your thing, just ask a language model (like Claude or ChatGPT) to generate a simple flashing sequence for emergency lights. Upload the code, and you’ll be good to go. See the code I used below:

/*
  ESP32 Police Lights with Pulsing Headlights
  
  This sketch simulates police car lights using two LEDs (red and blue)
  connected to pins 18 and 19 of an ESP32, and adds pulsing headlights on pin 17.
  
  The police LEDs will flash in alternating patterns while the headlights pulse
  with a breathing effect.
*/

// Pin definitions
const int HEADLIGHT_LED = 17;  // Headlight LED connected to pin 17
const int RED_LED = 18;        // Red police light connected to pin 18
const int BLUE_LED = 19;       // Blue police light connected to pin 19

// Timing variables (in milliseconds)
const int FLASH_DELAY = 150;     // Delay between flashes
const int PATTERN_DELAY = 1000;  // Delay between pattern changes

// Headlight pulsing parameters (adjust these to change the pulsing behavior)
const int PULSE_STEP = 10;        // Step size for breathing effect (higher = faster pulse)
                                 // Try values between 1-20

const int PULSE_MIN = 0;         // Minimum brightness (0 = fully off)
const int PULSE_MAX = 255;       // Maximum brightness (255 = fully on)
                                 // Adjust these min/max values to change the range

// Global variable to track the pulse value
int pulseValue = 0;
int pulseDirection = 1;  // 1 for increasing, -1 for decreasing

void setup() {
  // Initialize the LED pins as outputs
  pinMode(RED_LED, OUTPUT);
  pinMode(BLUE_LED, OUTPUT);
  pinMode(HEADLIGHT_LED, OUTPUT);
  
  // Initially all LEDs are off
  digitalWrite(RED_LED, LOW);
  digitalWrite(BLUE_LED, LOW);
  digitalWrite(HEADLIGHT_LED, LOW);
}

// Function to update the pulsing headlights
void updateHeadlights() {
  // Update the pulse value based on the direction
  pulseValue += PULSE_STEP * pulseDirection;
  
  // Change direction if we hit the limits
  if (pulseValue >= PULSE_MAX) {
    pulseValue = PULSE_MAX;
    pulseDirection = -1;
  } else if (pulseValue <= PULSE_MIN) {
    pulseValue = PULSE_MIN;
    pulseDirection = 1;
  }
  
  // Set the analog output value (brightness)
  analogWrite(HEADLIGHT_LED, pulseValue);
}

void loop() {
  // Pattern 1: Alternating flashes
  for (int i = 0; i < 5; i++) {
    updateHeadlights();
    
    // Red LED on, Blue LED off
    digitalWrite(RED_LED, HIGH);
    digitalWrite(BLUE_LED, LOW);
    delay(FLASH_DELAY);
    
    updateHeadlights();
    
    // Red LED off, Blue LED on
    digitalWrite(RED_LED, LOW);
    digitalWrite(BLUE_LED, HIGH);
    delay(FLASH_DELAY);
  }
  
  // Pattern 2: Double flashes
  for (int i = 0; i < 3; i++) {
    updateHeadlights();
    
    // Red double flash
    digitalWrite(RED_LED, HIGH);
    digitalWrite(BLUE_LED, LOW);
    delay(FLASH_DELAY);
    digitalWrite(RED_LED, LOW);
    
    updateHeadlights();
    
    delay(FLASH_DELAY / 2);
    digitalWrite(RED_LED, HIGH);
    delay(FLASH_DELAY);
    digitalWrite(RED_LED, LOW);
    
    updateHeadlights();
    
    delay(FLASH_DELAY / 2);
    
    // Blue double flash
    digitalWrite(BLUE_LED, HIGH);
    delay(FLASH_DELAY);
    digitalWrite(BLUE_LED, LOW);
    
    updateHeadlights();
    
    delay(FLASH_DELAY / 2);
    digitalWrite(BLUE_LED, HIGH);
    delay(FLASH_DELAY);
    digitalWrite(BLUE_LED, LOW);
    delay(FLASH_DELAY / 2);
  }
  
  // Pattern 3: Both LEDs flashing together and then alternating
  for (int i = 0; i < 2; i++) {
    updateHeadlights();
    
    // Both LEDs on
    digitalWrite(RED_LED, HIGH);
    digitalWrite(BLUE_LED, HIGH);
    delay(FLASH_DELAY * 2);
    
    updateHeadlights();
    
    // Both LEDs off
    digitalWrite(RED_LED, LOW);
    digitalWrite(BLUE_LED, LOW);
    delay(FLASH_DELAY);
    
    // Alternating quick flashes
    for (int j = 0; j < 6; j++) {
      updateHeadlights();
      
      digitalWrite(RED_LED, j % 2 == 0 ? HIGH : LOW);
      digitalWrite(BLUE_LED, j % 2 == 0 ? LOW : HIGH);
      delay(FLASH_DELAY / 2);
    }
    
    updateHeadlights();
    
    // Both LEDs off
    digitalWrite(RED_LED, LOW);
    digitalWrite(BLUE_LED, LOW);
    delay(FLASH_DELAY);
  }
}

Step 2: Modifying the STL File

With the circuit working, I turned to the 3D model itself. I edited the STL file to include mounting holes for 5mm LEDs in the light bar. I also carved out space for smaller headlight LEDs while I was at it.

Note – You can get the modified version of this file here

To avoid wasting filament, I printed a quick cross-section of the vehicle to test the LED fit. Once I was happy with it, I went ahead and printed the full model using my Bambu Labs P1S.

Step 3: Assembly

With the parts printed, I installed the LEDs and connected everything to the ESP32 board. A quick test confirmed everything was working perfectly. The flashing red and blue lights added just the right touch of realism to the vehicle.

Adding lighting to your prints doesn’t have to be expensive or complicated, and it adds so much character to your builds. Hopefully this inspires you to try it for yourself!

Want to grab the police cruiser STL – Grab the STL file here

‘Holographic’ Display for Miniature Projects!

I’ve been playing around with adding holographic displays into my builds and this uses the classic Pepper’s Ghost illusion, which looks seriously cool in person! It’s super simple and can even be done with any screen or phone if you don’t want to jump straight into electronics or coding.

Here’s a quick breakdown of how I did it. Feel free to ask questions or check the links for more details!

What I Used to create the effect:

– ST7735 1.8″ TFT Display Module
– ESP32 Development Board
– Dupont Jumper Wires
– 5V USB Power Pack
– 3D Printed Enclosure (STL files coming soon)
– Transparent acetate sheet or plastic film

The Process:

Step 1:
Followed this awesome tutorial → https://www.youtube.com/watch?v=GrNIfwUNaaw
Modified code from → bitbank2/AnimatedGIF GitHub

Step 2:
Wired the display to the ESP32 using this pinout (no soldering needed): VCC → 3v3, GND → GND, CS → 5, RESET → 4, AO → 2, SOA → 23, SCK → 18, LED → 3v3

Step 3:
Created an animated GIF (128x160px for my screen) and converted it using the tool suggested in tutorial.

Step 4:
Uploaded the modified code to the ESP32 using Arduino IDE. Note: You may need to tweak the User_Setup.h file based on your board.

Below is the main code I used

//TUTORIAL FROM https://www.youtube.com/watch?v=GrNIfwUNaaw
//CONVERT NEW GIF TO C (.h) WITH https://github.com/bitbank2/image_to_c
//Edit User_Setup.h for screen specific adjustments

// Edited by Saucermen Studios


//#define USE_DMA       // ESP32 ~1.25x single frame rendering performance boost for badgers.h
                        // Note: Do not use SPI DMA if reading GIF images from SPI SD card on same bus as TFT
  #define NORMAL_SPEED  // Comment out for rame rate for render speed test

// Load GIF library
#include <AnimatedGIF.h>
AnimatedGIF gif;

// Example AnimatedGIF library images
// #include "anim2.h"
 #include "anim3.h"
// #include "../test_images/badger.h"
// #include "vending1.h"
// #include "../test_images/homer_tiny.h"
// #include "../test_images/pattern.h"

                                // ESP32 40MHz SPI single frame rendering performance
                                // Note: no DMA performance gain on smaller images or transparent pixel GIFs
  #define GIF_IMAGE anim3   //  No DMA  63 fps, DMA:  71fps
//#define GIF_IMAGE ucHomer     //  No DMA 162 fps, DMA: 141 fps
//#define GIF_IMAGE homer_tiny  //  No DMA 564 fps, DMA: 481 fps
//#define GIF_IMAGE ucPattern   //  No DMA  90 fps, DMA:  78 fps

#include <SPI.h>
#include <TFT_eSPI.h>

// Color definitions
// #define BLACK   0x0000
// #define BLUE    0x001F
// #define RED     0xF800
// #define GREEN   0x07E0
// #define CYAN    0x07FF
// #define MAGENTA 0xF81F
// #define YELLOW  0xFFE0
// #define WHITE   0xFFFF


TFT_eSPI tft = TFT_eSPI();


#define imageWidth 128
#define imageHeight 160

void setup() {
  Serial.begin(115200);

  tft.begin();
#ifdef USE_DMA
  tft.initDMA();
#endif
  tft.setRotation(-1);
  tft.fillScreen(TFT_BLACK);
//  tft.invertDisplay(1);

gif.begin(BIG_ENDIAN_PIXELS); // COOKED mode
}


// Pin definitions
#define CS_PIN     5     // Chip select control pin
#define RST_PIN    4     // Reset pin (could connect to RST pin on board)
#define DC_PIN     2     // Data/Command control pin
#define SCLK_PIN   18    // Serial clock
#define MOSI__PIN   23    // Master Out Slave In (SPI data)
#define LED_PIN    -1    // Use -1 if backlight is always on or connected to 3.3v



#ifdef NORMAL_SPEED // Render at rate that is GIF controlled
void loop()
{
  // Put your main code here, to run repeatedly:
  if (gif.open((uint8_t *)GIF_IMAGE, sizeof(GIF_IMAGE), GIFDraw))
  {
    Serial.printf("Successfully opened GIF; Canvas size = %d x %d\n", gif.getCanvasWidth(), gif.getCanvasHeight());
    tft.startWrite(); // The TFT chip select is locked low
    while (gif.playFrame(true, NULL))
    {
      yield();
    }
    gif.close();
    tft.endWrite(); // Release TFT chip select for other SPI devices
  }
}
#else // Test maximum rendering speed
void loop()
{
  long lTime = micros();
  int iFrames = 0;

  if (gif.open((uint8_t *)GIF_IMAGE, sizeof(GIF_IMAGE), GIFDraw))
  {
    tft.startWrite(); // For DMA the TFT chip select is locked low
    while (gif.playFrame(false, NULL))
    {
      // Each loop renders one frame
      iFrames++;
      yield();
    }
    gif.close();
    tft.endWrite(); // Release TFT chip select for other SPI devices
    lTime = micros() - lTime;
    Serial.print(iFrames / (lTime / 1000000.0));
    Serial.println(" fps");
  }
}
#endif

Step 5:
3D printed the enclosure and slotted the screen in place.

Step 6:
Cut a piece of transparent film and mounted it at a 45° angle in front of the screen to get that floating hologram effect.