Skip to main content
skill CX Codex

build-wireframe-scan-reveal — Claude Code skill: scanning 3D reveal

build-wireframe-scan-reveal reveals a Three.js model with a wavefront that leads a wire cage, then builds the solid surface behind it. The cage burns away at the end.

MIT 1,500 installs ★ 7,995 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add MengTo/Skills --skill build-wireframe-scan-reveal -a claude-code
Open on GitHub

What build-wireframe-scan-reveal does

The skill pairs two representations of one geometry: a LineSegments cage and a solid mesh. Both share uScanRadius in world space. The cage leads the fill by 520 units — while the wave travels, topology remains visible. After the pass, the cage fades through smoothstep(.72, 1, t).

Default duration is 3.4 seconds, radius grows along 1 - (1 - t)^1.35. Two long sine terms in unscanned() produce an organic front without sparkle. A narrow rim aliases, a wide rim turns to fog — the demo holds 135 units.

The temporary cage and its shader are disposed immediately after completion. Geometry hidden via opacity loads the GPU until the session ends. No FFmpeg or render required — the skill works with browser Three.js. Under prefers-reduced-motion, it shows a still at 62% radius rather than hiding the scene.

What it helps with

  • drive a reveal wave across a 3D model with visible topology at the front
  • show mesh structure before the textured surface arrives
  • build a holographic assembly with a burning wire front
  • replace flat geometry fade-in with radial scanning from a point
  • control two representations of one geometry with shared timing

Example prompts for the agent

  • Add a scanning reveal for root.glb with the wave starting at the lower left corner
  • Make the cage lead the fill by 400 units and fade during the last 30% of the animation
  • Install build-wireframe-scan-reveal and set the wave to 2.8 seconds with an organic front

How to install build-wireframe-scan-reveal

1Skills CLI (Vercel)

npx skills add MengTo/Skills --skill build-wireframe-scan-reveal -a claude-code

2Manually: put the files in place

~/.claude/skills/build-wireframe-scan-reveal/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/build-wireframe-scan-reveal/

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

Questions about build-wireframe-scan-reveal

How to install build-wireframe-scan-reveal in Claude Code?

Run npx skills add MengTo/Skills --skill build-wireframe-scan-reveal -a claude-code, the skill will appear in ~/.claude/skills/build-wireframe-scan-reveal/SKILL.md.

What does build-wireframe-scan-reveal do?

It creates a wave that reveals Three.js geometry: a wire cage at the front shows topology, solid surface builds behind it. The cage disappears after the pass completes.

Why is the 520-unit lag between cage and fill needed?

Without lag, wire and fill arrive together — reads as a plain wipe. The lag gives time to see mesh structure before the surface covers it.

Source text

SKILL.md · MIT
---
name: build-wireframe-scan-reveal
description: Reveal Three.js geometry with an expanding world-space scan whose wire cage leads the solid surface, then burns away. Use for wireframe scanning, radial mesh reveals, survey pulses, holographic assembly, topology intros, and 3D model entrances where a plain opacity wipe does not explain the form.
---

# Build a Wireframe Scan Reveal

Make one world-space wavefront conduct both representations: draw topology at the front, hold the solid behind it, then remove the temporary cage. Reach for `technical-wireframe-info-layout` when wireframe is the page's permanent visual language; reach for `animation-on-scroll` when the conductor is DOM scroll rather than a 3D wave.

Extracted from `inner-green-3d.html`, where a survey pulse had to grow a procedural moss root through cards and type without reading as a circular mask.

## Pair two representations

Create the solid mesh and a temporary `LineSegments` cage from the same source geometry. Share `uScanOrigin`, `uScanRadius`, and time between their materials. Keep both in world space; local-space distance changes when a group is scaled or nested and tears the two fronts apart.

Discard the solid beyond the front, with a lag that leaves the cage visible first:

```glsl
uniform vec3 uScanOrigin;
uniform float uScanRadius;
uniform float uScanEnabled;

bool unscanned(vec3 worldPosition, float lag) {
  if (uScanEnabled < 0.5) return false;
  float wobble =
      sin(worldPosition.y * 0.011 + worldPosition.x * 0.007) * 36.0
    + sin(worldPosition.z * 0.021 + worldPosition.y * 0.013) * 17.0;
  return distance(worldPosition, uScanOrigin)
       > uScanRadius - lag + wobble;
}

// In the solid fragment shader:
if (unscanned(vWorldPosition, 520.0)) discard;
```

Use one origin outside the silhouette, usually low and left. A centered origin reads as a loading ring. Keep the two long sine terms; a perfectly circular front reads as a clip-path, while high-frequency noise makes the edge sparkle.

## Make the cage ride the front

Measure each line fragment against the same radius:

```glsl
float distanceFromOrigin = distance(vWorldPosition, uScanOrigin);
float rim = exp(-pow((distanceFromOrigin - uScanRadius) / 135.0, 2.0));
float trail = smoothstep(uScanRadius, uScanRadius - 950.0, distanceFromOrigin);
float alpha = (rim * 1.60 + trail * 0.34) * uWireOpacity;
```

Use additive blending, `transparent: true`, `depthWrite: false`, and a pale version of the scene accent. Keep depth testing on unless the cage must read through the object. Turning depth test off exposes the back half of dense topology and produces a bright unreadable ball.

## Animate one conductor

Use the landed timing as a starting point:

| parameter | default | failure prevented |
| --- | ---: | --- |
| duration | 3.4 s | a fast reveal reads as a flash |
| radius easing | `1 - (1 - t)^1.35` | linear travel stalls visually near the far corner |
| solid lag | 520 world units | zero lag makes wire and fill arrive as one wipe |
| rim width | 135 units | a narrow rim aliases; a wide rim becomes fog |
| wire trail | 950 units | no trail hides topology before it can be read |
| wire fade | `smoothstep(.72, 1, t)` | persistent cage competes with the finished surface |
| radius reach | scene diagonal × 1.3 + 900 | the far corner remains clipped after completion |

Snap the cage on over the first 6% of the timeline, then fade it during the final 28%:

```js
const e = Math.min(1, elapsed / 3.4);
scanRadius.value = easeOutPow(e) * maxRadius;
wireOpacity.value = Math.min(1, e / 0.06) * (1 - smoothstep(0.72, 1, e));
```

At completion, disable the discard branch, remove the cage, and dispose its geometry and material. Hiding it with opacity leaves duplicate geometry and shader work alive for the rest of the page.

## Stage and size the scan

Resolve `maxRadius` after layout and after parent matrices update. Use a `ResizeObserver`, guard zero-sized roots, update the camera projection, then recompute the origin and farthest reach. A one-time measurement before fonts or layout settle leaves the last corner unrevealed.

Keep the demo's scene recognisable: grey-green field, bottom light pool, white editorial type, pale cards, and the root-shaped form. The staging belongs in the demo; the reusable skill is only the paired representations and shared conductor.

## Respect motion and lifecycle

- Under `prefers-reduced-motion: reduce`, render a designed diagnostic still at about 62% radius with both cage and solid visible. Let the replay control recompose that still and announce the state; do not hide the scene.
- Clamp `dt` to 1/30 s. Reset the time base after a hidden tab or offscreen section resumes.
- Pause on `document.hidden` and when an `IntersectionObserver` says the section is offscreen.
- Cap device pixel ratio at 2.
- Expose replay as a real button with visible focus and an `aria-live` status. Keep the canvas `aria-hidden` when it is decorative.
- On teardown, cancel the frame, disconnect observers, remove listeners, and dispose geometry, materials, textures, and the renderer.

## State the cost honestly

The temporary second representation and its line coverage are the real cost. Topology density and overdraw matter more than the radius math. Build the wire cage only for the entrance, use the coarsest edge graph that preserves the silhouette, and dispose it as soon as the scan finishes. Do not claim a performance gain without profiling GPU frame time before and during the cage pass.

## Verify

- Compare the opening, midpoint, and completed states with the source at 1440×900.
- Confirm the cage leads the solid everywhere, including scaled child groups.
- Fast-forward across completion and verify no clipped islands remain.
- Replay twice and confirm only one frame loop and one cage survive.
- Resize during the scan at 390×844 and 1440×900.
- Tab to replay and confirm visible focus and a live status update.
- Test `?reduced=1` or system reduced motion: composed still, no advancing radius.
- Hide/show the tab and leave/re-enter the viewport; confirm no time jump.
- Confirm a clean console and disposed cage resources after completion.

Use [demo/index.html](demo/index.html) as the working proof and [demo/PROMPT.md](demo/PROMPT.md) to recreate or remix it.

© MengTo · MIT · MengTo/Skills

Similar skills

All skills for Frontend and UI →

From the same set178

The whole set →
build-mobile-threejs-games build-mobile-threejs-games — a skill for building and testing a Three.js game for mobile web: touch controls, responsive HUD, performance budgets. CX Codex +1 1,600installs design-game-encounters design-game-encounters is a Claude Code skill for planning, tuning, and testing action-game encounters in Three.js. It comes into play when shaping arenas, enemy waves, or boss phases. CX Codex +1 1,600installs design-action-combat design-action-combat guides the design and testing of tactical combat for web games using deterministic state machines. Useful when tuning parry windows, attack startup, and hit registration. CX Codex +1 1,600installs x-bookmark-quote-posts x-bookmark-quote-posts extracts recent X bookmarks and turns them into first-person quote-post drafts matched to your last 100 authored posts. CX Codex +1 1,600installs publish-project-to-github publish-project-to-github packages a local project into a GitHub repository, audits files for leaked secrets, generates a verified README, and configures GitHub Pages. CX Codex +1 1,500installs build-interactive-particle-trail build-interactive-particle-trail — a skill for pointer-driven particle trails: the cursor or finger leaves discrete motes that fly on their own path. Useful in 3D scenes and landing pages. CX Codex +1 1,500installs web-technique-to-skill web-technique-to-skill turns a visual or interaction technique you already built into a reusable web-design skill, with a demo that proves both the mechanism and the visual fidelity. CX Codex +1 1,500installs add-mouse-driven-orbit add-mouse-driven-orbit adds subtle mouse-driven orbit and parallax to Three.js hero sections without OrbitControls. Useful for cinematic headers that react to cursor movement. CX Codex +1 1,500installs

Project sponsors

Companies that keep this analytics open