The lion is sitting on the grass.
It should be sitting in it.

This surprised me. Wooga's June's Journey places hidden objects onto the scene as a discrete step after the background art is finished — composited on a finished plate, exactly like us. Their base scene is a single 3D render, not hand-separated depth layers. One scene takes ~30 artist-hours; they had shipped 315+ by 2018, at a chapter a week, using two outsourcing partners.

A separate production postmortem describes the handoff as a flat colour image plus mask layers — masks that separate elements, not pre-separated transparent layers. That is precisely what SAM 3 gives us for half a penny. And the shadows? In that pipeline roughly 70% is 2D overpaint, with "self-shadows, cast shadows and edge integration mostly added by hand."

Two studios name partial occlusion as a core concealment technique, and both note that pasted-on-ness comes from mismatched lighting as much as missing occlusion. Which is the whole argument for the shadow slider.

Hidden Folks is not a model for us. Every object hand-drawn on paper, scanned, assembled in Unity — two people, three years. They rebought an identical cheap scanner mid-production because switching scanners visibly changed the art style.

It fixes the trapped river at source

This is the part post-processing can never do. The model draws white between the blades, so there is no river left inside the blob to steal. Compare this sheet to the broken one further up — same magenta ground, same SAM settings, and the pale blue is simply gone.

An earlier version of this page showed the SAM cut here and called it clean. It wasn't — it sliced through the lion's face. That render is now the "before" in the bug section below. This one is the best current result: self-segmented occluders, clean sprite, halo added in code.

We don't need the model to draw the borders

On a white sheet, a sticker's white halo and the white background are the same pixels, so no cutter can tell them apart — BiRefNet ate the lion's halo unevenly, leaving it on some edges and not others. Dilating the alpha and filling the ring with white instead gives a border that is uniform by construction, on any sprite, in any style, for nothing.

Cut around the outline, not inside it

Daniel's note on the first sticker render: the cut was landing inside the white border. SAM masks the green blades, so the halo stays behind in the plate and the lion comes right up against the artwork with nothing separating them — the sticker stops reading as a sticker.

The first fix was to grow SAM's mask outward onto adjacent white pixels — colour does the discriminating, so it stops dead at the edge of the halo and never grabs the scenery. It worked (+8.8% mask area, all of it halo) but came out patchy, because SAM's blob has nothing to do with where a sticker ends — it happily cuts through the middle of one, and there's no white there to grow into.

The catch: stickers whose interiors touch merge into one component, so you get 33 regions rather than 100 — some are whole banks (one is 1145×956) instead of single tufts. Coarser than SAM, but a bank is still a perfectly good occluder. Getting individual stickers means generating the plate with a visible white gap between every one — a prompt change, not a new model.

Sticker sprites can't be cut — so don't draw them that way

Daniel again, on the render above this fix: white speckle on the lion's body. The cause is the same trap as the halo itself — the sticker sheet is drawn on white with white borders, so BiRefNet can't tell halo from background. It keeps ragged scraps of halo stuck to the lion, and then the programmatic border adds a second halo on top of the scraps.

So the rule inverts: never ask the model to draw sticker borders on sprites. Cut a normal sheet, add the halo in Python. Which means the sprite sheets we already have work as-is — only the plate needs restyling.

The flecks: growth that jumped to the neighbour's halo

Daniel again — white flecks on the lion's back. First I checked whether the sprite was dirty: zero white pixels inside it. So the flecks weren't his; they were bits of occluder halo landing on him. A plain dilation grows in every direction and happily jumps a gap to grab white belonging to a different sticker, which then paints over whatever is behind.

The fix is to grow geodesically — each step constrained to white that is connected to this sticker's own border, so growth can only ever travel along its own halo and stops dead at the first non-white pixel. Anything that still breaks off gets dropped: a sticker is one island, never a scatter of flecks.

def grow_into_own_halo(comp, white, steps=13):
    allowed = white | comp
    cur = comp
    for _ in range(steps):
        cur = dilate(cur, 1) & allowed   # can only travel along its OWN halo
    return cur

Five characters, actually hidden

Everything above is a single lion behind a single tuft. This is the whole thing working at once: five findables hidden behind sticker covers, sprites from the normal sheet with the halo added in code, occluders self-segmented off the plate for nothing.

That number is the point. Placing them by eye first buried the owl and rabbit at 100% — invisible isn't hidden, it's absent — while the deer and peacock weren't covered at all. So the placement is searched: composite the occluder alpha once, then for each character find the spot whose visible fraction lands nearest the target. It's the same check the editor will want when you're placing 30 objects a level.

Left to itself the search parked the deer in the sky at a perfect 55% — it optimises hiding and knows nothing about whether a spot makes sense. I fenced it to the ground. Which is the honest limit of all of this: it proves the occlusion works. It is not a level designer. That's still you, in the editor.

The objection, which is the whole genre

Every element now wears a white outline announcing "I am a separate object" — in a game whose entire mechanic is objects blending into a scene. It partly cancels out, because the scenery is stickered too, so the lion camouflages among stickers rather than popping. But look at the two panels: on the left the lion is inside a painted world; on the right he is on top of a collage. The white gaps between stickers also give you arguably fewer places to hide things, not more.

And it's a 20-level restyle against an art bible that specifies bold-outline coloured storybook — which is the left panel.

Loading 38 layers…

Layers—

↑↓ select · Ctrl+]/[ raise/lower

Pick a layer

X-ray covers

Raise Lower Reset

Nothing here is a picture of an editor — it's the real cut-outs, 33 self-segmented stickers and five sprites with code-drawn haloes, layered the way the game layers them. Which is why raising a cover above the lion really does hide him, and why the maths agrees.

One decision first: art direction. If Eden stays in the current style, the hybrid is done and I wire it up. If you want the sticker look, say so now — it's a full restyle and everything downstream changes. Cutting convenience isn't a reason to pick it; liking it is.

Either way the next moves are the same and cost nothing: wire the occluders into the editor as a pinned front-layer group, and add the shadow slider. Then you place Eden with things actually hidden behind things, and we run the Unity import. A full sticker Eden — all 30 findables sheeted, bordered and placed — is about €0.35 if you want to see it properly before choosing.

Two loose ends. The lion sprite has a thin dotted gold line across his back — a slicing artifact that survived the 18px inset; worth a reroll. And there's a jagged notch where the bush meets his mane in every panel above: that's SAM's mask boundary being ragged, and a 2px feather on the mask should soften it.