Communitygithub.com

Prozeduraler 3D-Mech-Animator

Zeigt einem Agenten, wie man einen 'prozeduralen 3D-Mech-Animator' plant, erstellt oder verwendet – mit konkreten Ergebnissen wie Plan, Kurzbeschreibung oder Checkliste. Die Vorgehensweise führt durch Prozeduralen 3D-Mech-Animator, Anwendungsfälle, Schritt 1: Prozedurale Loft-Geometrie und konforme UV-Mapping. Nutze es, wenn eine neue Aufgabe dieses Handwerk erfordert.

Was ist Prozeduraler 3D-Mech-Animator?

Diese Skill-Anleitung beschreibt, wie man mit Three.js vollständig prozedurale 3D-Mechs, Roboter und Hartflächenfahrzeuge erstellt – ohne externe `.glb`-Modelle oder eingebettete Base64-Bilddaten. Sie umfasst die Generierung von loftbasierter Geometrie mit konformen, topologieangepassten UV-Koordinaten, prozedurale PBR-Texturen über HTML5-Canvas sowie eine analytische 2-Knochen-Inverse-Kinematik (Zero-Drift Foot IK). Letztere verhindert, dass Füße bei tiefen Hocken, Ausfallschritten oder Kampfanimationen durch den Boden sinken oder unnatürlich rutschen. Die Anleitung beschreibt zudem mehrphasige Ganzkörperanimationen wie schwere Nahkampf-Angriffe, kombinierte Waffen-Combo-Sequenzen und rhythmische Tanzbewegungen mit kinetischer Kettenverzögerung. Ein Verifikations-Checklist am Ende stellt die Syntaxkorrektheit und korrekte Einbindung der IK-Lösung sicher. Skill wird hauptsächlich für Claude Code, Cursor, Codex und ähnliche KI-Agenten im Bereich 3D-Webentwicklung mit Three.js eingesetzt.

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

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Was macht Prozeduraler 3D-Mech-Animator?

Baue produktionsreife, einzeldatei- oder modulare 3D-Hartflächenroboter und Mechs in Three.js mit konformer UV-Abbildung, prozeduralen PBR-Texturen im Speicher, analytischer 2-Knochen-Inverser-Kinematik (Zero-Drift Foot IK) und mehrphasigen Ganzkörperanimationen.

Wann verwenden

  • Erstellung prozeduraler 3D-Mechs, Roboter, Läufer oder Hartflächenfahrzeuge in Three.js ohne externe .glb-Assets.
  • Implementierung analytischer 2-Knochen-Inverser-Kinematik (IK), damit Füße bei Kniebeugen, Ausfallschritten, Gehen, Tanzen oder Kampfangriffen auf dem Boden bleiben.
  • Entwurf mehrphasiger kinetischer Kampf- oder Fortbewegungsanimationen mit Antizipation, kinetischer Kettenverzögerung, Aufprall-Schockwellen und Erholung.
  • Generierung topologiekonformer UV-Koordinaten und THREE.CanvasTexture-PBR-Materialien im Speicher (Schweißnähte, Nieten, Kantenabnutzung, Bump-Maps, Schablonen) ohne externe Bildabhängigkeiten.

Schritt 1: Prozedurale Loft-Geometrie und konforme UV-Abbildung

Vermeide weltraumbezogene planare UV-Projektion auf 3D-Figuren oder Mechs, da diese Projektion Muster wie flache Tapete oder einen Trainingsanzug über Gelenken wirken lässt. Berechne immer konforme, topologieausgerichtete UV-Koordinaten direkt in den Loft- und Röhrenbauern:

  • Parametrisiere u (0.0 bis 1.0) kontinuierlich um den Querschnitts-Umfangsring (i / nPts).
  • Parametrisiere v (0.0 bis 1.0) entlang der Längs-Loft-Scheiben von der unteren Fase zur oberen Fase (r / (numRings - 1)).
  • Bilde Endkappen-Dreiecke radial um (0.5, 0.5) ab.
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);
    }
  }
  // Füge radiale Kappen hinzu, wenn capBot / capTop true sind, dann 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;
}

Schritt 2: Prozedurale PBR-Texturen im Speicher via HTML5-Canvas

Betten Sie niemals mehr MegaByte große Base64-Strings ein, die HTML-Dateien aufblähen oder fehlende Variablenreferenzen riskieren. Generiere Albedo-, Bump-, Hazard-, Decal- und Shield-Texturen beim Start im Speicher mit HTML5 2D-Canvas und THREE.CanvasTexture:

  • Konforme Nahtausrichtung: Platziere bei einem 8-seitigen gefasten Block (nPts = 8) vertikale Naht-Gräben und Kantenabnutzungs-Highlights bei u = 0.0, 0.25, 0.50, 0.75. Platziere horizontale Fasnähte, muschelförmige Schweißraupen und Bolzenreihen nahe v = 0.02..0.08 (unterer Rand) und v = 0.92..0.98 (oberer Rand).
  • 3D-Bump Relief: Fülle den Bump-Canvas mit neutralem #808080 (128), zeichne tiefe Nahtgräben in #181818, erhabene Schweißraupen in #dcdcdc und Bolzenköpfe in #f5f5f5 mit #1c1c1c-Schattenringen. Setze bumpScale: 0.055 bis 0.065 auf THREE.MeshStandardMaterial.

Schritt 3: Artikulierte Pivot-Kompensations-Hierarchie

Beim Erstellen von Meshes in globalen Modellkoordinaten konvertiere jedes Körperteil in eine lokale Pivot-Gruppe, sodass Rotationen sauber um den anatomischen Gelenkmittelpunkt (px, py, pz) erfolgen:

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 };
}

Standard-Mech-Kinematikbaum

  • root -> pelvis [0, 0.00, 0]
    • torso [0, 0.10, 0] (rotiert relativ zum Becken)
      • sensorPod [0, 1.08, 0.42] (gegenrotierend, um Optik auf Ziel fixiert zu halten)
      • hatchL / hatchR [±0.42, 1.44, -0.05] -> missilePodL / missilePodR
      • shoulderL [+0.98, 0.92, 0] -> armL -> elbowL [+1.26, 0.36, 0] (Railgun-Baugruppe)
      • 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]

Schritt 4: Analytischer 2-Knochen-Bein-IK-Löser (Zero-Drift Foot Lock)

Wenn Beckenhöhe oder -rotation allein mit Vorwärtskinematik (FK) animiert wird, sinken die Füße durch den Boden oder rutschen unnatürlich. Treibe die Beine immer mit einem analytischen 2-Knochen-Inversen-Kinematik-Löser (solveLegIK) an, der jeden Frame nach dem Setzen der Becken-Transformationen ausgewertet wird:

  1. Starrer Knochen-Lock: Halte ankleJoint.position genau an der Spitze des Schienbeinknochens fest, damit der Fuß niemals vom Bein abreißt.
  2. Welt-zu-Becken-Ziel-Transform: Konvertiere die gewünschte Weltraum-Knöchelposition targetWorldVec in den lokalen Raum von pelvis.children[0] mit worldToLocal().
  3. Reichweiten-Clamping: Miss die Entfernung D vom Hüftgelenk [sx * 0.54, -0.12, 0] zum lokalen Ziel. Clampe D auf maxReach = L1 + L2 - 0.003, sodass sich das Bein glatt ausstreckt, ohne NaN-Fehler, wenn das Becken weit weg gezogen wird.
  4. Kosinussatz für Kniebeugung:
    • Berechne inneren Knie-Winkel: cosB = clamp((L1*L1 + L2*L2 - D*D) / (2 * L1 * L2), -1, 1)
    • Setze Knie-X-Rotation: kx = (Math.PI - Math.acos(cosB)) - REST_KNEE_OFFSET
  5. Quaternion-Hüft-Zielen:
    • Rotiere den unrotierten Schienbein-Vektor um kx um X, addiere den Oberschenkel-Vektor, um _vHipToAnkleUnrot zu erhalten, und richte ihn mit der lokalen Zielrichtung [dx, dy, dz] über _qAim.setFromUnitVectors(_vHipToAnkleUnrot.normalize(), _vTargetLocal.normalize()) aus.
  6. Weltraum-Fuß-Orientierung:
    • Berechne das übergeordnete Knie-Welt-Quaternion _qParentWorld, bilde das gewünschte Welt-Fuß-Quaternion _qDesiredFoot aus (footPitch, footYaw, footRoll) und setze ankleJoint.quaternion.copy(_qParentWorld).invert().multiply(_qDesiredFoot), sodass die Sohle unabhängig von Hüft-/Knie-Winkeln flach auf dem Boden bleibt.

Schritt 5: Prinzipien der prozeduralen Ganzkörper-Animation

Animniere niemals eine einzelne Gliedmaße isoliert (das wirkt roboterhaft und schwerelos). Jede Animation muss die gesamte kinetische Kette einbeziehen:

1. 4-Phasen-Kampf-Schlagmuster (z. B. Klauenschlag & Kombinationsangriff)

Unterteile schwere Nahkampf- oder Waffenanimationen in vier separate normalisierte Phasen über den Zyklus u in [0, 1]:

  • Phase 1: Antizipation & Spannung (0.00 - 0.42) :
    • Setze den vorderen Fuß entlang eines Bogens nach vorne (stepLift = Math.sin(stepU * Math.PI) * 0.28) und pflanze ihn weit auf.
    • Verlagere das Beckengewicht auf das hintere Standbein und spanne Hüfte + Rumpf nach hinten (-70° kombiniertes Gieren).
    • Gegenrotiere den Kopf/Sensor-Pod (+85°), sodass die Augen auf das Ziel fixiert bleiben.
    • Ziehe die schlagende Schulter und den Ellbogen hoch hinter den Rücken, schwinge den gegenüberliegenden Arm als Gegengewicht quer über die Brust, drehe das Handgelenk-Futter hoch und öffne die Klaue auf 100%.
  • Phase 2: Explosiver Ausfallschritt & Peitsche (0.42 - 0.58) :
    • Halte beide Füße mit solveLegIK am Boden fixiert, während das Becken nach vorne (+0,62m Z) und unten (-0,27m Y) getrieben wird.
    • Führe die kinetische Kette mit Peitschenverzögerung: Hüften schnappen zuerst vor (smoothstep(0.0, 0.85, u)), der Rumpf folgt und der schlagende Arm beschleunigt nichtlinear (Math.pow(smoothstep(0.08, 1.0, u), 1.35)) entlang eines weiten äußeren Kreisbogens (Math.sin(armWhip * Math.PI)).
  • Phase 3: Aufprall, Zangen & Hit-Stop (0.58 - 0.72) :
    • Schnappe die Klaue im Moment des Aufpralls zu (clawVal = 0.05).
    • Löse prozedurale Kameraerschütterung, radiale Schockwellenringe, hochfrequentes strukturelles Zittern (Math.sin(u * Math.PI * 10) * Math.exp(-u * 5)) und synthetisierte Aufprall-Audio aus.
  • Phase 4: Hydraulische Erholung (0.72 - 1.00) :
    • Bringe den vorderen Fuß und das Becken mit 1.0 - smoothstep(0.0, 1.0, u) sanft in die neutrale Ausgangsposition zurück.

2. Multi-Action-Kombinationssequenz (all_out_attack)

Verkette mehrere Kampfphasen über einen längeren Zeitstrahl (z. B. 10.0s Periode):

  • Stufe A (0.00 - 0.24): Schwerer Klauenschlag mit Vorwärtsausfall und Funkenstoß.
  • Stufe B (0.24 - 0.50): Rumpf-Schnellzielen, doppelter Railgun-Rückstoß (armL tritt entlang der Laufachse zurück, während der Rumpf durch den Rückstoßimpuls verdreht wird) und Erzeugen eines hochenergetischen Projektil-Geschosses.
  • Stufe C (0.50 - 0.78): Abstützstellung, Dachraketenklappen öffnen (setHatchState(1)), Abschussbehälter anheben und gestaffelte Salve bogenförmiger ballistischer Raketen mit Rauchspuren abfeuern.
  • Stufe D (0.78 - 1.00): Aktiviere den hexagonalen Plasma-Dom-Schild (rig.shieldDome.visible = true) mit pulsierenden Schockwellen, während die Systeme herunterkühlen.

3. Fortbewegungs- und Tanzdynamik

  • Schwerer Gang / Lauf: Verwende entgegengesetzte Phasenversätze (phaseL = cycle * 2 * Math.PI, phaseR = phaseL + Math.PI). Hebe den schwingenden Fuß nur an, wenn Math.sin(phase) > 0, verschiebe das Becken seitlich (cos(phase)) über das Standbein und schwinge die Arme gegenläufig (armL bewegt sich mit legR).
  • Tanz-Groove: Fixiere beide Füße mit solveLegIK am Boden, während du rhythmische Achter-Hüftbewegungen, doppelt so schnelle Kniehüpfer (Math.abs(Math.sin(beat * 2))), abwechselnde Schulter-Pops und sich drehende Klauen-Flourishes ausführst.

Überprüfungs-Checkliste

  1. Führe eine Syntaxprüfung des generierten Skripts aus (node -e "new Function(code)"), um null Syntax- oder nicht deklarierte Variablenfehler zu bestätigen.
  2. Stelle sicher, dass solveLegIK('L', ...) und solveLegIK('R', ...) am Ende von evaluateAnimation(t, dt) nach allen Aktualisierungen der Beckenposition/-rotation aufgerufen werden.
  3. Füge im HTML ein Top-Level-window.onerror-Diagnosebanner ein, sodass jeder Laufzeitfehler sofort auf dem Bildschirm sichtbar ist.

Verwandte Skills