Initial commit
This commit is contained in:
ryanfitzpatrickio
@@ -0,0 +1,693 @@
|
||||
import * as THREE from 'three';
|
||||
import { mergeGeoms } from '../core/math.js';
|
||||
import { PART } from './body.js';
|
||||
import { computeSkin } from './skinning.js';
|
||||
import { carvedShell, loft, mergeBars, tint, tube } from './gearMesh.js';
|
||||
|
||||
/**
|
||||
* Skater equipment, in layers.
|
||||
*
|
||||
* A hockey player is dressed, not painted, and the order is the order it goes
|
||||
* on in a dressing room:
|
||||
*
|
||||
* 1. shoulder pads and elbow caps — the under layer that gives the torso its
|
||||
* shape. Mostly hidden, which is the point: the jersey drapes over it.
|
||||
* 2. jersey — long sleeves, hem past the waist, cut wide enough to clear the
|
||||
* pads underneath.
|
||||
* 3. pants — waist-high padded shorts down to just above the knee.
|
||||
* 4. socks over shin guards, taped at the top and bottom of the wrap.
|
||||
* 5. skates, gloves, helmet.
|
||||
*
|
||||
* ### Skinned vs socketed
|
||||
*
|
||||
* Anything that crosses a joint is skinned to the same skeleton the body uses
|
||||
* (`computeSkin`, then bound as a second SkinnedMesh sharing `skelData`). A
|
||||
* jersey bolted to the chest bone tears open at the shoulder the first time an
|
||||
* arm swings; a pant leg bolted to the pelvis passes through the thigh on a
|
||||
* knee bend. Cloth is authored in rest space, exactly like the body geometry.
|
||||
*
|
||||
* Boots, gloves and the helmet are rigid shells that genuinely do not bend, so
|
||||
* they are socketed to the foot, hand and head bones and cost nothing to skin.
|
||||
*
|
||||
* ### Fit
|
||||
*
|
||||
* Every radius scales off the physique factors the body loft was built from
|
||||
* (`bodyGeo.userData.physique`), so a heavy build gets a bigger jersey instead
|
||||
* of wearing its chest through the front of it.
|
||||
*/
|
||||
|
||||
/** Rest direction the upper arm points, in its own bone space (A-pose). */
|
||||
const ARM_DIR = {
|
||||
L: new THREE.Vector3(0.15, -0.252, 0.01).normalize(),
|
||||
R: new THREE.Vector3(-0.15, -0.252, 0.01).normalize(),
|
||||
};
|
||||
/** Rest direction the fingers point, from the hand bone. */
|
||||
const HAND_DIR = {
|
||||
L: new THREE.Vector3(0.045, -0.095, 0.008).normalize(),
|
||||
R: new THREE.Vector3(-0.045, -0.095, 0.008).normalize(),
|
||||
};
|
||||
const DOWN = new THREE.Vector3(0, -1, 0);
|
||||
|
||||
export const KIT = {
|
||||
helmet: {
|
||||
/** Skull centre in head-bone-local space. */
|
||||
riseY: 0.094,
|
||||
pushZ: -0.004,
|
||||
rx: 0.114,
|
||||
ry: 0.148,
|
||||
rz: 0.125,
|
||||
/**
|
||||
* Polar angle the shell starts at. This is the number that decides whether
|
||||
* you get a helmet or a beanie: the bottom ring sits at
|
||||
* riseY − ry·cos(phi0), so it has to come out *below* the ear line.
|
||||
*/
|
||||
phi0: 0.36,
|
||||
wall: 0.009,
|
||||
/** Brow line: everything in front of and below this is open face. */
|
||||
browY: 0.03,
|
||||
earY: -0.022,
|
||||
},
|
||||
/** Blade bottom, in foot-bone-local metres. Feet plant at y ≈ 0.09. */
|
||||
bladeY: -0.09,
|
||||
};
|
||||
|
||||
/**
|
||||
* What the kit covers, as `aT` ranges per body part.
|
||||
*
|
||||
* The body underneath a dressed skater is wasted work and a source of
|
||||
* poke-through: a shoulder rolls, a hip flexes, and a sliver of the layer below
|
||||
* pushes through a seam. Ludus solved it by dropping the covered body faces
|
||||
* once the clothing went on, and the same applies here.
|
||||
*
|
||||
* Ranges are deliberately short of the seams. A triangle is only dropped when
|
||||
* *all three* of its vertices are covered, which leaves a one-triangle fringe
|
||||
* under every edge of the gear — cheap insurance against a gap opening up at
|
||||
* the collar or the cuff when the pose moves.
|
||||
*/
|
||||
export const COVERAGE = {
|
||||
// Jersey and pants, up to the collar. The neck and above stay.
|
||||
[PART.TORSO]: [0.0, 0.9],
|
||||
// Sleeve and glove, deltoid to fingertips. The shoulder ball has to be in
|
||||
// here: it is the widest thing on the arm and it sits exactly where the
|
||||
// sleeve meets the yoke, so leaving it visible shows it through the seam.
|
||||
[PART.ARM_L]: [0.0, 1.0],
|
||||
[PART.ARM_R]: [0.0, 1.0],
|
||||
// Pants, socks and boots enclose the leg end to end.
|
||||
[PART.LEG_L]: [0.0, 1.0],
|
||||
[PART.LEG_R]: [0.0, 1.0],
|
||||
};
|
||||
|
||||
/**
|
||||
* Drop the body faces the kit covers. Call after `computeSkin` and after the
|
||||
* body has been painted — it only rewrites the index.
|
||||
*/
|
||||
export function hideCoveredBody(geo, coverage = COVERAGE) {
|
||||
const partAttr = geo.attributes.aPart;
|
||||
const tAttr = geo.attributes.aT;
|
||||
if (!partAttr || !tAttr || !geo.index) return geo;
|
||||
|
||||
const covered = (v) => {
|
||||
const range = coverage[partAttr.getX(v)];
|
||||
if (!range) return false;
|
||||
const t = tAttr.getX(v);
|
||||
return t >= range[0] && t <= range[1];
|
||||
};
|
||||
|
||||
const idx = geo.index.array;
|
||||
const keep = [];
|
||||
for (let f = 0; f < idx.length; f += 3) {
|
||||
const a = idx[f];
|
||||
const b = idx[f + 1];
|
||||
const c = idx[f + 2];
|
||||
if (covered(a) && covered(b) && covered(c)) continue;
|
||||
keep.push(a, b, c);
|
||||
}
|
||||
geo.setIndex(keep);
|
||||
return geo;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {*} mats from `buildSkaterGearMaterials`
|
||||
* @param {*} skelData the skeleton the cloth binds to
|
||||
* @param {{bulk:number,waistF:number,shoulderF:number,armF:number,legF:number,headF:number}} phys
|
||||
*/
|
||||
export function buildSkaterGear(mats, skelData, phys) {
|
||||
const pieces = [];
|
||||
const skinned = [];
|
||||
const disposables = [];
|
||||
|
||||
const bulk = phys?.bulk ?? 1;
|
||||
const shoulder = (phys?.shoulderF ?? 1) * bulk;
|
||||
const waist = (phys?.waistF ?? 1) * bulk;
|
||||
const armF = phys?.armF ?? 1;
|
||||
const legF = phys?.legF ?? 1;
|
||||
const headF = phys?.headF ?? 1;
|
||||
|
||||
const PAL = {
|
||||
jersey: tint(mats.jersey.color),
|
||||
accent: tint(mats.accent.color),
|
||||
trim: tint(mats.trim.color),
|
||||
pad: tint(mats.pad.color),
|
||||
tape: tint(mats.tape.color),
|
||||
};
|
||||
|
||||
const V = (x, y, z = 0) => new THREE.Vector3(x, y, z);
|
||||
const S = (c, rx, rz, e, col) => ({ c, rx, rz, e, col });
|
||||
|
||||
function mesh(geo, mat, name) {
|
||||
const m = new THREE.Mesh(geo, mat);
|
||||
m.name = name;
|
||||
m.castShadow = true;
|
||||
m.receiveShadow = true;
|
||||
disposables.push(geo);
|
||||
return m;
|
||||
}
|
||||
|
||||
/** Point a group's −Y down a bone's real limb direction. */
|
||||
function alignTo(group, dir) {
|
||||
group.quaternion.setFromUnitVectors(DOWN, dir);
|
||||
return group;
|
||||
}
|
||||
|
||||
/**
|
||||
* Merge rest-space pieces, solve skin weights, and bind to the body's
|
||||
* skeleton. `computeSkin` overwrites the colour attribute with its debug
|
||||
* heatmap, so the kit colours are stashed and put back afterwards — same
|
||||
* dance `paintKit` does for the body.
|
||||
*/
|
||||
function skin(parts, mat, name) {
|
||||
const geo = mergeGeoms(parts);
|
||||
for (const p of parts) p.dispose();
|
||||
const colors = geo.attributes.color.array.slice();
|
||||
computeSkin(geo, skelData);
|
||||
geo.userData.heatColors = geo.attributes.color.array.slice();
|
||||
geo.setAttribute('color', new THREE.BufferAttribute(colors, 3));
|
||||
geo.computeVertexNormals();
|
||||
|
||||
const m = new THREE.SkinnedMesh(geo, mat);
|
||||
m.name = name;
|
||||
m.castShadow = true;
|
||||
m.receiveShadow = true;
|
||||
m.frustumCulled = false;
|
||||
// Bound before parenting, so the bind matrix is identity — matching the
|
||||
// body mesh. The root bone stays parented to the body; a second mesh only
|
||||
// borrows the skeleton.
|
||||
m.updateMatrixWorld(true);
|
||||
m.bind(skelData.skeleton, m.matrixWorld.clone());
|
||||
disposables.push(geo);
|
||||
skinned.push(m);
|
||||
pieces.push(m);
|
||||
return m;
|
||||
}
|
||||
|
||||
// ---- 1. under layer: shoulder pads -------------------------------------
|
||||
// Sits between skin and jersey. Barely seen, but it is what makes the jersey
|
||||
// sit square across the shoulders instead of shrink-wrapping the deltoids.
|
||||
// Kept a clear centimetre inside the jersey at every ring. Two skinned
|
||||
// meshes never deform identically — their vertices sit in different places,
|
||||
// so the distance-field solve hands them different weights — and a pad that
|
||||
// merely *touches* the inside of a sweater will tear through it on a shoulder
|
||||
// roll. What actually shows is the collar, standing above the neckline.
|
||||
const padChest = loft([
|
||||
S(V(0, 1.18, 0.006), 0.156 * bulk, 0.108 * bulk, 4, PAL.pad),
|
||||
S(V(0, 1.26, 0.008), 0.17 * shoulder, 0.116 * bulk, 4),
|
||||
S(V(0, 1.335, 0.008), 0.186 * shoulder, 0.12 * bulk, 4),
|
||||
S(V(0, 1.392, 0.01), 0.16 * shoulder, 0.106 * bulk, 4),
|
||||
S(V(0, 1.428, 0.012), 0.1 * bulk, 0.09 * bulk, 3),
|
||||
S(V(0, 1.452, 0.013), 0.094 * bulk, 0.085 * bulk, 3),
|
||||
], { radial: 16, sub: 3, part: PART.TORSO, t0: 0.5, t1: 0.96 });
|
||||
skin([padChest], mats.padded, 'shoulderPads');
|
||||
|
||||
// Deltoid caps ride the upper arms so they follow the shoulder, not the ribs.
|
||||
function makeCap(side) {
|
||||
const g = new THREE.Group();
|
||||
g.name = `shoulderCap${side}`;
|
||||
// Kept under the sleeve radius at every ring: the cap is rigid on the bone
|
||||
// and the sleeve is skinned, so anything close to the same size pushes
|
||||
// through the cloth the moment the arm swings.
|
||||
const cap = loft([
|
||||
S(V(0, 0.04, 0.008), 0.062 * armF, 0.058 * armF, 3, PAL.pad),
|
||||
S(V(0, -0.025, 0.01), 0.074 * armF, 0.07 * armF, 4),
|
||||
S(V(0, -0.09, 0.008), 0.068 * armF, 0.064 * armF, 4),
|
||||
S(V(0, -0.14, 0.006), 0.054 * armF, 0.05 * armF, 3),
|
||||
], { radial: 14, sub: 3 });
|
||||
g.add(mesh(cap, mats.padded, `shoulderCap${side}Shell`));
|
||||
alignTo(g, ARM_DIR[side]);
|
||||
pieces.push(g);
|
||||
return g;
|
||||
}
|
||||
const capL = makeCap('L');
|
||||
const capR = makeCap('R');
|
||||
|
||||
// ---- 2. jersey ----------------------------------------------------------
|
||||
// Torso plus two long sleeves, merged into one skinned mesh. Waist stripes
|
||||
// and cuff bands are cut the same way the goalie's pad bands are: two
|
||||
// sections a centimetre apart.
|
||||
const jerseyParts = [];
|
||||
jerseyParts.push(loft([
|
||||
// Hem hangs over the pants, so it has to clear the widest part of them.
|
||||
S(V(0, 0.878, 0.004), 0.226 * bulk, 0.17 * bulk, 4, PAL.jersey),
|
||||
S(V(0, 0.905, 0.004), 0.232 * bulk, 0.174 * bulk, 4, PAL.accent),
|
||||
S(V(0, 0.94, 0.004), 0.233 * bulk, 0.175 * bulk, 4),
|
||||
S(V(0, 0.95, 0.004), 0.232 * bulk, 0.174 * bulk, 4, PAL.trim),
|
||||
S(V(0, 0.98, 0.005), 0.229 * bulk, 0.171 * bulk, 4),
|
||||
S(V(0, 0.99, 0.005), 0.228 * bulk, 0.17 * bulk, 4, PAL.jersey),
|
||||
S(V(0, 1.075, 0.005), 0.207 * waist, 0.152 * waist, 4),
|
||||
S(V(0, 1.165, 0.007), 0.202 * bulk, 0.148 * bulk, 4),
|
||||
S(V(0, 1.255, 0.009), 0.212 * bulk, 0.155 * bulk, 4),
|
||||
// Over the shoulder pads — the widest point of a dressed player.
|
||||
S(V(0, 1.335, 0.01), 0.242 * shoulder, 0.16 * bulk, 5),
|
||||
S(V(0, 1.395, 0.012), 0.222 * shoulder, 0.142 * bulk, 4),
|
||||
S(V(0, 1.418, 0.013), 0.17 * shoulder, 0.12 * bulk, 4),
|
||||
S(V(0, 1.432, 0.013), 0.108 * bulk, 0.098 * bulk, 3, PAL.trim),
|
||||
S(V(0, 1.462, 0.014), 0.098 * bulk, 0.09 * bulk, 3),
|
||||
], { radial: 20, sub: 3, part: PART.TORSO, t0: 0.0, t1: 0.98 }));
|
||||
|
||||
for (const side of ['L', 'R']) {
|
||||
const s = side === 'L' ? 1 : -1;
|
||||
const P = (x, y, z = 0) => V(s * x, y, z);
|
||||
jerseyParts.push(loft([
|
||||
// Wide enough at the top to swallow the deltoid ball, and buried in the
|
||||
// torso shell so the shoulder seam never opens.
|
||||
S(P(0.10, 1.415, 0.008), 0.108 * armF, 0.10 * armF, 3, PAL.jersey),
|
||||
S(P(0.175, 1.385, 0.01), 0.118 * armF, 0.112 * armF, 3),
|
||||
S(P(0.245, 1.325, 0.01), 0.105 * armF, 0.10 * armF, 3),
|
||||
S(P(0.30, 1.27, 0.01), 0.09 * armF, 0.086 * armF, 3),
|
||||
S(P(0.355, 1.16, 0.012), 0.072 * armF, 0.068 * armF, 3),
|
||||
// Elbow cap under the sleeve.
|
||||
S(P(0.397, 1.095, 0.013), 0.076 * armF, 0.072 * armF, 3),
|
||||
S(P(0.447, 0.985, 0.016), 0.064 * armF, 0.06 * armF, 3),
|
||||
S(P(0.472, 0.93, 0.018), 0.058 * armF, 0.055 * armF, 3, PAL.accent),
|
||||
S(P(0.487, 0.898, 0.02), 0.057 * armF, 0.054 * armF, 3),
|
||||
S(P(0.497, 0.876, 0.022), 0.056 * armF, 0.053 * armF, 3, PAL.trim),
|
||||
S(P(0.512, 0.844, 0.024), 0.053 * armF, 0.05 * armF, 3),
|
||||
], {
|
||||
radial: 14,
|
||||
sub: 3,
|
||||
part: side === 'L' ? PART.ARM_L : PART.ARM_R,
|
||||
t0: 0.1,
|
||||
t1: 0.94,
|
||||
}));
|
||||
}
|
||||
skin(jerseyParts, mats.cloth, 'jersey');
|
||||
|
||||
// ---- 3. pants -----------------------------------------------------------
|
||||
// Waist-high padded shorts: a hip shell plus two thigh tubes that stop above
|
||||
// the knee. Stiff, so they are wide and barely taper.
|
||||
const pantParts = [];
|
||||
pantParts.push(loft([
|
||||
S(V(0, 1.115, 0.004), 0.178 * waist, 0.132 * waist, 4, PAL.trim),
|
||||
S(V(0, 1.09, 0.004), 0.186 * waist, 0.138 * waist, 4),
|
||||
S(V(0, 1.08, 0.004), 0.19 * waist, 0.142 * waist, 4, PAL.accent),
|
||||
S(V(0, 1.055, 0.005), 0.196 * waist, 0.146 * waist, 4),
|
||||
S(V(0, 1.045, 0.005), 0.198 * waist, 0.148 * waist, 4, PAL.trim),
|
||||
S(V(0, 0.99, 0.005), 0.205 * bulk, 0.152 * bulk, 5),
|
||||
S(V(0, 0.94, 0.005), 0.207 * bulk, 0.154 * bulk, 5),
|
||||
S(V(0, 0.90, 0.004), 0.198 * bulk, 0.146 * bulk, 5),
|
||||
], { radial: 18, sub: 3, part: PART.TORSO, t0: 0.02, t1: 0.34 }));
|
||||
|
||||
for (const side of ['L', 'R']) {
|
||||
const s = side === 'L' ? 1 : -1;
|
||||
const P = (x, y, z = 0) => V(s * x, y, z);
|
||||
pantParts.push(loft([
|
||||
S(P(0.098, 0.97, 0.004), 0.142 * legF, 0.132 * legF, 4, PAL.trim),
|
||||
S(P(0.112, 0.90, 0.006), 0.138 * legF, 0.13 * legF, 4),
|
||||
S(P(0.12, 0.80, 0.008), 0.13 * legF, 0.122 * legF, 4),
|
||||
S(P(0.126, 0.71, 0.008), 0.122 * legF, 0.114 * legF, 4),
|
||||
S(P(0.127, 0.688, 0.008), 0.119 * legF, 0.111 * legF, 4, PAL.accent),
|
||||
S(P(0.128, 0.668, 0.008), 0.116 * legF, 0.108 * legF, 4),
|
||||
S(P(0.1285, 0.658, 0.008), 0.114 * legF, 0.106 * legF, 4, PAL.trim),
|
||||
S(P(0.129, 0.645, 0.008), 0.112 * legF, 0.104 * legF, 4),
|
||||
], {
|
||||
radial: 14,
|
||||
sub: 3,
|
||||
part: side === 'L' ? PART.LEG_L : PART.LEG_R,
|
||||
t0: 0.02,
|
||||
t1: 0.34,
|
||||
}));
|
||||
}
|
||||
skin(pantParts, mats.padded, 'pants');
|
||||
|
||||
// ---- 4. socks over shin guards -----------------------------------------
|
||||
// The sock is the visible layer; the guard underneath is read as the bulge at
|
||||
// the knee and the flat down the front of the shin. Tape bands at the top and
|
||||
// bottom of the wrap, where a player actually tapes.
|
||||
const sockParts = [];
|
||||
for (const side of ['L', 'R']) {
|
||||
const s = side === 'L' ? 1 : -1;
|
||||
const part = side === 'L' ? PART.LEG_L : PART.LEG_R;
|
||||
const P = (x, y, z = 0) => V(s * x, y, z);
|
||||
sockParts.push(loft([
|
||||
S(P(0.124, 0.735, 0.008), 0.098 * legF, 0.094 * legF, 3, PAL.jersey),
|
||||
S(P(0.128, 0.66, 0.01), 0.094 * legF, 0.09 * legF, 3),
|
||||
// Tape at the top of the wrap.
|
||||
S(P(0.129, 0.638, 0.01), 0.093 * legF, 0.089 * legF, 3, PAL.tape),
|
||||
S(P(0.13, 0.60, 0.012), 0.092 * legF, 0.088 * legF, 3),
|
||||
S(P(0.13, 0.578, 0.012), 0.092 * legF, 0.088 * legF, 3, PAL.jersey),
|
||||
// Knee.
|
||||
S(P(0.131, 0.53, 0.016), 0.096 * legF, 0.094 * legF, 3),
|
||||
S(P(0.132, 0.45, 0.014), 0.086 * legF, 0.082 * legF, 3),
|
||||
S(P(0.133, 0.35, 0.01), 0.079 * legF, 0.074 * legF, 3),
|
||||
S(P(0.133, 0.26, 0.006), 0.072 * legF, 0.066 * legF, 3),
|
||||
// Tape at the bottom of the wrap.
|
||||
S(P(0.133, 0.232, 0.005), 0.07 * legF, 0.064 * legF, 3, PAL.tape),
|
||||
S(P(0.132, 0.20, 0.004), 0.068 * legF, 0.062 * legF, 3),
|
||||
S(P(0.132, 0.18, 0.003), 0.066 * legF, 0.06 * legF, 3, PAL.jersey),
|
||||
S(P(0.131, 0.135, 0.002), 0.06 * legF, 0.056 * legF, 3),
|
||||
S(P(0.131, 0.105, 0.004), 0.056 * legF, 0.052 * legF, 3, PAL.trim),
|
||||
], { radial: 14, sub: 3, part, t0: 0.30, t1: 0.87 }));
|
||||
|
||||
// Knee cap: a dome off the front of the wrap.
|
||||
sockParts.push(loft([
|
||||
S(P(0.131, 0.545, 0.02), 0.062 * legF, 0.058 * legF, 3, PAL.jersey),
|
||||
S(P(0.131, 0.542, 0.058), 0.07 * legF, 0.066 * legF, 3),
|
||||
S(P(0.131, 0.538, 0.088), 0.058 * legF, 0.054 * legF, 3),
|
||||
S(P(0.131, 0.534, 0.104), 0.03 * legF, 0.028 * legF, 3),
|
||||
], { radial: 14, sub: 3, part, t0: 0.48, t1: 0.54 }));
|
||||
}
|
||||
skin(sockParts, mats.cloth, 'socks');
|
||||
|
||||
// ---- 5. skates ----------------------------------------------------------
|
||||
// Foot-bone local: +Z is forward past the toe, the sole sits a little under
|
||||
// the bone, the blade hangs where the ice is.
|
||||
function makeSkate(side) {
|
||||
const g = new THREE.Group();
|
||||
g.name = `skate${side}`;
|
||||
|
||||
const boot = loft([
|
||||
S(V(0, -0.014, -0.088), 0.036, 0.042, 4, PAL.trim),
|
||||
S(V(0, -0.02, -0.05), 0.046, 0.05, 4),
|
||||
S(V(0, -0.026, 0.01), 0.05, 0.048, 4),
|
||||
S(V(0, -0.03, 0.07), 0.048, 0.042, 4),
|
||||
S(V(0, -0.034, 0.125), 0.04, 0.032, 4),
|
||||
S(V(0, -0.038, 0.162), 0.022, 0.018, 3),
|
||||
], { radial: 16, sub: 4 });
|
||||
g.add(mesh(boot, mats.hard, `skate${side}Boot`));
|
||||
|
||||
// Ankle cuff — the kit stops at the ankle, as asked.
|
||||
const cuff = loft([
|
||||
S(V(0, -0.012, -0.05), 0.048, 0.05, 4, PAL.trim),
|
||||
S(V(0, 0.03, -0.045), 0.05, 0.048, 4),
|
||||
S(V(0, 0.062, -0.038), 0.047, 0.044, 4, PAL.pad),
|
||||
S(V(0, 0.078, -0.032), 0.041, 0.038, 3),
|
||||
], { radial: 14, sub: 3 });
|
||||
g.add(mesh(cuff, mats.hard, `skate${side}Cuff`));
|
||||
|
||||
// Tongue up the front of the ankle.
|
||||
const tongue = loft([
|
||||
S(V(0, -0.01, 0.03), 0.03, 0.014, 3, PAL.trim),
|
||||
S(V(0, 0.03, 0.012), 0.033, 0.015, 3),
|
||||
S(V(0, 0.07, 0.0), 0.031, 0.014, 3, PAL.accent),
|
||||
], { radial: 10, sub: 3 });
|
||||
g.add(mesh(tongue, mats.hard, `skate${side}Tongue`));
|
||||
|
||||
// Holder: two posts off the sole down to the runner.
|
||||
const holder = [];
|
||||
for (const z of [-0.045, 0.085]) {
|
||||
holder.push(tube([
|
||||
V(0, -0.05, z),
|
||||
V(0, -0.062, z + (z < 0 ? 0.008 : -0.008)),
|
||||
V(0, -0.072, z + (z < 0 ? 0.012 : -0.012)),
|
||||
], 0.011, { radial: 6 }));
|
||||
}
|
||||
holder.push(tube([
|
||||
V(0, -0.073, -0.075), V(0, -0.076, 0), V(0, -0.073, 0.13),
|
||||
], 0.008, { radial: 6 }));
|
||||
g.add(mesh(mergeBars(holder), mats.holder, `skate${side}Holder`));
|
||||
|
||||
// Runner: a thin steel blade with the toe and heel curling up off the ice.
|
||||
const blade = loft([
|
||||
S(V(0, KIT.bladeY + 0.028, -0.108), 0.0035, 0.012, 3, PAL.trim),
|
||||
S(V(0, KIT.bladeY + 0.012, -0.088), 0.0035, 0.013, 3),
|
||||
S(V(0, KIT.bladeY + 0.012, 0.12), 0.0035, 0.013, 3),
|
||||
S(V(0, KIT.bladeY + 0.03, 0.145), 0.0035, 0.012, 3),
|
||||
], { radial: 6, sub: 4 });
|
||||
g.add(mesh(blade, mats.steel, `skate${side}Blade`));
|
||||
|
||||
// Laces.
|
||||
const laces = [];
|
||||
for (const y of [0.0, 0.022, 0.044]) {
|
||||
laces.push(tube([
|
||||
V(-0.03, y - 0.005, 0.03 - y * 0.4),
|
||||
V(0, y + 0.004, 0.022 - y * 0.4),
|
||||
V(0.03, y - 0.005, 0.03 - y * 0.4),
|
||||
], 0.004, { radial: 5 }));
|
||||
}
|
||||
g.add(mesh(mergeBars(laces), mats.lace, `skate${side}Laces`));
|
||||
|
||||
pieces.push(g);
|
||||
return g;
|
||||
}
|
||||
const skateL = makeSkate('L');
|
||||
const skateR = makeSkate('R');
|
||||
|
||||
// ---- 6. gloves ----------------------------------------------------------
|
||||
// Glove space: fingers down −Y, back of the hand +Z, then rotated onto the
|
||||
// hand bone's real axis. The stick is aimed from the same bone, so the glove
|
||||
// has to stay a shell around the hand and not swallow the shaft.
|
||||
function makeGlove(side) {
|
||||
const s = side === 'L' ? 1 : -1;
|
||||
const g = new THREE.Group();
|
||||
g.name = `glove${side}`;
|
||||
|
||||
const body = loft([
|
||||
// Flared cuff roll at the wrist.
|
||||
S(V(0, 0.085, -0.004), 0.056, 0.054, 3, PAL.trim),
|
||||
S(V(0, 0.062, -0.002), 0.068, 0.064, 3, PAL.accent),
|
||||
S(V(0, 0.03, 0.002), 0.074, 0.068, 3),
|
||||
S(V(0, 0.012, 0.004), 0.076, 0.07, 3, PAL.jersey),
|
||||
S(V(0, -0.04, 0.01), 0.08, 0.068, 4),
|
||||
S(V(0, -0.105, 0.014), 0.082, 0.066, 4),
|
||||
S(V(0, -0.16, 0.014), 0.076, 0.06, 4),
|
||||
S(V(0, -0.19, 0.012), 0.062, 0.05, 4, PAL.trim),
|
||||
S(V(0, -0.215, 0.008), 0.042, 0.034, 3),
|
||||
], { radial: 16, sub: 4 });
|
||||
g.add(mesh(body, mats.hard, `glove${side}Body`));
|
||||
|
||||
// Backhand rolls — the padded ridges across the knuckles.
|
||||
for (const [y, r] of [[-0.06, 0.026], [-0.115, 0.024]]) {
|
||||
const roll = loft([
|
||||
S(V(-s * 0.058, y + 0.012, 0.05), r * 0.8, r * 0.7, 3, PAL.accent),
|
||||
S(V(0, y, 0.062), r, r * 0.9, 3),
|
||||
S(V(s * 0.058, y + 0.012, 0.05), r * 0.8, r * 0.7, 3),
|
||||
], { radial: 10, sub: 4 });
|
||||
g.add(mesh(roll, mats.hard, `glove${side}Roll`));
|
||||
}
|
||||
|
||||
// Thumb, curling toward the shaft.
|
||||
const thumb = loft([
|
||||
S(V(s * 0.058, -0.005, 0.03), 0.03, 0.028, 3, PAL.jersey),
|
||||
S(V(s * 0.09, -0.065, 0.052), 0.028, 0.026, 3),
|
||||
S(V(s * 0.092, -0.12, 0.066), 0.023, 0.022, 3, PAL.trim),
|
||||
], { radial: 10, sub: 4 });
|
||||
g.add(mesh(thumb, mats.hard, `glove${side}Thumb`));
|
||||
|
||||
alignTo(g, HAND_DIR[side]);
|
||||
g.rotateY(s * 0.25);
|
||||
pieces.push(g);
|
||||
return g;
|
||||
}
|
||||
const gloveL = makeGlove('L');
|
||||
const gloveR = makeGlove('R');
|
||||
|
||||
// ---- 7. helmet ----------------------------------------------------------
|
||||
// Same carved-shell builder as the goalie mask, cut differently: the whole
|
||||
// lower front is open face, with ear ports at the sides.
|
||||
const H = KIT.helmet;
|
||||
const skull = new THREE.Vector3(0, H.riseY, H.pushZ);
|
||||
|
||||
function helmetSurface(theta, v, out) {
|
||||
const phi = H.phi0 + (Math.PI - H.phi0) * v;
|
||||
const sp = Math.sin(phi);
|
||||
const cp = Math.cos(phi);
|
||||
const f = Math.cos(theta);
|
||||
const sx = Math.sin(theta);
|
||||
const front = Math.max(0, f);
|
||||
const back = Math.max(0, -f);
|
||||
|
||||
let rx = H.rx * headF;
|
||||
let rz = H.rz * headF;
|
||||
// Occipital shell carries out over the back of the skull.
|
||||
rz *= 1 + 0.10 * back * v;
|
||||
// Slight flat across the forehead.
|
||||
rz *= 1 - 0.06 * front * front * v;
|
||||
|
||||
const x = rx * sp * sx;
|
||||
const y = -H.ry * headF * cp;
|
||||
let z = rz * sp * f;
|
||||
// Brow lip juts forward over the eyes.
|
||||
const lip = Math.exp(-(((v - 0.08) / 0.12) ** 2)) * front ** 2;
|
||||
z += 0.008 * lip;
|
||||
|
||||
return out.set(skull.x + x, skull.y + y, skull.z + z);
|
||||
}
|
||||
|
||||
/** Open face below the brow, plus a port over each ear. */
|
||||
const helmetPort = (p) => {
|
||||
const dy = p.y - skull.y;
|
||||
const dz = p.z - skull.z;
|
||||
const ax = Math.abs(p.x);
|
||||
// The face: front-centre below the brow. Narrow, so the shell keeps its
|
||||
// cheek coverage instead of turning into a cap.
|
||||
if (dz > 0.028 && dy < H.browY && ax < 0.072) return true;
|
||||
// Ear ports, covered by the cups.
|
||||
if (ax > 0.088 && dy < H.earY + 0.026 && dy > H.earY - 0.042 && Math.abs(dz + 0.014) < 0.038) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
};
|
||||
|
||||
const helmetColor = (p, kind) => {
|
||||
if (kind === 'inner') return PAL.pad;
|
||||
const dy = p.y - skull.y;
|
||||
// Dark brim around the bottom edge of the shell.
|
||||
if (dy < -0.028) return PAL.trim;
|
||||
// Centre stripe over the crown.
|
||||
if (Math.abs(p.x) < 0.019 && dy > 0.03) return PAL.accent;
|
||||
return PAL.jersey;
|
||||
};
|
||||
|
||||
const helmet = new THREE.Group();
|
||||
helmet.name = 'helmet';
|
||||
helmet.add(mesh(
|
||||
carvedShell({
|
||||
rows: 26,
|
||||
cols: 36,
|
||||
thickness: H.wall,
|
||||
center: skull,
|
||||
surface: helmetSurface,
|
||||
port: helmetPort,
|
||||
color: helmetColor,
|
||||
}),
|
||||
mats.hard,
|
||||
'helmetShell',
|
||||
));
|
||||
|
||||
// Ear cups over the ports, on their own straps.
|
||||
for (const s of [1, -1]) {
|
||||
const cup = loft([
|
||||
S(V(s * 0.09, skull.y + H.earY, skull.z - 0.014), 0.028, 0.026, 3, PAL.trim),
|
||||
S(V(s * 0.104, skull.y + H.earY, skull.z - 0.014), 0.03, 0.028, 3),
|
||||
S(V(s * 0.111, skull.y + H.earY, skull.z - 0.014), 0.023, 0.021, 3),
|
||||
], { radial: 12, sub: 3, ref: new THREE.Vector3(0, 1, 0) });
|
||||
helmet.add(mesh(cup, mats.hard, 'helmetEar'));
|
||||
}
|
||||
|
||||
// Chin strap under the jaw.
|
||||
helmet.add(mesh(
|
||||
tube([
|
||||
V(-0.105, skull.y + H.earY - 0.012, skull.z - 0.01),
|
||||
V(-0.07, skull.y - 0.12, skull.z + 0.03),
|
||||
V(0, skull.y - 0.145, skull.z + 0.05),
|
||||
V(0.07, skull.y - 0.12, skull.z + 0.03),
|
||||
V(0.105, skull.y + H.earY - 0.012, skull.z - 0.01),
|
||||
], 0.006, { radial: 6 }),
|
||||
mats.strap,
|
||||
'helmetStrap',
|
||||
));
|
||||
|
||||
// Half visor: eye level only. Run it down over the whole face and the player
|
||||
// reads as a welder.
|
||||
{
|
||||
const arc = [];
|
||||
for (let i = 0; i <= 10; i++) {
|
||||
const a = -0.82 + (1.64 * i) / 10;
|
||||
arc.push(V(
|
||||
Math.sin(a) * 0.106 * headF,
|
||||
skull.y + 0.004,
|
||||
skull.z + Math.cos(a) * 0.116 * headF,
|
||||
));
|
||||
}
|
||||
// The ring axes here are u = up, w = front-to-back, so `rx` is the shield's
|
||||
// height and `rz` is its thickness. Swap those two and you get a shelf
|
||||
// sticking out of the face instead of a shield hanging over the eyes.
|
||||
const visor = loft(
|
||||
arc.map((c, i) => S(c, i === 0 || i === arc.length - 1 ? 0.026 : 0.038, 0.003, 3)),
|
||||
{ radial: 8, sub: 2, ref: new THREE.Vector3(0, 1, 0) },
|
||||
);
|
||||
helmet.add(mesh(visor, mats.visor, 'helmetVisor'));
|
||||
}
|
||||
pieces.push(helmet);
|
||||
|
||||
return {
|
||||
padChest,
|
||||
capL,
|
||||
capR,
|
||||
skateL,
|
||||
skateR,
|
||||
gloveL,
|
||||
gloveR,
|
||||
helmet,
|
||||
/** Skinned cloth meshes — these go on the mover, not on a bone. */
|
||||
skinned,
|
||||
pieces,
|
||||
|
||||
attachTo(bones, mover) {
|
||||
for (const m of skinned) mover.add(m);
|
||||
bones.upperArmL.add(capL);
|
||||
bones.upperArmR.add(capR);
|
||||
bones.footL.add(skateL);
|
||||
bones.footR.add(skateR);
|
||||
bones.handL.add(gloveL);
|
||||
bones.handR.add(gloveR);
|
||||
bones.head.add(helmet);
|
||||
},
|
||||
|
||||
destroy() {
|
||||
for (const p of pieces) p.removeFromParent();
|
||||
for (const g of disposables) g.dispose();
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
export function buildSkaterGearMaterials(teamJersey, teamAccent = 0xf0e6d2) {
|
||||
return {
|
||||
/** Cloth: jersey, socks. Vertex-coloured, matte. */
|
||||
cloth: new THREE.MeshStandardMaterial({
|
||||
color: 0xffffff,
|
||||
vertexColors: true,
|
||||
roughness: 0.88,
|
||||
metalness: 0.0,
|
||||
}),
|
||||
/** Padded shells: pants, shoulder pads. */
|
||||
padded: new THREE.MeshStandardMaterial({
|
||||
color: 0xffffff,
|
||||
vertexColors: true,
|
||||
roughness: 0.72,
|
||||
metalness: 0.02,
|
||||
}),
|
||||
/** Hard shells: helmet, skate boots, gloves. */
|
||||
hard: new THREE.MeshStandardMaterial({
|
||||
color: 0xffffff,
|
||||
vertexColors: true,
|
||||
roughness: 0.38,
|
||||
metalness: 0.06,
|
||||
}),
|
||||
steel: new THREE.MeshStandardMaterial({
|
||||
color: 0xc8ccd4,
|
||||
roughness: 0.22,
|
||||
metalness: 0.85,
|
||||
}),
|
||||
holder: new THREE.MeshStandardMaterial({
|
||||
color: 0x16181d,
|
||||
roughness: 0.45,
|
||||
metalness: 0.1,
|
||||
}),
|
||||
lace: new THREE.MeshStandardMaterial({ color: 0xdad6cc, roughness: 0.9 }),
|
||||
strap: new THREE.MeshStandardMaterial({ color: 0x14141a, roughness: 0.85 }),
|
||||
visor: new THREE.MeshPhysicalMaterial({
|
||||
color: 0x9fb8c8,
|
||||
roughness: 0.08,
|
||||
metalness: 0.0,
|
||||
transparent: true,
|
||||
opacity: 0.32,
|
||||
side: THREE.DoubleSide,
|
||||
}),
|
||||
// Colour sources for the vertex-painted pieces.
|
||||
jersey: new THREE.MeshStandardMaterial({ color: teamJersey }),
|
||||
accent: new THREE.MeshStandardMaterial({ color: teamAccent }),
|
||||
trim: new THREE.MeshStandardMaterial({ color: 0x16181d }),
|
||||
pad: new THREE.MeshStandardMaterial({ color: 0x3a3f4a }),
|
||||
tape: new THREE.MeshStandardMaterial({ color: 0xe8e4d8 }),
|
||||
};
|
||||
}
|
||||
Reference in New Issue
Block a user