Communitygithub.com

Animador Procedimental de Mechs 3D

Muestra a un agente cómo planificar, construir o recortar un 'animador procedimental de mechs 3D' para que el resultado concreto sea un plan, un resumen o una lista de verificación. El procedimiento avanza a través del Animador Procedimental de Mechs 3D, Cuándo Usarlo, Paso 1: Geometría de Loft Procedimental y Mapeo UV Conforme. Úsalo cuando una nueva tarea requiera esta técnica.

¿Qué es Animador Procedimental de Mechs 3D?

Esta skill proporciona un plan detallado paso a paso para que un agente de IA genere robots y mechs 3D de superficie dura, de grado de producción, utilizando Three.js, sin depender de activos externos .glb. La skill se enfoca en la construcción procedimental de geometría con mapeo UV conforme, la generación de texturas PBR en memoria mediante Canvas de HTML5, una jerarquía cinemática articulada con compensación de pivote y un solucionador analítico de Cinemática Inversa (IK) de dos huesos para lograr un bloqueo de pie sin deriva. Además, detalla principios para animaciones de cuerpo completo, incluyendo patrones de ataque de combate de cuatro fases, secuencias de combos de múltiples acciones y dinámicas de locomoción y baile. Es compatible con cualquier plataforma que ejecute JavaScript/Three.js (como navegadores web) y es ideal para crear animaciones cinéticas complejas para mechs, robots y vehículos de forma totalmente procedimental.

Compatible con~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/etofot/Robo-Blender-Academy/tree/HEAD/dreadnought-3d-ik-studio

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

¿Qué hace Animador Procedimental de Mechs 3D?

Construye robots y mechs 3D de superficie dura, de grado de producción, en un solo archivo o de forma modular en Three.js con mapeo UV conforme, texturas PBR procedimentales en memoria, Cinemática Inversa (IK) analítica de dos huesos (Zero-Drift Foot IK) y animaciones de cuerpo completo de múltiples fases.

Cuándo Usarlo

  • Crear mechs, robots, caminantes o vehículos de superficie dura procedimentales en Three.js sin activos .glb externos.
  • Implementar Cinemática Inversa (IK) analítica de dos huesos para que los pies permanezcan plantados en el suelo durante sentadillas, estocadas, caminatas, bailes o ataques de combate.
  • Diseñar animaciones de combate cinético o locomoción de múltiples fases con anticipación, retardo de cadena cinética, ondas de choque de impacto y recuperación.
  • Generar coordenadas UV conformes a la topología y materiales PBR THREE.CanvasTexture en memoria (costuras de soldadura, remaches, desgaste de bordes, mapas de relieve, esténciles) sin dependencias de imágenes externas.

Paso 1: Geometría de Loft Procedimental y Mapeo UV Conforme

Evita la proyección UV planar en espacio mundial en personajes o mechs 3D, ya que la proyección en espacio mundial hace que los patrones parezcan papel tapiz plano o una chándal estirado sobre las articulaciones. Siempre calcula coordenadas UV conformes alineadas con la topología directamente dentro de los constructores de loft y tubo:

  • Parametriza u (0.0 a 1.0) continuamente alrededor del anillo del perímetro de la sección transversal (i / nPts).
  • Parametriza v (0.0 a 1.0) a lo largo de las rebanadas longitudinales del loft desde el chaflán inferior hasta el chaflán superior (r / (numRings - 1)).
  • Mapa los triángulos de los extremos radialmente alrededor de (0.5, 0.5).
function buildLoftGeometry(slices, capBot = true, capTop = true) {
  const numRings = slices.length;
  const nPts = slices[0].length;
  const positions = [];
  const uvs = [];

  for (let r = 0; r < numRings - 1; r++) {
    const v0 = r / (numRings - 1);
    const v1 = (r + 1) / (numRings - 1);
    for (let i = 0; i < nPts; i++) {
      const u0 = i / nPts;
      const u1 = (i + 1) / nPts;
      const p00 = slices[r][i];
      const p10 = slices[r][(i + 1) % nPts];
      const p01 = slices[r + 1][i];
      const p11 = slices[r + 1][(i + 1) % nPts];

      positions.push(...p00, ...p10, ...p11);
      uvs.push(u0, v0, u1, v0, u1, v1);

      positions.push(...p00, ...p11, ...p01);
      uvs.push(u0, v0, u1, v1, u0, v1);
    }
  }
  // Añadir tapas radiales si capBot / capTop son true, luego computeVertexNormals()
  const geo = new THREE.BufferGeometry();
  geo.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
  geo.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
  geo.computeVertexNormals();
  return geo;
}

Paso 2: Texturas PBR Procedimentales en Memoria a través de HTML5 Canvas

Nunca incrustes cadenas Base64 de varios megabytes que inflen los archivos HTML o corran el riesgo de que falten referencias de variables. Genera texturas Albedo, Bump, Hazard, Decal y Shield en memoria al inicio usando HTML5 2D Canvas y THREE.CanvasTexture:

  • Alineación de Costuras Conformes: Para un bloque chaflanado de 8 lados (nPts = 8), coloca zanjas de costura verticales y resaltes de desgaste de bordes en u = 0.0, 0.25, 0.50, 0.75. Coloca costuras de chaflán horizontales, cordones de soldadura festoneados y filas de pernos cerca de v = 0.02..0.08 (borde inferior) y v = 0.92..0.98 (borde superior).
  • Relieve 3D (Bump): Llena el lienzo de bump con #808080 neutro (128), dibuja zanjas de costura profundas en #181818, cordones de soldadura elevados en #dcdcdc, y cabezas de pernos en #f5f5f5 con anillos de sombra #1c1c1c. Establece bumpScale: 0.055 a 0.065 en THREE.MeshStandardMaterial.

Paso 3: Jerarquía Articulada con Compensación de Pivote

Al construir mallas en coordenadas globales del modelo, convierte cada parte del cuerpo en un grupo de pivote local para que las rotaciones ocurran limpiamente alrededor del centro de la articulación anatómica (px, py, pz):

function createLocalPartGroup(name, pivotX, pivotY, pivotZ, parentGroup) {
  const joint = new THREE.Group();
  joint.name = name;
  joint.position.set(pivotX, pivotY, pivotZ);
  parentGroup.add(joint);

  const offsetGroup = new THREE.Group();
  offsetGroup.position.set(-pivotX, -pivotY, -pivotZ);
  joint.add(offsetGroup);
  return { joint, space: offsetGroup };
}

Árbol Cinemático Estándar de Mech

  • root -> pelvis [0, 0.00, 0]
    • torso [0, 0.10, 0] (rota en relación a la pelvis)
      • sensorPod [0, 1.08, 0.42] (contra-rota para mantener la óptica fijada en el objetivo)
      • hatchL / hatchR [±0.42, 1.44, -0.05] -> missilePodL / missilePodR
      • shoulderL [+0.98, 0.92, 0] -> armL -> elbowL [+1.26, 0.36, 0] (Montaje del cañón de riel)
      • shoulderR [-0.98, 0.92, 0] -> armR -> elbowR [-1.26, 0.36, 0] -> wristChuck -> claw1..3
    • legL [+0.54, -0.12, 0] -> kneeL [+0.62, -0.86, 0.12] -> ankleL [+0.66, -1.72, 0.02]
    • legR [-0.54, -0.12, 0] -> kneeR [-0.62, -0.86, 0.12] -> ankleR [-0.66, -1.72, 0.02]

Paso 4: Solucionador IK Analítico de 2 Huesos para Piernas (Bloqueo de Pie Sin Deriva)

Si la altura o rotación de la pelvis se anima usando solo Cinemática Directa (FK), los pies se hundirán en el suelo o se deslizarán de forma antinatural. Siempre impulsa las piernas con un solucionador de Cinemática Inversa (IK) analítico de dos huesos (solveLegIK) evaluado cada fotograma después de establecer las transformaciones de la pelvis:

  1. Bloqueo Rígido del Hueso: Mantén ankleJoint.position fijo en la punta exacta del hueso de la espinilla para que el pie nunca se desprenda de la pierna.
  2. Transformación del Objetivo de Mundo a Pelvis: Convierte la posición deseada del tobillo en espacio mundial targetWorldVec al espacio local de pelvis.children[0] usando worldToLocal().
  3. Limitación del Alcance: Mide la distancia D desde el pivote de la cadera [sx * 0.54, -0.12, 0] hasta el objetivo local. Limita D a maxReach = L1 + L2 - 0.003 para que la pierna se extienda suavemente sin errores NaN cuando la pelvis se estira demasiado.
  4. Ley de Cosenos para la Flexión de la Rodilla:
    • Calcula el ángulo interno de la rodilla: cosB = clamp((L1*L1 + L2*L2 - D*D) / (2 * L1 * L2), -1, 1)
    • Establece la rotación X de la rodilla: kx = (Math.PI - Math.acos(cosB)) - REST_KNEE_OFFSET
  5. Apunten con Cuaternión de Cadera:
    • Rota el vector de espinilla sin rotar por kx alrededor de X, suma el vector del muslo para obtener _vHipToAnkleUnrot, y alínealo con la dirección del objetivo local [dx, dy, dz] a través de _qAim.setFromUnitVectors(_vHipToAnkleUnrot.normalize(), _vTargetLocal.normalize()).
  6. Orientación del Pie en Espacio Mundial:
    • Calcula el cuaternión mundial de la rodilla padre _qParentWorld, construye el cuaternión deseado del pie en el mundo _qDesiredFoot a partir de (footPitch, footYaw, footRoll), y establece ankleJoint.quaternion.copy(_qParentWorld).invert().multiply(_qDesiredFoot) para que la planta del pie permanezca plana sobre el suelo independientemente de los ángulos de cadera/rodilla.

Paso 5: Principios de Animación Procedimental de Cuerpo Completo

Nunca animes una sola extremidad de forma aislada (lo que se ve robótico y sin peso). Cada animación debe involucrar toda la cadena cinética:

1. Patrón de Ataque de Combate de 4 Fases (Ej. Golpe de Garra y Ataque en Combo)

Divide las animaciones de combate cuerpo a cuerpo pesadas o de armas en cuatro fases normalizadas distintas a lo largo del ciclo u in [0, 1]:

  • Fase 1: Anticipación y Contracción (0.00 - 0.42) :
    • Adelanta el pie delantero a lo largo de un arco (stepLift = Math.sin(stepU * Math.PI) * 0.28) y plántalo bien abierto.
    • Desplaza el peso de la pelvis sobre la pierna trasera de anclaje y contrae las caderas y el torso hacia atrás (-70 deg de guiñada combinada).
    • Contrarrota la cabeza / sensor pod (+85 deg) para que los ojos permanezcan fijos en el objetivo.
    • Prepara el hombro y el codo golpeadores en alto detrás de la espalda, balancea el brazo opuesto a través del pecho como contrapeso, acelera el mandril de la muñeca y abre la garra al 100%.
  • Fase 2: Estocada Explosiva y Latigazo (0.42 - 0.58) :
    • Mantén ambos pies bloqueados en el suelo a través de solveLegIK mientras impulsas la pelvis hacia adelante (+0.62m Z) y hacia abajo (-0.27m Y).
    • Secuencia la cadena cinética con retardo de látigo: las caderas se mueven hacia adelante primero (smoothstep(0.0, 0.85, u)), el torso sigue, y el brazo golpeador acelera no linealmente (Math.pow(smoothstep(0.08, 1.0, u), 1.35)) a lo largo de un amplio arco circular hacia afuera (Math.sin(armWhip * Math.PI)).
  • Fase 3: Impacto, Sujeción y Parada de Golpe (0.58 - 0.72) :
    • Cierra la garra de golpe (clawVal = 0.05) en el momento del impacto.
    • Activa la vibración de cámara procedimental, anillos de onda de choque radiales, estremecimiento estructural de alta frecuencia (Math.sin(u * Math.PI * 10) * Math.exp(-u * 5)) y audio de impacto sintetizado.
  • Fase 4: Recuperación Hidráulica (0.72 - 1.00) :
    • Devuelve suavemente el pie delantero y la pelvis a la postura neutral usando 1.0 - smoothstep(0.0, 1.0, u).

2. Secuenciación de Combos de Múltiples Acciones (all_out_attack)

Encadena múltiples etapas de combate en una línea de tiempo más larga (ej. período 10.0s):

  • Etapa A (0.00 - 0.24): Golpe Pesado de Garra con estocada hacia adelante y explosión de chispas.
  • Etapa B (0.24 - 0.50): Apuntado rápido del torso, retroceso del Cañón de Riel gemelo (armL retrocede a lo largo del eje del cañón mientras el torso gira por el impulso del retroceso) y generación de pernos de proyectil de alta velocidad.
  • Etapa C (0.50 - 0.78): Postura de apoyo, abrir las escotillas de misiles del techo (setHatchState(1)), elevar las plataformas lanzadoras y disparar una salva escalonada de misiles balísticos en arco con estelas de humo.
  • Etapa D (0.78 - 1.00): Activar el escudo de cúpula de plasma hexagonal (rig.shieldDome.visible = true) con ondas de choque pulsantes mientras se enfrían los sistemas.

3. Dinámicas de Locomoción y Baile

  • Caminata / Carrera Pesada: Usa desfases de fase opuestos (phaseL = cycle * 2 * Math.PI, phaseR = phaseL + Math.PI). Levanta el pie que se balancea solo cuando Math.sin(phase) > 0, desplaza el balanceo lateral de la pelvis (cos(phase)) sobre la pierna de apoyo, y contrabalancea los brazos (armL se mueve con legR).
  • Ritmo de Baile: Bloquea ambos pies en el suelo a través de solveLegIK mientras impulsas un balanceo de cadera en forma de 8 rítmico, rebotes de rodilla al doble de tiempo (Math.abs(Math.sin(beat * 2))), movimientos alternos de hombros y giros de garra giratorios.

Lista de Verificación

  1. Ejecuta la validación de sintaxis en el script generado (node -e "new Function(code)") para confirmar cero errores de sintaxis o variables no declaradas.
  2. Verifica que solveLegIK('L', ...) y solveLegIK('R', ...) sean llamados al final de evaluateAnimation(t, dt) después de todas las actualizaciones de posición/rotación de la pelvis.
  3. Incluye un banner de diagnóstico window.onerror de nivel superior en el HTML para que cualquier error en tiempo de ejecución sea inmediatamente visible en la pantalla.

Skills relacionados