Download web/js/scene/animate.js from paralaif/tiny-scene-three: direct link, hf CLI and curl.
- Browser
- Download file 16.8 kB
-
https://huggingface.co/paralaif/tiny-scene-three/resolve/main/web/js/scene/animate.js
- Command line
-
hf download hf://paralaif/tiny-scene-three/web/js/scene/animate.js
-
curl -L -o animate.js https://huggingface.co/paralaif/tiny-scene-three/resolve/main/web/js/scene/animate.js
16.8 kB
| // Procedural animation: every pose is a pure function of time, so nothing drifts and any frame can be rebuilt. | |
| import * as THREE from 'three'; | |
| const { sin, cos, abs, PI, min, max, floor, atan2, sqrt } = Math; | |
| const clamp = (v, a, b) => min(b, max(a, v)); | |
| const smooth = (u) => u * u * (3 - 2 * u); | |
| export const SPEED = { walk: 1.5, run: 4.2, drive: 5.5, swim: 1.7, roll: 2.4, circle: 1.6, fly: 4.0, jump: 1.6, dance: 1.2 }; | |
| export const LOCO = new Set(['walk', 'run', 'drive', 'swim', 'roll']); | |
| export const SPD_MUL = { slow: 0.45, fast: 2.0 }; | |
| export function speedOf(inst, act) { | |
| const f = clamp(sqrt((inst.rig.h * inst.scale) / 1.3), 0.55, 2.2); | |
| return (SPEED[act] ?? 1.5) * f; | |
| } | |
| // ------------------------------------------------------------------ paths | |
| function path(inst, T, s) { | |
| const mo = inst.motion; | |
| if (mo.kind === 'patrol') { | |
| const leg = (2 * mo.A) / mo.v, tt = 0.7, P = 2 * (leg + tt); | |
| let u = (T + leg / 2) % P; | |
| if (u < leg) { s.x += -mo.A + mo.v * u; s.yaw = PI / 2; } | |
| else if (u < leg + tt) { s.x += mo.A; s.yaw = PI / 2 - PI * smooth((u - leg) / tt); } | |
| else if (u < 2 * leg + tt) { s.x += mo.A - mo.v * (u - leg - tt); s.yaw = -PI / 2; } | |
| else { s.x -= mo.A; s.yaw = -PI / 2 + PI * smooth((u - 2 * leg - tt) / tt); } | |
| s.dist = mo.v * T; | |
| } else if (mo.kind === 'circle') { | |
| const a = mo.ph + (mo.v / mo.R) * T; | |
| s.x = mo.cx + inst.off.x + mo.R * cos(a); | |
| s.z = mo.cz + inst.off.z + mo.R * sin(a); | |
| s.yaw = atan2(-sin(a), cos(a)); | |
| s.dist = mo.v * T; | |
| } else if (mo.kind === 'fly') { | |
| if (inst.rig.vertical) { | |
| s.y += mo.alt * (0.55 + 0.45 * sin(T * 0.8)); | |
| s.x += sin(T * 0.5) * 0.6; | |
| } else { | |
| const a = mo.ph + mo.w * T; | |
| s.x = mo.cx + inst.off.x + mo.Rx * cos(a); | |
| s.z = mo.cz + inst.off.z + mo.Rz * sin(a); | |
| s.yaw = atan2(-mo.Rx * sin(a), mo.Rz * cos(a)); | |
| s.y += mo.alt + sin(T * 1.3) * 0.25; | |
| s.roll = inst.rig.floaty ? 0 : 0.28; | |
| } | |
| s.dist = 4 * T; | |
| } else if (mo.kind === 'hopover') { | |
| const k = floor(T / mo.P), u = T / mo.P - k, dir = k % 2 ? -1 : 1; | |
| if (u < 0.62) { | |
| const a = u / 0.62; | |
| s.x = mo.cx + inst.off.x + dir * (-mo.d + 2 * mo.d * a); | |
| s.y += mo.H * 4 * a * (1 - a); | |
| s.yaw = dir * PI / 2; | |
| s.air = a; | |
| } else { | |
| s.x = mo.cx + inst.off.x + dir * mo.d; | |
| s.yaw = dir * (PI / 2) * (1 - 2 * smooth((u - 0.62) / 0.38)); | |
| s.air = -1; | |
| } | |
| s.z = mo.cz + inst.off.z; | |
| } | |
| } | |
| // ------------------------------------------------------------------ gaits | |
| function gait(g, ph, amp, run, dist) { | |
| const b = g.body, L = g.legs, A = g.arms, s1 = sin(ph); | |
| if (g.kind === 'quad') { | |
| if (run) { | |
| L[0].rotation.x += s1 * amp; L[1].rotation.x += sin(ph + 0.4) * amp; | |
| L[2].rotation.x += sin(ph + 2.4) * amp; L[3].rotation.x += sin(ph + 2.8) * amp; | |
| b.rotation.x += sin(ph + 1) * 0.07; | |
| b.position.y += (1 - cos(ph)) * 0.06 * g.leg; | |
| } else { | |
| L[0].rotation.x += s1 * amp; L[3].rotation.x += s1 * amp; | |
| L[1].rotation.x -= s1 * amp; L[2].rotation.x -= s1 * amp; | |
| b.position.y += (1 - cos(2 * ph)) * 0.02 * g.leg; | |
| } | |
| if (g.head) g.head.rotation.x += sin(2 * ph) * 0.04; | |
| if (g.tail) g.tail.rotation.z += sin(ph) * 0.25; | |
| } else if (g.kind === 'biped') { | |
| L[0].rotation.x += s1 * amp; L[1].rotation.x -= s1 * amp; | |
| if (A) { A[0].rotation.x -= s1 * amp * 0.8; A[1].rotation.x += s1 * amp * 0.8; } | |
| b.position.y += (1 - cos(2 * ph)) * 0.025 * g.leg; | |
| if (run) b.rotation.x += 0.16; | |
| if (g.tail) g.tail.rotation.y += sin(ph) * 0.2; | |
| } else if (g.kind === 'bird') { | |
| L[0].rotation.x += s1 * amp; L[1].rotation.x -= s1 * amp; | |
| if (g.upright) b.rotation.z += s1 * 0.13; | |
| else if (g.head) g.head.position.z += sin(2 * ph) * 0.03; | |
| b.position.y += abs(s1) * 0.02; | |
| } else if (g.kind === 'fish') { | |
| g.tail.rotation.y += sin(ph * 1.4) * 0.55; | |
| b.rotation.y += sin(ph * 1.4 - 1) * 0.12; | |
| } else if (g.kind === 'vehicle') { | |
| const r = g.board ? 0.06 : 0.36; | |
| if (g.wheels) for (const w of g.wheels) w.rotation.x += dist / r; | |
| else b.rotation.z += sin(ph * 0.5) * 0.03; | |
| } else { | |
| b.rotation.z += s1 * 0.1; | |
| b.position.y += abs(s1) * 0.07 * g.h; | |
| if (A) { A[0].rotation.x += s1 * 0.5; A[1].rotation.x -= s1 * 0.5; } | |
| } | |
| } | |
| /** Rotate `body` by `a` around the X axis through its centre, keeping that centre at height c2. */ | |
| function tumble(g, a, c2) { | |
| const c = g.h / 2; | |
| g.body.rotation.x += a; | |
| g.body.position.y += c2 - c * cos(a); | |
| g.body.position.z += -c * sin(a); | |
| } | |
| function flap(g, T, rate, amp) { | |
| if (!g.wings) return false; | |
| g.wings.forEach((w, i) => { | |
| const sx = i ? -1 : 1; | |
| if (g.kind === 'bird' && !g.upright) w.rotation.z = sx * sin(T * rate) * amp; | |
| else w.rotation.z += sx * sin(T * rate) * amp; | |
| }); | |
| return true; | |
| } | |
| // ------------------------------------------------------------------ poses | |
| const POSE = { | |
| idle(i, g, T, s) { | |
| g.body.scale.y *= 1 + sin(T * 2) * 0.012; | |
| if (g.tail && g.kind !== 'fish') g.tail.rotation.z += sin(T * 3) * 0.18; | |
| if (g.head && g.kind !== 'prop') g.head.rotation.y += sin(T * 0.7) * 0.25; | |
| if (g.sway) g.head.rotation.z += sin(T * 1.1) * 0.035; | |
| if (g.kind === 'fish') { g.tail.rotation.y += sin(T * 3) * 0.3; s.y += sin(T * 1.2) * 0.06; } | |
| if (g.floaty) { s.y += (g.hover ?? 0.3) * 0.5 + sin(T * 1.4) * 0.12; s.roll += sin(T * 0.9) * 0.04; } | |
| if (g.trunk) g.trunk.rotation.x += sin(T * 1.3) * 0.12; | |
| }, | |
| move(i, g, T, s, act) { | |
| const stride = max(0.22, (g.leg ?? g.h * 0.35) * i.scale * 1.25); | |
| const ph = (s.dist / stride) * (act === 'run' ? 0.8 : 1); | |
| gait(g, ph, act === 'run' ? 0.85 : act === 'swim' ? 0.35 : 0.5, act === 'run', s.dist / i.scale); | |
| if (g.kind === 'fish') s.y += sin(T * 1.2) * 0.06; | |
| }, | |
| swim(i, g, T, s) { | |
| POSE.move(i, g, T, s, 'swim'); | |
| if (g.kind === 'biped' && g.arms) { | |
| g.body.rotation.x += 1.2; | |
| g.body.position.y += g.leg * 0.25; | |
| g.arms[0].rotation.x += PI + T * 5; | |
| g.arms[1].rotation.x += T * 5; | |
| } | |
| if (!s.water) s.y += g.kind === 'fish' ? 0 : 0.2; | |
| s.yaw += sin(T * 3) * 0.08; | |
| }, | |
| roll(i, g, T, s) { | |
| if (g.roller) { g.roller.rotation.x += s.dist / i.scale / g.round; return; } | |
| if (g.kind === 'vehicle' && g.wheels) { gait(g, 0, 0, false, s.dist / i.scale); return; } | |
| tumble(g, s.dist / i.scale / max(0.4, g.h * 0.5), max(g.h / 2, g.r * 0.75)); | |
| }, | |
| jump(i, g, T, s) { | |
| let a = s.air; | |
| if (a == null) { | |
| const u = ((s.beat ?? T * 1.8) / 2) % 1; // one jump every two beats | |
| a = u < 0.62 ? u / 0.62 : -1; | |
| if (a >= 0) s.y += clamp(g.h * 0.8, 0.5, 2.2) * i.scale * 4 * a * (1 - a); | |
| } | |
| if (a < 0) { g.body.scale.y *= 0.9; return; } | |
| const k = sin(a * PI); | |
| if (g.kind === 'quad') { | |
| g.legs[0].rotation.x -= k * 0.9; g.legs[1].rotation.x -= k * 0.9; | |
| g.legs[2].rotation.x += k * 0.9; g.legs[3].rotation.x += k * 0.9; | |
| g.body.rotation.x += (a - 0.5) * 0.5; | |
| } else if (g.kind === 'biped' || g.kind === 'bird') { | |
| g.legs[0].rotation.x -= k * 0.7; g.legs[1].rotation.x += k * 0.5; | |
| if (g.arms) { g.arms[0].rotation.z += k * 2.4; g.arms[1].rotation.z -= k * 2.4; } | |
| flap(g, T, 18, 0.7); | |
| } else { | |
| g.body.scale.y *= 1 + k * 0.08; | |
| } | |
| }, | |
| spin(i, g, T, s) { s.yaw += T * 2.6; POSE.idle(i, g, T, s); }, | |
| dance(i, g, T, s) { | |
| const b = (s.beat ?? T * 1.5) * 2 * PI; // one bounce per beat | |
| g.body.position.y += abs(sin(b / 2)) * 0.1 * g.h; | |
| g.body.rotation.z += sin(b / 2) * 0.12; | |
| s.yaw += sin(b / 4) * 0.55; | |
| if (g.arms) { | |
| g.arms[0].rotation.z += 2.3 + sin(b) * 0.5; | |
| g.arms[1].rotation.z -= 2.3 + sin(b + PI) * 0.5; | |
| } | |
| if (g.kind === 'quad') { | |
| g.legs[0].rotation.x -= max(0, sin(b / 2)) * 0.9; | |
| g.legs[1].rotation.x -= max(0, -sin(b / 2)) * 0.9; | |
| } else if (g.legs) { | |
| g.legs[0].rotation.x -= max(0, sin(b / 2)) * 0.5; | |
| g.legs[1].rotation.x -= max(0, -sin(b / 2)) * 0.5; | |
| } | |
| if (g.head && g.kind !== 'prop') g.head.rotation.z += sin(b / 2 + 1) * 0.16; | |
| if (g.tail && g.kind !== 'fish') g.tail.rotation.z += sin(b) * 0.4; | |
| flap(g, T, 9, 0.6); | |
| }, | |
| fly(i, g, T, s) { | |
| const winged = flap(g, T, g.kind === 'bird' ? 16 : 6, g.kind === 'bird' ? 0.75 : 0.5); | |
| if (g.kind === 'quad' && !winged) { | |
| g.legs[0].rotation.x -= 1.2; g.legs[1].rotation.x -= 1.2; g.legs[2].rotation.x += 1.2; g.legs[3].rotation.x += 1.2; | |
| } else if (g.kind === 'quad') { | |
| for (const l of g.legs) l.rotation.x += 0.5; | |
| } else if (g.kind === 'biped' && g.arms) { | |
| g.body.rotation.x += 1.2; | |
| g.body.position.y += g.leg * 0.2; | |
| g.arms[0].rotation.x += PI - 0.2; g.arms[1].rotation.x += 0.4; | |
| g.legs[0].rotation.x += sin(T * 2) * 0.1; | |
| } else if (g.kind === 'bird') { | |
| for (const l of g.legs) l.rotation.x += 1.2; | |
| } | |
| if (g.flame) { g.flame.visible = true; g.flame.scale.y = 1 + sin(T * 40) * 0.2; } | |
| if (g.tail && g.kind !== 'fish') g.tail.rotation.z += sin(T * 4) * 0.15; | |
| }, | |
| float(i, g, T, s) { | |
| s.y += 0.5 + 0.35 * g.h * i.scale + sin(T * 1.3) * 0.22; | |
| s.yaw += T * 0.35; | |
| s.roll += sin(T * 0.8) * 0.12; | |
| s.pitch += sin(T * 0.6 + 1) * 0.1; | |
| if (g.arms) { g.arms[0].rotation.z += 0.6 + sin(T) * 0.2; g.arms[1].rotation.z -= 0.6 + sin(T + 1) * 0.2; } | |
| if (g.legs) g.legs.forEach((l, k) => { l.rotation.x += sin(T * 1.1 + k) * 0.2; }); | |
| flap(g, T, 3, 0.2); | |
| }, | |
| sit(i, g, T, s) { | |
| if (g.kind === 'quad') { | |
| const phi = clamp(Math.asin(clamp((g.leg - 0.3 * g.bodyH) / (2 * g.hipZ), 0.1, 0.65)), 0.15, 0.7); | |
| g.body.rotation.x -= phi; | |
| g.body.position.y -= g.leg * cos(phi) - g.hipZ * sin(phi) - g.bodyH * 0.3; | |
| g.legs[0].rotation.x += phi; g.legs[1].rotation.x += phi; | |
| g.legs[2].rotation.x += phi - PI / 2; g.legs[3].rotation.x += phi - PI / 2; | |
| if (g.head) g.head.rotation.x += phi * 0.7; | |
| if (g.tail) g.tail.rotation.z += sin(T * 4) * 0.25; | |
| } else if (g.kind === 'biped') { | |
| g.legs[0].rotation.x -= PI / 2; g.legs[1].rotation.x -= PI / 2; | |
| g.body.position.y -= g.leg - 0.12; | |
| if (g.arms) { g.arms[0].rotation.x -= 0.5; g.arms[1].rotation.x -= 0.5; } | |
| if (g.head) g.head.rotation.y += sin(T * 0.7) * 0.3; | |
| } else if (g.kind === 'bird') { | |
| for (const l of g.legs) l.rotation.x -= PI / 2; | |
| g.body.position.y -= g.leg * 0.9; | |
| } else { | |
| g.body.scale.y *= 0.93; | |
| } | |
| }, | |
| sleep(i, g, T, s) { | |
| const br = 1 + sin(T * 1.6) * 0.025; | |
| if (g.kind === 'quad') { | |
| g.body.position.y -= g.leg * 0.9; | |
| for (const l of g.legs) l.rotation.x -= PI / 2; | |
| if (g.head) { g.head.rotation.x += 0.6; g.head.rotation.z += 0.3; } | |
| g.body.scale.y *= br; | |
| } else if (g.kind === 'biped') { | |
| g.body.rotation.x -= PI / 2; | |
| g.body.position.y += 0.18; | |
| g.body.position.z += g.h * 0.5; | |
| g.body.scale.z *= br; | |
| } else if (g.kind === 'bird') { | |
| for (const l of g.legs) l.rotation.x -= PI / 2; | |
| g.body.position.y -= g.leg * 0.9; | |
| if (g.head) g.head.rotation.x += 0.5; | |
| } else { | |
| s.roll += g.kind === 'prop' || g.kind === 'vehicle' ? 0.06 : 0.25; | |
| g.body.scale.y *= br; | |
| } | |
| i.zzz = true; | |
| }, | |
| wave(i, g, T, s) { | |
| const w = sin(T * 8) * 0.35; | |
| if (g.arms) g.arms[1].rotation.z -= 2.5 + w; | |
| else if (g.kind === 'quad') { g.legs[1].rotation.x -= 1.5 + w; g.body.rotation.x -= 0.06; } | |
| else if (g.wings) g.wings[1].rotation.z -= 1.0 + w * 2; | |
| else g.body.rotation.z += sin(T * 5) * 0.16; | |
| if (g.head && g.kind !== 'prop') g.head.rotation.z += 0.12; | |
| if (g.tail && g.kind !== 'fish') g.tail.rotation.z += sin(T * 6) * 0.3; | |
| }, | |
| bounce(i, g, T, s) { | |
| const H = clamp(g.h * 0.7, 0.5, 1.8) * i.scale, k = abs(sin((s.beat ?? T * 1.3) * PI)); | |
| s.y += H * k; | |
| const sq = max(0, 1 - k * 6) * 0.22; | |
| g.body.scale.y *= 1 - sq; | |
| g.body.scale.x *= 1 + sq * 0.6; | |
| g.body.scale.z *= 1 + sq * 0.6; | |
| }, | |
| shake(i, g, T, s) { | |
| g.body.rotation.z += sin(T * 41) * 0.06; | |
| g.body.position.x += sin(T * 53) * 0.03 * g.h; | |
| if (g.head && g.kind !== 'prop') g.head.rotation.y += sin(T * 37) * 0.1; | |
| if (g.arms) { g.arms[0].rotation.z += 0.3 + sin(T * 45) * 0.1; g.arms[1].rotation.z -= 0.3 + sin(T * 47) * 0.1; } | |
| }, | |
| }; | |
| POSE.walk = POSE.run = POSE.drive = POSE.circle = POSE.move; | |
| function ridePose(i, g, T) { | |
| if (g.kind === 'biped') { | |
| g.legs[0].rotation.z += 0.5; g.legs[1].rotation.z -= 0.5; | |
| g.legs[0].rotation.x -= 0.5; g.legs[1].rotation.x -= 0.5; | |
| if (g.arms) { g.arms[0].rotation.x -= 0.7; g.arms[1].rotation.x -= 0.7; } | |
| return -g.leg * 0.7; | |
| } | |
| if (g.kind === 'quad') { POSE.sit(i, g, T, {}); return 0; } | |
| if (g.kind === 'bird') { for (const l of g.legs) l.rotation.x -= PI / 2; return -g.leg * 0.9; } | |
| return 0; | |
| } | |
| // ------------------------------------------------------------------ per-frame update | |
| const _s = {}; | |
| export function updateInstance(inst, t, ctx = {}) { | |
| const g = inst.rig, o = inst.obj; | |
| for (const p of g.all) { | |
| const r = p.userData.rest; | |
| p.position.copy(r.p); p.rotation.copy(r.r); p.scale.copy(r.s); | |
| } | |
| if (g.flame) g.flame.visible = false; | |
| const T = t * inst.spdMul + inst.phase, act = inst.act; | |
| const s = _s; | |
| s.x = inst.base.x; s.y = inst.base.y; s.z = inst.base.z; | |
| s.yaw = inst.yaw0; s.roll = 0; s.pitch = 0; s.dist = 0; s.air = null; s.water = false; | |
| // musical time: dancing, bouncing and jumping lock to it; 'slow' is half time and 'fast' double time | |
| s.beat = ctx.beat == null ? null : ctx.beat * (inst.spdMul < 1 ? 0.5 : inst.spdMul > 1 ? 2 : 1); | |
| if (s.beat == null) s.beat = undefined; | |
| inst.zzz = false; | |
| if (inst.mount) { | |
| s.x = inst.seat[0]; s.y = inst.seat[1]; s.z = inst.seat[2]; s.yaw = 0; | |
| if (inst.mode === 'ride') { | |
| s.y += ridePose(inst, g, T) * (inst.scale / inst.mount.scale); | |
| if (act === 'wave' || act === 'dance' || act === 'shake') POSE[act](inst, g, T, {}); | |
| } else { | |
| const loco = { walk: 1, run: 1, drive: 1, circle: 1, swim: 1, roll: 0 }[act]; | |
| if (loco) { s.dist = speedOf(inst, act) * T; POSE.move(inst, g, T, s, act); } | |
| else if (act === 'fly') { POSE.fly(inst, g, T, s); s.y += (0.4 + sin(T * 1.5) * 0.1) / inst.mount.scale; } | |
| else if (act !== 'roll') { | |
| const y0 = s.y; | |
| (POSE[act] ?? POSE.idle)(inst, g, T, s, act); | |
| s.y = y0 + (s.y - y0) / inst.mount.scale; | |
| } | |
| } | |
| } else { | |
| path(inst, T, s); | |
| if (ctx.waterY != null && (g.swims || act === 'swim')) { | |
| const sink = g.floats ? 0.1 : g.kind === 'fish' ? (g.hover + 0.05) * inst.scale | |
| : g.kind === 'bird' ? (g.leg + 0.04) * inst.scale : g.h * inst.scale * 0.55; | |
| if (act !== 'fly' && act !== 'jump' && act !== 'bounce' && act !== 'float') { | |
| s.y = ctx.waterY - sink + sin(T * 1.5) * 0.05; | |
| s.water = true; | |
| s.roll += g.floats ? sin(T * 1.1) * 0.05 : 0; | |
| } | |
| } | |
| (POSE[act] ?? POSE.idle)(inst, g, T, s, act); | |
| if (inst.motion.kind !== 'none' && act !== 'idle' && !POSE[act]) POSE.move(inst, g, T, s, 'walk'); | |
| } | |
| if (g.spinners) { | |
| const on = act === 'fly' || act === 'drive' || LOCO.has(act) || inst.motion.kind !== 'none'; | |
| for (const sp of g.spinners) if (on || sp.userData.always) sp.rotation[sp.userData.axis] += T * (sp.userData.always && !on ? 2 : 24); | |
| } | |
| if (inst.shift && !inst.mount) { s.x += inst.shift.x; s.z += inst.shift.z; } // live drag preview | |
| o.position.set(s.x, s.y, s.z); | |
| o.rotation.set(s.pitch, s.yaw, s.roll); | |
| if (inst.sprites) updateZzz(inst, T); | |
| } | |
| // ------------------------------------------------------------------ sleeping "z z z" | |
| let zTex = null; | |
| function zTexture() { | |
| if (zTex || typeof document === 'undefined') return zTex; | |
| const c = document.createElement('canvas'); | |
| c.width = c.height = 64; | |
| const x = c.getContext('2d'); | |
| x.font = 'bold 54px sans-serif'; | |
| x.textAlign = 'center'; | |
| x.textBaseline = 'middle'; | |
| x.lineWidth = 6; | |
| x.strokeStyle = '#1c2540'; | |
| x.strokeText('z', 32, 30); | |
| x.fillStyle = '#ffffff'; | |
| x.fillText('z', 32, 30); | |
| zTex = new THREE.CanvasTexture(c); | |
| return zTex; | |
| } | |
| export function addZzz(inst) { | |
| const tex = zTexture(); | |
| if (!tex) return; | |
| inst.sprites = [0, 1, 2].map(() => { | |
| const sp = new THREE.Sprite(new THREE.SpriteMaterial({ map: tex, transparent: true, depthWrite: false })); | |
| inst.obj.add(sp); | |
| return sp; | |
| }); | |
| } | |
| function updateZzz(inst, T) { | |
| const g = inst.rig; | |
| inst.sprites.forEach((sp, k) => { | |
| const u = (T * 0.35 + k / 3) % 1; | |
| sp.visible = inst.zzz; | |
| const m = clamp(g.h, 0.6, 2), y0 = g.kind === 'biped' ? 0.45 : g.h * 0.45; | |
| sp.position.set(0.15 + u * 0.3 * m + sin(u * 6) * 0.06, y0 + u * (0.5 + 0.35 * m), g.kind === 'biped' ? -g.h * 0.2 : 0.25); | |
| sp.scale.setScalar((0.1 + u * 0.16) * m); | |
| sp.material.opacity = sin(u * PI); | |
| }); | |
| } | |