Skip to main content
Glama

retopologize_mesh

Retopologize a textured GLB into a game-ready mesh with new topology, fresh UVs, and baked PBR textures, plus optional LODs for engines.

Instructions

Make a game weight copy of a textured GLB: new topology, new UVs, and baked PBR textures.

method "quad" (default): an all quad mesh with even edge flow (Instant Meshes), suited to rigging, deformation and further modelling. "decimate": triangles, closest silhouette. The new mesh gets a fresh UV layout, and base color, roughness, metallic and a tangent space normal map baked from the original (target_faces 200 to 500000, texture_size 256 to 8192). Where the faces go (method "decimate" only): detail "auto" (default) keeps more faces where the surface bends sharply (fingers, joints, face features) and fewer on flat panels; "paint" reads the mesh's vertex colours as a detail map you painted in Blender (white = most detail, black = least; export as GLB); "none" is uniform. detail_strength 0 to 1 sets how strongly (default 1, the most that keeps the shape intact). The quad method always uses one density everywhere. Runs in headless Blender on the CPU, about 10 to 30 s at 10k faces; the GPU is not used. Output: <output_dir or the input's folder>/retopo_.glb, plus an .fbx with embedded textures that keeps real quads (glTF stores only triangles). Returns the path, face and vertex counts before and after, the method that ran and timings. lods (for example [10000, 3000, 800]): a LOD chain for a game engine instead of one mesh. lods[0] replaces target_faces and is LOD0, the retopology above with its baked textures; each further entry is a triangle budget for a decimation of LOD0 that keeps LOD0's UVs, so every LOD uses the same textures and one material. Entries must be strictly decreasing (1 to 8 of them). Output: retopolods.glb and .fbx holding objects _LOD0, _LOD1, ... (Unity's FBX importer builds a LOD Group from that suffix). The report's "lods" lists each LOD's face and triangle counts and texture_fit: uv_drift_texels_median (how far its UVs sit from LOD0's at the same place; a few texels is right, hundreds means broken mapping) and colour_mismatch_share (share of its triangles whose base colour differs from LOD0's there; it grows as small features collapse). With method "decimate", the detail map also steers the LOD decimations.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "input_mesh": "<input_mesh>"
    },
    "name": "retopologize_mesh"
  }
}

Input Schema

NameRequiredDescriptionDefault
lodsNo
detailNo
methodNoquad
input_meshYes
output_dirNo
target_facesNo
texture_sizeNo
detail_strengthNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A4.5/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does well: it discloses the execution environment (headless Blender, CPU only, no GPU), cost ('about 10 to 30 s at 10k faces'), exact output naming and formats (.glb plus .fbx retaining real quads because 'glTF stores only triangles'), and hard constraints on lods ('strictly decreasing', '1 to 8 of them'). It stops short of saying whether the input mesh is left untouched, how failures surface, or that existing output files are overwritten, which keeps it at 4.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

It is front-loaded with the purpose and every sentence carries real information, so the length is earned by 8 undocumented parameters. Sentences do run together awkwardly, though — target_faces/texture_size ranges are buried in a parenthetical mid-sentence, and the note 'The quad method always uses one density everywhere' sits as a dangling fragment between unrelated clauses.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema and no annotations exist, yet the description documents the return value ('the path, face and vertex counts before and after, the method that ran and timings') plus the richer 'lods' report fields (uv_drift_texels_median, colour_mismatch_share) with interpretation guidance. For a complex 8-parameter mutation tool, nothing an agent needs in order to call it correctly is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must compensate, and it does: method values, all three detail modes with their semantics ('auto' curves-aware, 'paint' reads vertex colours with white=most detail, 'none' uniform), detail_strength's 0-1 range and default, target_faces range 200-500000, texture_size range 256-8192, lods entry meaning (lods[0] replaces target_faces, later entries are triangle budgets retaining LOD0 UVs), and where output_dir places files. Essentially all 8 parameters gain meaning beyond their bare typed schema entries.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The opening sentence names a specific verb and resource: 'Make a game[-ready] copy of a textured GLB: new topology, new UVs, and baked PBR textures.' That is a precise operation (retopology + texture bake) that cannot be confused with generate_mesh, texture_mesh or rig_creature, which the description also implicitly separates itself from by describing what it consumes (an existing textured GLB) rather than producing from scratch.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives clear context for choosing the 'quad' method ('suited to rigging, deformation and further modelling') versus 'decimate' ('triangles, closest silhouette') and explains when to use lods ('a LOD chain for a game engine instead of one mesh'). It does not state exclusions or name a sibling tool to use instead when retopology is not what is wanted, so 4 rather than 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.