Skip to main content
skill CX Codex

exploded-view — Claude Code skill: 3D breakdowns and install

The exploded-view Claude Code skill builds interactive three.js explainers for machines and products. It animates parts in stages, reveals the casing’s interior, and attaches labels to the model.

MIT ★ 448 updated 2026-11-09

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add Moh4696/open-3d-skills
/plugin install open-3d-skills@open-3d-skills
Open on GitHub

What exploded-view does

The skill helps create a browser-based 3D scene that shows how a machine or product is assembled. A slider or scroll sequence moves parts apart in stages; the casing can turn transparent or open along a section plane. Labels stay linked to parts with leader lines, and users can select a part by hovering or clicking.

The package includes assets/explode.js, with tools for staged separation, labels, x-ray, section cuts, and picking, plus a demo page that takes apart a motor. Models can be built in code or loaded from GLB. three.js is required; the demo import map uses r169. For GLB models, meshes need grouping by node name, and each part needs its own materials.

What it helps with

  • show how an engine comes apart, stage by stage
  • label model parts and connect each label to its anchor
  • reveal a machine’s interior through a transparent casing
  • add a section cut and hover or click selection
  • turn a 2D cutaway drawing into an interactive 3D scene

Example prompts for the agent

  • Build a three.js engine breakdown with a slider for each disassembly stage.
  • Add a transparent casing, a section cut, and part labels to this GLB model.
  • Create an interactive camera teardown with staged part movement and click selection.

How to install exploded-view

1Plugin marketplace

/plugin marketplace add Moh4696/open-3d-skills
/plugin install open-3d-skills@open-3d-skills

This installs the whole open-3d-skills plugin with all its skills

2Skills CLI (Vercel)

npx skills add Moh4696/open-3d-skills --skill exploded-view -a claude-code

3Manually: put the files in place

~/.claude/skills/exploded-view/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/exploded-view/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about exploded-view

How do I install exploded-view in Claude Code?

Add the marketplace with /plugin marketplace add Moh4696/open-3d-skills, then install the skill with /plugin install open-3d-skills@open-3d-skills.

What does exploded-view do?

It helps build interactive 3D explainers for machines and products, with staged part movement, casing cutaways, labels, and part selection.

What does exploded-view need to run?

It requires three.js. Models can be created in code or loaded from GLB; GLB meshes need grouping by node name.

Source text

SKILL.md · MIT
---
name: exploded-view
description: Builds interactive 3D explainers of how a machine or product works, in three.js, with a staged exploded view driven by a slider or scroll, x-ray shells, a section cut through the casing, labels pinned to parts with leader lines that never cover the model, and hover or click to pick parts. Works on code-built models and loaded GLB files. Use for "show how it works", teardown or cutaway pages, product anatomy, engine, motor, gearbox, camera, phone or vehicle internals, technical education pages, or turning a 2D cutaway drawing into an interactive 3D one.
---

# Exploded view

People understand a machine when they see it come apart in the order it was put together, with each part named where it sits. This skill does that in the browser: parts slide apart along sensible lines, outer shells go ghostly or get cut open, and labels follow their parts without ever sitting on top of the model.

## Tools

| File | What it does |
| --- | --- |
| `assets/explode.js` | `Exploder` (staged explode), `Labels` (pinned labels with leader lines), `Xray`, `Section` (clipping plane through shells), `Picker` (hover and click) |
| `assets/demo/` | A complete page: a code-built induction motor taken apart, with sliders, x-ray and section. `?explode=1`, `?cut=1`, `?xray=1` set the state |

Requires three.js (r169 in the demo's import map). Build the model with `threejs-scene` techniques or load a GLB.

## Build

### 1. Structure the model as parts

The unit of an exploded view is a part: a `Group` that moves as one. Make every part a direct child of one assembly group, and give each part **its own materials** (x-ray and hover change materials; shared ones would change every part at once).

For a GLB, regroup on load: walk the scene, and parent meshes into named part groups by their node names. Preserve world transforms when re-parenting (`group.attach(mesh)`).

### 2. Decide how each part moves

Per-part settings live on `userData`:

```js
housing.userData = { shell: true, stage: 0, explode: [0, 0.32, 0] };   // lifts off first
rotor.userData   = { stage: 2, explode: [0.42, 0, 0] };                // slides out along the shaft last
```

- `explode: [x, y, z]` is the offset at full explosion. Without it, the part moves away from the assembly centre (along `axis` if you pass one to `Exploder`), scaled by its distance.
- `stage` orders the motion: stage 0 moves first, and each later stage starts when the previous is half done. Take things apart the way a mechanic would: covers and shells, then fasteners and caps, then the inner parts.
- `shell: true` marks casings for x-ray and section cuts.

Lay out the exploded state like a technical illustration: one main axis (the shaft, the stack direction), parts spaced so each is clear of its neighbours, large shells moved off-axis (up) so the core stays visible.

```js
const ex = new Exploder(assembly);
ex.set(t);   // 0 assembled .. 1 exploded; ease toward a target each frame for slider input
```

### 3. Label the parts

```js
const labels = new Labels(document.querySelector(".labels"), camera, canvas);
labels.add(rotor, "Rotor", { note: "turns in the magnetic field", anchor: [0.03, 0.07, 0] });
// every frame, after renderer.render():
labels.update();
```

Labels sit in two columns at the screen edges, keep their anchors' vertical order and push apart when they would overlap; a leader line runs from each label to its anchor point. They follow the part as it explodes and hide when the part is hidden or behind the camera. Anchor each label on a point of the part that stays visible from the main view (the top edge, the end of a shaft), in the part's local coordinates.

Style `.label`, `.label b`, `.label span`, `.leader` and their `.focus` variants in CSS. On narrow phones, hide the labels and show the hovered or tapped part's name in one caption instead: two columns of labels do not fit beside a model on a 390 px screen.

### 4. X-ray and section

```js
const xray = new Xray(assembly);      xray.set(true);          // shells to 14% opacity, no depth write
renderer.localClippingEnabled = true;
const section = new Section(assembly, [0, 0, -1]);  section.set(0);   // cut the shells' front half away; null = off
```

The section plane cuts only shells, so the interior stays whole inside an opened casing, the way a cutaway drawing shows it. Cut materials are made double-sided so the inside of the casing reads.

### 5. Picking

```js
new Picker(canvas, camera, assembly.children, {
  onHover: (part) => highlightLabelOf(part),
  onPick: (part) => focusOn(part),
});
```

Hover tints the part's emissive slightly and switches the pointer cursor. A click can isolate the part, fly the camera to it, or open its description.

## Camera and framing

- Fit the camera to the assembly for the current screen shape, and let the distance follow the explode amount (the demo's `autoDistance`): close when assembled, pulled back when exploded. Stop doing it once the visitor zooms or orbits.
- Raise `OrbitControls.maxDistance` above the fitted distance, or the controls silently clamp it and phones see a crop.
- A three-quarter view slightly from above (the demo uses direction 0.42, 0.34, 1) shows ends and sides of a cylindrical machine at once.

## Driving it from scroll

Map scroll progress to `ex.set()` through keys with holds, as `scroll-film` does for frames: assembled while the intro reads, explode stage by stage with a caption per stage, hold fully exploded, then section cut. The model is real-time, so the visitor can stop and orbit at any point.

## Rendering

Product-shot lighting suits explainers better than a sky: a `RoomEnvironment` PMREM for reflections, one soft key light with shadows onto a `ShadowMaterial` floor, ACES tone mapping, and the page's own background colour as the clear colour (an opaque canvas defaults to black). Metals read through roughness 0.3 to 0.45 and metalness 0.8 to 0.95; painted parts through a clearcoat.

## Accuracy

If the subject is a real product, use real part names and the real assembly order, and say in the page copy which internal details are illustrative. An explainer that is wrong teaches the wrong thing confidently.

© exploraX · MIT · Moh4696/open-3d-skills

Similar skills

All skills for Frontend and UI →

From the same set9

site-check The site-check Claude Code skill checks 3D and animated web pages in Chromium and WebKit. Run it after page changes to catch browser errors, mobile layout issues, and slow frames before publishing. CX Codex +1 ★ 448repo stars motion-assets The motion-assets skill for Claude Code plans and generates images and video clips for animated websites. It activates for requests to create site visuals, loop a background, or animate an image. CX Codex +1 ★ 448repo stars cursor-rig The cursor-rig Claude Code skill turns an illustration into a portrait that follows the cursor with its head. It’s for adding a reactive character to a page without a 3D model or face tracking. CX Codex +1 ★ 448repo stars alpha-cutout The alpha-cutout Claude Code skill removes a clip’s background and prepares transparent animation for the web. It runs on requests for alpha video or a subject layered over page content. CX Codex +1 ★ 448repo stars frame-capture The frame-capture skill for Claude Code records web pages to MP4 with frame-by-frame control of time. Use it to capture animations, page scrolls, or a comparison of two clips. CX Codex +1 ★ 448repo stars scroll-film The scroll-film Claude Code skill builds film-like page sections controlled by scrolling. It covers clip joins, caption pauses, frame loading and mobile versions. CX Codex +1 ★ 448repo stars threejs-scene This Claude Code skill builds interactive three.js scenes from code, without model files. It activates for 3D websites, WebGL hero sections and real-world objects rendered in 3D. CX Codex +1 ★ 448repo stars open-3d-skills The open-3d-skills Claude Code plugin adds skills for 3D scenes and animated websites. Its eight skills cover three.js builds, scroll-controlled films, and browser checks. CX Codex ★ 448repo stars

Project sponsors

Companies that keep this analytics open