Communitygithub.com

Animateur 3D de mechs procédural

Guide l'agent pour planifier, construire ou découper un « animateur 3D de mechs procédural » afin d'obtenir un plan, un brief ou une checklist. La procédure parcourt l'Animateur 3D de mechs procédural, Quand l'utiliser, Étape 1 : Géométrie de loft procédural et UV mapping conforme. Utilisez-le lorsqu'une nouvelle tâche requiert ce savoir-faire.

Qu'est-ce que Animateur 3D de mechs procédural ?

Ce skill fournit une méthodologie complète pour créer, dans Three.js, des robots et mechs 3D à surface dure, de qualité production, avec un seul fichier ou une architecture modulaire. Il couvre la construction procédurale de géométrie par loft avec UV mapping conforme (évitant les projections planaires world-space), la génération en mémoire de textures PBR procédurales via Canvas HTML5 et THREE.CanvasTexture (albedo, bump, décal, etc.), ainsi qu'un système analytique d'Inverse Kinematics (IK) à 2 os zéro-dérive pour verrouiller les pieds au sol. Le skill détaille aussi les principes d'animation procédurale corps entier : séquences de combat en 4 phases (anticipation, impulsion, impact, récupération), combos multi-actions, locomotion, et même des dynamiques de danse. L'agent apprend à structurer une hiérarchie de pivots compensés, à utiliser une loi des cosinus pour le pliage du genou et des quaternions pour l'orientation de la hanche, le tout sans assets externes et avec une checklist de vérification finale.

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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Que fait Animateur 3D de mechs procédural ?

Construisez des robots et mechs 3D à surface dure, de qualité production, avec un seul fichier ou une architecture modulaire dans Three.js, avec UV mapping conforme, textures PBR procédurales en mémoire, Inverse Kinematics analytique à 2 os (Zero-Drift Foot IK) et animations corps entier multi-phases.

Quand l'utiliser

  • Création procédurale de mechs 3D, robots, marcheurs ou véhicules à surface dure dans Three.js sans assets .glb externes.
  • Implémentation d'Inverse Kinematics (IK) analytique à 2 os pour que les pieds restent plantés au sol lors de squats, fentes, marches, danses ou frappes de combat.
  • Conception d'animations de combat ou de locomotion cinétiques multi-phases avec anticipation, chaîne cinétique avec retard, ondes de choc d'impact et récupération.
  • Génération de coordonnées UV conformes à la topologie et de matériaux PBR THREE.CanvasTexture en mémoire (cordons de soudure, rivets, usure des bords, relief, pochoirs) sans dépendances d'images externes.

Étape 1 : Géométrie de loft procédural et UV mapping conforme

Évitez la projection UV planaire world-space sur les personnages ou mechs 3D, car elle donne l'impression que les motifs sont comme un papier peint plat ou un survêtement étiré sur les articulations. Calculez toujours des coordonnées UV conformes alignées sur la topologie directement dans les constructeurs de lofts et de tubes :

  • Paramétrez u (0.0 à 1.0) en continu autour de l'anneau de la section transversale (i / nPts).
  • Paramétrez v (0.0 à 1.0) le long des tranches longitudinales du loft, du chanfrein inférieur au chanfrein supérieur (r / (numRings - 1)).
  • Mappez les triangles des extrémités radialement autour 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);
    }
  }
  // Ajouter les capuchons radiaux si capBot / capTop sont true, puis 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;
}

Étape 2 : Textures PBR procédurales en mémoire via Canvas HTML5

N'intégrez jamais de chaînes Base64 de plusieurs mégaoctets qui gonflent les fichiers HTML ou risquent de manquer des références de variables. Générez les textures Albedo, Bump, Hazard, Décal et Bouclier en mémoire au démarrage en utilisant Canvas 2D HTML5 et THREE.CanvasTexture :

  • Alignement des coutures conformes : pour un bloc chanfreiné à 8 faces (nPts = 8), placez les tranchées de couture verticales et les rehauts d'usure des bords à u = 0.0, 0.25, 0.50, 0.75. Placez les coutures de chanfrein horizontales, les cordons de soudure festonnés et les rangées de boulons près de v = 0.02..0.08 (bord inférieur) et v = 0.92..0.98 (bord supérieur).
  • Relief 3D : remplissez le canvas du relief avec du gris neutre #808080 (128), dessinez les tranchées de couture profondes en #181818, les cordons de soudure surélevés en #dcdcdc, et les têtes de boulons en #f5f5f5 avec des anneaux d'ombre #1c1c1c. Définissez bumpScale: 0.055 à 0.065 sur THREE.MeshStandardMaterial.

Étape 3 : Hiérarchie de compensation de pivot articulée

Lors de la construction de maillages dans les coordonnées globales du modèle, convertissez chaque partie du corps en un groupe de pivot local afin que les rotations se produisent proprement autour du centre articulaire anatomique (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 };
}

Arbre cinématique standard du mech

  • root -> pelvis [0, 0.00, 0]
    • torso [0, 0.10, 0] (tourne par rapport au pelvis)
      • sensorPod [0, 1.08, 0.42] (contre-rotation pour que l'optique reste verrouillée sur la cible)
      • hatchL / hatchR [±0.42, 1.44, -0.05] -> missilePodL / missilePodR
      • shoulderL [+0.98, 0.92, 0] -> armL -> elbowL [+1.26, 0.36, 0] (ensemble Railgun)
      • 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]

Étape 4 : Solveur IK analytique à 2 os pour les jambes (Zero-Drift Foot Lock)

Si la hauteur ou la rotation du pelvis est animée uniquement par Forward Kinematics (FK), les pieds s'enfonceront dans le sol ou glisseront de manière non naturelle. Pilotez toujours les jambes avec un solveur Inverse Kinematics analytique à 2 os (solveLegIK) évalué à chaque frame après avoir défini les transformations du pelvis :

  1. Verrouillage rigide des os : maintenez ankleJoint.position fixé à l'extrémité exacte de l'os du tibia afin que le pied ne se détache jamais de la jambe.
  2. Transformation de la cible du monde au pelvis : convertissez la position world-space souhaitée de la cheville targetWorldVec dans l'espace local de pelvis.children[0] à l'aide de worldToLocal().
  3. Limitation de la portée : mesurez la distance D du pivot de la hanche [sx * 0.54, -0.12, 0] à la cible locale. Limitez D à maxReach = L1 + L2 - 0.003 pour que la jambe s'étende en douceur sans erreurs NaN lorsque le pelvis s'éloigne.
  4. Loi des cosinus pour le pliage du genou :
    • Calculez l'angle interne du genou : cosB = clamp((L1*L1 + L2*L2 - D*D) / (2 * L1 * L2), -1, 1)
    • Définissez la rotation X du genou : kx = (Math.PI - Math.acos(cosB)) - REST_KNEE_OFFSET
  5. Orientation de la hanche par quaternion :
    • Faites pivoter le vecteur du tibia non tourné de kx autour de X, ajoutez le vecteur de la cuisse pour obtenir _vHipToAnkleUnrot, et alignez-le avec la direction cible locale [dx, dy, dz] via _qAim.setFromUnitVectors(_vHipToAnkleUnrot.normalize(), _vTargetLocal.normalize()).
  6. Orientation du pied en world-space :
    • Calculez le quaternion world du genou parent _qParentWorld, construisez le quaternion world du pied souhaité _qDesiredFoot à partir de (footPitch, footYaw, footRoll), et définissez ankleJoint.quaternion.copy(_qParentWorld).invert().multiply(_qDesiredFoot) afin que la semelle reste plate sur le sol quels que soient les angles de la hanche/du genou.

Étape 5 : Principes de l'animation procédurale corps entier

N'animez jamais un seul membre isolément (cela donne un aspect robotique et sans poids). Chaque animation doit engager la chaîne cinétique complète :

1. Motif de frappe de combat en 4 phases (ex. : Attaque par écrasement de griffe et combo)

Décomposez les animations de combat lourdes ou d'arme en quatre phases normalisées distinctes sur le cycle u in [0, 1] :

  • Phase 1 : Anticipation et enroulement (0.00 - 0.42) :
    • Avancez le pied avant le long d'un arc (stepLift = Math.sin(stepU * Math.PI) * 0.28) et plantez-le large.
    • Déplacez le poids du pelvis sur la jambe arrière d'ancrage et enroulez les hanches + le torse vers l'arrière (-70 deg de lacet combiné).
    • Contre-rotation de la tête / du pod capteur (+85 deg) pour que les yeux restent verrouillés sur la cible.
    • Armez l'épaule et le coude du bras frappeur haut derrière le dos, balancez le bras opposé en travers de la poitrine comme contrepoids, faites tourner le mandrin du poignet et ouvrez la pince à 100 %.
  • Phase 2 : Fente explosive et coup de fouet (0.42 - 0.58) :
    • Maintenez les deux pieds verrouillés au sol via solveLegIK tout en poussant le pelvis vers l'avant (+0.62m Z) et vers le bas (-0.27m Y).
    • Séquencez la chaîne cinétique avec un retard de fouet : les hanches se projettent d'abord vers l'avant (smoothstep(0.0, 0.85, u)), le torse suit, et le bras frappeur accélère de manière non linéaire (Math.pow(smoothstep(0.08, 1.0, u), 1.35)) le long d'un large arc circulaire extérieur (Math.sin(armWhip * Math.PI)).
  • Phase 3 : Impact, serrage et arrêt au contact (0.58 - 0.72) :
    • Refermez la pince (clawVal = 0.05) au moment de l'impact.
    • Déclenchez un tremblement de caméra procédural, des anneaux d'onde de choc radiaux, une secousse structurelle à haute fréquence (Math.sin(u * Math.PI * 10) * Math.exp(-u * 5)) et un son d'impact synthétisé.
  • Phase 4 : Récupération hydraulique (0.72 - 1.00) :
    • Ramenez doucement le pied avant et le pelvis à la position neutre en utilisant 1.0 - smoothstep(0.0, 1.0, u).

2. Séquençage de combo multi-actions (all_out_attack)

Enchaînez plusieurs phases de combat sur une timeline plus longue (par exemple une période de 10.0s) :

  • Phase A (0.00 - 0.24) : Écrasement lourd avec griffe, fente avant et explosion d'étincelles.
  • Phase B (0.24 - 0.50) : Visée rapide du torse, recul double Railgun (armL recule le long de l'axe du canon tandis que le torse tourne sous l'impulsion du recul) et apparition d'un projectile à grande vélocité.
  • Phase C (0.50 - 0.78) : Posture d'appui, ouverture des trappes à missiles du toit (setHatchState(1)), élévation des pods de lancement et tir d'une salve étagée de missiles balistiques arqués avec des traînées de fumée.
  • Phase D (0.78 - 1.00) : Activation du bouclier hexagonal à plasma (rig.shieldDome.visible = true) avec ondes de choc pulsées pendant la phase de refroidissement des systèmes.

3. Dynamiques de locomotion et de danse

  • Marche lourde / Course : Utilisez des décalages de phase opposés (phaseL = cycle * 2 * Math.PI, phaseR = phaseL + Math.PI). Levez le pied en balancement uniquement quand Math.sin(phase) > 0, déplacez latéralement le pelvis (cos(phase)) au-dessus de la jambe d'appui, et contre-balancez les bras (armL bouge avec legR).
  • Groove de danse : Verrouillez les deux pieds au sol via solveLegIK tout en effectuant un balancement rythmique des hanches en forme de 8, des rebonds de genoux en double time (Math.abs(Math.sin(beat * 2))), des pops d'épaules alternés et des mouvements de pince tournoyants.

Checklist de vérification

  1. Exécutez une validation syntaxique du script généré (node -e "new Function(code)") pour confirmer zéro erreur de syntaxe ou de variable non déclarée.
  2. Vérifiez que solveLegIK('L', ...) et solveLegIK('R', ...) sont appelés à la fin de evaluateAnimation(t, dt) après toutes les mises à jour de position/rotation du pelvis.
  3. Incluez une bannière de diagnostic window.onerror de haut niveau dans le HTML pour que toute erreur d'exécution soit immédiatement visible à l'écran.

Skills associés