3D scenes and models

Mixture’s 3D isn’t a separate world you import things into. A 3D scene is a layer whose children are ordinary layers — text, video, groups — given a three-dimensional form. The children keep everything: their content, their styling, their animations. The 3D is a treatment on top, which means you can take a finished 2D design and bend, extrude, or put it on a phone without rebuilding anything.

Make something 3D

Select a layer on the canvas, right-click, and choose Make 3D. The layer becomes the content of a new 3D scene; Add to 3D scene puts further layers into an existing one.

The properties panel grows a 3D section. The big button — Edit 3D on canvas — turns the canvas into a direct-manipulation view: drag to orbit to any angle, scroll to change perspective, and drag the sun dot to move the key light.

Forms

The Form dropdown picks the shape the content takes:

• flat — a plane in space. The simplest: a tilted card, a floating screenshot.
• cylinder — text wraps around a barrel. Put the text first and other items after: the later items face the camera and hold still while the text orbits — animate the text child’s Rotate Y for the spin.
• curve — a bent banner, with a Bend dial for the arc.
• sphere and wave — spherical mapping, and a rippling surface with wave count and amplitude dials.
• extrude — real solid geometry with depth and lit surfaces, built from a text, path, or rectangle child (those are the types with outlines to extrude — images and video stay on texture forms).
• shatter — the content breaks into flying shards, below.
• model — a 3D device or your own imported model, below.

Forms can hard-cut over time: Switch form at playhead (in the section’s + menu) adds a timed switch, and several can chain — extrude, then flat, then cylinder.

Shatter

The shatter form breaks the content into flying Voronoi shards. It’s real geometry, not a screen-space trick, which is the whole point: the pieces have parallax, they can fly toward the camera, and whatever sits behind the layer is revealed as they separate. A cracked-glass filter can draw fracture lines but can’t do any of that.

Shatter plays itself from a start time and a duration rather than being keyframed — the geometry is rebuilt when the settings change, so the timing lives in the settings. The dials that matter:

• Origin is the impact point. Shards radiate from it, and Bias clusters the fracture there — aim it at whatever was struck.
• Stagger makes the break travel outward instead of every piece leaving at once. That ordering is most of the realism; a zero-stagger shatter reads as a puff.
• Spread is a multiple of the box’s half-diagonal, so the same value reads the same at any size.
• Seed locks the fracture. The same seed gives the same break in preview and in export, every time — change it to reroll a break you don’t like, keep it to lock a take.

To shatter on a beat, hold another form and switch to shatter at the moment of impact — and set the shatter’s own start time to that same moment, or it appears already mid-break.

Shards show the layer’s own pixels, unlit, so a shattered screen keeps its exact colours instead of needing to be relit.

Breaking a device’s screen

Shatter can’t be pointed at a model: a GLB is real geometry rather than a texture plane, so the form would swap the whole device for a flat plane of its screen content and the chassis would vanish.

Use Screen shatter instead. Same controls, but the shards live inside the device’s own screen holder — so the display breaks apart with the phone as it turns, and the body, bezel and Dynamic Island all survive. That’s the shot where a phone tumbles through the air with a broken screen, and it’s the only way to get it.

Extruded type

Extrude is the “solid 3D logo” form. Depth sets the thickness; Metalness and Gloss shape the surface; Clearcoat, Glass, and Glow wait behind the + for the fancier materials. Being real lit geometry, it responds to the light rig — Ambient, Key light, and Reflections (studio image-based lighting, the thing that makes metal read as metal), plus a Floor shadow to ground it.

Device mockups with a live screen

The model form renders a photoreal device whose display shows your content. The iPhone 15 Pro Max ships with the editor — tuned body materials, glass sheen, Dynamic Island — and the Model dropdown also lists ready-made models like the MacBook Pro 13 that download the first time you use one, so the editor stays light until you reach for them. Each carries its creator’s credit in the picker. Below those sit any models you’ve uploaded to the project.

The first item in the scene is the screen content, and this is the part worth internalising: the screen is a real layer. A video plays your app demo on the phone. A group with its own entrance animations plays them on the display. Swap the child’s source and the phone shows something else.

Practical rules:

• The device scales to fill the layer box’s height — size the box to size the phone.
• Screen content is cover-fitted and clipped to the display, like a real phone. Size the child near the display’s aspect (roughly 430×932 portrait) so the crop is minimal; a 16:9 video works but crops hard at the sides.
• Tilt with the layer’s Tilt X/Y, animate them to turn the phone, add a Floor shadow to ground it.

Add a screen block ("screen": {} — or ask a connected agent) and the content composites like real hardware: full-bleed across the display, running behind the Dynamic Island — the model’s actual island and front camera sit over your content, exactly as a phone renders an app.

The screen block

"screen": {
  "fit": "cover",
  "background": "#171717",
  "safeArea": { "top": 59 }
}

Everything is optional. fit is cover (crop) or contain (letterbox); background fills the whole display and bezel ring behind the content (default black); safeArea insets are in the device’s design pixels (430×932 for the iPhone) — add "safeArea": { "top": 59 } if you want content to start below the island instead of running behind it. Any filters on the screen layer apply across the entire composed display — a cracked-glass effect covers the glass, not just the fitted content.

Screen glare

Real product films get their life from light moving across the cover glass. That’s built in: Screen glare, behind the 3D section’s +, sweeps a soft light band across the display — above the content and the Dynamic Island, the way glass actually catches light. Ticking it on gives a single three-second pass; the knobs tune the sweep time, strength, band angle and width, and a Loop mode repeats it. Keep the strength subtle — glare reads best when you feel it rather than see it.

Directing a device shot

A tip from making these look filmic: split your animation channels the way a film set splits jobs. Tilt the device by animating the screen item’s Rotate X/Y (it pivots on the device’s own centre); move the camera with the 3D layer’s Zoom (dolly), Perspective (fov) and Rotation (a dutch roll); and animate the light rig for mood. Place and size the device with the item’s 3D placement — not by moving or scaling the layer box, which should stay aligned to the composition.

Imported 3D models

The model form also takes your own GLB. A model file becomes a model3d asset in the project, and the 3D scene renders it in place of the bundled device — product shots, packaging, logos, a laptop with your app on screen.

What a model needs to be:

• A self-contained binary .glb (glTF 2.0), up to 50 MB. External buffer or texture URIs and compressed formats (Draco, KTX2, Meshopt) are rejected at upload — re-export with everything embedded.
• The live-screen convention: name one mesh (or material) containing screen or display when exporting from Blender, and the scene’s first item is textured onto it — your GLB gets a live display exactly like the bundled iPhone. For a model that wasn’t exported that way, the 3D panel’s Screen row lists the model’s parts so you can point at the display yourself; the bundled MacBook is already pointed for you. A display with nothing on it shows as a plain black, switched-off screen. Without any screen, the model simply renders as-is.
• Animation comes with it. A model that carries its own animation — a Blender action, a rigged character, shape keys — keeps it, and the panel offers each clip by name. See Playing a model’s own animation.

Uploaded models are previewed properly: the assets view renders the actual model as its thumbnail, and opening one turns it slowly so you can read its shape before committing to it. Models you reuse — a product, a packaging mock, a stage set — belong in the workspace Library rather than in one project.

The light rig applies: Ambient, Key light and Floor shadow shape it, and Reflections scales the model’s own reflective materials — try around 1.5 for a glossier product shot, 0 for matte. The material dials (Metalness, Gloss) do not restyle a model — its materials are the author’s own. For that, models declare their own controls:

Animating the light

Every light control keyframes, and Reflections is a true dimmer — at 0 the studio environment goes dark too, not just the material sampling. That is what makes a light reveal possible: start Reflections, Key light and Ambient at 0 and ramp them up, and a device rises out of black with its metal reflections intact. Time it against a held pose — reveal the phone while it sits side-on, then let it turn.

One trap worth knowing: a key light only reads against darkness. The studio environment plus a default Ambient already light the scene, so animating Key light on top of that can change the picture by well under a percent — technically animating, visually nothing. If the movement of light is the point, pull Ambient down and bring Reflections into the animation with it.

Spot light

The key light is directional — parallel rays from a direction. It shapes a form beautifully but it can never throw a bounded pool of light, because it has no position to throw from.

Add a Spot and you get one that does: a real position, a cone, and distance falloff. That’s what gives you a travelling highlight across a surface, a pool on the floor, or a subject picked out of darkness.

• It’s off until its intensity goes above zero, so adding one costs nothing until you use it.
• Position is measured in multiples of the scene’s radius rather than pixels, so the same numbers frame the light identically on a 400px layer and a 4K one.
• Angle is the cone’s half-angle; Penumbra feathers its edge, from a hard circle to a soft pool.
• Falloff is physical inverse-square by default, so a spot needs a higher intensity than the key light to read — start around 3–6, not 1.
• Position, intensity and angle all animate. Sweeping the spot across a dark scene is the classic reveal.

Like the key light, it only reads against darkness. Drop Ambient and Reflections or the studio environment will drown it.

Orthographic camera

Set Projection to orthographic and perspective disappears entirely: edges stay parallel instead of converging, and the form keeps its true proportions. This is the isometric / technical-drawing look, and how product line-ups are usually drawn.

The Perspective dial (field of view) is ignored in this mode; Zoom still frames the shot. Combine it with 45° of Tilt X and Tilt Y for a clean isometric.

Depth-aware effects

This is the part 2D post-production genuinely cannot fake, and it’s worth reaching for on any 3D shot that should look photographed rather than rendered.

A filter on a 3D scene layer can read the scene’s real per-pixel depth, and the surface normals derived from it:

• Depth of field focuses at a distance into the scene, so a rack focus stays locked to the geometry as the shot spins or dollies.
• Depth fog thickens with distance, so far content recedes regardless of where it sits in frame or how bright it is.
• Rim light relights the scene after rendering, from its normals — a contour highlight that wraps the body and travels across it as the device turns. It’s additive contour rather than a real light: no shadows, and it can’t reach a surface the camera can’t see. Use it for edge separation on top of the real light rig.

These belong on the 3D scene layer itself, not on its children — a 2D child has no depth to read, so they simply do nothing there.

Depth of field or tilt shift?

This is a question of how much depth the shot actually has, not preference.

Depth of field needs real Z spread — a strongly tilted device, or several items at different depths. On a near-frontal pose the whole device sits in a thin slice of depth, and a small focus change swings the blur violently, quantising into blotchy grey mottling. That’s the “the whole device went soft” failure.

On thin-depth shots use tilt shift instead — it’s band-based and immune to that, at the cost of being screen-space. If a shot ramps from tilted to frontal, fade the depth of field out as the pose flattens, or use tilt shift throughout.

The move that sells a tilted device shot: far-side-only focus, so the front face stays crisp while the body recedes, with the aperture opening as the camera pushes in — like a real lens.

Depth-aware filters make the renderer draw the scene a second time to capture depth. That pass is shared, so depth of field, depth fog and rim light together still cost one extra pass rather than three — but don’t add a depth filter you can’t actually see.

Models with their own settings panel

A GLB can embed a small manifest (in Blender: a Custom Property named mixture on the Scene, exported with custom properties on) declaring tunable parameters — a body colour, a laptop’s lid angle — each mapped to a material property or a node transform. The editor reads the manifest and auto-generates panel controls for them, the same way a custom filter’s @param lines become sliders. Up to 16 parameters; types cover numbers, percentages, angles, colours and toggles.

Numeric parameters animate. A lid opening, a turntable spinning, a dial sweeping — declare the parameter and drive it over time, with no rebuild between frames. Give it a start and end value and a moment to run, or place several keys for a multi-step move (open, hold, half-close). Colours and toggles stay static, since changing one rebuilds the model.

Two things to get right:

• Timing is scene-local. A model parameter’s start time is measured from the start of the scene — the same convention as form switches and shatter, and not the same as a filter’s parameter animation, whose clock starts when that filter begins.
• The model is measured once, at its static pose. Set the base parameters to the pose you want framed — usually open — and the moving part then swings inside a fixed frame instead of the whole model resizing as it moves. For a silhouette that changes a lot, switch the fit to contain so it stays in frame.

Models without a manifest

Most models from the wild have no mixture manifest, and rewriting a GLB just to add one is miserable. So a parameter can instead target a node or material path directly — the model keeps its authored pose, and you animate the one node you care about without disturbing anything else.

The catch is that direct targeting removes the manifest step, not the need for a sensible pivot: a hinge whose geometry is baked at the model’s origin will swing about that origin rather than the hinge, and that still has to be fixed in the model.

Getting a model in: drop a .glb into the Assets view like any other file — the picker and drag-and-drop both accept it — and it appears in the Model dropdown alongside the bundled devices. A connected agent can also upload one for you, which is usually the faster route when the model needs preparing first (“find a laptop model, add a hinge pivot, and put our demo on its screen”).

Playing a model’s own animation

Lots of models arrive already moving: an action keyframed in Blender (a lid, a propeller, a drawer), a rigged character with a walk cycle, a face built from shape keys. Mixture plays all three kinds straight from the file — nothing to re-author.

When a model carries clips, its section in the 3D panel gains an Animation row listing every clip by name with its length. Pick one and three controls appear:

• Start — the scene time the clip begins. Before it, the model holds the clip’s first frame.
• Speed — a rate multiplier; 0.5 for slow motion, 2 for double time.
• Loop — Repeat, or Play once, hold last frame for a one-shot move like a lid opening.

Playback is tied to the timeline rather than a running clock, so scrubbing, stills and export all show exactly the same pose at the same time. A model is off by default: until you pick a clip it sits in its authored pose, however many animations the file contains — so a model that “doesn’t move” usually just needs its clip chosen.

To change clips mid-shot — a character that looks around, then breaks into a run — use Switch form at playhead from the section’s + menu: the switch is a cut, and the new clip starts from its first frame at that moment. Set the new clip’s Start to the cut time.

Two framing notes. Choose the contain fit for anything long — an animal, a vehicle — since it budgets the model’s depth as well as its width, so the body stays in frame however the layer is turned. And the model is sized at the clip’s first frame, so a clip that travels (a walk with root motion rather than an in-place cycle) will walk out of its box; prefer in-place cycles and move the layer instead.

If a clip and a model parameter both drive the same part, the clip wins that part — use parameters for the pieces the clip leaves alone.

Exporting from Blender: in the glTF exporter’s Animation panel choose Animation mode: Actions so each action becomes its own named clip (this is what fills the picker); tick Shape Keys and Shape Key Animations for morph targets; keep Sampling on so constraints and drivers bake to keyframes. Name your actions — the names are what you’ll see in the list.

Camera and motion

Everything that moves in 3D is a property you can keyframe:

• Tilt X/Y on the scene layer turns the whole scene; the same properties on a child item spin just that item — real per-item 3D rotation, which is how a logo spins while its caption holds still.
• Perspective is the camera’s field of view (the distance compensates, so content stays the same size while distortion changes) — animate it for a dolly-zoom. Zoom is a true camera dolly.
• Each item also gets a 3D placement section: position, Depth (Z), rotation, scale — a stack of cards at different depths is just different Z values.
• Back face chooses what a turned-away surface shows: hidden, a ghost, or solid.

Entrances and the rest of the animation system keep working on the children, so a phone can fade in while the UI on its screen staggers in line by line.

Agents know 3D too

The whole system is documented to agents — connect one and these are one-liners:

• “Put this screen recording on a tilted iPhone with a floor shadow, and ease the tilt from -32° to -12° over two seconds.”
• “Extrude the logo, brushed metal, slow spin.”
• “Upload this GLB and use it as a product shot with studio reflections.”

Models from your AI

There’s no model marketplace to wait on: a connected agent can create or convert a 3D model and upload it for you — including wiring up the mixture manifest so the model arrives with its own settings panel, and naming a screen mesh so your video plays on its display. Describe the prop you need; the .glb lands in your assets.

---

The bundled iPhone device is “iPhone 15 Pro Max” by MpPower™, used under CC Attribution 4.0. The bundled MacBook is “Macbook Pro 13 inch 2020” by timblewee, used under CC Attribution 4.0. Not affiliated with or endorsed by Apple.