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.0bis1.0) kontinuierlich um den Querschnitts-Umfangsring (i / nPts). - Parametrisiere
v(0.0bis1.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 beiu = 0.0, 0.25, 0.50, 0.75. Platziere horizontale Fasnähte, muschelförmige Schweißraupen und Bolzenreihen nahev = 0.02..0.08(unterer Rand) undv = 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#dcdcdcund Bolzenköpfe in#f5f5f5mit#1c1c1c-Schattenringen. SetzebumpScale: 0.055bis0.065aufTHREE.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/missilePodRshoulderL[+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:
- Starrer Knochen-Lock: Halte
ankleJoint.positiongenau an der Spitze des Schienbeinknochens fest, damit der Fuß niemals vom Bein abreißt. - Welt-zu-Becken-Ziel-Transform: Konvertiere die gewünschte Weltraum-Knöchelposition
targetWorldVecin den lokalen Raum vonpelvis.children[0]mitworldToLocal(). - Reichweiten-Clamping: Miss die Entfernung
Dvom Hüftgelenk[sx * 0.54, -0.12, 0]zum lokalen Ziel. ClampeDaufmaxReach = L1 + L2 - 0.003, sodass sich das Bein glatt ausstreckt, ohne NaN-Fehler, wenn das Becken weit weg gezogen wird. - 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
- Berechne inneren Knie-Winkel:
- Quaternion-Hüft-Zielen:
- Rotiere den unrotierten Schienbein-Vektor um
kxum X, addiere den Oberschenkel-Vektor, um_vHipToAnkleUnrotzu erhalten, und richte ihn mit der lokalen Zielrichtung[dx, dy, dz]über_qAim.setFromUnitVectors(_vHipToAnkleUnrot.normalize(), _vTargetLocal.normalize())aus.
- Rotiere den unrotierten Schienbein-Vektor um
- Weltraum-Fuß-Orientierung:
- Berechne das übergeordnete Knie-Welt-Quaternion
_qParentWorld, bilde das gewünschte Welt-Fuß-Quaternion_qDesiredFootaus(footPitch, footYaw, footRoll)und setzeankleJoint.quaternion.copy(_qParentWorld).invert().multiply(_qDesiredFoot), sodass die Sohle unabhängig von Hüft-/Knie-Winkeln flach auf dem Boden bleibt.
- Berechne das übergeordnete Knie-Welt-Quaternion
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%.
- Setze den vorderen Fuß entlang eines Bogens nach vorne (
- Phase 2: Explosiver Ausfallschritt & Peitsche (
0.42 - 0.58) :- Halte beide Füße mit
solveLegIKam Boden fixiert, während das Becken nach vorne (+0,62mZ) und unten (-0,27mY) 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)).
- Halte beide Füße mit
- 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.
- Schnappe die Klaue im Moment des Aufpralls zu (
- 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.
- Bringe den vorderen Fuß und das Becken mit
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ß (armLtritt 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, wennMath.sin(phase) > 0, verschiebe das Becken seitlich (cos(phase)) über das Standbein und schwinge die Arme gegenläufig (armLbewegt sich mitlegR). - Tanz-Groove: Fixiere beide Füße mit
solveLegIKam 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
- Führe eine Syntaxprüfung des generierten Skripts aus (
node -e "new Function(code)"), um null Syntax- oder nicht deklarierte Variablenfehler zu bestätigen. - Stelle sicher, dass
solveLegIK('L', ...)undsolveLegIK('R', ...)am Ende vonevaluateAnimation(t, dt)nach allen Aktualisierungen der Beckenposition/-rotation aufgerufen werden. - Füge im HTML ein Top-Level-
window.onerror-Diagnosebanner ein, sodass jeder Laufzeitfehler sofort auf dem Bildschirm sichtbar ist.