--- title: "Agent Skill to Unity 6 MCP Skill: Blender To Unity" platform: "Promptally" canonical_url: "https://app.promptally.dev/p/skill-blender-to-unity" modality: "SKILL" category: "Game Development" compatible_models: [Universal / Model Agnostic] access_tier: "Free Public Artifact (No Auth Required)" license: "MIT" --- # Agent Skill to Unity 6 MCP Skill: Blender To Unity **Summary:** Agent Skill to Unity 6 MCP Skill: Blender To Unity is a verified SKILL blueprint on Promptally in Game Development optimized for leading AI models. Hand off a model from Blender (via BlenderMCP) into Unity (via MCP for Unity) — export the current Blender model, import it through import model file, and place it in the open scene. Use when the user has BlenderMCP and MCP for Unity both connected and wants to bring a Blender model into Unity. Does NOT drive Blender's own generators; BlenderMCP owns how the model got into Blender. Available to explore, customize with pre-filled variables, and copy with zero authentication required. ## Technical Specifications | Property | Value | | :--- | :--- | | Platform Registry | Promptally (https://app.promptally.dev) | | Modality | SKILL | | Category | Game Development | | Compatible Engines | Universal / Model Agnostic | | Dynamic Variables | None (Static Blueprint) | | Approx. Token Length | 2,502 | | Access Tier | Free Public Artifact (No Auth Required) | | License | MIT | ### Pre-Filled Template & Production Source ````md --- name: blender-to-unity description: Hand off a model from Blender (via BlenderMCP) into Unity (via MCP for Unity) — export the current Blender model, import it through import_model_file, and place it in the open scene. Use when the user has BlenderMCP and MCP for Unity both connected and wants to bring a Blender model into Unity. Does NOT drive Blender's own generators; BlenderMCP owns how the model got into Blender. --- # Blender → Unity Model Handoff Bring whatever model is currently in Blender into the open Unity scene. The seam is the local filesystem: Blender exports a file, Unity imports it. The two servers never talk directly. ## Preconditions - Both `mcp__blender__*` tools and MCP for Unity tools are connected. - A model exists in the Blender scene (confirm with `mcp__blender__get_scene_info` / `mcp__blender__get_object_info`). If empty, stop and tell the user — this skill does not generate models. - **`import_model_file` is in the `asset_gen` tool group, which is off by default** (only `core` loads). Enable it first with `manage_tools` (enable the `asset_gen` group), **or** call the C# handler straight through `batch_execute` — `{"tool":"import_model_file","params":{"sourcePath":...,"name":...,"outputFolder":...}}` (camelCase) — which dispatches by name regardless of group gating. ## Steps 1. **Resolve the Unity project path.** Read `mcpforunity://editor/state` for the project root (the editor dataPath's parent). Decide the export format: - **GLB (glTFast) when the model has a rig, animation, PBR (metallic/roughness), emission, or transparency** — glTFast carries all of these automatically, no post-processing (see [references/bridge-fidelity.md](references/bridge-fidelity.md)). Multi-material zones survive either format, so they alone don't force GLB. - **FBX otherwise** — when glTFast isn't installed, the model is plain geometry, or you specifically need the built-in importer's humanoid-avatar pipeline. FBX drops emission/metallic (Step 5 restores emission) and surfaces animation only with `animation_type` set (Step 3). 2. **Export from Blender to a temp path** via `mcp__blender__execute_blender_code`: ```python import bpy, os, tempfile out = os.path.join(tempfile.gettempdir(), "blender_to_unity.fbx") # Export the selection if any, else the whole scene: bpy.ops.export_scene.fbx(filepath=out, use_selection=bool(bpy.context.selected_objects), apply_unit_scale=True, bake_space_transform=True) print(out) ``` (glTF branch: `out_glb = os.path.join(tempfile.gettempdir(), "blender_to_unity.glb")`, then `bpy.ops.export_scene.gltf(filepath=out_glb, export_format='GLB', use_active_scene=True)` — its default `use_active_scene=False` can silently export a *different* open scene.) 3. **Import into Unity** with `import_model_file`: `import_model_file(source_path=, name=, target_size=)`. For a **rigged/animated FBX**, also pass `animation_type="generic"` (or `"humanoid"`; `"legacy"` targets the old Animation-component system) — the importer defaults to `"none"`, which deliberately imports the mesh with **zero animation clips**. GLB ignores this (glTFast imports animation itself), so it's an FBX-only knob. It returns `{ asset_path, asset_guid }`. Pass `target_size` as the intended final size, but treat it only as a hint: it rescales at import solely when the project's **Auto-normalize** pref is on, and even then is unreliable for Blender FBX (see the **Scale** note). Step 4 does the reliable normalization. 4. **Place it in the scene, normalized to size.** Ensure the scene has a camera + directional light (`manage_scene` / `manage_gameobject`). Instantiate the model at the chosen position via `manage_gameobject(action="create", prefab_path=, name=, position=[x,y,z])`. Then normalize its size deterministically — Blender FBX commonly imports ~100× too large — by measuring the placed model's world bounds and scaling so its largest dimension equals your target size. Run via `execute_code` (substitute your object name and target meters): ```csharp var go = GameObject.Find(""); var rs = go.GetComponentsInChildren(); var b = rs[0].bounds; for (int i = 1; i < rs.Length; i++) b.Encapsulate(rs[i].bounds); float maxDim = Mathf.Max(b.size.x, Mathf.Max(b.size.y, b.size.z)); float target = 2f; // intended size in meters if (maxDim > 0.0001f) go.transform.localScale *= target / maxDim; ``` 5. **Restore emission FBX dropped (FBX path).** Blender scenes commonly store their color/glow in *material emission* (and other Principled-node inputs). FBX carries base/diffuse color but **not emission**, so neon / "Tron" scenes import as dark bodies with black accents. If the import looks flat vs. Blender, restore it: a. Dump the emissive materials from Blender via `execute_blender_code`: ```python import bpy, json out = {} for m in bpy.data.materials: if not (m.use_nodes and m.node_tree): continue col, s = (0, 0, 0), 0.0 p = next((n for n in m.node_tree.nodes if n.type == 'BSDF_PRINCIPLED'), None) es = next((k for k in ('Emission Color', 'Emission') if p and k in p.inputs), None) # 4.x / 3.x name if es: col = tuple(p.inputs[es].default_value)[:3] s = float(p.inputs['Emission Strength'].default_value) e = next((n for n in m.node_tree.nodes if n.type == 'EMISSION'), None) if e and s == 0: col = tuple(e.inputs['Color'].default_value)[:3]; s = float(e.inputs['Strength'].default_value) if s > 0 and sum(col) > 0.01: out[m.name] = [round(col[0], 3), round(col[1], 3), round(col[2], 3), round(s, 3)] print(json.dumps(out)) ``` b. In Unity (`execute_code`): extract the FBX's materials so they're editable (`AssetDatabase.ExtractAsset` per `Material`, then `ImportAsset(fbx, ForceUpdate)`), then for each dumped name set `_EmissionColor = color * Mathf.Clamp(strength*0.45f, 1.5f, 5f)`, `EnableKeyword("_EMISSION")`, and `globalIlluminationFlags = RealtimeEmissive`. Match names **case-insensitively** — FBX mangles case and can split one material into variants (`EdgeCyan` → `EdgeCyan` + `EDGE_CYAN`); set every match. Add a global Bloom volume and enable the camera's `renderPostProcessing` so the emission actually glows. 6. **Verify** with `manage_camera(action="screenshot", include_image=true)` and report the asset path + a screenshot. ## Notes - **Scale.** Models from Blender almost always arrive at the wrong scale — its FBX unit handling makes them land ~100× too large in Unity. `import_model_file`'s `target_size` only rescales at import when the project's Auto-normalize pref is enabled, and its importer-level normalization is unreliable for Blender FBX (it can over- or under-shoot, e.g. a `target_size=2` model measured 200 m). The robust fix is the Step 4 measure-bounds-then-set-`localScale` routine, which hits the target size deterministically regardless of the import scale or the Auto-normalize pref. - **Materials & emission.** FBX carries base/diffuse color and transforms fine, but **drops emission and any node-based color** — so Blender neon / "Tron" scenes (color stored in emission) import as dark bodies with black accents. Two fixes: **(a) prefer glTF/GLB when glTFast is installed** — glTF's PBR model carries `emissiveFactor` + `KHR_materials_emissive_strength` natively, so emission survives with no post-step (`bpy.ops.export_scene.gltf(filepath=out, export_format='GLB', use_active_scene=True)`); **(b) with FBX, run Step 5** to dump Blender's emission and reapply it. Also check the mesh for a `color_attributes` (vertex color) layer — the *data* survives FBX, but URP Lit won't *display* it; that needs a vertex-color-reading shader, not `_EmissionColor`. - FBX is the default because glTFast is optional in MCP for Unity. If the import errors with "GLB import requires glTFast", re-export as FBX (or install glTFast from the Dependencies tab). - **Format fidelity.** [references/bridge-fidelity.md](references/bridge-fidelity.md) is a tested matrix of what each format carries. Summary: **GLB (glTFast)** keeps textures, metallic/roughness, emission, transparency, and animation automatically; **FBX** drops metallic + emission, needs `ModelImporter.animationType = Generic` to surface transform animation, and needs material/texture extraction to assign an embedded texture. Both bake modifiers and carry geometry + vertex-color *data* (URP Lit won't *display* vertex colors). Neither carries procedural/node materials — bake them to image textures in Blender first. - **Animation doesn't auto-play.** An imported clip won't move the model until an `AnimatorController` drives it — the placed model has an `Animator` with a **null controller**, so it looks frozen. Build one with `manage_animation` (`controller_create` → add the clip as a looping state → `controller_assign` onto the instance) rather than hand-rolling `execute_code`. See bridge-fidelity gotcha #7. - **Multi-material zones survive.** A mesh split into material slots in Blender (e.g. skin/shirt/pants regions) imports as submeshes with one material each — base colors carry over GLB natively — so you can "dress" a model with material zones and it arrives intact. - Keep one model per handoff; for batches, repeat the loop with distinct names. - This skill never sends API keys or file bytes over the MCP bridge — Unity reads the file from disk. - `import_model_file` copies only the single source file; for multi-file exports (a text `.gltf` with an external `.bin`, or an `.obj` with a sibling `.mtl`/textures), zip them first and pass the `.zip` — a bare `.gltf`/`.obj` will lose its sidecars. ```` ## Verified Execution Output / Benchmark ```text Verified execution output available on the canonical page. ``` ## Related Blueprints on Promptally - [Agent Skill to Community Mod Pack](https://app.promptally.dev/p/skill-community-mod-pack) - [Agent Skill to Game Dev Rust Godot](https://app.promptally.dev/p/skill-game-dev-rust-godot) - [Agent Skill to Godot Engine 3D Developer](https://app.promptally.dev/p/skill-godot-engine-3d-developer) - [Agent Skill to Solo Community Outreach](https://app.promptally.dev/p/skill-solo-community-outreach) - [Agent Skill to Game-Dev Skill: Router (GAMEDEV-SKILLS AWESOME-GAMEDEV-AGENT-SKILLS)](https://app.promptally.dev/p/skill-router-1) - [Agent Skill to Game-Dev Skill: Ebitengine Game (EBITENGINE)](https://app.promptally.dev/p/skill-ebitengine-game) - [Agent Skill to Game-Dev Skill: Godot Tilemap (GODOT)](https://app.promptally.dev/p/skill-godot-tilemap) - [Agent Skill to Game-Dev Skill: Godot Multiplayer (GODOT)](https://app.promptally.dev/p/skill-godot-multiplayer)