Source confidence: medium
See also: Deeper Dive — Napkin Sketch → Production Asset: The 5-Tool Creative Pipeline →

Napkin Sketch → Production Asset: The 5-Tool Creative Pipeline

Insight class: Creative Fusion · Difficulty: Easy · Quality: 4/5 Connected entries: 4 · Tools: 3DAI Studio, ChatGPT, Hunyuan3D, Hunyuan3D-2, Kling, Magnific, Magnific AI, Midjourney, Move AI, Procreate, Tencent

In short: Running this system takes one hand-drawn character from a Procreate kit-bash sheet to a rigged, animated, rendered 3D shot using Jon Finger's chain (Procreate, Magnific style transfer, 3DAI Studio or Hunyuan3D-2, Move AI mocap, render) with Kling as a fallback for 2D-to-video.

Key fact Detail
What it covers animation, art, image generation, video production
Tools 3DAI Studio, ChatGPT, Hunyuan3D, Hunyuan3D-2, Kling
Posts covered 4 posts (1 S-tier, 2 A-tier) · top: Hunyuan3D-2 — Tencent's free image-to-3D model… · Kling Motion Brush — direct up to 5 characters… · Sketch-to-3D-anim pipeline — Procreate +…
Creators @chatgptricks, @iamfesq, @nick_saraev
Sources dated Apr 2024 – Apr 2025
Difficulty Easy
Prompt system Run-it-yourself prompts
Last verified 2026-10-22

Thesis

A hand-drawn sketch can become a production-ready 3D animation in under an hour by chaining Procreate → Magnific AI → 3DAI Studio → Move AI → final render. Each tool handles one transformation step.

Why it matters

The gap between 'I have an idea' and 'I have a production asset' used to be weeks of specialized work across multiple disciplines. This pipeline collapses it to under an hour by chaining five AI tools, each handling one transformation: sketch → upscale → 3D mesh → motion → final render. The key is that each tool is best-in-class at its specific step, and they hand off cleanly. A napkin doodle at lunch becomes a rigged, animated 3D character by dinner. For indie creators, this is the difference between having ideas and shipping them.

The evidence — connected entries

Sketch-to-3D-anim pipeline — Procreate + Magnific + 3DAI + Move AI

Creator: @chatgptricks · Tier: A Tools: 3DAI Studio, ChatGPT, Magnific, Magnific AI, Move AI, Procreate

The full pipeline: sketch → upscale → 3D → motion capture → animate

Director Jon Finger's pipeline: Procreate sketches -> Magnific AI style transfer -> 3DAI Studio for 3D models -> Move AI for mocap -> Cinema 4D for render. Concrete multi-tool AI animation workflow.

View original post

Kling Motion Brush — direct up to 5 characters in one AI video

Creator: @realrileybrown · Tier: A Tools: Kling, Midjourney

Kling Motion Brush: direct up to 5 characters in one AI video

@realrileybrown on Kling's Motion Brush: select up to 5 characters/objects in a starting image (often Midjourney-generated) and draw motion paths to animate them. One of the sharpest controllable video-gen workflows at the time.

View original post

Hunyuan3D-2 — Tencent's free image-to-3D model generator

Creator: @nick_saraev · Tier: S Tools: Hunyuan3D, Hunyuan3D-2, Tencent

Hunyuan3D-2: skip the 3D modeling step entirely with AI

Tencent's Hunyuan3D-2 turns text or an uploaded image into textured 3D models in seconds. Free web UI; pipeline is upload > Generate Shape > Generate Textured Shape > download. Good for game/app asset workflows.

View original post

AI rotoscoping — mask yourself into your own animations

Creator: @iamfesq · Tier: B

AI rotoscoping: mask yourself into your own animations

@iamfesq demos using an AI detection/segmentation model to auto-rotoscope a mask of himself for compositing into his animated art. Quick technique reference for AI-assisted rotoscoping.

View original post

Action sketch — how to implement this

Draw in Procreate → upscale with Magnific → generate 3D mesh with Hunyuan3D or 3DAI → capture motion with Move AI → composite with Kling or Runway. Total time: ~45 minutes per asset.

Prerequisites

Procreate or any drawing app, Magnific AI, Hunyuan3D-2 or 3DAI Studio, Kling or Runway account

Key tools and resources

Creators to follow

Prompt system — run this yourself

Everything below is pasteable into Claude Code, Claude, or any agent. Use the one-shot when you want the whole result in one run; use the step prompts when you want to steer. Every step carries its own audit, and the gap audit at the end makes the agent find and fill what it missed.

Mission. Running this system takes one hand-drawn character from a Procreate kit-bash sheet to a rigged, animated, rendered 3D shot using Jon Finger's chain (Procreate, Magnific style transfer, 3DAI Studio or Hunyuan3D-2, Move AI mocap, render) with Kling as a fallback for 2D-to-video. It is for an indie creator who wants to know if the 'under an hour, about 45 minutes per asset' claim holds and where the chain breaks. Done means a timed log for each stage, a mesh that passes technical checks (manifold, polycount, UVs, valid glTF), a retargeted mocap clip without foot sliding, a render, and a gap report naming the stages that needed manual cleanup.

1 · Deeper, not bigger

Before running anything, make the task deeper rather than larger. Ask: what would a top professional do here that I am not asking for; what is the rawest material; which methods and tools; what, other than the model or me, proves it right. Then ask for exactly that.

Rewritten prompt — ask for exactly that:

Take my Procreate character from sketch to a rendered animated shot and measure every stage. Do not start from one loose drawing: help me produce a kit-bash sheet of separate parts plus a front and side view at the same scale, as Jon Finger did. Run each part through Magnific with high resemblance and low creativity, then to 3D through Hunyuan3D-2 (local, shape then texture) and, as a comparison, 3DAI Studio. In Blender headless: normalize scale to meters, set pivots, assemble the humanoid, remesh with QuadriFlow to under 30k quads, project UVs, bake the generated texture, rig with Rigify, and retarget a Move AI capture of me. Check with trimesh (watertight, polycount), glTF-Validator (zero errors), and a foot-contact script (contact frames within 1 cm of the floor). Render 5 seconds at 24 fps and assemble with FFmpeg. Keep a CSV of start and end time per stage, including failed generations and manual fixes, so the '45 minutes per asset' claim is tested. Read the Hunyuan3D-2 license and each service's commercial terms and list restrictions. Finish with a gap report: which stages needed manual work, total time, and whether the asset is game-ready or only render-ready.

2 · One-shot prompt

ROLE AND STANCE
You are a character technical director running an AI-assisted asset pipeline. You care about whether the asset survives rigging, animation and export, not whether a turntable looks good. You time everything and count failed attempts. You treat 'under an hour' as a claim to measure.

CONTEXT
- Jon Finger's chain (chatgptricks post): sketch parts as a kit-bash sheet in Procreate, Magnific AI style transfer to make them look 3D, 3D AI Studio to convert to meshes, assemble a humanoid, Move AI motion capture of his own performance, Cinema 4D render. He called it 'a little experiment'.
- Hunyuan3D-2 (nick_saraev): free image-to-3D, Generate Shape then Generate Textured Shape; open weights on GitHub.
- Kling motion brush (realrileybrown): select up to 5 subjects in a still and draw motion paths; a 2D-to-video fallback when 3D fails.
- AI rotoscoping (iamfesq): segmentation mask to composite yourself into the scene.
- The dive's claim: about 45 minutes per asset from napkin to animated render.

HARD CONSTRAINTS
- Every stage writes its output to stages/NN_name/ with the exact settings used and a row in timing.csv (stage, start, end, attempts, manual_fix_minutes, notes).
- Mesh budget: under 30k quads after retopology, single material, 2048 px texture.
- Scale in meters, character about 1.7 m, feet on Z=0, forward -Y.
- No commercial-use claim until each tool's license and plan terms are recorded in licenses.md (Hunyuan3D-2's license has territory restrictions; Magnific, 3DAI Studio, Move AI and Kling terms vary by plan).
- Do not upload other people's art or likeness.

DELIVERABLES, IN ORDER
1. ground_truth.md: tool versions and plans, license notes, the original sketch files, and a reference timing goal.
2. stages/01_sheet: kit-bash parts sheet plus front and side views exported as separate 2048 px PNGs on white.
3. stages/02_magnific: each part with recorded resemblance and creativity settings.
4. stages/03_mesh: Hunyuan3D-2 meshes and 3DAI Studio meshes for the same parts, with a comparison table (triangles, watertight, visual fidelity score 1-5).
5. stages/04_assembly: Blender .blend and a headless script assemble.py that imports, scales, sets pivots, joins, remeshes with QuadriFlow, UV-projects and bakes.
6. stages/05_rig: Rigify rig with weights; test poses.
7. stages/06_mocap: Move AI capture exported to FBX, retargeted; foot-contact report.
8. stages/07_render: 5-second 24 fps render, FFmpeg-assembled MP4, GLB export validated.
9. fallback/: if 3D fails, a Kling motion-brush clip from the Magnific image, labeled as 2D.
10. report.md.

BUILT-IN GAP ANALYSIS
Maintain GAPS in report.md. For each claim mark VERIFIED, UNVERIFIED or FALSE with evidence: total time under 60 minutes; parts converted without manual mesh repair; Hunyuan3D-2 versus 3DAI Studio fidelity; mesh watertight after assembly; weights deform without candy-wrapping at elbows and knees; mocap retarget without foot sliding; GLB valid; commercial use allowed. Run the checks; list what is left with the next action.

SELF-QUESTIONS
- Did a single sketch angle produce a plausible back side, or did the model invent one?
- Did Magnific change the design (extra details, different proportions) and did I accept drift without noticing?
- Are the generated meshes one shell or many intersecting shells?
- Is the texture baked onto my new UVs or still on the generator's atlas?
- Is the timing honest, including generation queues and retries?
- Would this asset survive a game engine import, or is it render-only?

STOP CONDITIONS
Stop and report if image-to-3D fails on more than half of the parts after 3 attempts each; produce the Kling fallback and document why. Stop before any paid upgrade or upload of identifiable likeness; ask the user.

RETURN FORMAT
report.md: a timing table per stage with attempts and manual minutes, the mesh comparison table, validator outputs, the foot-contact result, license table, verdict (game-ready / render-ready / failed), GAPS, and links to the MP4 and GLB.

3 · Step-by-step prompts

Step 1 — Ground truth: tools, licenses, source sketch

Goal: Pin tool versions, terms and the raw sketch before generating anything.

List every tool in the chain (Procreate, Magnific AI, 3DAI Studio, Hunyuan3D-2, Move AI, Blender, Kling) with the version or plan the user has. Clone Tencent's Hunyuan3D-2 repo, read README and LICENSE, and record the territory restrictions and commercial terms verbatim. For each paid service record what the current plan allows for commercial use and output ownership, with the URL of the terms page and the date read. Collect the user's original sketch files at full resolution. Write the 45-minute claim as a hypothesis and create timing.csv with headers stage, start, end, attempts, manual_fix_minutes, notes. Check whether a local GPU can run Hunyuan3D-2 (record VRAM and the repo's stated minimum) or whether the web UI must be used. Note that Jon Finger rendered in Cinema 4D; decide whether Blender replaces it and say so. Write ground_truth.md and licenses.md.

Expect: ground_truth.md, licenses.md with quoted terms and dates, timing.csv header, sketches in stages/00_source.

Audit before moving on: Fail if any license row says 'probably fine' or lacks a source URL and date. Mark the tool UNVERIFIED for commercial use instead.

Step 2 — Kit-bash sheet and turnaround

Goal: Give the image-to-3D stage inputs it can succeed with.

From the source sketch, produce in Procreate (or describe exactly for the user to draw) a kit-bash sheet like Jon Finger's: head, torso, each arm, each leg, hands and props drawn separately, front-facing, consistent scale, on white, with clear silhouettes and no overlapping parts. Add a front and side view of the assembled character at the same height. Export each part as a 2048 px PNG with a transparent or white background. Then run each part through Magnific with high resemblance and low creativity; record the slider values and prompt per part. Compare each Magnific output to its sketch with an overlay at 50% opacity and note any added or removed features. Keep part names consistent across files (head, torso, arm_L, arm_R) so later scripts can find them.

Expect: stages/01_sheet with 8-12 part PNGs and two views; stages/02_magnific with outputs, settings.json and an overlay note per part.

Audit before moving on: Fail any part whose Magnific silhouette deviates visibly from the sketch (new limbs, changed proportions); rerun with lower creativity. Log time and attempts.

Step 3 — Image to 3D, two generators

Goal: Convert parts to meshes and compare Hunyuan3D-2 with 3DAI Studio.

For each Magnific part, generate a mesh with Hunyuan3D-2 locally (shape pipeline, then paint pipeline for texture; record seed, steps and octree resolution) and with 3DAI Studio's web tool. Export GLB or OBJ. Write mesh_check.py using trimesh: triangle count, number of connected bodies, is_watertight, bounding box, and texture presence. Produce a comparison table per part: generator, triangles, bodies, watertight, fidelity to the sketch scored 1-5 by overlaying a front render on the sketch. Pick the better mesh per part with a reason. Log generation time and queue time separately in timing.csv. If Hunyuan3D-2 is run locally, also record GPU time per part so the cost of the free route is visible. Keep every rejected mesh with its seed; do not overwrite.

Expect: stages/03_mesh with two meshes per part, mesh_check.py output and a comparison table.

Audit before moving on: Fail a mesh with more than 3 bodies or that is non-watertight where it should be solid; retry with a cleaner input image, then mark for manual repair. Stop per the stop condition if more than half the parts fail after 3 attempts.

Step 4 — Assemble, retopologize, bake

Goal: Make one clean animation-ready mesh in Blender headless.

Write assemble.py for blender -b -P: import chosen part meshes, scale so total height is 1.7 m, place feet at Z=0 facing -Y, position parts using the front and side views as reference planes, join into one object, voxel remesh at 1 cm to fuse shells, then QuadriFlow remesh to a target of 25k faces. Duplicate the original textured parts as a bake source. Smart UV project the new mesh with 0.02 island margin, bake diffuse from the source with cage extrusion 0.02 to a 2048 px image, assign a single material. Save .blend and export GLB. Run mesh_check.py and Khronos glTF-Validator on the GLB. Record the face count before and after QuadriFlow and how long each Blender operation took.

Expect: assembly .blend, assemble.py, character.glb, validator report with zero errors, mesh_check output.

Audit before moving on: Render front and side views and overlay them on the sketch views. Fail if the texture has black bake holes over 2% of the surface or validator errors exist; fix cage distance or UVs and rerun.

Step 5 — Rig, mocap, retarget

Goal: Drive the character with the user's own performance.

Add a Rigify human metarig, fit bones to the mesh using the side view, generate the rig and bind with automatic weights. Test 6 poses (arms up, squat, twist, walk contact, fist, head turn) and note candy-wrapping or tearing. Capture a 5-second Move AI performance of the user (single or multi-camera as their plan allows), export FBX at 24 fps, and retarget to the Rigify rig with the Rokoko retargeting add-on or a bone-mapping script. Write foot_contact.py: detect frames where foot velocity is under 2 cm per frame and report foot height and horizontal drift in those frames. Confirm the Move AI frame rate matches the scene frame rate before retargeting; a mismatch causes sliding that no IK fix hides. Log manual weight-paint minutes in timing.csv.

Expect: rigged .blend, pose test renders, retargeted action, foot_contact report.

Audit before moving on: Fail if foot height in contact frames exceeds 1 cm or drift exceeds 2 cm per contact; fix with a root-height offset or IK foot locks, rerun the script.

Step 6 — Render and fallback

Goal: Produce the final shot and a 2D fallback for comparison.

Light the scene with a three-point setup, render 120 frames at 24 fps in Eevee at 1920x1080 headless (blender -b scene.blend -a), and assemble with FFmpeg: ffmpeg -framerate 24 -i frame_%04d.png -c:v libx264 -pix_fmt yuv420p -crf 18 shot.mp4. Export a final GLB with the animation and validate it again; open it in the Babylon.js sandbox or three.js editor and confirm the animation plays and the texture is not missing. Log render time per frame in timing.csv. As a fallback and comparison, feed the best Magnific image into Kling, use motion brush on up to 5 regions to animate a similar action, and save it labeled 2D. If AI rotoscoping of the user is wanted, segment the user's video with a segmentation model and composite the character beside them.

Expect: shot.mp4, animated GLB passing validation, a third-party viewer screenshot, Kling fallback clip.

Audit before moving on: Check shot.mp4 with ffprobe for 120 frames at 24 fps. Fail if the GLB animation does not play in the third-party viewer.

Step 7 — Validate against oracles and write the gap report

Goal: Test the 45-minute claim and the production-ready claim.

Sum timing.csv per stage and total, separating machine time, queue time and manual minutes. Compare to the 45-minute claim, and compute what the total would be on a second asset reusing the scripts (exclude one-time setup like installing Hunyuan3D-2). Rerun mesh_check.py, glTF-Validator and foot_contact.py and paste outputs. Ask one person (ideally an animator) to compare the render to the original sketch and score likeness 1-5 and motion quality 1-5. Classify the asset: game-ready (valid GLB, under budget, clean rig), render-ready (looks right, fails technical checks), or failed. Write report.md with GAPS: each claim VERIFIED, UNVERIFIED or FALSE with evidence, plus the three most expensive stages and what would shorten them next time. State plainly whether the dive's under-an-hour claim held for this asset, and with how many attempts.

Expect: report.md with totals, validator outputs, reviewer scores, classification and GAPS.

Audit before moving on: Fail if total time omits failed attempts or manual fixes. Fail if any VERIFIED row lacks a pasted output.

4 · Gap analysis and audit

Run this after the build. It makes the agent enumerate its own claims, mark what is verified, rank the gaps and fix the top ones.

You are auditing a sketch-to-animated-3D asset produced with Procreate, Magnific, Hunyuan3D-2 or 3DAI Studio, Blender, Move AI and optionally Kling. Inputs: stages/, timing.csv, licenses.md, report.md, character.glb, shot.mp4. 1) Enumerate claims: total time, game-ready status, watertight mesh, validator clean, foot contact within 1 cm, likeness to the sketch, commercial use allowed. 2) Re-verify: rerun mesh_check.py, glTF-Validator, foot_contact.py, ffprobe; recompute totals from timing.csv; check licenses.md rows have URLs and dates; render a front view and overlay on the sketch. Mark each VERIFIED, UNVERIFIED or FALSE with output. 3) Hunt hidden manual work: compare .blend modification history and file times against timing.csv; look for parts sculpted by hand but logged as generated. 4) List missing pieces: no back view, no LODs, no texture for hands, no retarget for fingers. 5) Rank by impact on the 'production asset' claim. 6) Fix the top three now and rerun checks. 7) Report what remains unfixed and why.

Questions the agent must ask itself before it says done:

5 · What proves it right

6 · Failure modes

7 · Agent direction (unattended runs)

Begin with licenses and source files; nothing generated is usable if terms forbid it. Use Blender headless via bpy scripts for every Blender stage so it is reproducible; avoid GUI-only steps except where the user must draw or perform. Run Hunyuan3D-2 locally if a GPU with enough VRAM exists, otherwise use the web UI and log it. Web services (Magnific, 3DAI Studio, Move AI, Kling) need the user's accounts: prepare inputs and settings, then ask the user to run them and return files. Spawn a sub-agent for mesh_check.py and foot_contact.py while you write assemble.py. Cache every generated mesh with its seed. Stop and ask before paid upgrades, before uploading the user's likeness, and when the stop condition fires. Return: stages/, timing.csv, licenses.md, character.glb, shot.mp4, fallback clip, report.md with GAPS.

Prompt system updated 2026-10-22 · all prompt systems · JSON

Browse more deep dives at DejaViewed — 846 entries across the full catalog.

Generated 2026-10-22 · curated by @6ab3 for DejaViewed