blender-to-unity
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.
How do I install this agent skill?
npx skills add https://github.com/coplaydev/unity-mcp --skill blender-to-unityIs this agent skill safe to install?
- Gen Agent Trust Hubpass
The skill provides a workflow to export 3D models from Blender and import them into Unity using local Model Context Protocol (MCP) servers. It relies on script execution within both environments to automate the process, adhering to the standard practices of the mentioned tools.
- Socketpass
No alerts
- Snykpass
Risk: LOW · No issues
What does this agent skill do?
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_fileis in theasset_gentool group, which is off by default (onlycoreloads). Enable it first withmanage_tools(enable theasset_gengroup), or call the C# handler straight throughbatch_execute—{"tool":"import_model_file","params":{"sourcePath":...,"name":...,"outputFolder":...}}(camelCase) — which dispatches by name regardless of group gating.
Steps
- Resolve the Unity project path. Read
mcpforunity://editor/statefor 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). 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_typeset (Step 3).
- Export from Blender to a temp path via
mcp__blender__execute_blender_code:
(glTF branch: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)out_glb = os.path.join(tempfile.gettempdir(), "blender_to_unity.glb"), thenbpy.ops.export_scene.gltf(filepath=out_glb, export_format='GLB', use_active_scene=True)— its defaultuse_active_scene=Falsecan silently export a different open scene.) - Import into Unity with
import_model_file:import_model_file(source_path=<temp path>, name=<asset name>, target_size=<final size in meters>). For a rigged/animated FBX, also passanimation_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 }. Passtarget_sizeas 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. - 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 viamanage_gameobject(action="create", prefab_path=<asset_path>, name=<asset 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 viaexecute_code(substitute your object name and target meters):var go = GameObject.Find("<asset name>"); var rs = go.GetComponentsInChildren<Renderer>(); 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; - 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:
b. In Unity (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))execute_code): extract the FBX's materials so they're editable (AssetDatabase.ExtractAssetperMaterial, thenImportAsset(fbx, ForceUpdate)), then for each dumped name set_EmissionColor = color * Mathf.Clamp(strength*0.45f, 1.5f, 5f),EnableKeyword("_EMISSION"), andglobalIlluminationFlags = 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'srenderPostProcessingso the emission actually glows. - 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'starget_sizeonly 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. atarget_size=2model measured 200 m). The robust fix is the Step 4 measure-bounds-then-set-localScaleroutine, 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_strengthnatively, 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 acolor_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 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 = Genericto 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
AnimatorControllerdrives it — the placed model has anAnimatorwith a null controller, so it looks frozen. Build one withmanage_animation(controller_create→ add the clip as a looping state →controller_assignonto the instance) rather than hand-rollingexecute_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_filecopies only the single source file; for multi-file exports (a text.gltfwith an external.bin, or an.objwith a sibling.mtl/textures), zip them first and pass the.zip— a bare.gltf/.objwill lose its sidecars.
How can the creator link this skill?
Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.
<a href="https://skillzs.dev/skills/coplaydev/unity-mcp/blender-to-unity">View blender-to-unity on skillZs</a>