'use strict'; (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); PH.mark = { "bird": "M247.97 466.14C257.49 468.97 266.53 472.59 276.5 473.89C285.77 475.1 295.17 474.82 304.5 474.8C315.83 474.77 327.17 474.82 338.5 474.83C368.39 474.84 398.28 474.91 428.17 474.78C428.29 471 429 467.3 429.18 463.5C429.62 453.99 428.74 444.79 426.89 435.5C422.96 415.87 413.83 399.35 419.16 378.5C424.11 359.17 440.58 345.77 459.5 341.29C467.89 339.3 476.91 339.48 485.5 339.1C527.02 337.27 568.47 335.02 609.9 331.67C576.17 327.82 542.34 326.59 508.5 324.33C494.96 323.42 478.55 324.6 465.5 321.67C447.4 317.62 438.74 304.82 423.5 296.16C395.5 280.23 355.3 284.26 331.5 306.29C318.86 317.98 310.65 332.99 306.23 349.5C302.24 364.43 300.73 379.83 295.74 394.5C285.94 423.29 269.16 444.67 247.97 466.14Z", "eye": "M406.88 320.5C409.46 320.86 412.22 321.05 413.88 323.5C416.64 327.57 415.2 334.92 409.5 335.61C403.64 336.31 397.39 335.75 391.5 335.73C388.94 335.73 385.87 336.18 383.5 335.07C375.8 331.48 378.35 321.63 387.5 320.73C390.89 309.28 402.91 309.36 406.88 320.5Z", "cloud": "M287.12 258.46C281.24 259.15 275.3 259.19 269.5 260.38C252.24 263.91 235.38 270.99 221.5 281.97C208.12 292.56 197.29 306.05 190.21 321.5C171.27 362.82 183.99 412.75 215.5 443.87C231.74 459.9 253.86 470.94 276.5 473.89C286.1 475.14 295.84 474.8 305.5 474.8C318.17 474.79 330.83 474.81 343.5 474.83C385.5 474.93 427.5 474.77 469.5 474.81C492.18 474.84 518.25 476.53 540.5 473.73C578.63 468.94 611.05 441.37 625.81 406.5C645.19 360.72 630.1 304.65 590.5 274.73C584.86 270.47 578.95 266.27 572.5 263.29C562.78 258.81 552.23 254.64 541.5 253.25C536.86 252.64 532.18 252.04 527.5 251.97C525.49 251.94 522.42 252.51 520.67 251.5C519.49 250.82 518.59 246.8 518.01 245.5C515.72 240.32 512.9 235.26 509.84 230.5C500.92 216.61 488.44 204.14 474.5 195.26C424.89 163.66 360.29 170.37 317.5 210.3C303.03 223.8 294.75 240.69 287.12 258.46Z", "sourceSha256": "ed277fb61f438c916ef7f13f318392b588b7b06dfd8479d7ca69124be88a5e4c" }; })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); PH.sacred = { "source": { "construction": "../../w17/brand-kit/concepts/sacred-geometry/construction.json", "sha256": "08418d4f36d2a6a53ba4a812becc5707154b6489f5cef241b8549bf64701cf19", "builder": "8db67e608ccab569aa70e8a4d6de664743e5a3bcd85cc39be65026966237c688" }, "units": "A06 trace units; the mark is 452.88 wide", "R": 124.90029838935334, "circles": [ { "name": "mother", "ratio": "1", "meaning": "the crown", "centre": [407.081,299.773], "r": 124.9 }, { "name": "left", "ratio": "√3/2", "meaning": "the vesica piscis", "centre": [289.215,366.616], "r": 108.167 }, { "name": "right", "ratio": "2/√5", "meaning": "the golden root", "centre": [522.215,363.069], "r": 111.714 }, { "name": "head", "ratio": "1/φ", "meaning": "the golden section", "centre": [382.84,363.321], "r": 77.193 }, { "name": "forehead", "ratio": "1/φ", "meaning": "the twin of the head", "centre": [482.447,245.366], "r": 77.193 }, { "name": "backOfNeck", "ratio": "√2", "meaning": "the root of the square", "centre": [130.897,332.441], "r": 176.636 }, { "name": "frontOfNeck", "ratio": "6/5", "meaning": "the harmonic third", "centre": [279.419,463.48], "r": 149.88 }, { "name": "throat", "ratio": "√3/4", "meaning": "half the vesica circle", "centre": [471.249,394.179], "r": 54.083 }, { "name": "eyeMother", "ratio": "the cloud itself at 1/12.79", "meaning": "the eye", "centre": [397.179,322.64], "r": 9.765 } ], "paths": { "cloud": "M 289.215 474.783 A 108.167 108.167 0 0 1 289.215 258.449 A 124.9 124.9 0 0 1 522.215 251.355 A 111.714 111.714 0 0 1 522.215 474.783 L 289.215 474.783 Z", "bust": "M 246.501 465.992 A 108.167 108.167 0 0 0 289.215 474.783 L 428.873 474.783 A 149.88 149.88 0 0 0 420.383 412.555 A 54.083 54.083 0 0 1 467.976 340.195 L 609.9 331.59 L 477.102 322.374 A 77.193 77.193 0 0 1 432.643 304.344 A 77.193 77.193 0 0 0 306.221 353.93 A 176.636 176.636 0 0 1 246.501 465.992 Z", "eye": "M 387.964 336.323 A 8.457 8.457 0 0 1 387.964 319.41 A 9.765 9.765 0 0 1 406.181 318.855 A 8.734 8.734 0 0 1 406.181 336.323 L 387.964 336.323 Z" }, "baseline": 474.783, "junctions": { "neckCorner": [246.501,465.992], "baseLeft": [289.215,474.783], "neckBase": [428.873,474.783], "neckThroat": [420.383,412.555], "throatBill": [467.976,340.195], "tip": [609.9,331.59], "billForehead": [477.102,322.374], "foreheadHead": [432.643,304.344], "headBack": [306.221,353.93], "tail": [136.613,508.984], "crown": [306.777,316.118] }, "profile": [ { "kind": "arc", "name": "belly", "centre": [279.419,463.48], "r": 149.88, "a0": 2.833, "a1": -0.347, "convex": true }, { "kind": "arc", "name": "throat", "centre": [471.249,394.179], "r": 54.083, "a0": 2.795, "a1": 4.652, "convex": false }, { "kind": "line", "name": "billLower", "start": [467.976,340.195], "end": [609.9,331.59] }, { "kind": "line", "name": "billUpper", "start": [609.9,331.59], "end": [477.102,322.374] }, { "kind": "arc", "name": "forehead", "centre": [482.447,245.366], "r": 77.193, "a0": 1.64, "a1": 2.272, "convex": false }, { "kind": "arc", "name": "head", "centre": [382.84,363.321], "r": 77.193, "a0": -0.87, "a1": -3.02, "convex": true }, { "kind": "arc", "name": "back", "centre": [130.897,332.441], "r": 176.636, "a0": 0.122, "a1": 1.538, "convex": false } ], "balls": [ [363.164,364.921,57.891,0], [365.052,357.18,58.374,0], [365.072,357.122,58.374,0], [367.734,351.373,57.933,0], [370.617,347.21,56.97,0], [375.439,342.275,54.883,0], [381.57,337.934,51.774,0], [383.488,336.869,50.732,0], [391.19,333.594,46.315,0], [396.671,332.039,42.99,0], [406.102,330.535,36.992,0], [408.195,330.375,35.62,0], [422.357,329.996,26.6,0], [423.183,329.983,26.113,0], [433.978,329.882,20.235,0], [434.223,329.881,20.113,0], [443.294,329.924,15.99,0], [443.552,329.927,15.884,0], [451.236,330.069,13.077,0], [451.543,330.077,12.979,0], [458.047,330.284,11.161,0], [463.046,330.499,10.123,0], [468.909,330.807,9.314,0], [471.418,330.91,9.059,0], [360.43,379.595,57.691,0.032], [359.683,384.186,57.929,0.052], [357.6,399.132,59.673,0.145], [357.163,402.848,60.331,0.173], [355.651,418.588,64.063,0.307], [355.319,423.054,65.389,0.348], [354.295,440.729,71.624,0.517], [354.239,441.426,71.878,0.524], [352.851,452.263,75.597,0.632], [352.347,454.988,76.46,0.659], [349.804,465.369,79.47,0.76], [347.254,473.016,81.379,0.83], [343.13,482.619,83.357,0.908], [338.881,490.477,84.578,0.958], [333.205,499.008,85.42,0.992], [137.126,509.345,0.378,1], [138.938,510.602,1.707,1], [141.838,512.555,3.81,1], [146.024,515.245,6.794,1], [151.299,518.433,10.472,1], [157.586,521.95,14.743,1], [157.882,522.108,14.942,1], [165.294,525.861,19.819,1], [165.775,526.091,20.13,1], [174.078,529.806,25.398,1], [174.936,530.163,25.932,1], [184.178,533.697,31.553,1], [185.857,534.278,32.551,1], [196.026,537.412,38.434,1], [198.646,538.112,39.906,1], [209.466,540.542,45.804,1], [212.833,541.147,47.578,1], [224.078,542.642,53.293,1], [228.412,543,55.408,1], [239.654,543.348,60.661,1], [245.379,543.193,63.203,1], [256.622,542.205,67.921,1], [262.97,541.225,70.415,1], [273.622,538.836,74.302,1], [280.756,536.671,76.678,1], [290.73,532.788,79.656,1], [297.8,529.352,81.493,1], [306.787,524.021,83.441,1], [313.442,519.249,84.553,1], [321.212,512.573,85.408,1], [327.613,505.933,85.655,1] ], "bill": { "tip": [609.9,331.59], "base": [476.503,331.007,8.654] }, "centroid": [326.957,465.509], "weight": { "from": [382.84,363.321], "toward": [-0.48,0.877], "start": 10, "end": 150 }, "tail": { "root": [136.613,508.984], "back": [0.999,-0.033], "belly": [0.304,0.953] }, "foot": [326.957,605.622], "eye": { "at": [397.179,322.64,46.936], "normal": [0.301,-0.295,0.907], "mother": [397.179,322.64,9.765] }, "shoulder": { "at": [318,418,57.674], "normal": [-0.461,-0.453,0.763] }, "gorget": { "at": [413,374,28.734], "normal": [0.821,0.288,0.492] }, "coverage": { "epsilon": 0.35, "step": 0.25, "samples": 5272, "spheres": 70, "maxGap": 0.35, "maxOvershoot": 0, "interiorPoints": 24954, "interiorPatches": 0, "interiorHoles": 0 } }; })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const TAU = Math.PI * 2; const clamp = (v, lo, hi) => (v < lo ? lo : (v > hi ? hi : v)); const clamp01 = (v) => clamp(v, 0, 1); const lerp = (a, b, u) => a + (b - a) * u; const ease = { inOutCubic: (u) => (u < 0.5 ? 4 * u * u * u : 1 - Math.pow(-2 * u + 2, 3) / 2), outCubic: (u) => 1 - Math.pow(1 - u, 3), inCubic: (u) => u * u * u, inOutSine: (u) => -(Math.cos(Math.PI * u) - 1) / 2, outBack: (u) => 1 + 2.70158 * Math.pow(u - 1, 3) + 1.70158 * Math.pow(u - 1, 2) }; const span = (t, a, b) => clamp01((t - a) / (b - a)); const bump = (u) => Math.sin(Math.PI * clamp01(u)); const envelope = (u, rise, fall) => { if (u <= 0 || u >= 1) { return 0; } if (u < rise) { return ease.inOutSine(u / rise); } if (u > 1 - fall) { return ease.inOutSine((1 - u) / fall); } return 1; }; const snap = (u, rise, fall) => { if (u <= 0 || u >= 1) { return 0; } if (u < rise) { return ease.outCubic(u / rise); } if (u > 1 - fall) { return ease.outCubic((1 - u) / fall); } return 1; }; const spring = (stiffness, damping) => { const w = Math.sqrt(stiffness); const z = damping / (2 * w); if (z >= 1) { return (t) => (t <= 0 ? 0 : 1 - Math.exp(-w * t) * (1 + w * t)); } const wd = w * Math.sqrt(1 - z * z); const q = z / Math.sqrt(1 - z * z); return (t) => (t <= 0 ? 0 : 1 - Math.exp(-z * w * t) * (Math.cos(wd * t) + q * Math.sin(wd * t))); }; const follow = (signalAt, t, response, reach, steps) => { const n = steps || 28; const step = reach / n; let previous = signalAt(t - reach); let value = previous; for (let i = 1; i <= n; i += 1) { const next = signalAt(t - reach + step * i); value += (next - previous) * response(reach - step * (i - 0.5)); previous = next; } return value; }; const hash = (seed, n) => { const x = Math.sin(seed * 127.1 + n * 311.7) * 43758.5453; return x - Math.floor(x); }; const wave = (t, seed) => Math.sin(t * 1.9 + hash(seed, 1) * TAU) * 0.55 + Math.sin(t * 4.7 + hash(seed, 2) * TAU) * 0.3 + Math.sin(t * 8.3 + hash(seed, 3) * TAU) * 0.15; const hexChannels = (hex) => [parseInt(hex.slice(1, 3), 16), parseInt(hex.slice(3, 5), 16), parseInt(hex.slice(5, 7), 16)]; const mixHex = (a, b, u) => { if (u <= 0) { return a; } if (u >= 1) { return b; } const ca = hexChannels(a); const cb = hexChannels(b); return '#' + [0, 1, 2].map((i) => Math.round(lerp(ca[i], cb[i], u)).toString(16).padStart(2, '0')).join(''); }; const rgba = (hex, alpha) => { const c = hexChannels(hex); return 'rgba(' + c[0] + ',' + c[1] + ',' + c[2] + ',' + Math.round(clamp01(alpha) * 1000) / 1000 + ')'; }; PH.TAU = TAU; PH.motion = { clamp, clamp01, lerp, ease, span, bump, envelope, snap, spring, follow, hash, wave, mixHex, rgba, BODY_SPRING: spring(150, 12), HEAD_SPRING: spring(320, 22) }; })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const S = PH.sacred; const PHI = (1 + Math.sqrt(5)) / 2; const PITCH = { mark: 0, perch: -0.62, hover: -0.3, brake: -0.1, cruise: 0.38 }; const TIP = [609.9, 331.67]; const HINGE = [352, 392]; const NECK = [362, 366]; const PIVOT = S.centroid; const NEST_RIM_Y = 362; const TAIL_ROOT = S.tail.root; const TAIL_AXIS = Math.atan2(-S.tail.back[1], -S.tail.back[0]) - 0.35; const R = S.R; const circle = (name) => S.circles.find((c) => c.name === name); const pointOn = (c, a) => [c.centre[0] + c.r * Math.cos(a), c.centre[1] + c.r * Math.sin(a)]; const FOOT = pointOn(circle('frontOfNeck'), Math.PI / 2 - PITCH.perch); const smooth = (a, b, v) => { const u = Math.min(1, Math.max(0, (v - a) / (b - a))); return u * u * (3 - 2 * u); }; const HEAD_BAND = { start: -10, end: 70 }; const along = (p) => (p[0] - S.weight.from[0]) * S.weight.toward[0] + (p[1] - S.weight.from[1]) * S.weight.toward[1]; const weightAt = (p) => smooth(S.weight.start, S.weight.end, along(p)); const headAt = (p) => 1 - smooth(HEAD_BAND.start, HEAD_BAND.end, along(p)); const throatArc = S.profile.find((p) => p.name === 'throat'); const throatOut = (share) => { const a = throatArc.a0 + (throatArc.a1 - throatArc.a0) * share; return [Math.cos(a), Math.sin(a)]; }; const throatAt = (share, inset) => { const out = throatOut(share); return [throatArc.centre[0] + out[0] * (throatArc.r + inset), throatArc.centre[1] + out[1] * (throatArc.r + inset), 0]; }; const THROAT = { at: throatAt(0.5, 14), r: 14, pump: 6 }; const SPHERES = S.balls.map((b) => ({ x: b[0], y: b[1], r: b[2], w: b[3], pump: 0 })).concat([{ x: THROAT.at[0], y: THROAT.at[1], r: THROAT.r, w: 0, pump: THROAT.pump }]); const BILL = { tip: S.bill.tip, base: S.bill.base }; const EYE = { at: S.eye.at, normal: S.eye.normal }; const SHOULDER = { at: S.shoulder.at, w: weightAt(S.shoulder.at) }; const GORGET = { at: throatAt(0.23, 10), r: 30, normal: throatOut(0.23).map((v) => -v).concat([0]) }; const WING = { length: 2 * R, lead: (3 + 2 * Math.SQRT2) * R, trail: PHI * R }; const TAIL = { length: R / PHI, step: Math.PI / 10, radius: (R / PHI) * 0.908 }; const reachOf = () => { const far = (p) => Math.hypot(p[0] - HINGE[0], p[1] - HINGE[1]); const hinge = Math.hypot(PIVOT[0] - HINGE[0], PIVOT[1] - HINGE[1]); const body = Math.max.apply(null, SPHERES.map((b) => far([b.x, b.y]) + b.r)); return hinge + Math.max(body, far(TAIL_ROOT) + TAIL.length, far(SHOULDER.at) + Math.hypot(SHOULDER.at[2], 0) + WING.length, far(TIP)) + 12; }; PH.skeleton = { PITCH, TIP, HINGE, NECK, PIVOT, NEST_RIM_Y, TAIL_ROOT, TAIL_AXIS, FOOT, SPHERES, BILL, EYE, SHOULDER, GORGET, WING, TAIL, BODY_CENTRE: PIVOT, REACH: reachOf(), weightAt, headAt }; })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const K = PH.skeleton; const M = PH.motion; const PUFF_GAIN = 0.11; const LOOK = 0.94; const HEAD_YAW_LIMIT = 1.75; const rotateAbout = (p, c, a) => { if (!a) { return [p[0], p[1]]; } const cs = Math.cos(a); const sn = Math.sin(a); const dx = p[0] - c[0]; const dy = p[1] - c[1]; return [c[0] + dx * cs - dy * sn, c[1] + dx * sn + dy * cs]; }; const rotateVector = (v, a) => [v[0] * Math.cos(a) - v[1] * Math.sin(a), v[0] * Math.sin(a) + v[1] * Math.cos(a)]; const skin = (point, weight, pitch, stretch) => { const turn = weight * pitch; const grow = 1 + weight * (stretch - 1); const dx = (point[0] - K.HINGE[0]) * grow; const dy = (point[1] - K.HINGE[1]) * grow; return [K.HINGE[0] + dx * Math.cos(turn) - dy * Math.sin(turn), K.HINGE[1] + dx * Math.sin(turn) + dy * Math.cos(turn)]; }; const headYawOf = (s) => { const own = s.headYaw || 0; const look = LOOK * M.clamp01(s.headTurn || 0) * (Math.PI / 2 - (s.azimuth || 0) - own); return M.clamp(own + look, -HEAD_YAW_LIMIT, HEAD_YAW_LIMIT); }; const skinPoint = (p, w, s, yaw) => { const folded = skin(p, w, s.pitch, s.stretch); const h = K.headAt(p); const turn = yaw === undefined ? headYawOf(s) : yaw; let z = p[2] || 0; if (h <= 0 || (!s.headTilt && !turn)) { return [folded[0], folded[1], z]; } const tilted = rotateAbout(folded, K.NECK, (s.headTilt || 0) * h); const a = turn * h; const dx = tilted[0] - K.NECK[0]; const x = K.NECK[0] + dx * Math.cos(a) - z * Math.sin(a); z = dx * Math.sin(a) + z * Math.cos(a); return [x, tilted[1], z]; }; const skinVector = (p, v, w, s, yaw) => { const a = skinPoint(p, w, s, yaw); const b = skinPoint([p[0] + v[0], p[1] + v[1], (p[2] || 0) + v[2]], w, s, yaw); return [b[0] - a[0], b[1] - a[1], b[2] - a[2]]; }; const skinSpheres = (s) => { const yaw = headYawOf(s); const centre = skin(K.BODY_CENTRE, 1, s.pitch, s.stretch); const puff = s.puff || 0; const pump = s.throat || 0; return K.SPHERES.map((b) => { const p = skinPoint([b.x, b.y, 0], b.w, s, yaw); const grow = 1 + PUFF_GAIN * puff * b.w; return { x: centre[0] + (p[0] - centre[0]) * grow, y: centre[1] + (p[1] - centre[1]) * grow, z: p[2] * grow, r: b.r * grow + b.pump * pump, w: b.w }; }); }; Object.assign(PH, { rotateAbout, rotateVector, skin, skinPoint, skinVector, skinSpheres, headYawOf }); })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const K = PH.skeleton; const matrixOf = (s) => { const ca = Math.cos(s.azimuth || 0); const sa = Math.sin(s.azimuth || 0); const cc = Math.cos(s.climb || 0); const sc = Math.sin(s.climb || 0); const cb = Math.cos(s.bank || 0); const sb = Math.sin(s.bank || 0); const a = [cc, sc * cb, -sc * sb, -sc, cc * cb, -cc * sb, 0, sb, cb]; return [ ca * a[0] - sa * a[6], ca * a[1] - sa * a[7], ca * a[2] - sa * a[8], a[3], a[4], a[5], sa * a[0] + ca * a[6], sa * a[1] + ca * a[7], sa * a[2] + ca * a[8] ]; }; const project = (s, m, p) => { const dx = p[0] - K.PIVOT[0]; const dy = p[1] - K.PIVOT[1]; const dz = p[2] || 0; return [s.x + s.k * (m[0] * dx + m[1] * dy + m[2] * dz), s.y + s.k * (m[3] * dx + m[4] * dy + m[5] * dz), m[6] * dx + m[7] * dy + m[8] * dz]; }; const turnVector = (m, v) => [m[0] * v[0] + m[1] * v[1] + m[2] * v[2], m[3] * v[0] + m[4] * v[1] + m[5] * v[2], m[6] * v[0] + m[7] * v[1] + m[8] * v[2]]; const toScreen = (s, p) => { const q = project(s, matrixOf(s), p); return [q[0], q[1]]; }; const placeBy = (s, localPoint, screenPoint) => { const at = toScreen(Object.assign({}, s, { x: 0, y: 0 }), localPoint); s.x = screenPoint[0] - at[0]; s.y = screenPoint[1] - at[1]; return s; }; const footLocal = (s) => PH.skinPoint(K.FOOT, 1, s); const tipLocal = (s) => PH.skinPoint(K.TIP, 0, s); const centreLocal = (s) => PH.skinPoint(K.BODY_CENTRE, 1, s); const tailLocal = (s) => PH.skinPoint(K.TAIL_ROOT, 1, s); const bounds = (s) => { const r = K.REACH * s.k; return { x: s.x - r, y: s.y - r, w: 2 * r, h: 2 * r }; }; const detailFor = (s, pixelRatio) => { const px = 360 * s.k * (pixelRatio || 1); return px > 150 ? 2 : (px > 64 ? 1 : 0); }; const frameOf = (s) => { const m = matrixOf(s); const yaw = PH.headYawOf(s); const spheres = PH.skinSpheres(s).map((b) => { const q = project(s, m, [b.x, b.y, b.z]); return { x: q[0], y: q[1], z: q[2], r: b.r * s.k }; }); const tip = project(s, m, PH.skinPoint([K.BILL.tip[0], K.BILL.tip[1], 0], 0, s, yaw)); const base = project(s, m, PH.skinPoint([K.BILL.base[0], K.BILL.base[1], 0], 0, s, yaw)); let upperY = Infinity; let lowerY = -Infinity; spheres.forEach((b) => { upperY = Math.min(upperY, b.y - b.r); lowerY = Math.max(lowerY, b.y + b.r); }); return { s, m, yaw, spheres, bill: { tip, base, r: K.BILL.base[2] * s.k }, upperY, lowerY }; }; const decalOf = (frame, anchor, normal, w, side) => { const s = frame.s; const at = [anchor[0], anchor[1], side * anchor[2]]; const n = [normal[0], normal[1], side * normal[2]]; const u = turnVector(frame.m, PH.skinVector(at, [1, 0, -n[0] / n[2]], w, s, frame.yaw)); const v = turnVector(frame.m, PH.skinVector(at, [0, 1, -n[1] / n[2]], w, s, frame.yaw)); const facing = turnVector(frame.m, PH.skinVector(at, n, w, s, frame.yaw)); const p = project(s, frame.m, PH.skinPoint(at, w, s, frame.yaw)); const k = s.k; return { a: u[0] * k, b: u[1] * k, c: v[0] * k, d: v[1] * k, e: p[0] - k * (u[0] * at[0] + v[0] * at[1]), f: p[1] - k * (u[1] * at[0] + v[1] * at[1]), facing: facing[2] / Math.hypot(facing[0], facing[1], facing[2]), depth: p[2] }; }; PH.place = { matrixOf, project, turnVector, toScreen, placeBy, footLocal, tipLocal, centreLocal, tailLocal, bounds, detailFor, frameOf, decalOf }; })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const M = PH.motion; const DEPTH = { farScale: 0.6, haze: 0.22, paper: '#fefefe', night: '#09122a' }; const FAR_GAIN = 1 / DEPTH.farScale - 1; const depthOf = (value) => M.clamp01(Number(value) || 0); const scaleOf = (depth) => 1 / (1 + FAR_GAIN * depthOf(depth)); const depthAtScale = (scale) => M.clamp01((1 / Math.max(scale, 1e-6) - 1) / FAR_GAIN); const groundOf = (livery) => M.mixHex(DEPTH.paper, DEPTH.night, M.clamp01(livery || 0)); const hazeColors = (colors, depth, ground) => { const amount = DEPTH.haze * depthOf(depth); if (amount <= 0.001) { return colors; } const out = {}; Object.keys(colors).forEach((key) => { if (Object.prototype.hasOwnProperty.call(colors, key)) { out[key] = M.mixHex(colors[key], ground, amount); } }); return out; }; PH.depth = { DEPTH, depthOf, scaleOf, depthAtScale, groundOf, hazeColors }; })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const TAU = PH.TAU; const MEET = 1e-9; const TURN = 4; const diamond = (dx, dy) => { const p = dx / (Math.abs(dx) + Math.abs(dy)); return dy < 0 ? 3 + p : 1 - p; }; const scratchFor = (n) => ({ count: 0, from: new Float64Array(2 * n), to: new Float64Array(2 * n), fx: new Float64Array(2 * n), fy: new Float64Array(2 * n), tx: new Float64Array(2 * n), ty: new Float64Array(2 * n), by: new Int32Array(2 * n), order: new Int32Array(2 * n) }); const addSpan = (span, from, to, fx, fy, tx, ty, by) => { const k = span.count; span.from[k] = from; span.to[k] = to; span.fx[k] = fx; span.fy[k] = fy; span.tx[k] = tx; span.ty[k] = ty; span.by[k] = by; span.count = k + 1; }; const coverSpans = (circles, i, span) => { const a = circles[i]; span.count = 0; for (let j = 0; j < circles.length; j += 1) { const b = circles[j]; const dx = b.x - a.x; const dy = b.y - a.y; const dd = dx * dx + dy * dy; const reach = a.r + b.r; if (j !== i && dd < reach * reach) { const d = Math.sqrt(dd); if (d + a.r <= b.r && (a.r < b.r || j < i)) { return false; } if (d + b.r > a.r) { const along = (a.r * a.r - b.r * b.r + dd) / (2 * d); const h = Math.sqrt(Math.max(0, a.r * a.r - along * along)); const ux = dx / d; const uy = dy / d; const fx = along * ux + h * uy; const fy = along * uy - h * ux; const tx = along * ux - h * uy; const ty = along * uy + h * ux; const from = diamond(fx, fy); const to = diamond(tx, ty); if (to >= from) { addSpan(span, from, to, fx, fy, tx, ty, j); } else { addSpan(span, from, TURN, fx, fy, tx, ty, j); addSpan(span, 0, to, fx, fy, tx, ty, j); } } } } return true; }; const orderOf = (span) => { const order = span.order; for (let k = 0; k < span.count; k += 1) { let m = k; while (m > 0 && span.from[order[m - 1]] > span.from[k]) { order[m] = order[m - 1]; m -= 1; } order[m] = k; } return order; }; const arcOf = (c, from, to, enter) => ({ x: c.x, y: c.y, r: c.r, from, to, enter, used: false, sx: c.x + c.r * Math.cos(from), sy: c.y + c.r * Math.sin(from), ex: c.x + c.r * Math.cos(to), ey: c.y + c.r * Math.sin(to) }); const gapArc = (c, span, last, next) => { const from = Math.atan2(span.ty[last], span.tx[last]); let to = Math.atan2(span.fy[next], span.fx[next]); while (to <= from) { to += TAU; } return arcOf(c, from, to, span.by[next]); }; const exposedArcs = (c, span) => { if (span.count === 0) { return [arcOf(c, 0, TAU, -1)]; } const order = orderOf(span); const arcs = []; const head = order[0]; let last = head; let end = span.to[head]; for (let m = 1; m < span.count; m += 1) { const s = order[m]; if (span.from[s] > end + MEET) { arcs.push(gapArc(c, span, last, s)); last = s; end = span.to[s]; } else if (span.to[s] > end) { last = s; end = span.to[s]; } } if (span.from[head] + TURN > end + MEET) { arcs.push(gapArc(c, span, last, head)); } return arcs; }; const gapTo = (arc, next) => (next.sx - arc.ex) * (next.sx - arc.ex) + (next.sy - arc.ey) * (next.sy - arc.ey); const nearest = (arc, candidates, best) => { let pick = best; candidates.forEach((candidate) => { if (!candidate.used && gapTo(arc, candidate) < gapTo(arc, pick)) { pick = candidate; } }); return pick; }; const nextArc = (arcs, byCircle, arc, first) => { const near = arc.enter < 0 ? first : nearest(arc, byCircle[arc.enter], first); return gapTo(arc, near) <= MEET ? near : nearest(arc, arcs, near); }; const traceHummingbirdSilhouette = (circles) => { const span = scratchFor(circles.length); const byCircle = circles.map(() => []); const arcs = []; circles.forEach((c, i) => { if (!coverSpans(circles, i, span)) { return; } exposedArcs(c, span).forEach((arc) => { byCircle[i].push(arc); arcs.push(arc); }); }); const contours = []; arcs.forEach((first) => { if (first.used) { return; } const contour = []; let arc = first; while (!arc.used) { arc.used = true; contour.push(arc); arc = nextArc(arcs, byCircle, arc, first); } contours.push(contour); }); return contours; }; PH.traceHummingbirdSilhouette = traceHummingbirdSilhouette; })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const K = PH.skeleton; const M = PH.motion; const SWEEP_STEPS = [5, 8, 14]; const EDGE_STEPS = [5, 8, 12]; const SWEEP_STRENGTH = { near: 0.42, far: 0.3 }; const GHOST_ALPHA = 0.2; const ROOT_IN = 0.92; const STROKE = { amplitude: 1.05, dihedral: 0.5, figure: 0.16, twist: 0.55, tilt: -0.6, splay: 0.24 }; const add3 = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]]; const scale3 = (a, s) => [a[0] * s, a[1] * s, a[2] * s]; const dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; const cross3 = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]; const unit3 = (v) => scale3(v, 1 / (Math.hypot(v[0], v[1], v[2]) || 1)); const tiltXY = (v, a) => [v[0] * Math.cos(a) - v[1] * Math.sin(a), v[0] * Math.sin(a) + v[1] * Math.cos(a), v[2]]; const nearOf = (s, side) => (side > 0) === (Math.cos(s.azimuth || 0) >= 0); const foldOf = (s, near) => M.clamp01(near ? (s.foldNear === null ? s.fold : s.foldNear) : (s.foldFar === null ? s.fold : s.foldFar)); const strokeOf = (s, side, phase) => { const amp = M.clamp01(s.wings); const cruise = M.clamp01((s.pitch - K.PITCH.hover) / (K.PITCH.cruise - K.PITCH.hover)); const phi = STROKE.amplitude * (0.35 + 0.65 * amp) * Math.sin(phase); const delta = STROKE.dihedral + STROKE.figure * amp * Math.cos(2 * phase); const plane = STROKE.tilt * cruise; const span = tiltXY([Math.sin(phi) * Math.cos(delta), -Math.sin(delta), side * Math.cos(phi) * Math.cos(delta)], plane); const flat = tiltXY([-Math.cos(phi), 0, side * Math.sin(phi)], plane); const twist = STROKE.twist * amp * Math.cos(phase); const chord = add3(scale3(flat, Math.cos(twist)), scale3(cross3(span, flat), side * Math.sin(twist))); return { span, chord }; }; const foldedOf = (s, side, near) => { const a = K.TAIL_AXIS + s.pitch * 0.92 - 0.16 + (near ? s.nearLift : 0); return { span: unit3([Math.cos(a), Math.sin(a), side * STROKE.splay]), chord: [Math.sin(a), -Math.cos(a), 0] }; }; const bladeOf = (frame, side, phase) => { const s = frame.s; const near = nearOf(s, side); const fold = foldOf(s, near); const stroke = strokeOf(s, side, phase); const folded = foldedOf(s, side, near); const span = unit3(add3(scale3(stroke.span, 1 - fold), scale3(folded.span, fold))); const mixed = add3(scale3(stroke.chord, 1 - fold), scale3(folded.chord, fold)); const chord = unit3(add3(mixed, scale3(span, -dot3(mixed, span)))); const root = PH.skinPoint([K.SHOULDER.at[0], K.SHOULDER.at[1], side * K.SHOULDER.at[2] * ROOT_IN], K.SHOULDER.w, s, frame.yaw); const dorsal = PH.place.turnVector(frame.m, scale3(cross3(span, chord), side)); return { near, fold, span, chord, root, under: Math.max(0, -dorsal[2]) * (1 - fold) * M.clamp01(s.wings) }; }; const lensOffset = (radius, length, u) => Math.sqrt(radius * radius - Math.pow(length * (u - 0.5), 2)) - Math.sqrt(radius * radius - length * length / 4); const outlineOf = (frame, blade, steps) => { const L = K.WING.length; const at = (u, offset) => PH.place.project(frame.s, frame.m, add3(add3(blade.root, scale3(blade.span, u * L)), scale3(blade.chord, offset))); const points = []; for (let i = 0; i <= steps; i += 1) { points.push(at(i / steps, -lensOffset(K.WING.lead, L, i / steps))); } for (let i = steps - 1; i > 0; i -= 1) { points.push(at(i / steps, lensOffset(K.WING.trail, L, i / steps))); } return points; }; const tipOf = (frame, blade) => PH.place.project(frame.s, frame.m, add3(blade.root, scale3(blade.span, K.WING.length))); const traceClosed = (c, points) => { c.beginPath(); c.moveTo((points[0][0] + points[1][0]) / 2, (points[0][1] + points[1][1]) / 2); for (let i = 1; i <= points.length; i += 1) { const p = points[i % points.length]; const q = points[(i + 1) % points.length]; c.quadraticCurveTo(p[0], p[1], (p[0] + q[0]) / 2, (p[1] + q[1]) / 2); } c.closePath(); }; const paintBlade = (c, frame, colors, side, phase, alpha, detail) => { if (alpha <= 0.004) { return; } const blade = bladeOf(frame, side, phase); const root = PH.place.project(frame.s, frame.m, blade.root); const tip = tipOf(frame, blade); const near = blade.near; const g = c.createLinearGradient(root[0], root[1], tip[0], tip[1]); g.addColorStop(0, M.mixHex(near ? colors.wingRoot : colors.farWingRoot, colors.wingUnder, blade.under)); g.addColorStop(0.5, M.mixHex(near ? colors.wingMid : colors.farWingRoot, colors.wingUnder, blade.under * 0.6)); g.addColorStop(1, M.mixHex(near ? colors.wingTip : colors.farWingTip, colors.wingUnder, blade.under * 0.35)); c.save(); c.globalAlpha *= alpha; c.fillStyle = g; traceClosed(c, outlineOf(frame, blade, EDGE_STEPS[detail])); c.fill(); c.restore(); }; const paintSweep = (c, frame, colors, side, phase, strength, detail) => { const s = frame.s; if (strength <= 0.01 || s.blurSpan <= 0.02 || typeof c.createConicGradient !== 'function') { return; } const steps = SWEEP_STEPS[detail]; const blades = []; for (let i = 0; i <= steps; i += 1) { blades.push(bladeOf(frame, side, phase - s.blurSpan * (1 - i / steps))); } const root = PH.place.project(s, frame.m, blades[steps].root); const tips = blades.map((b) => tipOf(frame, b)); const angles = tips.map((t) => Math.atan2(t[1] - root[1], t[0] - root[0])); for (let i = 1; i < angles.length; i += 1) { angles[i] = angles[i - 1] + Math.atan2(Math.sin(angles[i] - angles[i - 1]), Math.cos(angles[i] - angles[i - 1])); } const lo = Math.min.apply(null, angles); const hi = Math.max.apply(null, angles); if (hi - lo < 0.02 || hi - lo > PH.TAU - 0.05) { return; } const rising = angles[steps] >= angles[0]; const color = blades[steps].near ? colors.wingMid : colors.farWingRoot; const g = c.createConicGradient(lo, root[0], root[1]); const highStop = (hi - lo) / PH.TAU; g.addColorStop(0, M.rgba(color, rising ? 0 : strength)); g.addColorStop(highStop, M.rgba(color, rising ? strength : 0)); g.addColorStop(Math.min(1, highStop + 0.002), M.rgba(color, 0)); g.addColorStop(1, M.rgba(color, 0)); c.fillStyle = g; c.beginPath(); c.moveTo(root[0], root[1]); tips.forEach((p) => c.lineTo(p[0], p[1])); c.closePath(); c.fill(); }; const wingDepth = (frame, side) => PH.place.turnVector(frame.m, [0, 0, side])[2] * K.SHOULDER.at[2] - 1; const paintHummingbirdWing = (c, frame, colors, side, detail) => { const s = frame.s; const near = nearOf(s, side); const base = (near ? 0.94 : 0.72) * M.clamp01(s.wingAlpha); if (base <= 0.004) { return; } const motion = s.blur * M.clamp01(s.wings) * M.clamp01(1 - foldOf(s, near) * 2) * M.clamp01(s.wingAlpha); if (motion > 0.01 && s.blurSpan > 0.02) { paintSweep(c, frame, colors, side, s.wingPhase, motion * (near ? SWEEP_STRENGTH.near : SWEEP_STRENGTH.far), detail); paintBlade(c, frame, colors, side, s.wingPhase - s.blurSpan * 0.5, base * GHOST_ALPHA * motion, Math.min(detail, 1)); } paintBlade(c, frame, colors, side, s.wingPhase, base, detail); }; Object.assign(PH, { paintHummingbirdWing, wingDepth }); PH.wing = { STROKE, bladeOf, tipOf, outlineOf, nearOf }; })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const K = PH.skeleton; const M = PH.motion; const FAN_TILT = 0.6; const FULL_SPREAD = 0.9; const STEPS = 6; const FEATHERS = [-2, -1, 0, 1, 2]; const add3 = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]]; const scale3 = (a, s) => [a[0] * s, a[1] * s, a[2] * s]; const tailFrame = (frame) => { const s = frame.s; const a = K.TAIL_AXIS + s.pitch + s.tailLift; const axis = [Math.cos(a), Math.sin(a), 0]; const across = [-Math.sin(a) * Math.sin(FAN_TILT), Math.cos(a) * Math.sin(FAN_TILT), Math.cos(FAN_TILT)]; return { root: PH.place.tailLocal(s), axis, across, open: M.clamp01(Math.max(0, s.tailSpread) / FULL_SPREAD) }; }; const featherOf = (frame, tail, i) => { const angle = i * K.TAIL.step * tail.open; const along = add3(scale3(tail.axis, Math.cos(angle)), scale3(tail.across, Math.sin(angle))); const side = add3(scale3(tail.across, Math.cos(angle)), scale3(tail.axis, -Math.sin(angle))); const L = K.TAIL.length; const rho = K.TAIL.radius; const lens = (u) => Math.sqrt(rho * rho - Math.pow(L * (u - 0.5), 2)) - Math.sqrt(rho * rho - L * L / 4); const at = (u, offset) => PH.place.project(frame.s, frame.m, add3(add3(tail.root, scale3(along, u * L)), scale3(side, offset))); const points = []; for (let j = 0; j <= STEPS; j += 1) { points.push(at(j / STEPS, lens(j / STEPS))); } for (let j = STEPS - 1; j > 0; j -= 1) { points.push(at(j / STEPS, -lens(j / STEPS))); } return { points, root: at(0, 0), tip: at(1, 0), depth: at(0.5, 0)[2] }; }; const tailDepth = (frame) => { const tail = tailFrame(frame); return PH.place.project(frame.s, frame.m, add3(tail.root, scale3(tail.axis, K.TAIL.length * 0.5)))[2] - 1; }; const paintHummingbirdTail = (c, frame, colors) => { const s = frame.s; const tail = tailFrame(frame); const tipColor = s.logo > 0.5 ? colors.tail : colors.tailTip; FEATHERS.map((i) => featherOf(frame, tail, i)).sort((a, b) => a.depth - b.depth).forEach((f) => { const g = c.createLinearGradient(f.root[0], f.root[1], f.tip[0], f.tip[1]); g.addColorStop(0, colors.tail); g.addColorStop(0.58, colors.tail); g.addColorStop(1, tipColor); c.fillStyle = g; c.beginPath(); c.moveTo(f.points[0][0], f.points[0][1]); f.points.slice(1).forEach((p) => c.lineTo(p[0], p[1])); c.closePath(); c.fill(); }); }; Object.assign(PH, { paintHummingbirdTail, tailDepth }); })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const K = PH.skeleton; const M = PH.motion; const RIM_OFFSET = [5, 7]; const RIM_ALPHA = 0.62; const MANDIBLE = { share: 0.62, offset: 0.38, widest: 0.9 }; const turned = (v, a) => [v[0] * Math.cos(a) - v[1] * Math.sin(a), v[0] * Math.sin(a) + v[1] * Math.cos(a)]; const mandiblesOf = (frame) => { const gape = M.clamp(frame.s.gape || 0, 0, MANDIBLE.widest); const tip = frame.bill.tip; const base = frame.bill.base; const r = frame.bill.r; if (gape <= 0.01) { return [{ tip: [tip[0], tip[1]], base: [base[0], base[1]], r }]; } const along = [tip[0] - base[0], tip[1] - base[1]]; const length = Math.hypot(along[0], along[1]) || 1; const u = [along[0] / length, along[1] / length]; const up = u[0] >= 0 ? [u[1], -u[0]] : [-u[1], u[0]]; const toward = u[0] * up[1] - u[1] * up[0] >= 0 ? 1 : -1; const jaw = (side) => { const at = [base[0] + side * up[0] * r * MANDIBLE.offset, base[1] + side * up[1] * r * MANDIBLE.offset]; const reach = turned(along, side * toward * gape / 2); return { tip: [base[0] + reach[0], base[1] + reach[1]], base: at, r: r * MANDIBLE.share }; }; return [jaw(1), jaw(-1)]; }; const traceCone = (p, cone) => { const d = Math.hypot(cone.tip[0] - cone.base[0], cone.tip[1] - cone.base[1]); if (d <= cone.r * 1.001) { return; } const back = Math.atan2(cone.tip[1] - cone.base[1], cone.tip[0] - cone.base[0]); const spread = Math.acos(cone.r / d); p.moveTo(cone.tip[0], cone.tip[1]); p.arc(cone.base[0], cone.base[1], cone.r, back + spread, back - spread + PH.TAU); p.closePath(); }; const outlineHummingbirdBody = (frame) => { const p = new Path2D(); PH.traceHummingbirdSilhouette(frame.spheres).forEach((contour) => { p.moveTo(contour[0].sx, contour[0].sy); contour.forEach((arc) => p.arc(arc.x, arc.y, arc.r, arc.from, arc.to)); p.closePath(); }); mandiblesOf(frame).forEach((cone) => traceCone(p, cone)); return p; }; const bodyGradient = (c, frame, colors, rim) => { const upper = M.mixHex(colors.bodyTop, colors.body, frame.s.logo); const g = c.createLinearGradient(0, frame.upperY, 0, frame.lowerY); g.addColorStop(0, M.mixHex(upper, colors.rim, rim)); g.addColorStop(0.55, M.mixHex(colors.body, colors.rim, rim)); g.addColorStop(1, M.mixHex(colors.body, colors.rim, rim)); return g; }; const paintGorget = (c, frame, colors, amount) => { const s = frame.s; const centre = PH.place.project(s, frame.m, PH.skinPoint(K.GORGET.at, 0, s, frame.yaw)); const facing = PH.place.turnVector(frame.m, PH.skinVector(K.GORGET.at, K.GORGET.normal, 0, s, frame.yaw)); const shine = M.clamp01(0.3 + 0.7 * Math.max(0, facing[2]) + 0.5 * s.glint + 0.12 * (s.throat || 0)); const r = (K.GORGET.r + 2.5 * (s.throat || 0)) * s.k; const along = [frame.bill.tip[0] - frame.bill.base[0], frame.bill.tip[1] - frame.bill.base[1]]; const reach = Math.hypot(along[0], along[1]) || 1; const lit = [centre[0] + along[0] / reach * r * 0.3, centre[1] + along[1] / reach * r * 0.3]; const g = c.createRadialGradient(lit[0], lit[1], 0, centre[0], centre[1], r); g.addColorStop(0, M.rgba(colors.gorgetB, 0.95 * amount * shine)); g.addColorStop(0.45, M.rgba(colors.gorgetA, 0.8 * amount * shine)); g.addColorStop(0.8, M.rgba(colors.gorgetC, 0.35 * amount * shine)); g.addColorStop(1, M.rgba(colors.gorgetC, 0)); c.fillStyle = g; c.beginPath(); c.arc(centre[0], centre[1], r, 0, PH.TAU); c.fill(); }; const paintBillEdge = (c, frame, colors) => { const s = frame.s; const tip = frame.bill.tip; const base = frame.bill.base; const full = Math.hypot(K.BILL.tip[0] - K.BILL.base[0], K.BILL.tip[1] - K.BILL.base[1]); const shown = Math.hypot(tip[0] - base[0], tip[1] - base[1]) / (s.k * full); const toward = M.clamp01((tip[2] - base[2]) / full * 1.6); const r = frame.bill.r; const d = Math.hypot(tip[0] - base[0], tip[1] - base[1]); const alpha = 0.8 * toward * M.clamp01((1 - shown) * 1.4) * M.clamp01((d - r) / (2 * r)) * (1 - s.logo) * (1 - M.clamp01((s.gape || 0) / 0.05)); if (alpha <= 0.01) { return; } const back = Math.atan2(tip[1] - base[1], tip[0] - base[0]); const spread = Math.acos(r / d); c.save(); c.strokeStyle = M.rgba(colors.rim, alpha); c.lineWidth = Math.max(0.8, 3.2 * s.k); c.lineCap = 'round'; c.beginPath(); c.moveTo(base[0] + r * Math.cos(back + spread), base[1] + r * Math.sin(back + spread)); c.lineTo(tip[0], tip[1]); c.lineTo(base[0] + r * Math.cos(back - spread), base[1] + r * Math.sin(back - spread)); c.stroke(); c.restore(); }; const paintHummingbirdBody = (c, frame, colors, body, detail) => { const s = frame.s; const rim = detail >= 1 ? s.rim * (1 - s.logo) : 0; const glow = s.gorget * (1 - s.logo); c.fillStyle = bodyGradient(c, frame, colors, rim > 0.01 ? RIM_ALPHA * rim : 0); c.fill(body); if (rim > 0.01 || glow > 0.01) { c.save(); c.clip(body); if (rim > 0.01) { c.save(); c.translate(RIM_OFFSET[0] * s.k, RIM_OFFSET[1] * s.k); c.fillStyle = bodyGradient(c, frame, colors, 0); c.fill(body); c.restore(); } if (glow > 0.01) { paintGorget(c, frame, colors, glow); } c.restore(); } paintBillEdge(c, frame, colors); }; Object.assign(PH, { mandiblesOf, outlineHummingbirdBody, paintHummingbirdBody }); })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const K = PH.skeleton; const M = PH.motion; const FADE = 0.18; const LID = { from: [381, 325.5], via: [397.5, 334.5], to: [414, 324.5], width: 3.6 }; const CATCHLIGHT = { at: [405.5, 318.5], r: 2.7 }; const cache = { eye: null }; const eyeOutline = () => { if (!cache.eye) { cache.eye = new Path2D(PH.sacred.paths.eye); } return cache.eye; }; const paintOneEye = (c, frame, colors, detail, decal) => { const s = frame.s; const centre = K.EYE.at; c.save(); c.globalAlpha *= M.clamp01(decal.facing / FADE); c.transform(decal.a, decal.b, decal.c, decal.d, decal.e, decal.f); if (s.eyeOpen > 0.16) { c.translate(centre[0], centre[1]); c.scale(1, s.eyeOpen); c.translate(-centre[0], -centre[1]); c.fillStyle = colors.eye; c.fill(eyeOutline()); if (detail >= 1 && s.logo < 0.5 && s.livery > 0.5) { c.fillStyle = M.rgba(colors.catchlight, 0.95 * (s.livery - 0.5) * 2); c.beginPath(); c.arc(CATCHLIGHT.at[0], CATCHLIGHT.at[1], CATCHLIGHT.r, 0, PH.TAU); c.fill(); } } else { c.strokeStyle = colors.eye; c.lineWidth = LID.width; c.lineCap = 'round'; c.beginPath(); c.moveTo(LID.from[0], LID.from[1]); c.quadraticCurveTo(LID.via[0], LID.via[1], LID.to[0], LID.to[1]); c.stroke(); } c.restore(); }; const paintHummingbirdEye = (c, frame, colors, detail) => { [1, -1].forEach((side) => { const decal = PH.place.decalOf(frame, K.EYE.at, K.EYE.normal, 0, side); if (decal.facing > 0.004) { paintOneEye(c, frame, colors, detail, decal); } }); }; PH.paintHummingbirdEye = paintHummingbirdEye; })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const K = PH.skeleton; const M = PH.motion; const LIVERIES = { ink: { body: '#09122a', bodyTop: '#172c55', rim: '#1bbaec', eye: '#fefefe', catchlight: '#09122a', tail: '#0b1730', tailTip: '#1bbaec', wingRoot: '#c9f1ff', wingMid: '#45c8f0', wingTip: '#1bbaec', wingUnder: '#eefaff', farWingRoot: '#7fd8f5', farWingTip: '#0e7fa3', shaft: '#0b5f7d', gorgetA: '#1bbaec', gorgetB: '#9ae6ff', gorgetC: '#20d580', shadow: '#09122a' }, night: { body: '#f4fbff', bodyTop: '#ffffff', rim: '#9ae6ff', eye: '#09122a', catchlight: '#fefefe', tail: '#d6e8f5', tailTip: '#9ae6ff', wingRoot: '#ffffff', wingMid: '#d4f4ff', wingTip: '#9ae6ff', wingUnder: '#ffffff', farWingRoot: '#9ae6ff', farWingTip: '#1bbaec', shaft: '#7fbfdc', gorgetA: '#1bbaec', gorgetB: '#20d580', gorgetC: '#9ae6ff', shadow: '#000000' } }; const REST = { x: 0, y: 0, k: 0.3, azimuth: 0, climb: 0, bank: 0, pitch: K.PITCH.hover, stretch: 1, headTilt: 0, headTurn: 0, headYaw: 0, tailSpread: 0.36, tailLift: 0, wingPhase: 0, wings: 1, wingAlpha: 1, fold: 0, foldNear: null, foldFar: null, nearLift: 0, blur: 1, blurSpan: 2.3, eyeOpen: 1, gorget: 0.55, glint: 0, throat: 0, puff: 0, livery: 0, rim: 1, alpha: 1, logo: 0, nest: null, depth: 0, ground: null, gape: 0 }; const cache = { bird: null }; const colorsFor = (livery) => { const out = {}; Object.keys(LIVERIES.ink).forEach((key) => { if (Object.prototype.hasOwnProperty.call(LIVERIES.night, key)) { out[key] = M.mixHex(LIVERIES.ink[key], LIVERIES.night[key], livery); } }); return out; }; const clipToNest = (c, nest) => { const before = c.getTransform(); c.translate(nest.x, nest.y); c.scale(nest.k, nest.k); c.translate(-K.TIP[0], -K.TIP[1]); const rim = K.NEST_RIM_Y + 900 * M.clamp01(nest.open || 0); const visible = new Path2D(PH.mark.cloud); visible.moveTo(K.TIP[0] - 8000, K.TIP[1] - 8000); visible.lineTo(K.TIP[0] - 8000, rim); visible.lineTo(K.TIP[0] + 8000, rim); visible.lineTo(K.TIP[0] + 8000, K.TIP[1] - 8000); visible.closePath(); c.clip(visible); c.setTransform(before); }; const layersOf = (c, frame, colors, detail) => { const s = frame.s; const winged = s.wings > 0.01 || s.fold > 0 || (s.foldNear !== null && s.foldNear < 1); const layers = [{ depth: PH.tailDepth(frame), paint: () => PH.paintHummingbirdTail(c, frame, colors) }]; const body = PH.outlineHummingbirdBody(frame); layers.push({ depth: 0, paint: () => { PH.paintHummingbirdBody(c, frame, colors, body, detail); PH.paintHummingbirdEye(c, frame, colors, detail); } }); if (winged) { [1, -1].forEach((side) => layers.push({ depth: PH.wingDepth(frame, side), paint: () => PH.paintHummingbirdWing(c, frame, colors, side, detail) })); } return layers.sort((a, b) => a.depth - b.depth); }; const drawHummingbird = (c, input, options) => { const s = Object.assign({}, REST, input); if (s.alpha <= 0.004) { return; } const opts = options || {}; const detail = opts.detail === undefined ? PH.place.detailFor(s, opts.pixelRatio) : opts.detail; const frame = PH.place.frameOf(s); c.save(); c.globalAlpha *= s.alpha; if (s.nest) { clipToNest(c, s.nest); } const colors = PH.depth.hazeColors(colorsFor(M.clamp01(s.livery)), s.depth, s.ground || PH.depth.groundOf(s.livery)); layersOf(c, frame, colors, detail).forEach((layer) => layer.paint()); c.restore(); }; const drawLogoBird = (c, at, colors) => { if (!cache.bird) { cache.bird = new Path2D(PH.mark.bird); } c.save(); c.translate(at.x, at.y); c.scale(at.k, at.k); c.translate(-K.TIP[0], -K.TIP[1]); c.fillStyle = (colors && colors.bird) || LIVERIES.ink.body; c.fill(cache.bird); c.restore(); }; const atTip = (fields, tip) => { const s = Object.assign({}, REST, fields); return PH.place.placeBy(s, PH.place.tipLocal(s), tip); }; Object.assign(PH, { version: '3.1.0', LIVERIES, REST, state: (fields) => Object.assign({}, REST, fields), atTip, colorsFor, drawHummingbird, drawLogoBird }); })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const K = PH.skeleton; const M = PH.motion; const CRUISE_SPEED = 1100; const TURN = { seconds: 0.6, share: 0.8 }; const HEAD_LEAD = 0.09; const CLIMB_LIMIT = 0.75; const BANK = { gain: 0.07, limit: 0.42 }; const LEAVE_RISE = 0.62; const ARRIVE_DROP = 0.32; const sub = (a, b) => [a[0] - b[0], a[1] - b[1]]; const plus = (a, b) => [a[0] + b[0], a[1] + b[1]]; const times = (a, s) => [a[0] * s, a[1] * s]; const dot = (a, b) => a[0] * b[0] + a[1] * b[1]; const unit = (a) => times(a, 1 / (Math.hypot(a[0], a[1]) || 1)); const lineSegment = (p, q) => ({ kind: 'line', p, dir: unit(sub(q, p)), length: Math.hypot(q[0] - p[0], q[1] - p[1]) }); const arcSegment = (p, tangent, q) => { const chord = sub(q, p); const normal = [-tangent[1], tangent[0]]; const lean = dot(chord, normal); if (Math.abs(lean) < 1e-6 * Math.max(1, dot(chord, chord))) { return lineSegment(p, q); } const r = dot(chord, chord) / (2 * lean); const centre = plus(p, times(normal, r)); const a0 = Math.atan2(p[1] - centre[1], p[0] - centre[0]); const a1 = Math.atan2(q[1] - centre[1], q[0] - centre[0]); const turn = r > 0 ? 1 : -1; let sweep = a1 - a0; if (turn > 0) { while (sweep <= 0) { sweep += PH.TAU; } } else { while (sweep >= 0) { sweep -= PH.TAU; } } return { kind: 'arc', centre, r: Math.abs(r), a0, sweep, length: Math.abs(sweep) * Math.abs(r) }; }; const biarc = (p0, t0, p1, t1) => { const v = sub(p1, p0); const t = plus(t0, t1); const tt = dot(t0, t1); const vv = dot(v, v); if (vv < 1e-9) { return []; } let d; if (1 - tt < 1e-9) { const vt = dot(v, t0); d = vt > 1e-9 ? vv / (4 * vt) : Math.sqrt(vv) / 2; } else { const vt = dot(v, t); d = (vt - Math.sqrt(vt * vt + 2 * (1 - tt) * vv)) / (2 * (tt - 1)); } const q0 = plus(p0, times(t0, d)); const q1 = sub(p1, times(t1, d)); const join = times(plus(q0, q1), 0.5); const tj = unit(sub(q1, q0)); return [arcSegment(p0, t0, join), arcSegment(join, tj, p1)].filter((s) => s.length > 1e-6); }; const pathOf = (segments) => { let total = 0; const parts = segments.map((s) => { const part = Object.assign({ from: total }, s); total += s.length; return part; }); return { parts, length: total }; }; const pathAt = (path, distance) => { const d = M.clamp(distance, 0, path.length); const part = path.parts.find((p) => d <= p.from + p.length + 1e-9) || path.parts[path.parts.length - 1]; if (!part) { return { point: [0, 0], tangent: [1, 0] }; } const s = d - part.from; if (part.kind === 'line') { return { point: plus(part.p, times(part.dir, s)), tangent: part.dir }; } const sign = part.sweep > 0 ? 1 : -1; const a = part.a0 + sign * s / part.r; return { point: [part.centre[0] + part.r * Math.cos(a), part.centre[1] + part.r * Math.sin(a)], tangent: [-Math.sin(a) * sign, Math.cos(a) * sign] }; }; const facingOf = (dx) => (dx >= 0 ? 0 : Math.PI); const leaveDirection = (from, to, rise) => { const side = to[0] >= from[0] ? 1 : -1; const a = rise === undefined ? LEAVE_RISE : rise; return [side * Math.cos(a), -Math.sin(a)]; }; const arriveDirection = (from, to, drop) => { const side = to[0] >= from[0] ? 1 : -1; const a = drop === undefined ? ARRIVE_DROP : drop; return [side * Math.cos(a), Math.sin(a)]; }; const flightPath = (from, to, options) => { const o = options || {}; const leave = o.leave ? unit(o.leave) : leaveDirection(from, to, o.rise); const arrive = o.arrive ? unit(o.arrive) : arriveDirection(from, to, o.drop); return pathOf(biarc(from, leave, to, arrive)); }; const travelOf = (spec, time) => { const tau = M.clamp01((time - spec.start) / spec.duration); const L = spec.path.length; const lead = Math.min(3 * L, (spec.startSpeed || 0) * spec.duration); return M.clamp(L * (3 * tau * tau - 2 * tau * tau * tau) + lead * (tau - 2 * tau * tau + tau * tau * tau), 0, L); }; const speedOf = (spec, time) => (travelOf(spec, time + 0.012) - travelOf(spec, time - 0.012)) / 0.024; const azimuthOf = (spec, time) => { const from = spec.fromAzimuth === undefined ? spec.toAzimuth : spec.fromAzimuth; const u = M.ease.inOutSine(M.span(time - spec.start, 0, Math.min(TURN.seconds, TURN.share * spec.duration))); return M.lerp(from, spec.toAzimuth, u); }; const climbOf = (tangent, pace) => M.clamp(Math.atan2(-tangent[1], Math.abs(tangent[0])), -CLIMB_LIMIT, CLIMB_LIMIT) * M.clamp01(pace * 1.6); const bankOf = (turnRate) => M.clamp(-BANK.gain * turnRate, -BANK.limit, BANK.limit); const wingFields = (t, hz, fps) => ({ wingPhase: PH.TAU * hz * t, wings: 1, fold: 0, foldNear: null, foldFar: null, nearLift: 0, blur: 1, blurSpan: Math.min(2.6, PH.TAU * hz / (fps || 60)) }); const poseHummingbirdFlight = (spec, t) => { const tau = M.clamp01((t - spec.start) / spec.duration); const at = pathAt(spec.path, travelOf(spec, t)); const paceAt = (time) => M.clamp01(speedOf(spec, time) / (CRUISE_SPEED * spec.k / 0.3)); const pace = paceAt(t); const pitch = M.follow((time) => (time >= spec.start + spec.duration ? K.PITCH.hover : M.lerp(K.PITCH.brake, K.PITCH.cruise, paceAt(time))), t, M.BODY_SPRING, 0.6); const azimuth = azimuthOf(spec, t); const turnRate = (azimuthOf(spec, t + 0.02) - azimuthOf(spec, t - 0.02)) / 0.04; const arrive = M.span(tau, 0.72, 1); return Object.assign({ x: at.point[0], y: at.point[1], k: spec.k, azimuth, headYaw: azimuthOf(spec, t + HEAD_LEAD) - azimuth, climb: climbOf(at.tangent, pace), bank: bankOf(turnRate), pitch, stretch: M.lerp(1.04, 0.98, arrive), tailSpread: 0.36 + 0.42 * M.bump(M.span(tau, 0.68, 1.08)) + 0.3 * M.clamp01(Math.abs(turnRate) / 6), tailLift: -0.1 * arrive, headTilt: 0, headTurn: 0, eyeOpen: 1, glint: M.clamp01(0.25 + 0.75 * Math.sin(azimuth)), livery: spec.livery || 0, gorget: 0.55, throat: 0, puff: 0 }, wingFields(t, spec.wingHz || 11.25, spec.fps)); }; PH.flight = { CRUISE_SPEED, TURN, HEAD_LEAD, biarc, pathOf, pathAt, flightPath, travelOf, speedOf, facingOf, azimuthOf, climbOf, bankOf, wingFields, poseHummingbirdFlight }; })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const K = PH.skeleton; const M = PH.motion; const poseHummingbirdHover = (spot, t, since, seed, k, extra) => { const more = extra || {}; const h = Math.max(0, t - since); const grow = M.ease.inOutCubic(M.span(h, 0.05, 0.7)); const scale = k / 0.3; const lift = 7 * scale * Math.sin(Math.PI * M.span(h, 0, 0.45)); return Object.assign({ x: spot[0] + grow * scale * (7 * Math.sin(1.9 * h + M.hash(seed, 4) * 3) + 2.5 * Math.sin(4.7 * h)), y: spot[1] - lift + grow * scale * (5 * Math.sin(3.8 * h + M.hash(seed, 5) * 3) + 2 * Math.sin(8.3 * h + 1.3)), azimuth: more.azimuth || 0, climb: 0, bank: 0, headYaw: 0, k, pitch: K.PITCH.hover + 0.07 * Math.sin(PH.TAU * 1.3 * h), stretch: 1 - 0.045 * M.bump(M.span(h, 0, 0.22)), tailSpread: 0.36 + 0.45 * Math.exp(-h / 0.2) * (h < 0.4 ? 1 : 0), tailLift: 0.08 * Math.sin(PH.TAU * 1.3 * h + 1), headTilt: 0.03 * Math.sin(4.1 * h), headTurn: 0, eyeOpen: 1, glint: 0.3 + 0.2 * Math.sin(h * 2.1), gorget: 0.55, throat: 0, puff: 0, livery: more.livery || 0 }, PH.flight.wingFields(t, more.wingHz || 11.25, more.fps)); }; PH.poseHummingbirdHover = poseHummingbirdHover; })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const K = PH.skeleton; const M = PH.motion; const TAU = PH.TAU; const SLEEP_IN = 1.6; const WAKE_IN = 0.45; const THROAT_HZ = 2.6; const WING_HZ = 11.25; const FRONT = Math.PI / 2; const perched = (k, livery, azimuth) => ({ azimuth: azimuth || 0, climb: 0, bank: 0, headYaw: 0, k, pitch: K.PITCH.perch, stretch: 1, tailSpread: 0.22, tailLift: 0.1, headTilt: 0, headTurn: 0, wingPhase: 0, wings: 0, fold: 1, foldNear: null, foldFar: null, nearLift: 0, blur: 0, eyeOpen: 1, gorget: 0.5, glint: 0.2, throat: 0, puff: 0, livery: livery || 0 }); const ACTIONS = { blink: { duration: 0.16, apply: (s, u) => { s.eyeOpen = Math.min(s.eyeOpen, 1 - 0.94 * M.bump(u)); } }, doubleBlink: { duration: 0.42, apply: (s, u) => { s.eyeOpen = Math.min(s.eyeOpen, 1 - 0.94 * (M.bump(u / 0.38) + M.bump((u - 0.62) / 0.38))); } }, look: { duration: 1.5, apply: (s, u, p) => { s.headTilt += (p.tilt === undefined ? -0.22 : p.tilt) * M.snap(u, 0.06, 0.07); } }, glance: { duration: 0.9, apply: (s, u, p) => { const a = M.snap(u, 0.09, 0.1); s.headTilt += (p.tilt === undefined ? 0.16 : p.tilt) * a; s.glint = Math.max(s.glint, 0.8 * a); } }, headFlick: { duration: 0.8, apply: (s, u, p) => { const a = M.snap(u, 0.09, 0.1); s.headTurn = Math.max(s.headTurn, (p.turn === undefined ? 0.8 : p.turn) * a); s.headTilt += (p.tilt || 0) * a; s.glint = Math.max(s.glint, a); } }, shuffle: { duration: 0.46, apply: (s, u, p) => { const hop = u < 0.5 ? u / 0.5 : (u - 0.5) / 0.5; const done = (u < 0.5 ? 0 : 1) + M.ease.inOutSine(hop); s.dx += (p.step || 6) * done; s.dy -= (p.hop || 4) * M.bump(hop); s.pitch += 0.05 * M.bump(hop); s.tailLift -= 0.08 * M.bump(hop); }, commit: (s, p) => { s.dx += 2 * (p.step || 6); } }, turnaround: { duration: 0.62, apply: (s, u, p) => { const from = s.azimuth; const body = M.ease.inOutSine(M.span(u, 0.12, 1)); const head = M.ease.inOutSine(M.span(u, 0, 0.78)); s.azimuth = M.lerp(from, Math.PI - from, body); s.headYaw += M.lerp(from, Math.PI - from, head) - s.azimuth; s.dy -= (p.hop || 7) * M.bump(M.span(u, 0.1, 0.9)); s.tailSpread += 0.25 * M.bump(u); s.glint = Math.max(s.glint, M.bump(u)); }, commit: (s) => { s.azimuth = Math.PI - s.azimuth; } }, preen: { duration: 1.5, apply: (s, u) => { const a = M.envelope(u, 0.16, 0.18); s.headTilt += 0.78 * a + 0.07 * a * Math.sin(TAU * 10.5 * u); s.eyeOpen = Math.min(s.eyeOpen, 1 - 0.45 * a); s.pitch += 0.06 * a; s.puff += 0.35 * a; s.tailSpread += 0.1 * a; } }, wingStretch: { duration: 1.2, apply: (s, u) => { const a = M.envelope(u, 0.22, 0.25); s.foldNear = 1 - 0.82 * a; s.nearLift = -1.05 * a; s.wings = Math.max(s.wings, 0.8 * a); s.tailSpread += 0.35 * a; s.eyeOpen = Math.min(s.eyeOpen, 1 - 0.3 * a); } }, tailFlick: { duration: 0.34, apply: (s, u) => { s.tailSpread += 0.6 * M.bump(u); s.tailLift -= 0.2 * M.bump(u); } }, tailPump: { duration: 0.5, apply: (s, u) => { const a = M.bump(u / 0.5) + M.bump((u - 0.5) / 0.5); s.tailLift -= 0.16 * a; s.tailSpread += 0.12 * a; } }, shake: { duration: 0.42, apply: (s, u) => { const a = M.bump(u); s.puff += 0.9 * a; s.stretch += 0.03 * a * Math.sin(TAU * 12 * u); s.headTilt += 0.05 * a * Math.sin(TAU * 12 * u + 1); s.tailSpread += 0.3 * a; s.eyeOpen = Math.min(s.eyeOpen, 1 - 0.8 * a); s.foldNear = 1 - 0.12 * a; s.foldFar = 1 - 0.12 * a; } }, bop: { duration: 0.7, apply: (s, u, p) => { const a = M.bump(u); s.headTilt += (p.tilt === undefined ? -0.14 : p.tilt) * M.snap(u, 0.12, 0.2); s.pitch += 0.05 * a; s.dy -= 3 * (s.k / 0.3) * a; } }, greet: { duration: 1.8, apply: (s, u) => { const a = M.envelope(u, 0.28, 0.3); const lift = M.bump(M.span(u, 0.36, 0.64)); s.azimuth = M.lerp(s.azimuth, FRONT, 0.42 * a); s.headTurn = Math.max(s.headTurn, a); s.headTilt += -0.08 * a; s.glint = Math.max(s.glint, a); s.gorget = Math.max(s.gorget, 0.5 + 0.4 * a); s.tailSpread += 0.32 * lift; s.dy -= 4 * (s.k / 0.3) * lift; } }, billWipe: { duration: 1.3, apply: (s, u) => { const a = M.envelope(u, 0.22, 0.24); const wipe = Math.sin(TAU * 1.6 * M.span(u, 0.22, 0.78)); s.pitch += 0.34 * a; s.headTilt += 0.95 * a; s.headYaw += 0.45 * a * wipe; s.dx += 4 * (s.k / 0.3) * a * wipe; s.tailLift -= 0.12 * a; s.eyeOpen = Math.min(s.eyeOpen, 1 - 0.25 * a); } }, yawn: { duration: 1.5, apply: (s, u) => { const a = M.envelope(u, 0.3, 0.36); s.gape = Math.max(s.gape || 0, 0.42 * M.envelope(u, 0.38, 0.4)); s.headTilt += -0.3 * a; s.eyeOpen = Math.min(s.eyeOpen, 1 - 0.7 * a); s.stretch += 0.03 * a; s.puff += 0.2 * a; s.tailSpread += 0.15 * a; } }, sun: { duration: 3.2, apply: (s, u) => { const a = M.envelope(u, 0.24, 0.28); s.foldNear = 1 - 0.12 * a; s.nearLift = 0.55 * a; s.tailSpread += 0.65 * a; s.puff += 0.55 * a; s.headTilt += -0.18 * a; s.eyeOpen = Math.min(s.eyeOpen, 1 - 0.4 * a); s.glint = Math.max(s.glint, 0.6 * a); s.pitch += 0.05 * a; } }, hoverHop: { duration: 2, apply: (s, u, p) => { const lift = M.envelope(u, 0.22, 0.26); const from = s.azimuth; const body = M.ease.inOutSine(M.span(u, 0.3, 0.72)); const head = M.ease.inOutSine(M.span(u, 0.24, 0.64)); s.fold = 1 - lift; s.wings = Math.max(s.wings, lift); s.blur = Math.max(s.blur || 0, lift); s.wingPhase = TAU * WING_HZ * u * 2; s.pitch = M.lerp(s.pitch, K.PITCH.hover, lift); s.dy -= (p.rise || 16) * (s.k / 0.3) * lift; s.azimuth = M.lerp(from, Math.PI - from, body); s.headYaw += M.lerp(from, Math.PI - from, head) - s.azimuth; s.tailSpread += 0.35 * lift; s.glint = Math.max(s.glint, M.bump(M.span(u, 0.3, 0.72))); }, commit: (s) => { s.azimuth = Math.PI - s.azimuth; } }, doze: { duration: 1.9, apply: (s, u) => { const sink = M.ease.inOutSine(M.span(u, 0, 0.72)); const wake = M.ease.outCubic(M.span(u, 0.74, 0.82)); const a = sink * (1 - wake); s.eyeOpen = Math.min(s.eyeOpen, 1 - 0.7 * a); s.headTilt += 0.16 * a; s.puff += 0.25 * a; s.glint = Math.max(s.glint, wake * (1 - M.span(u, 0.82, 1))); } } }; const breathOf = (plan) => (plan.breathe === undefined ? 1 : plan.breathe); const sleepLevel = (t, since, wakeAt) => { if (since === null || since === undefined || t < since) { return 0; } let level = M.ease.inOutSine(M.span(t - since, 0, SLEEP_IN)); if (wakeAt !== null && wakeAt !== undefined && t >= wakeAt) { level *= 1 - M.ease.inOutSine(M.span(t - wakeAt, 0, WAKE_IN)); } return level; }; const applySleep = (s, level, t, breath) => { if (level <= 0) { return s; } const lids = M.clamp01(level * 1.6); const lean = M.clamp01(level * 1.25 - 0.25); const rock = lean * (breath === undefined ? 1 : breath); s.eyeOpen = Math.min(s.eyeOpen, 1 - lids); s.headTilt += -0.72 * lean + 0.03 * rock * Math.sin(TAU * 0.11 * t); s.puff += 1.05 * lean + 0.2 * rock * Math.sin(TAU * 0.22 * t); s.pitch += -0.03 * lean + 0.022 * rock * Math.sin(TAU * 0.11 * t + 0.4); s.tailLift += 0.12 * lean; s.tailSpread -= 0.08 * lean; s.gorget *= 1 - 0.6 * lean; s.throat *= 1 - lean; return s; }; const applyAction = (s, action, t) => { const def = ACTIONS[action.name]; const u = (t - action.start) / def.duration; if (u >= 1 && def.commit) { def.commit(s, action.params || {}); return; } if (u <= 0 || u >= 1) { return; } def.apply(s, u, action.params || {}); }; const blinkCycle = (seed, t) => 2.6 + 3.2 * M.hash(seed, Math.floor(t / 4)); const livelyIn = (plan, t) => { if (breathOf(plan) > 0) { return 0; } const settling = plan.sleepSince !== null && plan.sleepSince !== undefined && t >= plan.sleepSince && t - plan.sleepSince < SLEEP_IN; const waking = plan.wakeAt !== null && plan.wakeAt !== undefined && t >= plan.wakeAt && t - plan.wakeAt < WAKE_IN; if (settling || waking) { return 0; } let next = Infinity; (plan.actions || []).forEach((action) => { const def = ACTIONS[action.name]; if (t >= action.start && t < action.start + def.duration) { next = 0; } else if (action.start > t) { next = Math.min(next, action.start - t); } }); if (next === 0 || sleepLevel(t, plan.sleepSince, plan.wakeAt) >= 0.5) { return next; } const every = blinkCycle(plan.seed || 1, t); const phase = t % every; return phase < 0.16 ? 0 : Math.min(next, every - phase); }; const poseHummingbirdPerch = (base, t, plan) => { const s = Object.assign({}, base, { dx: 0, dy: 0 }); const seed = plan.seed || 1; const level = sleepLevel(t, plan.sleepSince, plan.wakeAt); s.throat = 0.5 + 0.5 * breathOf(plan) * Math.sin(TAU * THROAT_HZ * t + M.hash(seed, 9) * TAU); (plan.actions || []).slice().sort((a, b) => a.start - b.start).forEach((action) => applyAction(s, action, t)); applySleep(s, level, t, breathOf(plan)); if (level < 0.5) { const blinkEvery = blinkCycle(seed, t); const phase = t % blinkEvery; if (phase < 0.16) { s.eyeOpen = Math.min(s.eyeOpen, 1 - 0.94 * M.bump(phase / 0.16)); } } return s; }; PH.perch = { SLEEP_IN, WAKE_IN, ACTIONS, perched, breathOf, sleepLevel, applySleep, applyAction, livelyIn, poseHummingbirdPerch }; })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const M = PH.motion; const IDLE_MENU = [ { name: 'headFlick', weight: 3.2 }, { name: 'look', weight: 2.2 }, { name: 'glance', weight: 1.6 }, { name: 'tailPump', weight: 1.6 }, { name: 'shuffle', weight: 1.4 }, { name: 'turnaround', weight: 1.1 }, { name: 'preen', weight: 1.2 }, { name: 'bop', weight: 1 }, { name: 'wingStretch', weight: 0.7 }, { name: 'shake', weight: 0.6 }, { name: 'tailFlick', weight: 0.9 }, { name: 'doubleBlink', weight: 0.8 }, { name: 'billWipe', weight: 0.6 }, { name: 'yawn', weight: 0.25 } ]; const TOTAL = IDLE_MENU.reduce((sum, item) => sum + item.weight, 0); const paramsFor = (name, r, k, count) => { if (name === 'headFlick') { return { turn: 0.55 + 0.35 * r, tilt: r < 0.5 ? -0.06 : 0.05 }; } if (name === 'look') { return { tilt: r < 0.5 ? -0.24 : 0.2 }; } if (name === 'glance') { return { tilt: r < 0.5 ? 0.18 : -0.12 }; } if (name === 'shuffle') { return { step: (count % 2 === 0 ? 1 : -1) * 22 * k, hop: 14 * k }; } if (name === 'bop') { return { tilt: r < 0.5 ? -0.14 : 0.1 }; } return {}; }; const pickHummingbirdIdle = (seed, n, k, count) => { let r = M.hash(seed, n * 7 + 3) * TOTAL; for (let i = 0; i < IDLE_MENU.length; i += 1) { r -= IDLE_MENU[i].weight; if (r <= 0) { return { name: IDLE_MENU[i].name, params: paramsFor(IDLE_MENU[i].name, M.hash(seed, n * 7 + 5), k, count) }; } } return { name: 'look', params: { tilt: -0.2 } }; }; const planHummingbirdIdle = (seed, startAt, until, k, pace) => { const actions = []; const spacing = pace || 1; let t = startAt + 0.7 + 1.1 * M.hash(seed, 0); let shuffles = 0; for (let n = 0; t < until && n < 600; n += 1) { const pick = pickHummingbirdIdle(seed, n, k, shuffles); if (pick.name === 'shuffle') { shuffles += 1; } actions.push({ name: pick.name, start: t, params: pick.params }); t += PH.perch.ACTIONS[pick.name].duration + spacing * (0.8 + 2.4 * M.hash(seed, n * 7 + 11)); } return actions; }; PH.idle = { IDLE_MENU, pickHummingbirdIdle, planHummingbirdIdle }; })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const K = PH.skeleton; const M = PH.motion; const BLENDED = ['x', 'y', 'pitch', 'tailSpread', 'tailLift', 'headTilt', 'stretch', 'puff', 'livery', 'azimuth', 'climb', 'bank', 'headYaw']; const BACK = { seconds: 0.26, distance: 18, rise: 10 }; const poseHummingbirdLanding = (hoverState, perchState, t, start, duration) => { const u = M.clamp01((t - start) / duration); const e = M.ease.inOutCubic(u); const s = Object.assign({}, hoverState); BLENDED.forEach((key) => { if (Object.prototype.hasOwnProperty.call(perchState, key) && Object.prototype.hasOwnProperty.call(hoverState, key)) { s[key] = M.lerp(hoverState[key], perchState[key], e); } }); s.fold = M.clamp01((u - 0.55) / 0.45); s.wings = 1 - s.fold; s.blur = 1 - s.fold; s.stretch -= 0.04 * M.bump(M.span(u, 0.75, 1.15)); s.tailSpread += 0.3 * M.bump(M.span(u, 0.5, 1)); return s; }; const poseHummingbirdTakeOff = (perchState, t, start) => { const u = M.clamp01((t - start) / 0.16); const away = M.ease.outCubic(M.clamp01((t - start) / BACK.seconds)); const scale = perchState.k / 0.3; const facing = Math.cos(perchState.azimuth || 0) >= 0 ? 1 : -1; const s = Object.assign({}, perchState); s.fold = 1 - u; s.wings = u; s.blur = u; s.pitch = M.lerp(perchState.pitch, K.PITCH.hover, u); s.dy = (s.dy || 0) - BACK.rise * scale * away; s.dx = (s.dx || 0) - facing * BACK.distance * scale * away; return s; }; PH.landing = { BACK, poseHummingbirdLanding, poseHummingbirdTakeOff }; })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const SITE = (PH.site = PH.site || {}); const NEVER = '[data-hummingbird="never"]'; const cache = { bird: null, eye: null, header: null }; const findMarkPath = (root, d) => { const paths = root.querySelectorAll('svg path'); for (let i = 0; i < paths.length; i += 1) { if (paths[i].getAttribute('d') === d) { return paths[i]; } } return null; }; const hasBox = (el) => { const box = el.getBoundingClientRect(); return box.width >= 4 && box.height >= 4; }; const nestIn = (header) => { if (header.closest(NEVER)) { return null; } const bird = findMarkPath(header, PH.mark.bird); return bird && !bird.closest(NEVER) && hasBox(bird) ? bird : null; }; const resolveLogoBird = () => { if (cache.bird && cache.bird.isConnected) { return cache; } cache.bird = null; cache.eye = null; cache.header = null; const headers = document.querySelectorAll('header'); for (let i = 0; i < headers.length; i += 1) { const bird = nestIn(headers[i]); if (bird) { cache.bird = bird; cache.eye = findMarkPath(bird.ownerSVGElement || headers[i], PH.mark.eye); cache.header = headers[i]; return cache; } } return cache; }; const readHummingbirdNest = () => { const found = resolveLogoBird(); if (!found.bird || typeof found.bird.getScreenCTM !== 'function') { return null; } if (!hasBox(found.bird)) { found.bird = null; return null; } const m = found.bird.getScreenCTM(); if (!m) { return null; } const tip = PH.skeleton.TIP; return { x: m.a * tip[0] + m.c * tip[1] + m.e, y: m.b * tip[0] + m.d * tip[1] + m.f, k: Math.hypot(m.a, m.b) }; }; const headerOf = () => resolveLogoBird().header; const showLogoBird = (visible) => { const found = resolveLogoBird(); [found.bird, found.eye].forEach((el) => { if (el) { el.style.visibility = visible ? '' : 'hidden'; } }); }; SITE.nest = { readHummingbirdNest, headerOf, showLogoBird }; })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const SITE = (PH.site = PH.site || {}); const PERCH_SELECTOR = [ '.gs-job-composer', '.pc-label', '.pc-bos-figure', '.pc-os-figure', '.pc-soft-figure', '.pc-office-figure', '.pc-cockpit-figure', '.pc-atlas-card', '.fig-approval', '.pc-btn--primary', 'h1:not(figure *)', 'h2:not(figure *)', '[class*="card"]:not(figure *)', '[data-hummingbird="perch"]' ].join(','); const REFUSED_SELECTOR = '.fig-approval button, .fig-approval [role="button"], .fig-approval .pc-btn, [data-hummingbird="never"]'; const SOLID = new Set([ 'BUTTON', 'IMG', 'INPUT', 'TEXTAREA', 'SELECT', 'VIDEO', 'CANVAS', 'IFRAME', 'path', 'circle', 'rect', 'ellipse', 'line', 'polyline', 'polygon', 'text', 'tspan', 'use', 'image' ]); const TEXT_PERCHES = ['H1', 'H2']; const CAP_INSET = 0.2; const NIGHT_LUMA = 0.4; const GLYPH_MARGIN = 6; const SWEEP = [0.92, 0.08, 0.85, 0.15, 0.7, 0.3, 0.5]; const PROBE_X = [-0.7, -0.35, 0, 0.35, 0.7]; const PROBE_Y = [0.1, 0.35, 0.6, 0.85, 1.1]; const VERDICT_TTL = 3; const DEPTH_TYPE = { near: 48, far: 14 }; const DEPTH_BOX = { near: 5, far: 2 }; const BIRD_LENGTH = 400; const DEPTH_WORDS = { near: 0, mid: 0.5, far: 1 }; const DEPTH_ATTRIBUTE = 'data-hummingbird-depth'; const registry = { keys: new WeakMap(), elements: new Map(), next: 1 }; const memory = new WeakMap(); const keyOf = (el) => { if (!registry.keys.has(el)) { const key = 'p' + registry.next++; registry.keys.set(el, key); registry.elements.set(key, el); } return registry.keys.get(el); }; const nameOf = (el) => { const raw = el.getAttribute('class'); const classes = raw ? raw.trim().split(/\s+/).filter(Boolean).slice(0, 2) : []; return el.tagName.toLowerCase() + (el.id ? '#' + el.id : '') + (classes.length ? '.' + classes.join('.') : ''); }; const colorsIn = (text) => (text.match(/rgba?\([^)]*\)/g) || []).map((c) => c.match(/[\d.]+/g).map(Number)).filter((c) => c.length < 4 || c[3] > 0.5); const lumaOf = (c) => (0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]) / 255; const depthForType = (px) => PH.motion.clamp01((DEPTH_TYPE.near - px) / (DEPTH_TYPE.near - DEPTH_TYPE.far)); const depthForBox = (width, k) => PH.motion.clamp01((DEPTH_BOX.near - width / (BIRD_LENGTH * k)) / (DEPTH_BOX.near - DEPTH_BOX.far)); const drawnAsBox = (style) => { const edged = ['Top', 'Right', 'Bottom', 'Left'].some((side) => parseFloat(style['border' + side + 'Width']) > 0 && ['none', 'hidden'].indexOf(style['border' + side + 'Style']) === -1); return edged || colorsIn(style.backgroundColor).length > 0 || style.backgroundImage !== 'none' || style.boxShadow !== 'none'; }; const declaredDepth = (raw) => { if (raw === null || raw === undefined) { return null; } const word = String(raw).trim().toLowerCase(); if (Object.prototype.hasOwnProperty.call(DEPTH_WORDS, word)) { return DEPTH_WORDS[word]; } const value = parseFloat(word); return Number.isFinite(value) ? PH.motion.clamp01(value) : null; }; const depthOfElement = (el, surface, k) => { const holder = el.closest('[' + DEPTH_ATTRIBUTE + ']'); const declared = holder ? declaredDepth(holder.getAttribute(DEPTH_ATTRIBUTE)) : null; if (declared !== null) { return declared; } const style = window.getComputedStyle(el); if (TEXT_PERCHES.indexOf(el.tagName) === -1 && drawnAsBox(style)) { return depthForBox(surface.width, k); } return depthForType(parseFloat(style.fontSize) || 16); }; const glyphsCover = (el, x, y) => { const range = document.createRange(); for (let i = 0; i < el.childNodes.length; i += 1) { const node = el.childNodes[i]; if (node.nodeType === 3 && node.nodeValue.trim()) { range.selectNodeContents(node); const rects = range.getClientRects(); for (let j = 0; j < rects.length; j += 1) { const r = rects[j]; if (x >= r.left - GLYPH_MARGIN && x <= r.right + GLYPH_MARGIN && y >= r.top - GLYPH_MARGIN && y <= r.bottom + GLYPH_MARGIN) { return true; } } } } return false; }; const blockerAt = (x, y, view, standsOn) => { const hit = document.elementFromPoint(x, y); if (!hit) { return 'offscreen'; } if (standsOn && standsOn.contains(hit)) { return null; } if (view.header && view.header.contains(hit)) { return 'header'; } if (!view.host.contains(hit)) { return 'outside-page ' + nameOf(hit); } if (hit.closest(REFUSED_SELECTOR)) { return 'refused ' + nameOf(hit); } if (SOLID.has(hit.tagName)) { return 'solid ' + nameOf(hit); } return glyphsCover(hit, x, y) ? 'text ' + nameOf(hit) : null; }; const blockerAbove = (footX, footY, view, standsOn) => { const reach = 400 * view.k; const tall = 300 * view.k; for (let i = 0; i < PROBE_X.length; i += 1) { for (let j = 0; j < PROBE_Y.length; j += 1) { const x = footX + PROBE_X[i] * reach; const y = footY - PROBE_Y[j] * tall; const blocker = blockerAt(x, y, view, standsOn); if (blocker) { return { x: Math.round(x), y: Math.round(y), blocker }; } } } return null; }; const footCover = (el, x, y) => { const hit = document.elementFromPoint(x, y + 2); if (!hit) { return 'offscreen'; } return hit === el || el.contains(hit) ? null : 'covered by ' + nameOf(hit); }; const anchorsFor = (key) => { const preferred = PH.motion.hash(Number(key.slice(1)) || 1, 3) < 0.5 ? [0.78, 0.22, 0.6] : [0.22, 0.78, 0.4]; return preferred.concat(SWEEP.filter((a) => preferred.indexOf(a) === -1)); }; const rectOf = (r) => ({ left: r.left, top: r.top, width: r.width, height: r.height }); const firstLineOf = (el) => { const range = document.createRange(); range.selectNodeContents(el); const rects = Array.prototype.filter.call(range.getClientRects(), (r) => r.width > 0 && r.height > 0); if (!rects.length) { return null; } const top = Math.min.apply(null, rects.map((r) => r.top)); const line = rects.filter((r) => r.top < top + 4); const left = Math.min.apply(null, line.map((r) => r.left)); const right = Math.max.apply(null, line.map((r) => r.right)); const bottom = Math.max.apply(null, line.map((r) => r.bottom)); const inset = CAP_INSET * (bottom - top); return { left, top: top + inset, width: right - left, height: bottom - top - inset }; }; const surfaceOf = (el) => (TEXT_PERCHES.indexOf(el.tagName) !== -1 ? firstLineOf(el) : null) || rectOf(el.getBoundingClientRect()); const refusalOf = (el, r, view) => { if (!view.host.contains(el)) { return 'outside the page'; } if (el.matches(REFUSED_SELECTOR) || el.closest(REFUSED_SELECTOR)) { return 'refused'; } if (r.width < 96 || r.height < 16) { return 'too small'; } if (r.top < view.headerBottom + 360 * view.k + 8 || r.top > view.h - 24) { return 'top edge out of the band'; } if (r.right < 40 || r.left > view.w - 40) { return 'off screen sideways'; } return null; }; const assessPerch = (el, r, view, trace) => { const depth = depthOfElement(el, r, view.k); const own = Object.assign({}, view, { k: view.k * PH.depth.scaleOf(depth) }); const refusal = refusalOf(el, r, own); const verdict = { el: nameOf(el), rect: rectOf(r), depth, refusal, perch: null, tried: [] }; if (refusal) { return verdict; } const key = keyOf(el); const anchors = anchorsFor(key); const margin = 0.75 * 400 * own.k + 4; for (let a = 0; a < anchors.length; a += 1) { const footX = r.left + anchors[a] * r.width; const edge = footX > margin && footX < view.w - margin ? null : 'too near the screen edge'; const cover = edge || footCover(el, footX, r.top); const above = cover ? null : blockerAbove(footX, r.top, own, TEXT_PERCHES.indexOf(el.tagName) !== -1 ? el : null); if (trace) { verdict.tried.push({ anchorX: anchors[a], footX: Math.round(footX), cover, above }); } if (!cover && !above) { verdict.perch = { key, anchorX: anchors[a], rect: rectOf(r), depth }; return verdict; } } return verdict; }; const groundOf = (el) => { for (let node = el; node && node.nodeType === 1; node = node.parentElement) { const declared = node.getAttribute('data-ground'); if (declared) { return declared === 'night' ? 1 : 0; } const style = window.getComputedStyle(node); const fill = colorsIn(style.backgroundColor); const stops = fill.length ? fill : colorsIn(style.backgroundImage); if (stops.length) { return stops.reduce((sum, c) => sum + lumaOf(c), 0) / stops.length < NIGHT_LUMA ? 1 : 0; } } return 0; }; const signatureOf = (el, r, view) => [ Math.round(r.left), Math.round(r.top), Math.round(r.width), Math.round(r.height), view.w, view.h, view.k, Math.round(view.headerBottom), view.host.contains(el) ].join(','); const recall = (el, r, view) => { const sig = signatureOf(el, r, view); const held = memory.get(el); if (held && held.sig === sig && view.now - held.at < VERDICT_TTL) { return held.verdict; } const verdict = assessPerch(el, r, view, false); memory.set(el, { sig, at: view.now, verdict }); return verdict; }; const findHummingbirdPerches = (view) => { const out = []; const nodes = document.querySelectorAll(PERCH_SELECTOR); for (let i = 0; i < nodes.length; i += 1) { const verdict = recall(nodes[i], surfaceOf(nodes[i]), view); if (verdict.perch) { out.push(verdict.perch); } } return out; }; const explainHummingbirdPerches = (view) => Array.prototype.map.call(document.querySelectorAll(PERCH_SELECTOR), (el) => assessPerch(el, surfaceOf(el), view, true)) .filter((v) => v.refusal !== 'top edge out of the band' && v.refusal !== 'too small'); const measurePerch = (key) => { const el = registry.elements.get(key); if (!el || !el.isConnected) { registry.elements.delete(key); return null; } const r = surfaceOf(el); return r.width > 0 ? r : null; }; const perchCovered = (key, anchorX) => { const el = registry.elements.get(key); if (!el || !el.isConnected) { return false; } const r = surfaceOf(el); const verdict = footCover(el, r.left + anchorX * r.width, r.top); return verdict !== null && verdict !== 'offscreen'; }; const readGround = (x, y) => { const hit = document.elementFromPoint(Math.max(0, x), Math.max(0, y)); return hit ? groundOf(hit) : 0; }; SITE.perches = { PERCH_SELECTOR, DEPTH_TYPE, DEPTH_BOX, DEPTH_ATTRIBUTE, depthForType, depthForBox, drawnAsBox, declaredDepth, findHummingbirdPerches, explainHummingbirdPerches, measurePerch, perchCovered, readGround }; })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const SITE = (PH.site = PH.site || {}); const K = PH.skeleton; const M = PH.motion; const F = PH.flight; const HZ = 11.25; const T = { introDelay: 0.9, emerge: 0.55, approach: 0.35, land: 0.6, takeOff: 0.26, tuck: 0.95, pivotShare: 0.34, routeRest: 0.7, hoverGiveUp: 2.8, dwellMin: 22, dwellMax: 40, idleDoze: 32, idleSleep: 35.5, wakeSettle: 4, settle: 0.35, fastScroll: 1400, blinkMin: 7, blinkMax: 13, glanceGap: 6, trail: 0.55, followAfter: 0.45, homeCooldown: 1.5, peek: 2.6, poll: 0.25, dragScroll: 900, idlePace: 2.2, breathe: 0, introGrace: 1.5, glide: 0.34, glideReach: 70, greetAfter: 10, greetGap: 30, yawnLead: 1.7, wipeAfter: 0.3, wipeOdds: 0.55, swing: 0.35, swingFrom: 260, swingSpan: 900, sunAfter: 15, hopAfter: 1.2, hopWindow: 2, hopReach: 2.6, hopGap: 12 }; const HEADER_MODES = ['nest', 'peeking', 'emerging', 'tucking', 'away']; const SETTLED_MODES = ['nest', 'peeking', 'perched']; const SCALE = { page: 0.24, compact: 0.18 }; const SPRING = { pitch: { stiffness: 150, damping: 12 }, body: { stiffness: 56.25, damping: 15 }, head: { stiffness: 169, damping: 26 } }; const RISE = { leave: 0.62, drop: 0.32, nest: 0.4 }; const kPage = (input) => (input.compact ? SCALE.compact : SCALE.page); const between = (lo, hi, r) => lo + (hi - lo) * r; const sideOf = (azimuth) => (Math.cos(azimuth) >= 0 ? 1 : -1); const unit = (v) => { const n = Math.hypot(v[0], v[1]) || 1; return [v[0] / n, v[1] / n]; }; const settle = (spring, target, dt, gains) => { const steps = Math.max(1, Math.ceil(dt * 120)); const h = dt / steps; for (let i = 0; i < steps; i += 1) { spring.v += (gains.stiffness * (target - spring.x) - gains.damping * spring.v) * h; spring.x += spring.v * h; } return spring.x; }; const sync = (spring, value) => { spring.x = value; spring.v = 0; return value; }; const settlePitch = (d, target, dt) => settle(d.pitch, target, dt, SPRING.pitch); const orient = (d, pose, facing, dt) => { settle(d.az, facing, dt, SPRING.body); settle(d.head, facing, dt, SPRING.head); settle(d.climb, pose.climb || 0, dt, SPRING.body); pose.azimuth = d.az.x; pose.headYaw = (pose.headYaw || 0) + d.head.x - d.az.x; pose.climb = d.climb.x; pose.bank = F.bankOf(d.az.v); return pose; }; const syncOrientation = (d, pose) => { sync(d.az, pose.azimuth || 0); sync(d.head, (pose.azimuth || 0) + (pose.headYaw || 0)); sync(d.climb, pose.climb || 0); }; const track = (d, pose, dt) => { if (d.at && dt > 0) { d.velocity = [(pose.x - d.at[0]) / dt, (pose.y - d.at[1]) / dt]; } d.at = [pose.x, pose.y]; }; const atFor = (pose, local, screen) => { const s = PH.state(pose); PH.place.placeBy(s, local(s), screen); return [s.x, s.y]; }; const wingsAt = (t) => F.wingFields(t, HZ, 60); const enter = (d, mode) => { d.mode = mode; d.since = d.clock; }; const riseOf = (nest) => 0.38 * 330 * nest.k; const nestState = (nest) => ({ x: nest.x, y: nest.y, k: nest.k }); const nestAt = (nest) => atFor({ k: nest.k, pitch: K.PITCH.mark, azimuth: 0 }, PH.place.tipLocal, [nest.x, nest.y]); const nestRise = (nest) => { const at = nestAt(nest); return [at[0], at[1] - riseOf(nest)]; }; const restPose = (nest, eyeOpen) => { const at = nestAt(nest); return PH.state({ x: at[0], y: at[1], k: nest.k, pitch: K.PITCH.mark, azimuth: 0, logo: 1, livery: 0, wings: 0, wingAlpha: 0, fold: 0, blur: 0, gorget: 0, rim: 0, eyeOpen, nest: nestState(nest) }); }; const footOf = (d, rect, pose) => [rect.left + d.perch.anchorX * rect.width + (pose ? pose.dx : 0), rect.top + (pose ? pose.dy : 0)]; const perchBase = (d, k) => PH.perch.perched(k, d.livery, d.face); const approachOf = (d, rect, k) => { const at = atFor(perchBase(d, k), PH.place.footLocal, footOf(d, rect, null)); const len = 400 * k; return [at[0] - sideOf(d.face) * 0.17 * len, at[1] - 0.3 * len]; }; const choosePerch = (d, input, exclude) => { const from = d.at || [input.viewport.w * 0.5, input.viewport.h * 0.4]; let best = null; let bestScore = -Infinity; input.perches.forEach((p, i) => { if (exclude && p.key === exclude) { return; } const foot = [p.rect.left + p.anchorX * p.rect.width, p.rect.top]; const dist = Math.hypot(foot[0] - from[0], foot[1] - from[1]); const band = 1 - Math.min(1, Math.abs(foot[1] / input.viewport.h - 0.55) / 0.45); const novelty = d.recent.indexOf(p.key) === -1 ? 1 : 0.15; const score = 0.9 * (1 - Math.min(1, dist / 1200)) + 0.8 * band + 1.1 * novelty + 0.25 * M.hash(d.seed + d.n, i + 1); if (score > bestScore) { bestScore = score; best = p; } }); return best; }; const startFlight = (d, input, target, trail) => { const from = d.at; const kFrom = d.k; const zFrom = d.depth; let zTo = d.depth; let kTo = kPage(input) * PH.depth.scaleOf(zTo); let end = from; if (target.kind === 'perch') { zTo = PH.depth.depthOf(target.perch.depth); kTo = kPage(input) * PH.depth.scaleOf(zTo); d.perch = { key: target.perch.key, anchorX: target.perch.anchorX, depth: zTo }; d.face = F.facingOf(target.perch.rect.left + target.perch.anchorX * target.perch.rect.width - from[0]); end = approachOf(d, target.perch.rect, kTo); } else if (target.kind === 'nest') { zTo = 0; kTo = input.nest.k; end = nestRise(input.nest); d.face = F.facingOf(end[0] - from[0]); d.perch = null; } else { end = target.at; d.face = F.facingOf(end[0] - from[0]); d.hoverAt = target.at; d.perch = null; } const dist = Math.hypot(end[0] - from[0], end[1] - from[1]); const velocity = d.velocity || [0, 0]; const speed = d.mode === 'flying' || d.mode === 'hovering' ? Math.hypot(velocity[0], velocity[1]) : 0; const fromNest = d.mode === 'emerging'; d.move = { target: target.kind, from, kFrom, kTo, zFrom, zTo, fromNest, trail: Boolean(trail), speed, leave: speed > 80 ? unit(velocity) : null, swing: target.kind === 'perch' && !fromNest ? T.swing * M.clamp01((dist - T.swingFrom) / T.swingSpan) : 0, ceiling: input.headerBottom + 0.3 * 400 * Math.max(kFrom, kTo), duration: M.clamp(0.55 + dist / 1200, 0.7, 1.6) }; if (dist < 24) { arriveAt(d); return; } enter(d, 'flying'); }; const flightDepth = (d, input, tau) => { const m = d.move; const e = M.ease.inOutSine(tau); d.depth = M.clamp01(M.lerp(m.zFrom, m.zTo, e) + m.swing * M.bump(tau)); if (m.target === 'nest') { d.k = M.lerp(m.kFrom, m.kTo, e); return; } const page = kPage(input); const start = m.kFrom / (page * PH.depth.scaleOf(m.zFrom)); d.k = page * PH.depth.scaleOf(d.depth) * M.lerp(start, 1, e); }; const busyAt = (plan, tl) => plan.actions.some((a) => PH.perch.ACTIONS[a.name] && a.start <= tl && tl < a.start + PH.perch.ACTIONS[a.name].duration); const insertAction = (plan, name, at) => { const A = PH.perch.ACTIONS; const start = plan.actions.filter((a) => a.start <= at && at < a.start + A[a.name].duration) .reduce((latest, a) => Math.max(latest, a.start + A[a.name].duration + 0.1), at); const end = start + A[name].duration; plan.actions = plan.actions.filter((a) => a.start < at || a.start >= end + 0.3).concat([{ name, start, params: {} }]); return start; }; const arriveAt = (d) => { if (d.move.target === 'perch') { enter(d, 'approach'); } else if (d.move.target === 'nest') { d.tuckFrom = d.at.slice(); enter(d, 'tucking'); } else { holdStation(d); } }; const highestOf = (path) => { let y = Infinity; for (let i = 0; i <= 12; i += 1) { y = Math.min(y, F.pathAt(path, path.length * i / 12).point[1]); } return y; }; const pathFor = (d, end) => { const m = d.move; if (m.leave) { return F.flightPath(m.from, end, { leave: m.leave }); } if (m.fromNest) { return F.flightPath(m.from, end, { leave: [sideOf(F.facingOf(end[0] - m.from[0])) * Math.cos(RISE.nest), Math.sin(RISE.nest)] }); } let rise = RISE.leave; let path = F.flightPath(m.from, end, { rise, drop: RISE.drop }); for (let i = 0; i < 5 && highestOf(path) < m.ceiling; i += 1) { rise *= 0.5; path = F.flightPath(m.from, end, { rise, drop: RISE.drop * rise / RISE.leave }); } return path; }; const flightEnd = (d, input) => { if (d.move.target === 'perch') { const rect = input.perchRect; return rect ? approachOf(d, rect, d.move.kTo) : null; } if (d.move.target === 'nest') { return input.nest ? nestRise(input.nest) : null; } return d.hoverAt; }; const goHome = (d, input, trail) => { if (input.nest) { startFlight(d, input, { kind: 'nest' }, trail); } else { startFlight(d, input, { kind: 'hover', at: [-120, input.viewport.h * 0.18] }, trail); } }; const retarget = (d, input, trail) => { const next = choosePerch(d, input, d.perch ? d.perch.key : null); if (next) { startFlight(d, input, { kind: 'perch', perch: next }, trail); } else { goHome(d, input, trail); } }; const perchLost = (rect, input, k) => rect.top < input.headerBottom + 300 * k || rect.top > input.viewport.h + 10; const rushing = (d, key, rect) => { const last = d.watch; d.watch = { key, top: rect.top, at: d.clock }; if (!last || last.key !== key || d.clock <= last.at || d.clock - last.at > 0.25) { return false; } return Math.abs(rect.top - last.top) / (d.clock - last.at) > T.dragScroll; }; const scrolledAway = (d, rect, input, k) => rushing(d, d.perch.key, rect) || Math.abs(input.scroll.velocity) > T.fastScroll || perchLost(rect, input, k); const holdStation = (d) => { const v = d.mode === 'flying' && d.velocity ? d.velocity : [0, 0]; const reach = Math.min(1, T.glideReach / (Math.hypot(v[0], v[1]) * T.glide * 0.4 || 1)); d.glide = { from: d.at.slice(), v: [v[0] * reach, v[1] * reach] }; d.hoverAt = [d.at[0] + d.glide.v[0] * T.glide * 0.4, d.at[1] + d.glide.v[1] * T.glide * 0.4]; d.perch = null; enter(d, 'hovering'); }; const glideAt = (d) => { const g = d.glide; if (!g) { return d.hoverAt; } const u = M.clamp01((d.clock - d.since) / T.glide); const a = u - 2 * u * u + u * u * u; const b = 3 * u * u - 2 * u * u * u; return [g.from[0] + g.v[0] * T.glide * a + (d.hoverAt[0] - g.from[0]) * b, g.from[1] + g.v[1] * T.glide * a + (d.hoverAt[1] - g.from[1]) * b]; }; const breakOff = (d, input) => { if (d.at[1] < input.headerBottom + 20) { goHome(d, input, false); } else { holdStation(d); } return d.last; }; const leavePerch = (d, then) => { d.leave = { pose: d.last, at: d.at.slice(), then }; enter(d, 'takeoff'); }; const recordTrail = (d, pose) => { if (pose) { const tail = PH.place.toScreen(pose, PH.place.tailLocal(PH.state(pose))); d.trail.push({ x: tail[0], y: tail[1], t: d.clock }); } while (d.trail.length && d.clock - d.trail[0].t > T.trail) { d.trail.shift(); } }; const stepNest = (d, input) => { if (!input.nest) { enter(d, 'away'); return null; } d.at = nestAt(input.nest); d.velocity = [0, 0]; d.k = input.nest.k; d.depth = 0; d.face = 0; syncOrientation(d, { azimuth: 0 }); sync(d.pitch, K.PITCH.mark); const routeReady = d.route && d.route.readyAt !== null && d.clock >= d.route.readyAt && d.clock - d.since > T.routeRest; const following = !d.intro && !d.route && input.scroll.top > 140 && input.scroll.settledFor > T.followAfter && d.clock - d.since > T.homeCooldown; const introReady = d.intro && d.clock >= T.introDelay && (input.perches.length > 0 || d.clock >= T.introDelay + T.introGrace); const arrived = introReady || routeReady; d.waiting = Boolean(d.route) || (d.intro && d.clock < T.introDelay + T.introGrace + 0.5) || (input.scroll.top > 140 && input.scroll.settledFor < T.followAfter + 1.5); if ((arrived || following) && !input.modalOpen && input.perches.length) { d.pending = { kind: 'perch', perch: choosePerch(d, input, null) }; d.trailOn = d.intro || Boolean(d.route); d.intro = false; d.route = null; enter(d, 'emerging'); return emergePose(d, input); } if (arrived && !d.peeked && !input.modalOpen) { d.peeked = true; d.intro = false; d.route = null; enter(d, 'peeking'); return peekPose(d, input); } if (d.intro && d.clock >= T.introDelay + 8) { d.intro = false; } if (d.clock >= d.nextBlink + 0.16) { d.nextBlink = d.clock + between(T.blinkMin, T.blinkMax, M.hash(d.seed, d.n)); } if (d.clock >= d.nextBlink) { return restPose(input.nest, 1 - 0.94 * M.bump((d.clock - d.nextBlink) / 0.16)); } return null; }; const peekPose = (d, input) => { const u = M.clamp01((d.clock - d.since) / T.peek); const up = M.ease.outCubic(M.span(u, 0, 0.2)) * (1 - M.ease.inOutCubic(M.span(u, 0.8, 1))); const look = Math.max(0.85 * M.bump(M.span(u, 0.22, 0.48)), 0.5 * M.bump(M.span(u, 0.52, 0.72))); const pose = restPose(input.nest, 1 - 0.94 * M.bump(M.span(u, 0.6, 0.66))); pose.y -= 0.55 * riseOf(input.nest) * up; pose.headTurn = look; pose.headTilt = 0.12 * M.bump(M.span(u, 0.48, 0.8)); pose.logo = 1 - 0.5 * up; return pose; }; const stepPeeking = (d, input) => { if (!input.nest) { enter(d, 'away'); return null; } d.at = nestAt(input.nest); d.k = input.nest.k; if (d.clock - d.since >= T.peek) { enter(d, 'nest'); d.nextBlink = d.clock + between(T.blinkMin, T.blinkMax, M.hash(d.seed, d.n)); return null; } return peekPose(d, input); }; const emergePose = (d, input) => { const u = M.clamp01((d.clock - d.since) / T.emerge); const spin = M.ease.outCubic(M.span(u, 0, 0.3)); const home = nestAt(input.nest); d.k = M.lerp(input.nest.k, kPage(input), 0.3 * M.ease.inOutSine(u)); const pose = PH.state(Object.assign(wingsAt(d.clock), { x: home[0], y: home[1] - riseOf(input.nest) * M.ease.outCubic(u), k: d.k, azimuth: 0, pitch: settlePitch(d, K.PITCH.hover, input.dt), logo: 1 - M.ease.inOutSine(M.span(u, 0, 0.5)), wings: spin, wingAlpha: spin, blur: spin, tailSpread: 0.36 + 0.4 * M.bump(M.span(u, 0, 0.8)), livery: 0, nest: nestState(input.nest) })); track(d, pose, input.dt); return pose; }; const stepEmerging = (d, input) => { if (!input.nest) { enter(d, 'away'); return null; } const pose = emergePose(d, input); if (d.clock - d.since >= T.emerge) { if (d.pending && d.pending.perch) { startFlight(d, input, d.pending, d.trailOn); } else { retarget(d, input, d.trailOn); } d.pending = null; } return pose; }; const stepFlying = (d, input) => { if (d.move.target === 'perch' && input.perchRect && scrolledAway(d, input.perchRect, input, d.move.kTo)) { return breakOff(d, input); } const end = flightEnd(d, input); if (!end) { retarget(d, input, d.move.trail); return d.last; } const tau = M.clamp01((d.clock - d.since) / d.move.duration); flightDepth(d, input, tau); const spec = { start: d.since, duration: d.move.duration, path: pathFor(d, end), k: d.k, fps: 60, wingHz: HZ, startSpeed: d.move.speed, fromAzimuth: d.face, toAzimuth: d.face }; const pose = F.poseHummingbirdFlight(spec, d.clock); const pace = M.clamp01(F.speedOf(spec, d.clock) / (F.CRUISE_SPEED * d.k / 0.3)); pose.pitch = settlePitch(d, tau < 1 ? M.lerp(K.PITCH.brake, K.PITCH.cruise, pace) : K.PITCH.hover, input.dt); orient(d, pose, d.face, input.dt); pose.livery = d.livery; pose.depth = d.depth; if (d.move.fromNest && input.nest) { const opened = M.ease.inOutSine(M.span(d.clock - d.since, 0, 0.4)); if (opened < 1) { pose.nest = Object.assign(nestState(input.nest), { open: opened }); } } track(d, pose, input.dt); recordTrail(d, d.move.trail ? pose : null); if (tau >= 1) { arriveAt(d); } return pose; }; const hoverPoseAt = (d, input, at, since) => { const pose = PH.poseHummingbirdHover(at, d.clock, since, d.seed, d.k, { fps: 60, wingHz: HZ }); pose.pitch = settlePitch(d, K.PITCH.hover, input.dt); orient(d, pose, d.face, input.dt); pose.livery = d.livery; pose.depth = d.depth; return pose; }; const stepApproach = (d, input) => { if (!input.perchRect) { retarget(d, input, false); return d.last; } if (scrolledAway(d, input.perchRect, input, d.k)) { return breakOff(d, input); } const pose = hoverPoseAt(d, input, approachOf(d, input.perchRect, d.k), d.since); track(d, pose, input.dt); if (d.clock - d.since >= T.approach) { d.landFrom = d.since; enter(d, 'landing'); } return pose; }; const stepLanding = (d, input) => { if (!input.perchRect) { retarget(d, input, false); return d.last; } if (scrolledAway(d, input.perchRect, input, d.k)) { return breakOff(d, input); } const hoverState = hoverPoseAt(d, input, approachOf(d, input.perchRect, d.k), d.landFrom); const landed = PH.state(perchBase(d, d.k)); const at = atFor(landed, PH.place.footLocal, footOf(d, input.perchRect, null)); landed.x = at[0]; landed.y = at[1]; const pose = PH.landing.poseHummingbirdLanding(hoverState, landed, d.clock, d.since, T.land); pose.pitch = settlePitch(d, K.PITCH.perch, input.dt); pose.depth = d.depth; track(d, pose, input.dt); if (d.clock - d.since >= T.land) { const seed = d.seed + d.n; const wipe = M.hash(seed, 17) < T.wipeOdds; const first = wipe ? [{ name: 'billWipe', start: T.wipeAfter, params: {} }] : []; const after = wipe ? T.wipeAfter + PH.perch.ACTIONS.billWipe.duration + 0.4 : 0; d.perch.since = d.clock; d.perch.dwell = between(T.dwellMin, T.dwellMax, M.hash(d.seed, d.n + 11)); d.perch.plan = { seed, actions: first.concat(PH.idle.planHummingbirdIdle(seed, after, 900, d.k, T.idlePace)), sleepSince: null, wakeAt: null, breathe: T.breathe }; d.perch.dozed = false; d.perch.yawned = false; d.perch.sunned = false; d.perch.idlePeak = 0; d.recent = [d.perch.key].concat(d.recent).slice(0, 3); enter(d, 'perched'); } return pose; }; const tendSleep = (d, input, tl) => { const plan = d.perch.plan; if (plan.sleepSince === null && !d.perch.dozed && !d.perch.yawned && input.idleFor > T.idleDoze - T.yawnLead) { plan.actions = plan.actions.filter((a) => a.start < tl).concat([{ name: 'yawn', start: tl, params: {} }]); d.perch.yawned = true; d.perch.yawnEnds = tl + PH.perch.ACTIONS.yawn.duration; } if (plan.sleepSince === null && !d.perch.dozed && input.idleFor > T.idleDoze) { const at = Math.max(tl, d.perch.yawnEnds || 0); plan.actions = plan.actions.filter((a) => a.start < tl || a.name === 'yawn').concat([{ name: 'doze', start: at, params: {} }]); d.perch.dozed = true; } if (plan.sleepSince === null && input.idleFor > T.idleSleep) { plan.sleepSince = tl; plan.actions = plan.actions.filter((a) => a.start < tl); } if (plan.sleepSince !== null && plan.wakeAt === null && input.idleFor < 0.6) { plan.wakeAt = tl; plan.actions = plan.actions.concat( [{ name: 'shake', start: tl + 0.55, params: {} }, { name: 'yawn', start: tl + 1.05, params: {} }, { name: 'greet', start: tl + 2.65, params: {} }], PH.idle.planHummingbirdIdle(d.seed + d.n, tl + 4.6, tl + 900, d.k, T.idlePace) ); d.perch.dwell = tl + 10; d.perch.idlePeak = 0; d.greetedAt = d.clock; } if (plan.wakeAt !== null && tl > plan.wakeAt + T.wakeSettle) { plan.sleepSince = null; plan.wakeAt = null; d.perch.dozed = false; d.perch.yawned = false; } return plan.sleepSince !== null && plan.wakeAt === null; }; const stepPerched = (d, input) => { const tl = d.clock - d.perch.since; const rect = input.perchRect; if (!rect) { leavePerch(d, 'retarget'); return d.last; } if (rushing(d, d.perch.key, rect)) { leavePerch(d, 'hover'); return d.last; } const asleep = tendSleep(d, input, tl); const awake = !asleep && d.perch.plan.wakeAt === null; d.perch.idlePeak = Math.max(d.perch.idlePeak || 0, input.idleFor); if (awake && input.idleFor < 0.6 && d.perch.idlePeak >= T.greetAfter && d.clock - d.greetedAt > T.greetGap) { insertAction(d.perch.plan, 'greet', tl + 0.15); d.greetedAt = d.clock; } if (input.idleFor < 0.6) { d.perch.idlePeak = 0; } if (awake && !d.perch.sunned && input.idleFor > T.sunAfter && input.idleFor < T.idleDoze - T.yawnLead - PH.perch.ACTIONS.sun.duration) { insertAction(d.perch.plan, 'sun', tl + 0.1); d.perch.sunned = true; } const pose = PH.perch.poseHummingbirdPerch(PH.state(Object.assign(perchBase(d, d.k), { livery: d.livery })), tl, d.perch.plan); const placed = PH.state(pose); PH.place.placeBy(placed, PH.place.footLocal(placed), footOf(d, rect, pose)); placed.livery = d.livery; placed.depth = d.depth; sync(d.pitch, placed.pitch); syncOrientation(d, placed); d.at = [placed.x, placed.y]; d.velocity = [0, 0]; if (input.pointer && input.pointer.age < 0.3 && !asleep && d.clock - d.glancedAt > T.glanceGap) { const body = PH.place.toScreen(placed, PH.place.centreLocal(placed)); if (Math.hypot(input.pointer.x - body[0], input.pointer.y - body[1]) < 200) { d.perch.plan.actions = d.perch.plan.actions.concat([{ name: 'headFlick', start: tl, params: { turn: 0.85 } }]); d.glancedAt = d.clock; } } if (input.pointer && awake && d.clock - d.hoppedAt > T.hopGap && input.pointer.age > T.hopAfter && input.pointer.age < T.hopAfter + T.hopWindow) { const body = PH.place.toScreen(placed, PH.place.centreLocal(placed)); const dx = input.pointer.x - body[0]; const reach = T.hopReach * 400 * d.k; if (dx * sideOf(placed.azimuth) < 0 && Math.abs(dx) < reach && Math.abs(input.pointer.y - body[1]) < reach) { insertAction(d.perch.plan, 'hoverHop', tl + 0.1); d.hoppedAt = d.clock; } } if (input.routeStart || input.modalOpen) { leavePerch(d, 'home'); } else if (input.perchCovered || perchLost(rect, input, d.k)) { leavePerch(d, 'retarget'); } else if (Math.abs(input.scroll.velocity) > T.fastScroll) { leavePerch(d, 'hover'); } else if (!asleep && tl > d.perch.dwell && !busyAt(d.perch.plan, tl) && input.perches.some((p) => p.key !== d.perch.key)) { leavePerch(d, 'retarget'); } return placed; }; const stepTakeOff = (d, input) => { const pose = PH.landing.poseHummingbirdTakeOff(Object.assign({}, d.leave.pose, { dx: 0, dy: 0 }), d.clock, d.since); const flaps = wingsAt(d.clock); pose.wingPhase = flaps.wingPhase; pose.blurSpan = flaps.blurSpan; pose.x = d.leave.at[0] + pose.dx; pose.y = d.leave.at[1] + pose.dy; pose.depth = d.depth; pose.headTurn = 0; pose.headYaw = 0; pose.eyeOpen = 1; pose.pitch = settlePitch(d, K.PITCH.hover, input.dt); orient(d, pose, F.facingOf(Math.cos(d.az.x)), input.dt); track(d, pose, input.dt); if (d.clock - d.since >= T.takeOff) { d.velocity = [0, 0]; if (d.leave.then === 'home') { goHome(d, input, true); } else if (d.leave.then === 'hover') { breakOff(d, input); } else { retarget(d, input, false); } } return pose; }; const stepHovering = (d, input) => { const pose = hoverPoseAt(d, input, glideAt(d), d.since); track(d, pose, input.dt); if (input.routeStart || input.modalOpen) { goHome(d, input, true); } else if (input.scroll.settledFor > T.settle && input.perches.length && d.clock - d.since > T.glide) { retarget(d, input, false); } else if (d.clock - d.since > T.hoverGiveUp && !input.perches.length) { goHome(d, input, false); } return pose; }; const stepTucking = (d, input) => { if (!input.nest) { enter(d, 'away'); return null; } const u = M.clamp01((d.clock - d.since) / T.tuck); const turn = M.span(u, 0, T.pivotShare); const sink = M.ease.inOutCubic(M.span(u, T.pivotShare, 1)); const rise = nestRise(input.nest); const home = nestAt(input.nest); const start = [M.lerp(d.tuckFrom[0], rise[0], M.ease.inOutSine(turn)), M.lerp(d.tuckFrom[1], rise[1], M.ease.inOutSine(turn))]; const fade = 1 - M.span(u, 0.72, 1); d.k = input.nest.k; if (u >= 1) { d.face = 0; d.depth = 0; enter(d, 'nest'); d.nextBlink = d.clock + between(T.blinkMin, T.blinkMax, M.hash(d.seed, d.n)); return null; } const pose = PH.state(Object.assign(wingsAt(d.clock), { x: M.lerp(start[0], home[0], sink), y: M.lerp(start[1], home[1], sink), k: d.k, pitch: settlePitch(d, u < 0.5 ? K.PITCH.hover : K.PITCH.mark, input.dt), wings: fade, wingAlpha: fade, blur: fade, logo: M.ease.inOutSine(M.span(u, 0.74, 1)), livery: d.livery, tailSpread: 0.36 + 0.3 * M.bump(turn), nest: Object.assign(nestState(input.nest), { open: 1 - M.ease.inOutSine(M.span(u, 0, 0.3)) }) })); orient(d, pose, 0, input.dt); if (u > 0.74) { pose.azimuth *= 1 - M.span(u, 0.74, 0.96); pose.headYaw *= 1 - M.span(u, 0.74, 0.96); pose.climb *= 1 - M.span(u, 0.74, 0.96); pose.bank *= 1 - M.span(u, 0.74, 0.96); } track(d, pose, input.dt); return pose; }; const stepAway = (d, input) => { if (input.nest) { enter(d, 'nest'); return null; } if ((d.intro && d.clock >= T.introDelay) || (input.scroll.top > 140 && input.scroll.settledFor > T.followAfter)) { if (input.perches.length) { d.intro = false; d.at = [-80, input.viewport.h * 0.2]; d.velocity = [0, 0]; d.depth = 0; d.k = kPage(input); startFlight(d, input, { kind: 'perch', perch: choosePerch(d, input, null) }, true); } } return null; }; const STEPS = { nest: stepNest, peeking: stepPeeking, emerging: stepEmerging, flying: stepFlying, approach: stepApproach, landing: stepLanding, perched: stepPerched, takeoff: stepTakeOff, hovering: stepHovering, tucking: stepTucking, away: stepAway }; const layerOf = (d) => (HEADER_MODES.indexOf(d.mode) !== -1 || (d.mode === 'flying' && (d.move.fromNest || d.move.target === 'nest')) ? 'header' : 'page'); const noteRoute = (d, input) => { if (input.routeStart) { d.route = { readyAt: null }; d.peeked = false; if (d.mode === 'flying' || d.mode === 'approach' || d.mode === 'landing') { goHome(d, input, true); } else if (d.mode === 'takeoff') { d.leave.then = 'home'; } else if (d.mode === 'emerging') { d.tuckFrom = d.at.slice(); enter(d, 'tucking'); } } if (input.routeReady && d.route && d.route.readyAt === null) { d.route.readyAt = d.clock + T.routeRest; } }; const createHummingbirdDirector = (seed) => ({ seed: seed || 7, clock: 0, n: 0, mode: 'nest', since: 0, at: null, velocity: [0, 0], k: null, face: 0, livery: 0, depth: 0, greetedAt: -99, hoppedAt: -99, pitch: { x: 0, v: 0 }, az: { x: 0, v: 0 }, head: { x: 0, v: 0 }, climb: { x: 0, v: 0 }, move: null, perch: null, watch: null, hoverAt: null, glide: null, route: null, intro: true, peeked: false, waiting: true, recent: [], nextBlink: 5, glancedAt: -99, trail: [], last: null, leave: null, pending: null, trailOn: false, tuckFrom: null, landFrom: 0 }); const stepHummingbirdDirector = (d, input) => { input.dt = Math.min(0.05, Math.max(0, input.dt)); d.clock += input.dt; d.n += 1; d.livery += ((HEADER_MODES.indexOf(d.mode) !== -1 ? 0 : M.clamp01(input.ground)) - d.livery) * Math.min(1, input.dt * 7); noteRoute(d, input); const pose = STEPS[d.mode](d, input); recordTrail(d, null); d.last = pose || d.last; const idle = d.mode === 'nest' && !pose; return { mode: d.mode, pose, trail: d.trail.slice(), showLogo: d.mode === 'nest' ? !pose : d.mode === 'away', idle, wakeIn: idle ? Math.max(0.05, Math.min(d.nextBlink - d.clock, d.waiting ? T.poll : Infinity)) : 0, layer: layerOf(d), settled: SETTLED_MODES.indexOf(d.mode) !== -1 }; }; SITE.director = { T, SCALE, SPRING, createHummingbirdDirector, stepHummingbirdDirector }; })(); (() => { const PH = (globalThis.PhorosHummingbird = globalThis.PhorosHummingbird || {}); const SITE = (PH.site = PH.site || {}); const TRAIL = { life: 0.55, width: 2.2, alpha: 0.55, rgb: '27,186,236' }; const PAGE_DEPTH_CLASS = 'pc-hummingbird-layer--page'; const YIELD_CLASS = 'pc-hummingbird-layer--yield'; const LOCAL = { pad: 24, grid: 32 }; const union = (a, b) => { if (!a) { return b; } if (!b) { return a; } const x = Math.min(a.x, b.x); const y = Math.min(a.y, b.y); return { x, y, w: Math.max(a.x + a.w, b.x + b.w) - x, h: Math.max(a.y + a.h, b.y + b.h) - y }; }; const inflate = (box, by) => ({ x: box.x - by, y: box.y - by, w: box.w + 2 * by, h: box.h + 2 * by }); const encloses = (outer, inner) => inner.x >= outer.x && inner.y >= outer.y && inner.x + inner.w <= outer.x + outer.w && inner.y + inner.h <= outer.y + outer.h; const viewportBox = () => ({ x: 0, y: 0, w: window.innerWidth, h: window.innerHeight }); const snapBox = (b) => { const x = Math.floor((b.x - LOCAL.pad) / LOCAL.grid) * LOCAL.grid; const y = Math.floor((b.y - LOCAL.pad) / LOCAL.grid) * LOCAL.grid; return { x, y, w: Math.ceil((b.x + b.w + LOCAL.pad) / LOCAL.grid) * LOCAL.grid - x, h: Math.ceil((b.y + b.h + LOCAL.pad) / LOCAL.grid) * LOCAL.grid - y }; }; const frameBox = (layer, frame) => { if (!frame.local) { return viewportBox(); } if (!frame.pose) { return layer.box || viewportBox(); } const need = inflate(PH.place.bounds(PH.state(frame.pose)), 6); return layer.local && layer.box && encloses(layer.box, need) ? layer.box : snapBox(need); }; const fitHummingbirdLayer = (layer, frame) => { const ratio = Math.min(2, window.devicePixelRatio || 1); const box = frameBox(layer, frame); const before = layer.box; if (!before || before.w !== box.w || before.h !== box.h || layer.ratio !== ratio) { layer.canvas.width = Math.round(box.w * ratio); layer.canvas.height = Math.round(box.h * ratio); layer.canvas.style.width = box.w + 'px'; layer.canvas.style.height = box.h + 'px'; layer.ratio = ratio; layer.dirty = null; } else if (before.x !== box.x || before.y !== box.y) { layer.context.setTransform(1, 0, 0, 1, 0, 0); layer.context.clearRect(0, 0, layer.canvas.width, layer.canvas.height); layer.dirty = null; } if (!before || before.x !== box.x || before.y !== box.y) { layer.canvas.style.transform = 'translate3d(' + box.x + 'px,' + box.y + 'px,0)'; } layer.box = box; layer.local = Boolean(frame.local); }; const createHummingbirdLayer = (mount) => { const canvas = document.createElement('canvas'); canvas.className = 'pc-hummingbird-layer'; canvas.setAttribute('aria-hidden', 'true'); canvas.setAttribute('role', 'presentation'); mount.appendChild(canvas); const layer = { canvas, context: canvas.getContext('2d'), ratio: 0, box: null, local: false, dirty: null, depth: 'header', yielding: false }; fitHummingbirdLayer(layer, { local: false }); return layer; }; const setHummingbirdLayerDepth = (layer, depth) => { if (layer.depth === depth) { return; } layer.canvas.classList.toggle(PAGE_DEPTH_CLASS, depth === 'page'); layer.depth = depth; }; const setHummingbirdLayerYield = (layer, yielding) => { const on = Boolean(yielding); if (layer.yielding === on) { return; } layer.canvas.classList.toggle(YIELD_CLASS, on); layer.yielding = on; }; const paintTrail = (c, trail, clock) => { let box = null; c.save(); c.lineCap = 'round'; for (let i = 1; i < trail.length; i += 1) { const a = trail[i - 1]; const b = trail[i]; const fresh = Math.max(0, 1 - (clock - b.t) / TRAIL.life); if (fresh <= 0.01) { continue; } c.strokeStyle = 'rgba(' + TRAIL.rgb + ',' + Math.round(TRAIL.alpha * fresh * 1000) / 1000 + ')'; c.lineWidth = 0.4 + TRAIL.width * fresh; c.beginPath(); c.moveTo(a.x, a.y); c.lineTo(b.x, b.y); c.stroke(); box = union(box, { x: Math.min(a.x, b.x), y: Math.min(a.y, b.y), w: Math.abs(a.x - b.x), h: Math.abs(a.y - b.y) }); } c.restore(); return box ? inflate(box, 4) : null; }; const paintHummingbirdLayer = (layer, frame) => { fitHummingbirdLayer(layer, frame); const c = layer.context; c.setTransform(layer.ratio, 0, 0, layer.ratio, -layer.box.x * layer.ratio, -layer.box.y * layer.ratio); if (layer.dirty) { c.clearRect(layer.dirty.x, layer.dirty.y, layer.dirty.w, layer.dirty.h); } let box = null; if (frame.trail && frame.trail.length > 1) { box = union(box, paintTrail(c, frame.trail, frame.clock)); } if (frame.pose) { PH.drawHummingbird(c, frame.pose, { pixelRatio: layer.ratio }); box = union(box, inflate(PH.place.bounds(PH.state(frame.pose)), 6)); } layer.dirty = box; }; SITE.paint = { PAGE_DEPTH_CLASS, YIELD_CLASS, createHummingbirdLayer, setHummingbirdLayerDepth, setHummingbirdLayerYield, paintHummingbirdLayer }; })(); (() => { const PH = globalThis.PhorosHummingbird; const SITE = PH.site; const BUILD = Number('1791172049623'); const previous = window.__phorosHummingbird; if (previous && previous.build >= BUILD && !previous.disconnected) { previous.rearm(); return; } if (previous && typeof previous.disconnect === 'function') { previous.disconnect(); } const APP_ROOT_ID = 'JMDK_app'; const NATIVE_MODAL = 'dialog:modal'; const supportsSelector = (selector) => Boolean(window.CSS && typeof window.CSS.supports === 'function' && window.CSS.supports('selector(' + selector + ')')); const MODAL_SELECTOR = ['.swal2-container', '[aria-modal="true"]'].concat(supportsSelector(NATIVE_MODAL) ? [NATIVE_MODAL] : []).join(', '); const SCAN = { moving: 0.3, calm: 1, calmAfter: 0.6, cover: 0.5 }; const TEMPO = { lively: 1 / 30, quiet: 1 }; const runtime = { build: BUILD, disconnected: false, layer: null, director: null, raf: 0, timer: 0, last: 0, resumed: false, lastActivity: 0, pointer: null, events: { routeStart: false, routeReady: false }, routePending: null, scroll: { host: null, top: 0, at: 0, velocity: 0, changedAt: -10 }, perches: [], perchesAt: -1, ground: 0, groundAt: -1, modal: false, modalAt: -1, covered: false, coverAt: -1, listeners: [] }; window.__phorosHummingbird = runtime; const nowSeconds = () => performance.now() / 1000; const reducedMotion = () => Boolean(window.matchMedia) && window.matchMedia('(prefers-reduced-motion: reduce)').matches; const appRoot = () => document.getElementById(APP_ROOT_ID); const phorosOn = () => (window.phoros && window.phoros.on) || null; const pageName = () => (window.phoros && window.phoros.page && typeof window.phoros.page.name === 'function' ? window.phoros.page.name() : ''); const scrollHost = () => { if (window.phoros && window.phoros.page && typeof window.phoros.page.scrollContainer === 'function') { const host = window.phoros.page.scrollContainer(); if (host) { return host; } } return document.scrollingElement || document.documentElement; }; const listen = (target, type, handler, options) => { target.addEventListener(type, handler, options); runtime.listeners.push([target, type, handler, options]); }; const noteActivity = () => { runtime.lastActivity = nowSeconds(); wake(); }; const shown = (el) => { const r = el.getBoundingClientRect(); if (r.width <= 0 || r.height <= 0 || window.getComputedStyle(el).visibility === 'hidden') { return false; } for (let node = el; node && node !== document.documentElement; node = node.parentElement) { const style = window.getComputedStyle(node); if (style.display === 'none' || parseFloat(style.opacity) < 0.05) { return false; } } return true; }; const modalOpen = () => Array.prototype.some.call(document.querySelectorAll(MODAL_SELECTOR), shown); const readScroll = (now) => { const host = scrollHost(); const s = runtime.scroll; const top = host ? host.scrollTop : 0; if (s.host !== host) { s.host = host; s.top = top; s.velocity = 0; s.at = now; } const dt = Math.max(1 / 240, now - s.at); s.velocity = s.velocity * 0.7 + ((top - s.top) / dt) * 0.3; if (Math.abs(top - s.top) > 0.5) { s.changedAt = now; } s.top = top; s.at = now; return { top, velocity: s.velocity, settledFor: now - s.changedAt }; }; const pageReady = (now, host, perchCount) => { const pending = runtime.routePending; if (!pending || now - pending.at < 0.35) { return false; } const opaque = !host || !host.classList || !host.classList.contains('JMDK_page') || parseFloat(window.getComputedStyle(host).opacity || '1') > 0.98; const named = !pending.to || pageName() === pending.to; return (opaque && named && perchCount > 0) || now - pending.at > 1.8; }; const gather = (now, dt) => { const view = { w: window.innerWidth, h: window.innerHeight }; const header = SITE.nest.headerOf(); const headerBottom = header ? Math.max(0, header.getBoundingClientRect().bottom) : 0; const compact = view.w < 720; const k = compact ? SITE.director.SCALE.compact : SITE.director.SCALE.page; const host = scrollHost(); const scroll = readScroll(now); const d = runtime.director; const asleep = d.mode === 'perched' && Boolean(d.perch && d.perch.plan && d.perch.plan.sleepSince !== null && d.perch.plan.wakeAt === null); const calm = !runtime.routePending && !d.intro && scroll.settledFor > SCAN.calmAfter && (d.mode === 'perched' || d.mode === 'nest'); if (!asleep && now - runtime.perchesAt > (calm ? SCAN.calm : SCAN.moving)) { runtime.perches = SITE.perches.findHummingbirdPerches({ w: view.w, h: view.h, headerBottom, header, k, host, now }); runtime.perchesAt = now; } if (!asleep && d.at && now - runtime.groundAt > 0.2) { runtime.ground = SITE.perches.readGround(d.at[0], d.at[1]); runtime.groundAt = now; } if (now - runtime.modalAt > 0.5) { runtime.modal = modalOpen(); runtime.modalAt = now; } if (d.mode !== 'perched' || !d.perch) { runtime.covered = false; } else if (now - runtime.coverAt > SCAN.cover) { runtime.covered = SITE.perches.perchCovered(d.perch.key, d.perch.anchorX); runtime.coverAt = now; } if (pageReady(now, host, runtime.perches.length)) { runtime.events.routeReady = true; runtime.routePending = null; } const input = { dt, viewport: view, headerBottom, compact, nest: SITE.nest.readHummingbirdNest(), perches: runtime.perches, perchRect: d.perch ? SITE.perches.measurePerch(d.perch.key) : null, scroll, idleFor: now - runtime.lastActivity, pointer: runtime.pointer ? { x: runtime.pointer.x, y: runtime.pointer.y, age: now - runtime.pointer.t } : null, routeStart: runtime.events.routeStart, routeReady: runtime.events.routeReady, modalOpen: runtime.modal, perchCovered: runtime.covered, ground: runtime.ground }; runtime.events.routeStart = false; runtime.events.routeReady = false; return input; }; const chainHook = (name, handler) => { const on = phorosOn(); if (!on || !Object.prototype.hasOwnProperty.call(on, name)) { return; } const current = on[name]; if (current && current.hummingbirdBuild === BUILD) { return; } const prior = current; const wrapped = function hummingbirdRouteHook() { const result = typeof prior === 'function' ? prior.apply(this, arguments) : undefined; if (!runtime.disconnected) { try { handler.apply(null, arguments); } catch (error) { console.error('[phoros-hummingbird] ' + name + ' handler failed', error); } } return result; }; wrapped.hummingbirdBuild = BUILD; on[name] = wrapped; }; const ensureHooks = () => { chainHook('beforeRoute', (fromPage, toPage) => { if (fromPage === toPage) { return; } runtime.events.routeStart = true; runtime.routePending = { to: toPage, at: nowSeconds() }; wake(); }); }; const schedule = (delay) => { if (runtime.disconnected || runtime.raf || runtime.timer || document.hidden) { return; } if (delay > 0.02) { runtime.timer = window.setTimeout(() => { runtime.timer = 0; runtime.raf = window.requestAnimationFrame(frame); }, delay * 1000); } else { runtime.raf = window.requestAnimationFrame(frame); } }; const wake = () => { if (runtime.timer) { window.clearTimeout(runtime.timer); runtime.timer = 0; runtime.resumed = true; } schedule(0); }; const frameDelay = (out) => { const d = runtime.director; if (out.mode !== 'perched' || !d.perch || !d.perch.plan) { return 0; } const until = PH.perch.livelyIn(d.perch.plan, d.clock - d.perch.since); if (until === 0) { return TEMPO.lively; } return Math.max(TEMPO.lively, Math.min(TEMPO.quiet, until)); }; const frame = (ms) => { runtime.raf = 0; if (runtime.disconnected) { return; } if (!runtime.layer.canvas.isConnected) { const root = appRoot(); if (!root) { runtime.disconnect(); return; } root.appendChild(runtime.layer.canvas); } const now = ms / 1000; const gap = runtime.last ? now - runtime.last : 1 / 60; runtime.last = now; if (runtime.resumed) { runtime.director.clock += Math.max(0, gap - 0.05); runtime.resumed = false; } ensureHooks(); const out = SITE.director.stepHummingbirdDirector(runtime.director, gather(now, gap)); SITE.nest.showLogoBird(out.showLogo); SITE.paint.setHummingbirdLayerDepth(runtime.layer, out.layer); SITE.paint.setHummingbirdLayerYield(runtime.layer, runtime.modal); SITE.paint.paintHummingbirdLayer(runtime.layer, { pose: out.pose, trail: out.trail, clock: runtime.director.clock, local: out.settled }); const delay = out.idle ? out.wakeIn : frameDelay(out); if (delay > 0.05) { runtime.resumed = true; } schedule(delay); }; runtime.rearm = () => { ensureHooks(); runtime.perchesAt = -1; wake(); }; runtime.disconnect = () => { runtime.disconnected = true; if (runtime.raf) { window.cancelAnimationFrame(runtime.raf); } if (runtime.timer) { window.clearTimeout(runtime.timer); } runtime.raf = 0; runtime.timer = 0; runtime.listeners.forEach((l) => l[0].removeEventListener(l[1], l[2], l[3])); runtime.listeners = []; if (runtime.layer && runtime.layer.canvas.parentNode) { runtime.layer.canvas.parentNode.removeChild(runtime.layer.canvas); } SITE.nest.showLogoBird(true); }; const start = () => { const root = appRoot(); if (reducedMotion() || runtime.disconnected || !root) { return; } runtime.director = SITE.director.createHummingbirdDirector(1 + Math.floor((BUILD % 997) + 3)); runtime.layer = SITE.paint.createHummingbirdLayer(root); runtime.lastActivity = nowSeconds(); listen(document, 'scroll', noteActivity, { capture: true, passive: true }); listen(window, 'wheel', noteActivity, { passive: true }); listen(window, 'touchstart', noteActivity, { passive: true }); listen(window, 'keydown', noteActivity, { passive: true }); listen(window, 'pointermove', (event) => { runtime.pointer = { x: event.clientX, y: event.clientY, t: nowSeconds() }; noteActivity(); }, { passive: true }); listen(window, 'resize', () => { runtime.perchesAt = -1; wake(); }, { passive: true }); listen(document, 'visibilitychange', () => { if (!document.hidden) { runtime.resumed = true; wake(); } }); if (window.matchMedia) { const query = window.matchMedia('(prefers-reduced-motion: reduce)'); const onChange = () => { if (query.matches) { runtime.disconnect(); } }; if (typeof query.addEventListener === 'function') { listen(query, 'change', onChange); } } ensureHooks(); schedule(0); }; start(); })();

We couldn't find that guide