Since having a 3D printer, a common item I want to design and print are custom plaques, tags, and signs. Using traditional 3D modeling software works for this, but it’s tedious to create really good looking designs. It’s especially hard to iterate/tweak a “graphic” design in CAD software.

So I developed a workflow that’s worked really well for me where I instead design a greyscale 2D image with image editing software, and use OpenSCAD to convert it into a 3D model for me to print. I’ve not seen this specific method documented very well online, so I thought I’d put together a little blog post detailing how it works.

This method is inspired by those sites that make a lithoplane STL out of an image you upload. I originally tried using these sites but ran into so many issues getting exactly what I wanted.

The Strategy

The goal is to create a thin print with images/text/logos “cut” out of the piece. We do this by creating a greyscale 2D image of the design, then using this image as a height-map to generate a 3d model (via the surface function). This can work for both fully cut-through designs, or two-tone designs by swapping out the filament half way through the print.

Design

You can use any software you want to design the 2D image. I like Photopea, which is a free Photoshop alternative. A fully cut through design is easy, make any fully black-and-white photo you want. But with this style, you need to follow stencil logic such that the black portion of your image is a single continuous body (resulting in a single object being printed).

But if you’d like a more complex shape, and avoid those stencil lines (and get a sturdier piece), you can design a two-tone image, like so. The grey can be printed with one color filament, the black another.

Depending on the depth of your piece, you can also bevel the edges to make the piece more readable from more angles - do this using Precise glows (not Softer).

Once we extrude a 3d model, this will make more sense.

Modeling

Once we have our image saved, we can head over to OpenSCAD to create the model. We’ll use the surface function in OpenSCAD to treat the image like a height map:

• White pixels #ffffff will be considered a height of 0
• Black pixels #000000 will be considered a height of 1
• Greys will be somewhere in between, #808080 is 0.5

PS: I like invert=true because the black portion being what I print is more intuitive to me.

The one caveat here is that 0 height portions of the image will still be drawn in the preview - but once brought into a slicer the 0 height will be ignored. Here’s an example OpenSCAD script:

src="/some-dir/src-2tone-grad.png";
surface(file = src, center = true, convexity = 5, invert=true);

This will result in a model that is 800mm x 500mm with a height of 100mm (the black pixel height). I normally scale this in my slicer, as scaling it in OpenSCAD takes FOREVER.

You can do this in the UI, but the preview window with the surface function can get really laggy. So I often use the CLI. To create a preview image:

/Applications/OpenSCAD.app/Contents/MacOS/OpenSCAD -o preview.png model.scad

Then to render an STL:

/Applications/OpenSCAD.app/Contents/MacOS/OpenSCAD -o render.stl model.scad

Slicing

I have a Prusa Mini, so I’m only familiar with the Prusa Slicer. Once the model is imported, I can adjust the dimensions to what I want, in this case, I’m slicing 80mmx50mm with a height of 5mm.

Then we slice! Here’s the cut-through example:

Looks great! But from the side (or back) it’s difficult to read. Also, that O looks fragile.

Using the straight-up 2-tone helps though, plus makes it so you can’t even see the design from the back, and we don’t need to worry about the flow!

But my favorite option is using the outer glow in the source image to make a bevel. It is the most readable from all angles, and looks great.

There you go!

Pokemon: Fire Red - Rocket Edition is a popular ROM-hack. As part of the hack, the pokemon evolutions and level-up move sets were heavily tweaked. For the life of me, I couldn’t find a resource online that listed these changes, so I decided to post my own findings.

Skip the how, and just bring me to the data!

Method

I used the HexManiacAdvance tool to inspect my patched ROM. Using the following script in the Tools > Show Automation Tool window, I was able to generate a JSON dump of the data I was looking for:

import json

ps = {}

for i, n in enumerate(data.pokemon.names):
  ps[i] = {'name':n.name}

for i, id in enumerate(data.pokedex.national):
  ps[i]['id'] = id.index

for i, e in enumerate(data.pokemon.evolutions):
  ps[i]['evolutions'] = []
  if e.method1 != 'None':
    ps[i]['evolutions'].append({'method':e.method1, 'arg':e.arg1, 'species':e.species1})
  if e.method2 != 'None':
    ps[i]['evolutions'].append({'method':e.method2, 'arg':e.arg2, 'species':e.species2})
  if e.method3 != 'None':
    ps[i]['evolutions'].append({'method':e.method3, 'arg':e.arg3, 'species':e.species3})
  if e.method4 != 'None':
    ps[i]['evolutions'].append({'method':e.method4, 'arg':e.arg4, 'species':e.species4})
  if e.method5 != 'None':
    ps[i]['evolutions'].append({'method':e.method5, 'arg':e.arg5, 'species':e.species5})


for i, lu in enumerate(data.pokemon.moves.levelup):
  ps[i]['moves_levelup'] = []
  for m in lu.movesFromLevel:
    mid = m.pair.move
    ps[i]['moves_levelup'].append({
      'move':{
        'name': data.pokemon.moves.names[mid].name,
        'power': data.pokemon.moves.stats.battle[mid].power,
        'type': data.pokemon.moves.stats.battle[mid].type,
        'accuracy': data.pokemon.moves.stats.battle[mid].accuracy,
        'pp': data.pokemon.moves.stats.battle[mid].pp
      },
      'level':m.pair.level
    })


for i, tmc in enumerate(data.pokemon.moves.tmcompatibility):
  ps[i]['moves_tm'] = []
  for num, m in enumerate(data.pokemon.moves.tms):
    name = m.move
    if " " in name:
      name = '"' + name + '"'
    if tmc.moves.HasField(name) and tmc.moves[name] > 0:
      mid = m.move
      ps[i]['moves_tm'].append({
        'name': data.pokemon.moves.names[mid].name,
        'tm': num + 1,
        'power': data.pokemon.moves.stats.battle[mid].power,
        'type': data.pokemon.moves.stats.battle[mid].type,
        'accuracy': data.pokemon.moves.stats.battle[mid].accuracy,
        'pp': data.pokemon.moves.stats.battle[mid].pp
      })

f = open("pokemon.json", "w")
f.write(json.dumps(ps, indent = 2))
f.close()
print("done")

The output looked something like this:

{
  "64": {
    "name": "Kadabra",
    "id": 65,
    "evolutions": [
      {
        "arg": 33,
        "species": "Alakazam",
        "method": "Level"
      }
    ],
    "moves_tm": [
      {
        "pp": 20,
        "type": "Fight",
        "tm": 1,
        "name": "Focus Punch",
        "accuracy": 100,
        "power": 150
      },
      {
        "pp": 20,
        "type": "Psychc",
        "tm": 4,
        "name": "Calm Mind",
        "accuracy": 0,
        "power": 0
      },
      // ...
    ],
    "moves_levelup": [
      {
        "move": {
          "pp": 20,
          "type": "Psychc",
          "name": "Teleport",
          "accuracy": 0,
          "power": 0
        },
        "level": 1
      },
      {
        "move": {
          "pp": 15,
          "type": "Psychc",
          "name": "Kinesis",
          "accuracy": 80,
          "power": 0
        },
        "level": 1
      },
      // ...
    ]
  }
  // ...
}

Then I just wrote a little golang script to print out the Markdown.

I hope it helps!

Explorer

Search by name, click to add a Pokemon to the comparison list, click again to remove. You can stack as many as you want side-by-side, and the URL hash tracks your selection so the “Open standalone” link preserves what you’re looking at.

Open the explorer in its own tab ↗