claude-code-arcane 2.6.1 → 2.7.1

package/skills/blender-export/SKILL.md

@@ -0,0 +1,143 @@
+---
+name: blender-export
+description: "Exporta desde Blender al engine y valida el resultado: eleccion de formato (glTF/GLB, FBX, .blend), settings que importan, export headless reproducible y validacion automatica de tris, UVs, escala, texturas y clips con validate_gltf.py. Usar para: exportar de blender, glb, fbx, validar export, blender a unity, blender a ue5."
+category: "gamedev"
+argument-hint: "[asset-slug] [--target unity|ue5|web] [--budget-tris <n>]"
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Bash, Write, Edit
+---
+# blender-export — Salida al engine
+
+Saca el asset de Blender y **verifica que lo que salio es lo que se esperaba**. Este skill cierra
+el pipeline: `asset-spec` → Meshy o modelado → Blender → **export validado** → `asset-audit`.
+
+> Requiere `/blender-context` (destino y escala definidos). Si el asset tiene rig, requiere el bake
+> de `/blender-animation` hecho: los constraints no viajan.
+
+---
+
+## Phase 1: Elegir formato
+
+| Formato | Cuando | Cuidado |
+|---|---|---|
+| **glTF 2.0 (`.glb`)** | Default para Unity URP, web, y cualquier cosa moderna | Un solo archivo, texturas embebidas, Y-up automatico |
+| **FBX** | Pipelines de UE5 y Unity legacy, skeletal meshes | Hay que fijar ejes y escala a mano, formato cerrado |
+| **`.blend` directo** | Prototipo rapido en Unity | Unity necesita Blender instalado para importarlo. **No usar en CI ni en un repo de equipo** |
+| **USD** | Pipelines de VFX / interop DCC | Soporte irregular en engines de juego |
+
+Regla practica: **glTF salvo que el destino lo impida.** FBX es la excepcion, no el default, y
+existe casi siempre por el lado del engine, no por el de Blender.
+
+---
+
+## Phase 2: Settings que importan
+
+### glTF / GLB
+
+| Setting | Valor | Por que |
+|---|---|---|
+| Format | `glTF Binary (.glb)` | Un archivo, texturas adentro |
+| Include | `Selected Objects` | Un export por asset, no la escena entera |
+| `+Y Up` | On | Es la convencion de glTF y de Unity |
+| Apply Modifiers | On | Lo que no se aplica no existe en el archivo |
+| Materials | `Export` | |
+| Images | `Automatic` | |
+| Compression (Draco) | Off al exportar | Se comprime despues, como paso propio |
+| Animation → Sampling | On, y **una accion por clip** | |
+
+### FBX
+
+| Setting | Valor | Por que |
+|---|---|---|
+| Scale | `1.0` con `Apply Unit` | El engine hace el resto |
+| Forward / Up | Segun el engine destino | UE5: `-Z Forward`, `Y Up` |
+| Apply Scalings | `FBX All` | Evita escalas dobles |
+| Bake Animation | On, con `NLA Strips` off si se exporta una sola accion | |
+| Add Leaf Bones | **Off** | Ensucia el esqueleto en el engine |
+
+Lo que **nunca** se exporta: huesos de control, objetos de referencia, camaras y luces de trabajo,
+collections de scratch. Si estan en el archivo, van a aparecer en el engine.
+
+---
+
+## Phase 3: Export headless
+
+Reproducible y versionable, a diferencia de exportar a mano desde la UI:
+
+```bash
+blender --background <archivo.blend> --python <export_script.py> -- \
+    --out assets/3d/<slug>/export/<slug>.glb
+```
+
+El script hace: seleccionar los objetos que corresponden, limpiar la seleccion de lo que no va, y
+llamar a `bpy.ops.export_scene.gltf(...)` con los settings de la Phase 2 explicitos — **ninguno
+por default**, porque los defaults del operador cambian entre versiones de Blender.
+
+El script vive en el repo (`assets/3d/_scripts/` o al lado del asset), no en el chat. Un export que
+solo existe como pasos manuales se hace distinto cada vez.
+
+**Pedir aprobacion antes de escribir** el script y antes del primer export a una ruta que ya tiene
+un archivo: un `.glb` sobrescrito no se recupera si el `.blend` cambio.
+
+---
+
+## Phase 4: Validar el resultado
+
+Nunca dar un export por bueno sin medirlo. El validador es stdlib puro, no instala nada:
+
+```bash
+python scripts/validate_gltf.py assets/3d/<slug>/export/<slug>.glb \
+    --budget-tris 8000 --max-materials 2 --require-uv1 --target unity
+```
+
+| Flag | Para que |
+|---|---|
+| `--budget-tris <n>` | Presupuesto declarado en `/blender-modeling` |
+| `--max-materials <n>` | Tope de draw calls |
+| `--require-uv1` | Exigir lightmap UV cuando el asset recibe luz bakeada |
+| `--target unity\|ue5\|web` | Avisos propios del destino (normal maps DirectX en UE5, compresion en web) |
+| `--json` | Salida parseable, para encadenarlo en CI |
+
+Que chequea, y por que cada uno esta:
+
+1. **Contenedor** — magic y chunks del GLB. Un archivo truncado se detecta aca, no en el engine.
+2. **Presupuesto de tris** — contando indices reales por primitiva, no estimando.
+3. **UV0 / UV1** — sin UV0 no hay textura; sin UV1 el lightmap sale manchado.
+4. **Escala** — nodos con escala 100 o 0.01 son conversion de unidades sin aplicar.
+5. **Materiales** — cantidad contra el tope, mas nombres autogenerados (`Material.001`) que en el
+   engine son imposibles de rastrear.
+6. **Texturas** — imagenes referenciadas fuera de un `.glb` (llegan roto al engine) y resoluciones
+   que no son potencia de dos.
+7. **Clips** — cantidad y nombres; un clip sin nombre entra al engine como `Animation_0`.
+
+Exit code 0 si el verdict es PASS o CONCERNS, 1 si es FAIL. Eso lo hace usable como gate.
+
+> El validador lee glTF/GLB, **no FBX**. FBX binario no se puede inspeccionar sin dependencias, y
+> este repo no las agrega. Si el destino es FBX, exportar **tambien** un `.glb` de control y
+> validar ese: la geometria y los materiales son los mismos.
+
+---
+
+## Phase 5: Resumen
+
+Reportar: formato y ruta de salida, settings usados, y la tabla completa del validador con su
+verdict.
+
+**Verdict:**
+- **PASS** — el validador da PASS y el asset esta listo para integrar.
+- **CONCERNS** — exportado con avisos (no potencia de dos, clips sin nombre, avisos del target).
+  Listar cada uno y decir si se acepta o se corrige.
+- **FAIL** — presupuesto excedido, sin UVs, escala sin aplicar, texturas externas en un `.glb`, o
+  contenedor invalido. **No integrar**: indicar el fix y volver al skill que corresponde
+  (`/blender-modeling`, `/blender-materials`, `/blender-animation`).
+
+## Next Steps
+
+- `/asset-audit` para validar naming, formatos y huerfanos ya dentro del proyecto
+- `/meshy-derive` si hacen falta mas targets del mismo master (web, print)
+- En UE5, `/ue-animation-system` o `/ue-materials-rendering` para el lado del engine
+- Si el verdict fue FAIL, volver al skill del area que fallo — no parchear el archivo exportado
+
+---
+
+> → Formatos, ejes, escala y reglas de Git LFS estan en `.claude/rules/blender-pipeline.md`.

package/skills/blender-export/scripts/validate_gltf.py

@@ -0,0 +1,362 @@
+#!/usr/bin/env python3
+"""Valida un .glb / .gltf exportado desde Blender contra el presupuesto del proyecto.
+
+Chequea lo que se rompe siempre y no se ve hasta que el asset ya esta en el engine:
+triangulos fuera de presupuesto, UVs ausentes, lightmap UV1 faltante, escalas sin
+aplicar, texturas que no son potencia de dos, imagenes externas dentro de un .glb,
+y materiales de sobra.
+
+Solo stdlib: corre en el proyecto del usuario sin instalar nada.
+
+    python validate_gltf.py export/prop.glb --budget-tris 2000 --target unity
+    python validate_gltf.py export/hero.glb --budget-tris 40000 --require-uv1 --json
+"""
+
+import argparse
+import json
+import os
+import struct
+import sys
+
+GLB_MAGIC = 0x46546C67  # 'glTF'
+CHUNK_JSON = 0x4E4F534A  # 'JSON'
+CHUNK_BIN = 0x004E4942  # 'BIN\0'
+MODE_TRIANGLES = 4
+
+# Escalas que delatan una conversion de unidades sin aplicar en lugar de una
+# decision de diseno.
+SUSPICIOUS_SCALES = (100.0, 0.01)
+SCALE_TOLERANCE = 0.001
+
+
+class Report:
+    def __init__(self):
+        self.checks = []
+
+    def add(self, level, check, message):
+        self.checks.append({"level": level, "check": check, "message": message})
+
+    def ok(self, check, message):
+        self.add("PASS", check, message)
+
+    def warn(self, check, message):
+        self.add("WARN", check, message)
+
+    def fail(self, check, message):
+        self.add("FAIL", check, message)
+
+    @property
+    def verdict(self):
+        levels = {c["level"] for c in self.checks}
+        if "FAIL" in levels:
+            return "FAIL"
+        if "WARN" in levels:
+            return "CONCERNS"
+        return "PASS"
+
+
+def load_gltf(path):
+    """Devuelve (json_dict, bin_chunk_or_None). Acepta .glb y .gltf."""
+    with open(path, "rb") as handle:
+        head = handle.read(4)
+        handle.seek(0)
+        if len(head) == 4 and struct.unpack("<I", head)[0] == GLB_MAGIC:
+            return _load_glb(handle)
+        return json.load(handle), None
+
+
+def _load_glb(handle):
+    magic, version, total = struct.unpack("<III", handle.read(12))
+    if magic != GLB_MAGIC:
+        raise ValueError("no es un GLB: falta el magic 'glTF'")
+    if version != 2:
+        raise ValueError("version de GLB no soportada: %d (se espera 2)" % version)
+
+    doc = None
+    binary = None
+    while handle.tell() < total:
+        header = handle.read(8)
+        if len(header) < 8:
+            break
+        length, kind = struct.unpack("<II", header)
+        payload = handle.read(length)
+        if kind == CHUNK_JSON:
+            doc = json.loads(payload.decode("utf-8"))
+        elif kind == CHUNK_BIN:
+            binary = payload
+    if doc is None:
+        raise ValueError("el GLB no tiene chunk JSON")
+    return doc, binary
+
+
+def image_size(blob):
+    """Dimensiones de un PNG o JPEG en bytes, o None si no se reconoce."""
+    if blob[:8] == b"\x89PNG\r\n\x1a\n" and len(blob) >= 24:
+        width, height = struct.unpack(">II", blob[16:24])
+        return width, height
+    if blob[:2] == b"\xff\xd8":
+        offset = 2
+        while offset + 9 < len(blob):
+            if blob[offset] != 0xFF:
+                offset += 1
+                continue
+            marker = blob[offset + 1]
+            # SOF0-3, SOF5-7, SOF9-11, SOF13-15 llevan las dimensiones.
+            if marker in (0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7,
+                          0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF):
+                height, width = struct.unpack(">HH", blob[offset + 5:offset + 9])
+                return width, height
+            if marker in (0xD8, 0xD9) or 0xD0 <= marker <= 0xD7:
+                offset += 2
+                continue
+            segment = struct.unpack(">H", blob[offset + 2:offset + 4])[0]
+            offset += 2 + segment
+    return None
+
+
+def is_power_of_two(value):
+    return value > 0 and (value & (value - 1)) == 0
+
+
+def count_triangles(doc):
+    """(tris, primitivas_no_triangulo) sumando todas las meshes del documento."""
+    accessors = doc.get("accessors", [])
+    tris = 0
+    non_triangles = 0
+    for mesh in doc.get("meshes", []):
+        for prim in mesh.get("primitives", []):
+            if prim.get("mode", MODE_TRIANGLES) != MODE_TRIANGLES:
+                non_triangles += 1
+                continue
+            if "indices" in prim:
+                count = accessors[prim["indices"]].get("count", 0)
+            else:
+                position = prim.get("attributes", {}).get("POSITION")
+                count = accessors[position].get("count", 0) if position is not None else 0
+            tris += count // 3
+    return tris, non_triangles
+
+
+def node_scale(node):
+    """Escala de un nodo, venga como 'scale' o dentro de 'matrix'."""
+    if "scale" in node:
+        return [float(v) for v in node["scale"]]
+    matrix = node.get("matrix")
+    if not matrix:
+        return [1.0, 1.0, 1.0]
+    # glTF guarda la matriz por columnas; la norma de las 3 primeras es la escala.
+    return [
+        (matrix[i] ** 2 + matrix[i + 1] ** 2 + matrix[i + 2] ** 2) ** 0.5
+        for i in (0, 4, 8)
+    ]
+
+
+def check_geometry(doc, report, budget):
+    tris, non_triangles = count_triangles(doc)
+    if budget is None:
+        report.warn("presupuesto", "%d tris, sin presupuesto declarado (--budget-tris)" % tris)
+    elif tris > budget:
+        report.fail("presupuesto", "%d tris contra un presupuesto de %d (+%d)" % (tris, budget, tris - budget))
+    else:
+        report.ok("presupuesto", "%d tris dentro del presupuesto de %d" % (tris, budget))
+
+    if non_triangles:
+        report.warn("primitivas", "%d primitivas no triangulares (lines/points) - el engine puede ignorarlas" % non_triangles)
+
+    if not doc.get("meshes"):
+        report.fail("meshes", "el archivo no tiene ninguna mesh")
+
+
+def check_uvs(doc, report, require_uv1):
+    missing_uv0 = []
+    missing_uv1 = []
+    for mesh in doc.get("meshes", []):
+        name = mesh.get("name", "<sin nombre>")
+        for prim in mesh.get("primitives", []):
+            attrs = prim.get("attributes", {})
+            if "TEXCOORD_0" not in attrs:
+                missing_uv0.append(name)
+            if "TEXCOORD_1" not in attrs:
+                missing_uv1.append(name)
+
+    if missing_uv0:
+        report.fail("uv0", "sin UV0, no se puede texturizar: %s" % ", ".join(sorted(set(missing_uv0))[:5]))
+    else:
+        report.ok("uv0", "todas las primitivas tienen UV0")
+
+    if require_uv1:
+        if missing_uv1:
+            report.fail("uv1", "sin UV1 para lightmap: %s" % ", ".join(sorted(set(missing_uv1))[:5]))
+        else:
+            report.ok("uv1", "todas las primitivas tienen UV1")
+
+
+def check_scales(doc, report):
+    offenders = []
+    for node in doc.get("nodes", []):
+        scale = node_scale(node)
+        for value in scale:
+            if any(abs(value - s) < SCALE_TOLERANCE for s in SUSPICIOUS_SCALES):
+                offenders.append((node.get("name", "<sin nombre>"), scale))
+                break
+    if offenders:
+        detail = ", ".join("%s=%s" % (name, [round(v, 4) for v in scale]) for name, scale in offenders[:5])
+        report.fail("escala", "escala sin aplicar (conversion de unidades): %s" % detail)
+    else:
+        report.ok("escala", "sin escalas de conversion sin aplicar")
+
+
+def check_materials(doc, report, max_materials):
+    materials = doc.get("materials", [])
+    unnamed = [i for i, m in enumerate(materials) if not m.get("name")]
+    autogen = [m["name"] for m in materials if m.get("name", "").split(".")[-1].isdigit()]
+
+    if max_materials is not None and len(materials) > max_materials:
+        report.fail("materiales", "%d materiales contra un maximo de %d (= draw calls)" % (len(materials), max_materials))
+    else:
+        report.ok("materiales", "%d materiales" % len(materials))
+
+    if unnamed:
+        report.warn("materiales", "%d materiales sin nombre" % len(unnamed))
+    if autogen:
+        report.warn("materiales", "nombres autogenerados sin renombrar: %s" % ", ".join(autogen[:5]))
+
+
+def check_images(doc, binary, report, base_dir, is_glb):
+    images = doc.get("images", [])
+    if not images:
+        report.warn("texturas", "el archivo no trae texturas")
+        return
+
+    buffer_views = doc.get("bufferViews", [])
+    external = []
+    not_pot = []
+    unreadable = 0
+
+    for index, image in enumerate(images):
+        label = image.get("name") or image.get("uri") or "image[%d]" % index
+        blob = None
+
+        uri = image.get("uri")
+        if uri and not uri.startswith("data:"):
+            if is_glb:
+                external.append(label)
+                continue
+            path = os.path.join(base_dir, uri)
+            if not os.path.exists(path):
+                external.append("%s (no existe)" % label)
+                continue
+            with open(path, "rb") as handle:
+                blob = handle.read(32)
+        elif "bufferView" in image and binary is not None:
+            view = buffer_views[image["bufferView"]]
+            start = view.get("byteOffset", 0)
+            blob = binary[start:start + min(view.get("byteLength", 0), 4096)]
+
+        if not blob:
+            unreadable += 1
+            continue
+
+        size = image_size(blob)
+        if size is None:
+            unreadable += 1
+        elif not (is_power_of_two(size[0]) and is_power_of_two(size[1])):
+            not_pot.append("%s (%dx%d)" % (label, size[0], size[1]))
+
+    if external:
+        level = report.fail if is_glb else report.warn
+        level("texturas", "imagenes fuera del archivo: %s" % ", ".join(external[:5]))
+    if not_pot:
+        report.warn("texturas", "no son potencia de dos: %s" % ", ".join(not_pot[:5]))
+    if unreadable:
+        report.warn("texturas", "%d imagenes cuyo tamano no se pudo leer (formato no PNG/JPEG)" % unreadable)
+    if not external and not not_pot and not unreadable:
+        report.ok("texturas", "%d texturas, todas embebidas y potencia de dos" % len(images))
+
+
+def check_animations(doc, report):
+    animations = doc.get("animations", [])
+    if not animations:
+        return
+    autogen = [a.get("name", "") for a in animations if a.get("name", "").split(".")[-1].isdigit()]
+    unnamed = sum(1 for a in animations if not a.get("name"))
+    report.ok("animaciones", "%d clips: %s" % (
+        len(animations),
+        ", ".join(a.get("name") or "<sin nombre>" for a in animations[:8]),
+    ))
+    if unnamed:
+        report.warn("animaciones", "%d clips sin nombre - llegan al engine como Animation_N" % unnamed)
+    if autogen:
+        report.warn("animaciones", "nombres autogenerados: %s" % ", ".join(autogen[:5]))
+
+
+def check_target(doc, report, target):
+    if target == "ue5":
+        if doc.get("materials"):
+            report.warn(
+                "target ue5",
+                "glTF trae normal maps OpenGL (+Y) y UE5 espera DirectX (-Y): invertir el canal "
+                "verde o marcarlo en el import",
+            )
+        report.warn("target ue5", "UE5 usa centimetros: verificar el factor de escala en el import")
+    elif target == "web":
+        report.warn("target web", "para web, correr draco/meshopt sobre el .glb antes de publicar")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Valida un .glb/.gltf exportado desde Blender.")
+    parser.add_argument("path", help="archivo .glb o .gltf")
+    parser.add_argument("--budget-tris", type=int, default=None, help="presupuesto de triangulos")
+    parser.add_argument("--max-materials", type=int, default=None, help="maximo de materiales (= draw calls)")
+    parser.add_argument("--require-uv1", action="store_true", help="exigir UV1 para lightmap")
+    parser.add_argument("--target", choices=("unity", "ue5", "web"), default=None)
+    parser.add_argument("--json", action="store_true", help="salida JSON en lugar de texto")
+    args = parser.parse_args()
+
+    if not os.path.exists(args.path):
+        print("no existe: %s" % args.path, file=sys.stderr)
+        return 2
+
+    report = Report()
+    try:
+        doc, binary = load_gltf(args.path)
+    except (ValueError, KeyError, struct.error, json.JSONDecodeError) as error:
+        report.fail("contenedor", "no se pudo leer: %s" % error)
+        emit(report, args, None)
+        return 1
+
+    is_glb = args.path.lower().endswith(".glb")
+    base_dir = os.path.dirname(os.path.abspath(args.path))
+
+    check_geometry(doc, report, args.budget_tris)
+    check_uvs(doc, report, args.require_uv1)
+    check_scales(doc, report)
+    check_materials(doc, report, args.max_materials)
+    check_images(doc, binary, report, base_dir, is_glb)
+    check_animations(doc, report)
+    if args.target:
+        check_target(doc, report, args.target)
+
+    emit(report, args, doc)
+    return 1 if report.verdict == "FAIL" else 0
+
+
+def emit(report, args, doc):
+    generator = (doc or {}).get("asset", {}).get("generator", "desconocido")
+    if args.json:
+        print(json.dumps({
+            "file": args.path,
+            "generator": generator,
+            "verdict": report.verdict,
+            "checks": report.checks,
+        }, indent=2, ensure_ascii=False))
+        return
+
+    print("%s  (%s)" % (os.path.basename(args.path), generator))
+    for check in report.checks:
+        print("  [%s] %-14s %s" % (check["level"], check["check"], check["message"]))
+    print("  VERDICT: %s" % report.verdict)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/blender-materials/SKILL.md

@@ -0,0 +1,165 @@
+---
+name: blender-materials
+description: "Materiales y texturas en Blender para assets de juego: Principled BSDF, UVs y lightmap UV1, bake de procedurales a textura, color space, normal maps OpenGL vs DirectX, atlas y draw calls. Usar para: materiales blender, texturas, UV unwrap, bake, shader nodes, normal map."
+category: "gamedev"
+argument-hint: "[asset-slug] [--bake] [--target unity|ue5|web]"
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Bash, Write, Edit
+---
+# blender-materials — Materiales y texturas
+
+Deja el asset con materiales que **sobreviven al export**. La mitad de los bugs de look en el
+engine se originan aca, y casi todos son color space o convencion de normal map.
+
+> Requiere `/blender-context`. El destino (Unity / UE5 / web) cambia decisiones concretas de este
+> skill, no es un detalle.
+
+---
+
+## Phase 1: Que sobrevive al export
+
+| En Blender | glTF / FBX | Que hacer |
+|---|---|---|
+| Principled BSDF con texturas | **Sobrevive** | Es el camino |
+| Principled BSDF con valores planos | Sobrevive | Ok para assets sin textura |
+| Nodos procedurales (Noise, Voronoi, Musgrave) | **No sobrevive** | Bakear a textura |
+| Node groups custom | No sobrevive | Bakear |
+| Shader mixes, Geometry / Object Info | No sobrevive | Bakear |
+| Emission | Sobrevive (canal propio) | |
+| Displacement real | No sobrevive | Bakear a normal, o meterlo en la malla |
+
+Regla practica: **si no es Principled BSDF alimentado por Image Textures, no existe fuera de
+Blender.** Antes de pulir un shader procedural, decidir si se bakea; si no se bakea, es tiempo
+tirado.
+
+---
+
+## Phase 2: UVs
+
+Diagnostico headless:
+
+```bash
+blender --background <archivo.blend> --python-expr "
+import bpy
+for o in bpy.data.objects:
+    if o.type != 'MESH': continue
+    uvs = [l.name for l in o.data.uv_layers]
+    print(f'{o.name}: uv_layers={uvs or \"NINGUNA\"} materials={len(o.material_slots)}')
+"
+```
+
+- **Sin UVs no hay texturas.** Es lo primero que se resuelve.
+- **UV0**: el mapa de texturas. Puede solaparse si la textura es tileable; **no puede solaparse si
+  se va a bakear**.
+- **UV1**: lightmaps. Unity y UE5 lo esperan **sin solapamiento y con margen** entre islas. Si el
+  asset va a recibir luz bakeada y no tiene UV1, el lightmap sale con manchas y nadie sabe por que.
+- Texel density consistente dentro de un mismo set de assets. Un prop con el doble de densidad que
+  el de al lado se nota mas que un prop con menos poligonos.
+- Margen entre islas proporcional a la resolucion: 2px a 1K, 4px a 2K. Menos margen = bleeding.
+
+---
+
+## Phase 3: Color space — el bug silencioso
+
+Esto no es preferencia, es correcto o incorrecto:
+
+| Textura | Color space |
+|---|---|
+| Base Color / Albedo / Emission | **sRGB** |
+| Normal | **Non-Color** |
+| Roughness / Metallic / AO / Displacement / Mask | **Non-Color** |
+
+Un Roughness en sRGB se ve *casi* bien en Blender y **mal** en el engine, con un error que no
+parece de textura. Verificar antes de exportar:
+
+```bash
+blender --background <archivo.blend> --python-expr "
+import bpy
+for img in bpy.data.images:
+    print(f'{img.name}: colorspace={img.colorspace_settings.name} size={tuple(img.size)}')
+"
+```
+
+Y de paso: resoluciones potencia de dos. Una textura de 1000x1000 no se comprime igual que una de
+1024x1024 y en mobile la diferencia es real.
+
+---
+
+## Phase 4: Normal maps
+
+| Destino | Convencion | Canal verde |
+|---|---|---|
+| Blender | OpenGL (+Y) | Como sale |
+| glTF / GLB | OpenGL (+Y) | Como sale |
+| Unity | OpenGL (+Y) | Como sale |
+| **UE5** | **DirectX (-Y)** | **Invertido** |
+
+Si el destino es UE5, hay dos salidas: invertir el canal verde en la textura, o marcarlo en el
+import del engine. **Elegir una y anotarla** — el sintoma de tenerlo mal es iluminacion que parece
+venir del lado opuesto, y se diagnostica tarde.
+
+El nodo Normal Map en Blender necesita el Image Texture en Non-Color y su propio `Strength`. Un
+Strength distinto de 1 no se exporta como tal: se hornea o se pierde.
+
+---
+
+## Phase 5: Bake
+
+Cuando hay procedurales que hay que conservar:
+
+1. **UV0 sin solapamiento** (requisito, no sugerencia).
+2. Crear la Image Texture destino con la resolucion final.
+3. Bake en Cycles (EEVEE no bakea todo). Tipos utiles: `Diffuse` sin luces para albedo,
+   `Normal`, `Roughness`, `AO`, `Combined` solo si se quiere luz pegada a la textura.
+4. **Margen** de bake para evitar costuras.
+5. Si se bakea de high-poly a low-poly: `Selected to Active` con **cage** y `Extrusion` ajustada.
+   Sin cage, los bordes salen sucios.
+6. Guardar la imagen a disco. Una imagen bakeada que quedo solo en memoria se pierde al cerrar y
+   no avisa.
+
+Despues del bake, reemplazar los procedurales por las Image Textures y **verificar que el look no
+cambio**. Si cambio, el bake esta mal, no el shader.
+
+Un bake escribe imagenes al repo y puede pisar texturas existentes. **Pedir aprobacion antes de
+escribir**, listando los archivos destino, y nunca sobrescribir una textura fuente sin confirmarlo.
+
+---
+
+## Phase 6: Materiales y draw calls
+
+Cantidad de materiales = cantidad de draw calls por objeto. Antes de sumar un material:
+
+- ¿Se puede resolver con una mascara en la misma textura?
+- ¿Se puede atlasear con los assets del mismo set?
+
+Un prop con 6 materiales y uno con 1 material atlaseado se ven igual y cuestan distinto. En mobile
+y VR la diferencia es la que decide si el frame entra.
+
+Nombrar los materiales igual que el asset (`M_<asset>_<parte>`); un `Material.001` que llega al
+engine es imposible de rastrear despues.
+
+---
+
+## Phase 7: Resumen
+
+Reportar por objeto: UV layers, materiales con nombre, texturas con su color space y resolucion,
+que se bakeo, y convencion de normal map elegida.
+
+**Verdict:**
+- **PASS** — UVs presentes, color space correcto, sin procedurales sin bakear, potencias de dos.
+- **CONCERNS** — funciona pero con deuda: falta UV1 y el asset recibe luz bakeada, materiales de
+  sobra, texturas no potencia de dos. Listar cada punto.
+- **FAIL** — sin UVs, color space invertido, procedurales sin bakear que el look necesita, o
+  normal map con la convencion equivocada para el destino. Indicar el fix.
+
+## Next Steps
+
+- `/blender-animation` si el asset lleva rig
+- `/blender-export` cuando materiales y UVs estan cerrados
+- `/asset-audit` para validar naming y formatos ya integrado
+- `/shader-dev` si el look necesita un shader propio en el engine, no una textura
+
+---
+
+> → Color space, convenciones de normal map y presupuesto de materiales estan en
+> `.claude/rules/blender-pipeline.md`.