Robotics MCP Server

# Blender to VRM Workflow for Robotics **Create custom VRM models in Blender for robots, machines, and non-humanoids - despite VRM's humanoid limitations** [](README.md) [](README.md) [](README.md) --- ## 🎯 **The Challenge: VRM for Non-Humanoids** **VRM format is designed exclusively for humanoid avatars with standardized bone structures:** - Head, spine, arms, legs, hands, feet - Humanoid proportions and animations - Facial blend shapes for expressions **For robots and machines, VRM is NOT ideal, but here's how to make it work anyway.** ### **⚠️ VRoid Studio vs. Blender: Know Your Tools** #### **VRoid Studio = Pretty Anime Humanoids Only** 🎨 **VRoid Studio is fantastic for:** - ✅ **Beautiful anime-style humanoids** (perfect proportions, cute faces) - ✅ **Pretty clothes, hairstyles, decorations** (thousands of options) - ✅ **Facial expressions and accessories** (glasses, hats, jewelry) - ✅ **Easy VRM export** (one-click for humanoids) - ❌ **Does NOT do anything else** - ❌ **No robots, animals, or machines** - ❌ **No custom non-humanoid shapes** - ❌ **No mechanical parts or technical models** **VRoid Studio = Human beauty salon for VRM avatars** #### **Blender = Everything Else (Including Robots!)** 🔧 **For VRM dogbots, caterpillars, articulated arms, or ANY non-humanoid:** - ✅ **Custom robot modeling** (from scratch or modifications) - ✅ **Animal creation** (dogs, cats, insects, dinosaurs) - ✅ **Machine design** (excavators, arms, vehicles) - ✅ **Mechanical animations** (joints, hydraulics, servos) - ✅ **Complex rigging** (beyond humanoid constraints) - ✅ **VRM export** (with workarounds for non-humanoids) **Blender = Full workshop for any 3D model imaginable** #### **The Reality Check:** ``` Want a cute anime girl with twintails? → VRoid Studio Want a VRM caterpillar robot? → Blender (DIY required) Want a humanoid avatar? → VRoid Studio Want a VRM dogbot? → Blender (DIY required) ``` ### **Why Use VRM Despite Limitations?** - ✅ **Unity compatibility** (direct import) - ✅ **VR platform support** (VRChat, Resonite, Cluster) - ✅ **Blend shapes** for mechanical animations - ✅ **Standardized format** for sharing - ❌ **Humanoid-only** bone requirements - ❌ **Limited to bipedal structure** ### **Better Alternatives for Non-Humanoids:** - **FBX/GLB** (recommended for robots) - **Custom glTF extensions** - **Proprietary formats** (USD, etc.) --- ## 🧠 **AI-Powered Research Phase (Architect First)** **Before touching any 3D software, let AI be your research assistant.** Build comprehensive knowledge of the "VRM scene" through systematic information gathering. Implementation becomes dramatically easier with a solid research foundation. **📚 [General AI Research Workflow](AI_RESEARCH_WORKFLOW.md)** - This VRM-specific research phase follows our comprehensive AI-powered research methodology for all development projects. The general workflow covers domain mapping, tool discovery, community intelligence, and web scraping integration across all technology domains. ### **Why Research First?** - **Avoid dead ends** - Know which tools actually work for non-humanoids - **Understand constraints** - VRM's humanoid limitations become clear - **Find communities** - Connect with experienced developers - **Discover alternatives** - FBX/GLB options when VRM doesn't fit - **Save time** - Don't reinvent solutions that already exist ### **AI Research Workflow:** #### **Phase 1: Domain Mapping** ``` Prompt AI: "Map the VRM ecosystem for robotics applications" - Standards organizations (VRM Consortium) - Official repositories and documentation - Current limitations and workarounds - Success stories with non-humanoid VRM ``` #### **Phase 2: Tool Discovery** ``` Prompt AI: "Find all VRM creation tools beyond VRoid Studio" - Blender add-ons and plugins - Unity packages and scripts - Alternative 3D software with VRM export - Web-based VRM editors - Command-line tools and APIs ``` #### **Phase 3: Community Intelligence** ``` Prompt AI: "Research VRM communities and resources" - GitHub repositories with examples - Subreddits (r/VRchat, r/VRM, r/3Dmodeling) - Discord servers and forums - YouTube tutorials and channels - Academic papers and research ``` #### **Phase 4: Web Scraping Integration** ``` Prompt AI: "Use web scraping to collect comprehensive VRM information" - Scrape official VRM documentation - Collect community forum discussions - Gather tutorial links and resources - Extract code examples and snippets - Build knowledge base of best practices ``` ### **Web Scraping as Research Tool** **BrightData MCP tools are perfect for this research phase:** - **Bypass restrictions** - Access locked documentation sites - **Comprehensive coverage** - Scrape entire communities and forums - **Structured collection** - Organize information systematically - **Real-time updates** - Get latest developments and tools **Fetch MCP tool works for accessible sites:** - GitHub repositories and documentation - Official websites and blogs - Open forums and communities - Public code examples ### **Research Output Goals:** #### **Knowledge Base Structure:** ``` VRM_Research/ ├── standards_and_specs.md # Official VRM specifications ├── tools_and_software.md # Creation and conversion tools ├── communities_and_forums.md # Where to get help ├── tutorials_and_guides.md # Learning resources ├── code_examples.md # Implementation snippets ├── success_stories.md # Real-world applications ├── limitations_and_workarounds.md # Known issues and fixes └── future_developments.md # What's coming next ``` #### **Tool Evaluation Matrix:** - **Compatibility** with non-humanoid models - **Community support** and documentation quality - **Learning curve** and ease of use - **Cost and licensing** considerations - **Integration** with existing workflows --- ## 🔧 **Blender VRM Creation Workflow** ### **Phase 1: Model Preparation** #### **1. Create Base Model** ``` 1. Model your robot/machine in Blender 2. Use proper scale (real-world units) 3. Keep polygons reasonable (<50k triangles) 4. UV unwrap for texturing 5. Create materials (PBR workflow) ``` #### **2. Rigging for VRM (The Tricky Part)** **VRM requires humanoid bone structure - map your robot parts to human bones:** ``` Humanoid Bones → Robot Parts Mapping: Hips (Root) → Main body/chassis ├── Spine → Main body (duplicate for multi-segment) ├── Chest → Upper body section ├── Neck → Neck/head mounting └── Head → Camera/sensor head Left Arm → Left manipulator arm ├── Left Shoulder → Arm base joint ├── Left Upper Arm → Upper arm segment ├── Left Lower Arm → Lower arm segment ├── Left Hand → End effector/gripper └── Fingers → Individual gripper fingers Right Arm → Right manipulator arm (same structure) Left Leg → Left locomotion system ├── Left Upper Leg → Hip/thigh joint ├── Left Lower Leg → Knee/shin segment └── Left Foot → Wheel/track system Right Leg → Right locomotion system (same structure) ``` #### **3. Create Humanoid Armature** ```python # Blender Python script to create VRM-compatible armature import bpy def create_vrm_armature(): # Create armature object bpy.ops.object.armature_add(enter_editmode=True, location=(0, 0, 0)) # Get armature and bones armature = bpy.context.object bones = armature.data.edit_bones # Create required VRM bones root_bones = [ ('Hips', (0, 0, 0.8)), ('Spine', (0, 0, 1.0)), ('Chest', (0, 0, 1.2)), ('Neck', (0, 0, 1.4)), ('Head', (0, 0, 1.6)), ('LeftShoulder', (-0.2, 0, 1.3)), ('LeftUpperArm', (-0.4, 0, 1.2)), ('LeftLowerArm', (-0.7, 0, 1.0)), ('LeftHand', (-1.0, 0, 0.8)), ('RightShoulder', (0.2, 0, 1.3)), ('RightUpperArm', (0.4, 0, 1.2)), ('RightLowerArm', (0.7, 0, 1.0)), ('RightHand', (1.0, 0, 0.8)), ('LeftUpperLeg', (-0.1, 0, 0.6)), ('LeftLowerLeg', (-0.1, 0, 0.3)), ('LeftFoot', (-0.1, 0, 0.1)), ('RightUpperLeg', (0.1, 0, 0.6)), ('RightLowerLeg', (0.1, 0, 0.3)), ('RightFoot', (0.1, 0, 0.1)), ] # Create bones with proper hierarchy for bone_name, location in root_bones: bone = bones.new(bone_name) bone.head = location bone.tail = (location[0], location[1], location[2] + 0.1) # Set parent relationships (simplified) bones['Spine'].parent = bones['Hips'] bones['Chest'].parent = bones['Spine'] bones['Neck'].parent = bones['Chest'] bones['Head'].parent = bones['Neck'] # Arm hierarchy bones['LeftUpperArm'].parent = bones['LeftShoulder'] bones['LeftLowerArm'].parent = bones['LeftUpperArm'] bones['LeftHand'].parent = bones['LeftLowerArm'] # Same for right arm and legs... return armature # Run the script create_vrm_armature() ``` ### **Phase 2: VRM-Specific Setup** #### **1. Install VRM Add-on for Blender** ``` 1. Download from: https://github.com/vrm-c/UniVRM/releases 2. Install VRM add-on in Blender preferences 3. Enable "VRM Format" add-on ``` #### **2. VRM Bone Naming Convention** **Blender bones must use VRM standard names:** ``` ✅ Correct: Hips, Spine, Head, LeftUpperArm ❌ Wrong: hip, spine_01, robot_head, arm_left ``` #### **3. Create VRM Required Objects** ``` Required for VRM export: ├── Armature with humanoid bone names ├── Mesh objects parented to armature ├── Materials (PBR with metallic/roughness) ├── UV maps for all meshes ├── Optional: Shape keys for blend shapes ``` #### **4. VRM Meta Information** ``` VRM requires metadata: ├── Title: "DogBot V1" or "Articulated Arm V2" ├── Author: Your name ├── Contact: email (optional) ├── Reference: URL (optional) ├── License: Select appropriate license ├── Allowed User: Everyone (recommended) ├── Violent Usage: Not allowed (for robots) ├── Sexual Usage: Not allowed (for robots) ├── Commercial Usage: Allow (for robotics) ├── Modification: Allow (open source robotics) ``` ### **Phase 3: Export from Blender** #### **1. Prepare for Export** ``` 1. Select all mesh objects + armature 2. Ensure proper hierarchy (mesh → armature) 3. Apply transforms if needed (Ctrl+A) 4. Check UV maps are assigned 5. Verify materials are PBR compatible ``` #### **2. VRM Export Settings** ``` File → Export → VRM (.vrm) ├── [✓] Export Textures ├── [✓] Export Binary ├── Pose: T-Pose (required for VRM) ├── [✓] Export Invisible Meshes (if any) ├── Thumbnail: Add preview image (optional) ``` #### **3. VRM Validation** ``` After export, VRM file contains: ├── model.vrm (binary glTF container) ├── Thumbnail image ├── Metadata (title, author, license) ├── Bone mappings ├── Materials and textures ├── Blend shapes (if created) ``` --- ## 🎨 **Non-Humanoid VRM Examples** ### **DogBot VRM Model** **Map quadruped to bipedal structure:** ``` DogBot Parts → VRM Humanoid Bones: Hips → Main chassis/body Spine → Body extension Head → Sensor/camera head Left Arm → Front left leg ├── Shoulder → Hip joint ├── Upper Arm → Upper leg ├── Lower Arm → Lower leg └── Hand → Paw/foot Right Arm → Front right leg (same) Left Leg → Rear left leg ├── Upper Leg → Hip joint ├── Lower Leg → Knee joint └── Foot → Rear paw Right Leg → Rear right leg (same) ``` ### **Articulated Arm VRM** **Map robotic arm to humanoid arm:** ``` Robot Arm → VRM Arm Bones: Shoulder → Base mounting point Upper Arm → First arm segment Lower Arm → Second arm segment Hand → End effector/wrist Fingers → Individual gripper fingers (if applicable) ``` ### **Digger Machine VRM** **Map excavator to humanoid:** ``` Excavator → VRM Structure: Hips → Main chassis Spine/Chest → Operator cabin area Head → Boom/arm base Left Arm → Excavator arm ├── Shoulder → Arm pivot ├── Upper Arm → Boom ├── Lower Arm → Stick/dipper └── Hand → Bucket Right Arm → Additional attachment (hammer, etc.) Legs → Undercarriage/tracks ``` --- ## 🔄 **Unity Import & Setup** ### **Phase 1: Import VRM** ``` 1. Drag .vrm file into Unity Assets 2. UniVRM importer dialog appears 3. Configure import settings: ├── [✓] Extract Textures ├── [✓] Extract Materials ├── [✓] Extract Meshes ├── [✓] Generate Animation Clips ├── [✓] Generate MToon Materials ``` ### **Phase 2: Fix Humanoid Mapping** ``` Unity humanoid system expects human proportions: 1. Select imported model 2. Go to Rig tab → Animation Type: Humanoid 3. Unity tries to auto-map bones 4. Manually adjust mappings for robot parts: ├── Hips → Robot main body ├── Head → Robot "head" (camera/sensor cluster) ├── Arms → Manipulator arms ├── Legs → Locomotion system ``` ### **Phase 3: Animation Setup** ```csharp // Create custom animations for non-humanoid movements using UnityEngine; public class RobotAnimationController : MonoBehaviour { private Animator animator; void Start() { animator = GetComponent<Animator>(); // Override humanoid animations with robot-specific ones } // Custom methods for robot animations public void ExtendArm() { // Use VRM "arm" bones for manipulator extension animator.SetTrigger("ExtendArm"); } public void Dig() { // Use VRM "hand" bones for bucket operation animator.SetTrigger("Dig"); } public void Walk() { // Override bipedal walk with robot locomotion animator.SetFloat("Speed", 1.0f); } } ``` ### **Phase 4: Blend Shapes for Robotics** ```csharp // Use VRM blend shapes for mechanical animations public class MechanicalBlendShapes : MonoBehaviour { private SkinnedMeshRenderer meshRenderer; void Start() { meshRenderer = GetComponent<SkinnedMeshRenderer>(); // Set up blend shape indices } public void OpenGripper(float amount) { // Map blend shape to gripper opening meshRenderer.SetBlendShapeWeight(0, amount * 100f); } public void ExtendArm(float amount) { // Use blend shapes for arm extension meshRenderer.SetBlendShapeWeight(1, amount * 100f); } public void ShowStatus(string status) { // Use blend shapes for status indicators switch (status) { case "working": SetBlendShapeWeight(2, 100f); break; case "error": SetBlendShapeWeight(3, 100f); break; case "charging": SetBlendShapeWeight(4, 100f); break; } } } ``` --- ## 🚀 **Advanced Robotics Applications** ### **Custom Blend Shapes for Machines** ``` Create shape keys in Blender for: ├── Gripper open/close ├── Arm extension/retraction ├── Wheel/track movement ├── Status indicators (LEDs, screens) ├── Damage states ├── Operational modes ``` ### **Multiple VRM Variants** ``` Create different VRM files for: ├── Base model (no attachments) ├── With manipulator arms ├── With different end effectors ├── Different color schemes ├── Damage/wear variants ``` ### **VRM for Robot Teams** ``` Use VRM avatars to represent: ├── Individual robots in a swarm ├── Robot operator avatars ├── Virtual robot twins ├── Training simulations ``` --- ## ⚠️ **Limitations & Workarounds** ### **VRM Humanoid Limitations:** - **Bone count:** Limited to humanoid skeleton - **Proportions:** Human-like scaling expected - **Animations:** Designed for bipedal movement - **Blend shapes:** Limited to facial expressions ### **Workarounds:** - **Multiple VRM files:** Different models for different configurations - **Custom animations:** Override humanoid animations with robot-specific ones - **Secondary rigs:** Use additional non-humanoid bones for complex mechanisms - **Hybrid approach:** VRM for avatar representation, FBX for detailed mechanics ### **When NOT to Use VRM:** - **Complex robotics:** Better with FBX/GLB - **Non-humanoid shapes:** VRM validation may fail - **High-polygon models:** VRM has size limits - **Real-time simulation:** FBX often better for physics --- ## 📊 **Alternative Formats for Non-Humanoids** ### **FBX/GLB (Recommended for Robots)** ```csharp // Unity import for FBX robot models public class RobotFBXImporter : MonoBehaviour { [MenuItem("Tools/Import Robot FBX")] static void ImportRobotFBX() { string path = EditorUtility.OpenFilePanel("Select FBX", "", "fbx"); if (string.IsNullOrEmpty(path)) return; // Import FBX with custom settings var assetPath = "Assets/Models/" + Path.GetFileName(path); File.Copy(path, Application.dataPath + assetPath); AssetDatabase.ImportAsset(assetPath); // Configure for robotics var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath); ConfigureRobotPrefab(prefab); } static void ConfigureRobotPrefab(GameObject prefab) { // Add robot-specific components prefab.AddComponent<RobotController>(); prefab.AddComponent<ArticulationBody>(); // For physics // Configure joints, colliders, etc. } } ``` ### **Custom glTF Extensions** ```json // Extended glTF for robotics { "extensions": { "ROBOT": { "joints": [ { "name": "shoulder_joint", "type": "revolute", "limits": {"min": -180, "max": 180}, "axis": [0, 0, 1] } ], "sensors": [ { "name": "camera", "type": "camera", "resolution": [1920, 1080] } ] } } } ``` --- ## 🔧 **Complete Workflow Summary** ### **Blender → VRM → Unity Pipeline:** ``` 1. Model robot/machine in Blender 2. Create humanoid armature (map robot parts to human bones) 3. Rig model to armature 4. Create materials and textures 5. Add blend shapes for mechanical animations 6. Set VRM metadata 7. Export as .vrm using VRM add-on 8. Import into Unity with UniVRM 9. Configure humanoid rig (with manual adjustments) 10. Create custom animations for robot movements 11. Implement robot control scripts 12. Test in VR environment ``` ### **Best Practices:** - **Start simple:** Begin with basic robot shapes - **Test frequently:** Import to Unity often to catch issues - **Use references:** Study existing VRM robot models - **Plan bone mapping:** Design robot to fit humanoid structure when possible - **Have fallbacks:** Be ready to use FBX if VRM doesn't work --- ## 📚 **Resources & Examples** ### **VRM Robot Examples:** - **GitHub VRM repos:** Search for "robot VRM" or "mechanical VRM" - **VRM community:** Forums with robot avatar examples - **Open-source robots:** Models available for modification ### **Blender VRM Tutorials:** - **VRM Add-on documentation:** https://vrm.dev/ - **Blender VRM workflow:** YouTube tutorials - **Community guides:** VRM creation for non-humanoids ### **Unity Robotics Integration:** - **Unity Robotics Hub:** https://github.com/Unity-Technologies/Unity-Robotics-Hub - **ROS# for Unity:** ROS integration - **Articulation Body:** Unity's robotics physics ### **Alternative Tools:** - **Mixamo:** For humanoid animations (if adapting) - **Blender Robot Add-on:** For mechanical modeling - **Unity's Robot SDK:** For industrial robot simulation --- ## 🎯 **When to Use VRM vs Alternatives** ### **Use VRM When:** - ✅ **VR platform deployment** (VRChat, Resonite) - ✅ **Avatar representation** of robots - ✅ **Social robotics** applications - ✅ **Blend shapes** for status indicators - ✅ **Standardized sharing** format ### **Use FBX/GLB When:** - ✅ **Complex robotics** with many joints - ✅ **Non-humanoid shapes** (quadrupeds, machines) - ✅ **High-fidelity simulation** required - ✅ **Physics-based interaction** needed - ✅ **Industrial applications** ### **Hybrid Approach:** ``` - Use VRM for avatar representation - Use FBX for detailed mechanics - Combine in Unity scenes - Best of both worlds ``` --- **Despite VRM's humanoid limitations, this workflow enables creating robot avatars for VR platforms while maintaining compatibility with existing tools!** 🤖🎮 *Note: For serious robotics work, consider FBX/GLB formats instead of forcing non-humanoids into VRM's humanoid constraints.*