neon-activity-graph 0.0.0-stage → 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +138 -2
- package/dist/chunk-5FJXKHZ7.js +2160 -0
- package/dist/chunk-5FJXKHZ7.js.map +1 -0
- package/dist/chunk-KOGPOPVA.js +224 -0
- package/dist/chunk-KOGPOPVA.js.map +1 -0
- package/dist/index.d.ts +58 -0
- package/dist/index.js +51 -0
- package/dist/index.js.map +1 -0
- package/dist/layout.d.ts +134 -0
- package/dist/layout.js +35 -0
- package/dist/layout.js.map +1 -0
- package/dist/react.d.ts +21 -0
- package/dist/react.js +56 -0
- package/dist/react.js.map +1 -0
- package/dist/templates-data-2RIHMIOJ.js +6 -0
- package/dist/templates-data-2RIHMIOJ.js.map +1 -0
- package/dist/types-Dalvh_07.d.ts +174 -0
- package/package.json +84 -4
|
@@ -0,0 +1,2160 @@
|
|
|
1
|
+
import {
|
|
2
|
+
CAMERA_DIR,
|
|
3
|
+
layoutGraph,
|
|
4
|
+
mountPlaceholder,
|
|
5
|
+
roomFor,
|
|
6
|
+
slabFor,
|
|
7
|
+
stripShifts
|
|
8
|
+
} from "./chunk-KOGPOPVA.js";
|
|
9
|
+
|
|
10
|
+
// src/ground-light.ts
|
|
11
|
+
var COMMON = (
|
|
12
|
+
/* glsl */
|
|
13
|
+
`
|
|
14
|
+
const float IOR = 1.5;
|
|
15
|
+
const float R0 = 0.04;
|
|
16
|
+
float reflectance(float c) { c = clamp(c, 0., 1.); return R0 + (1. - R0) * pow(1. - c, 5.); }
|
|
17
|
+
float sdf(vec3 p, vec3 h, float r) {
|
|
18
|
+
vec3 q = abs(p) - (h - r);
|
|
19
|
+
return length(max(q, 0.)) + min(max(q.x, max(q.y, q.z)), 0.) - r;
|
|
20
|
+
}
|
|
21
|
+
// where a ray enters and leaves the sharp box (x, y), y < x for a miss
|
|
22
|
+
vec2 slab(vec3 o, vec3 d, vec3 h) {
|
|
23
|
+
float t0 = -1e9; float t1 = 1e9;
|
|
24
|
+
for (int i = 0; i < 3; i++) {
|
|
25
|
+
float di = d[i]; float oi = o[i]; float hi = h[i];
|
|
26
|
+
if (abs(di) < 1e-9) { if (abs(oi) > hi) return vec2(1., -1.); continue; }
|
|
27
|
+
float a = (-hi - oi) / di; float b = (hi - oi) / di;
|
|
28
|
+
t0 = max(t0, min(a, b)); t1 = min(t1, max(a, b));
|
|
29
|
+
}
|
|
30
|
+
return vec2(t0, t1);
|
|
31
|
+
}
|
|
32
|
+
vec3 roundedNormal(vec3 p, vec3 h, float r, vec3 bias) {
|
|
33
|
+
vec3 q = abs(p) - (h - r);
|
|
34
|
+
vec3 s = vec3(p.x >= 0. ? 1. : -1., p.y >= 0. ? 1. : -1., p.z >= 0. ? 1. : -1.);
|
|
35
|
+
float m = max(q.x, max(q.y, q.z));
|
|
36
|
+
vec3 n;
|
|
37
|
+
if (m <= 0.) {
|
|
38
|
+
n = q.x >= q.y && q.x >= q.z ? vec3(s.x, 0., 0.) : q.y >= q.z ? vec3(0., s.y, 0.) : vec3(0., 0., s.z);
|
|
39
|
+
} else {
|
|
40
|
+
n = normalize(max(q, 0.) * s);
|
|
41
|
+
}
|
|
42
|
+
return normalize(n + bias);
|
|
43
|
+
}
|
|
44
|
+
// from inside the glass, at p going along d: bounce until it gets out; where it lands on the ground (world y = 0), the share of its power that got out, the length it went through glass
|
|
45
|
+
bool leaveGlass(vec3 p, vec3 dir, vec3 c, vec3 h, float r, vec3 bias, out vec3 land, out float share, out float path) {
|
|
46
|
+
vec3 o = p; vec3 d = dir; share = 1.; path = 0.; land = vec3(0.);
|
|
47
|
+
for (int b = 0; b < 12; b++) {
|
|
48
|
+
vec2 s = slab(o, d, h);
|
|
49
|
+
if (s.y < s.x) return false;
|
|
50
|
+
float lo = 0.; float hi = s.y + 0.01;
|
|
51
|
+
for (int k = 0; k < 14; k++) { float mid = .5 * (lo + hi); if (sdf(o + d * mid, h, r) < 0.) lo = mid; else hi = mid; }
|
|
52
|
+
float t = .5 * (lo + hi);
|
|
53
|
+
path += t;
|
|
54
|
+
vec3 q = o + d * t;
|
|
55
|
+
vec3 n = roundedNormal(q, h, r, bias);
|
|
56
|
+
vec3 outd = refract(d, -n, IOR);
|
|
57
|
+
if (dot(outd, outd) > 1e-8) {
|
|
58
|
+
share *= 1. - reflectance(dot(outd, n));
|
|
59
|
+
if (outd.y >= -1e-3) return false;
|
|
60
|
+
float g = -(q.y + c.y) / outd.y;
|
|
61
|
+
land = vec3(q.x + c.x + outd.x * g, 0., q.z + c.z + outd.z * g);
|
|
62
|
+
return true;
|
|
63
|
+
}
|
|
64
|
+
d = reflect(d, n);
|
|
65
|
+
o = q + d * 1e-4;
|
|
66
|
+
}
|
|
67
|
+
return false;
|
|
68
|
+
}
|
|
69
|
+
float reachFade(float dist, float near, float far) {
|
|
70
|
+
if (dist <= near) return 1.;
|
|
71
|
+
if (dist >= far) return 0.;
|
|
72
|
+
float u = 1. - (dist - near) / (far - near);
|
|
73
|
+
return u * u * (3. - 2. * u);
|
|
74
|
+
}
|
|
75
|
+
`
|
|
76
|
+
);
|
|
77
|
+
var ATTRIBUTES = (
|
|
78
|
+
/* glsl */
|
|
79
|
+
`
|
|
80
|
+
attribute float ray;
|
|
81
|
+
attribute vec3 iC; attribute vec3 iH; attribute vec3 iBias; attribute vec3 iCol;
|
|
82
|
+
attribute vec4 iA; // r, power, near, far
|
|
83
|
+
attribute vec4 iB; // rod, seed0, seed1, seed2
|
|
84
|
+
attribute vec2 iD; // seed3, seed4
|
|
85
|
+
uniform vec4 uGrid; // pixels per unit, x0, z0, (unused)
|
|
86
|
+
uniform vec2 uSize; // target size in pixels
|
|
87
|
+
varying vec3 vColor;
|
|
88
|
+
vec4 toClip(vec3 land) {
|
|
89
|
+
float gx = (land.x - uGrid.y) * uGrid.x;
|
|
90
|
+
float gz = (land.z - uGrid.z) * uGrid.x;
|
|
91
|
+
return vec4(gx / uSize.x * 2. - 1., 1. - gz / uSize.y * 2., 0., 1.);
|
|
92
|
+
}
|
|
93
|
+
void discardPoint() { gl_Position = vec4(2., 2., 2., 1.); gl_PointSize = 0.; vColor = vec3(0.); }
|
|
94
|
+
`
|
|
95
|
+
);
|
|
96
|
+
var SUN_VERT = (
|
|
97
|
+
/* glsl */
|
|
98
|
+
`
|
|
99
|
+
${COMMON}
|
|
100
|
+
${ATTRIBUTES}
|
|
101
|
+
uniform vec3 uDir; // the way the light travels
|
|
102
|
+
uniform float uN; // rays per side
|
|
103
|
+
uniform float uFree; // 0: where the glass lands the ray (adds), 1: where it would have landed (takes away)
|
|
104
|
+
uniform float uAbsorb;
|
|
105
|
+
uniform float uStraight;
|
|
106
|
+
uniform float uPerArea; // pixel area / cos
|
|
107
|
+
float hash(float n) { return fract(sin(n * 12.9898 + 78.233) * 43758.5453); }
|
|
108
|
+
void main() {
|
|
109
|
+
float i = ray;
|
|
110
|
+
float r = iA.x; float power = iA.y; float near = iA.z; float far = iA.w;
|
|
111
|
+
vec3 h = iH;
|
|
112
|
+
float R = length(h);
|
|
113
|
+
float gi = mod(i, uN); float gj = floor(i / uN);
|
|
114
|
+
float cell = 2. * R / uN;
|
|
115
|
+
float a = -R + (gi + hash(i + iB.y)) * cell;
|
|
116
|
+
float b = -R + (gj + hash(i * 1.37 + iB.z)) * cell;
|
|
117
|
+
vec3 d = uDir;
|
|
118
|
+
vec3 u = normalize(cross(d, vec3(0., 1., 0.)));
|
|
119
|
+
vec3 v = cross(d, u);
|
|
120
|
+
vec3 o = u * a + v * b - d * 2. * R;
|
|
121
|
+
vec2 s = slab(o, d, h);
|
|
122
|
+
if (s.y < s.x) { discardPoint(); return; }
|
|
123
|
+
float area = cell * cell * uPerArea;
|
|
124
|
+
if (uFree > .5) {
|
|
125
|
+
float fy = -(o.y + iC.y) / d.y;
|
|
126
|
+
vec3 free = vec3(o.x + iC.x + d.x * fy, 0., o.z + iC.z + d.z * fy);
|
|
127
|
+
vec3 tint = vec3(1.) - uStraight * exp(-uAbsorb * (vec3(1.) - iCol));
|
|
128
|
+
vColor = -area * tint;
|
|
129
|
+
gl_Position = toClip(free);
|
|
130
|
+
gl_PointSize = 1.;
|
|
131
|
+
return;
|
|
132
|
+
}
|
|
133
|
+
// sphere tracing from where it enters the sharp box, to the rounded one
|
|
134
|
+
float te = max(0., s.x - 1e-3);
|
|
135
|
+
bool hit = false;
|
|
136
|
+
for (int k = 0; k < 48; k++) {
|
|
137
|
+
float sd = sdf(o + d * te, h, r);
|
|
138
|
+
if (sd < 1e-4) { hit = true; break; }
|
|
139
|
+
te += sd;
|
|
140
|
+
if (te > s.y + 1e-3) break;
|
|
141
|
+
}
|
|
142
|
+
if (!hit) { discardPoint(); return; }
|
|
143
|
+
vec3 q = o + d * te;
|
|
144
|
+
vec3 nrm = roundedNormal(q, h, r, iBias);
|
|
145
|
+
vec3 inside = refract(d, nrm, 1. / IOR);
|
|
146
|
+
if (dot(inside, inside) < 1e-8) { discardPoint(); return; }
|
|
147
|
+
float entered = 1. - reflectance(-dot(d, nrm));
|
|
148
|
+
vec3 land; float share; float path;
|
|
149
|
+
if (!leaveGlass(q + inside * 1e-4, inside, iC, h, r, iBias, land, share, path)) { discardPoint(); return; }
|
|
150
|
+
float fade = reachFade(length(land.xz - iC.xz), near, far);
|
|
151
|
+
if (fade <= 0.) { discardPoint(); return; }
|
|
152
|
+
vColor = area * entered * share * fade * exp(-uAbsorb * (vec3(1.) - iCol) * path);
|
|
153
|
+
gl_Position = toClip(land);
|
|
154
|
+
gl_PointSize = 1.;
|
|
155
|
+
}
|
|
156
|
+
`
|
|
157
|
+
);
|
|
158
|
+
var POINT_FRAG = (
|
|
159
|
+
/* glsl */
|
|
160
|
+
`varying vec3 vColor; void main() { gl_FragColor = vec4(vColor, 1.); }`
|
|
161
|
+
);
|
|
162
|
+
var FULL_VERT = (
|
|
163
|
+
/* glsl */
|
|
164
|
+
`varying vec2 vUv; void main() { vUv = uv; gl_Position = vec4(position.xy, 0., 1.); }`
|
|
165
|
+
);
|
|
166
|
+
var TEMPLATE_HEIGHTS = [0.5, 1.3, 2.4];
|
|
167
|
+
var TEMPLATE_FEET = [0, 0.9, 1.8, 2.7];
|
|
168
|
+
var TEMPLATE_EXTENT = 8;
|
|
169
|
+
var STAMP_CONTRAST = 2.4;
|
|
170
|
+
var STAMP_FOOT = 0.04;
|
|
171
|
+
var TEMPLATE_SIZE = 128;
|
|
172
|
+
var LOG_FLOOR = 1e-4;
|
|
173
|
+
var LOG_RANGE = 10;
|
|
174
|
+
async function loadCausticTemplates(THREE, url) {
|
|
175
|
+
const img = new Image();
|
|
176
|
+
img.src = url;
|
|
177
|
+
await img.decode();
|
|
178
|
+
const canvas = document.createElement("canvas");
|
|
179
|
+
canvas.width = img.width;
|
|
180
|
+
canvas.height = img.height;
|
|
181
|
+
const ctx = canvas.getContext("2d", { willReadFrequently: true });
|
|
182
|
+
ctx.drawImage(img, 0, 0);
|
|
183
|
+
const px = ctx.getImageData(0, 0, img.width, img.height).data;
|
|
184
|
+
const half = new Uint16Array(img.width * img.height * 4);
|
|
185
|
+
const one = THREE.DataUtils.toHalfFloat(1);
|
|
186
|
+
for (let i = 0; i < img.width * img.height; i++) {
|
|
187
|
+
const v = (Math.exp(px[i * 4] / 255 * LOG_RANGE) - 1) * LOG_FLOOR;
|
|
188
|
+
half[i * 4] = half[i * 4 + 1] = half[i * 4 + 2] = THREE.DataUtils.toHalfFloat(v);
|
|
189
|
+
half[i * 4 + 3] = one;
|
|
190
|
+
}
|
|
191
|
+
const texture = new THREE.DataTexture(half, img.width, img.height, THREE.RGBAFormat, THREE.HalfFloatType);
|
|
192
|
+
texture.minFilter = THREE.LinearFilter;
|
|
193
|
+
texture.magFilter = THREE.LinearFilter;
|
|
194
|
+
texture.needsUpdate = true;
|
|
195
|
+
return { texture, heights: TEMPLATE_HEIGHTS, feet: TEMPLATE_FEET, extent: TEMPLATE_EXTENT };
|
|
196
|
+
}
|
|
197
|
+
var STAMP_VERT = (
|
|
198
|
+
/* glsl */
|
|
199
|
+
`
|
|
200
|
+
attribute vec2 iPos; attribute vec3 iCol; attribute vec4 iIdx; attribute vec3 iPoolCol; attribute float iPoolR;
|
|
201
|
+
uniform vec4 uGrid; uniform vec2 uSize; uniform float uExtent;
|
|
202
|
+
varying vec3 vCol; varying vec2 vLocal; varying vec4 vIdx; varying vec3 vPoolCol; varying float vPoolR;
|
|
203
|
+
void main() {
|
|
204
|
+
vPoolCol = iPoolCol; vPoolR = iPoolR;
|
|
205
|
+
vLocal = position.xy * 2. * uExtent;
|
|
206
|
+
vCol = iCol; vIdx = iIdx;
|
|
207
|
+
vec2 world = iPos + vLocal;
|
|
208
|
+
float gx = (world.x - uGrid.y) * uGrid.x;
|
|
209
|
+
float gz = (world.y - uGrid.z) * uGrid.x;
|
|
210
|
+
gl_Position = vec4(gx / uSize.x * 2. - 1., 1. - gz / uSize.y * 2., 0., 1.);
|
|
211
|
+
}
|
|
212
|
+
`
|
|
213
|
+
);
|
|
214
|
+
var STAMP_FRAG = (
|
|
215
|
+
/* glsl */
|
|
216
|
+
`
|
|
217
|
+
uniform sampler2D atlas; uniform float uContrast; uniform float uFoot; uniform float uExtent; uniform vec2 uCells; uniform float uQuarter;
|
|
218
|
+
varying vec3 vCol; varying vec2 vLocal; varying vec4 vIdx; varying vec3 vPoolCol; varying float vPoolR;
|
|
219
|
+
float tap(float h, float f, vec2 u) {
|
|
220
|
+
// the template of height class h, foot class f: the cell of the atlas, sampled inside it (never across its edge)
|
|
221
|
+
vec2 inside = (clamp(u, 0., 1.) * (uQuarter - 1.) + .5) / uQuarter;
|
|
222
|
+
return texture2D(atlas, (vec2(f, h) + inside) / uCells).r;
|
|
223
|
+
}
|
|
224
|
+
void main() {
|
|
225
|
+
// the soft pool: a round spot of haze under the block, a third of its peak at 0.45 of its radius and out to nothing at the radius
|
|
226
|
+
float pu = length(vLocal) / vPoolR;
|
|
227
|
+
float pool = pu >= 1. ? 0. : (pu < .45 ? 1. - (pu / .45) * .65 : .35 * (1. - (pu - .45) / .55));
|
|
228
|
+
vec2 u = abs(vLocal) / uExtent;
|
|
229
|
+
float edge = length(u);
|
|
230
|
+
if (edge >= 1.) discard;
|
|
231
|
+
float h0 = vIdx.x; float fH = vIdx.y; float f0 = vIdx.z; float fF = vIdx.w;
|
|
232
|
+
float h1 = min(h0 + 1., uCells.y - 1.); float f1 = min(f0 + 1., uCells.x - 1.);
|
|
233
|
+
float v = mix(mix(tap(h0, f0, u), tap(h0, f1, u), fF), mix(tap(h1, f0, u), tap(h1, f1, u), fF), fH);
|
|
234
|
+
// (a curve that keeps the bright structure and lowers the faint wide glow under it, so that the streaks are not drowned: where the template is a tenth of its peak, it is far less than a tenth)
|
|
235
|
+
v = pow(max(v, 0.), uContrast);
|
|
236
|
+
// (the template ends at its edge: let it fade out just before, not stop)
|
|
237
|
+
v *= 1. - smoothstep(.5, 1., edge);
|
|
238
|
+
// (the bright foot of a block is for a block on open ground: in the picture its neighbours stand in the way, and the ground between blocks is not lit like that; it is lowered near the block, and the light that goes further out is kept)
|
|
239
|
+
v *= mix(uFoot, 1., smoothstep(1., 3., length(vLocal)));
|
|
240
|
+
gl_FragColor = vec4(vCol * v + vPoolCol * pool * 0.04, 1.);
|
|
241
|
+
}
|
|
242
|
+
`
|
|
243
|
+
);
|
|
244
|
+
function createGroundLight(THREE, renderer, grid) {
|
|
245
|
+
const type = renderer.extensions.has("EXT_float_blend") && renderer.extensions.has("EXT_color_buffer_float") ? THREE.FloatType : THREE.HalfFloatType;
|
|
246
|
+
const make = () => new THREE.WebGLRenderTarget(grid.w, grid.h, { type, depthBuffer: false, minFilter: THREE.LinearFilter, magFilter: THREE.LinearFilter });
|
|
247
|
+
let target = make();
|
|
248
|
+
let spare = make();
|
|
249
|
+
const cam = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
|
|
250
|
+
const points = new THREE.Scene();
|
|
251
|
+
const full = new THREE.Scene();
|
|
252
|
+
const quad = new THREE.Mesh(new THREE.PlaneGeometry(2, 2));
|
|
253
|
+
full.add(quad);
|
|
254
|
+
const blurMat = new THREE.ShaderMaterial({
|
|
255
|
+
uniforms: { map: { value: null }, stepv: { value: new THREE.Vector2() } },
|
|
256
|
+
vertexShader: FULL_VERT,
|
|
257
|
+
fragmentShader: `uniform sampler2D map; uniform vec2 stepv; varying vec2 vUv;
|
|
258
|
+
void main() { gl_FragColor = (texture2D(map, vUv - 2. * stepv) + 4. * texture2D(map, vUv - stepv) + 6. * texture2D(map, vUv) + 4. * texture2D(map, vUv + stepv) + texture2D(map, vUv + 2. * stepv)) / 16.; }`,
|
|
259
|
+
depthTest: false,
|
|
260
|
+
depthWrite: false
|
|
261
|
+
});
|
|
262
|
+
const disposables = [blurMat, quad.geometry];
|
|
263
|
+
const draw = (blocks, rays, vertex, uniforms, keep) => {
|
|
264
|
+
const geo = new THREE.InstancedBufferGeometry();
|
|
265
|
+
geo.instanceCount = blocks.length;
|
|
266
|
+
const ray = new Float32Array(rays);
|
|
267
|
+
for (let i = 0; i < rays; i++) ray[i] = i;
|
|
268
|
+
geo.setAttribute("ray", new THREE.BufferAttribute(ray, 1));
|
|
269
|
+
geo.setAttribute("position", new THREE.BufferAttribute(new Float32Array(rays * 3), 3));
|
|
270
|
+
const inst = (size, fill) => {
|
|
271
|
+
const a = new Float32Array(blocks.length * size);
|
|
272
|
+
blocks.forEach((b, i) => a.set(fill(b), i * size));
|
|
273
|
+
return new THREE.InstancedBufferAttribute(a, size);
|
|
274
|
+
};
|
|
275
|
+
geo.setAttribute("iC", inst(3, (b) => b.c));
|
|
276
|
+
geo.setAttribute("iH", inst(3, (b) => b.h));
|
|
277
|
+
geo.setAttribute("iBias", inst(3, (b) => b.bias));
|
|
278
|
+
geo.setAttribute("iCol", inst(3, (b) => b.col));
|
|
279
|
+
geo.setAttribute("iA", inst(4, (b) => [b.r, b.power, b.near, b.far]));
|
|
280
|
+
geo.setAttribute("iB", inst(4, (b) => [b.rod, b.seed[0], b.seed[1], b.seed[2]]));
|
|
281
|
+
geo.setAttribute("iD", inst(2, (b) => [b.seed[3], b.seed[4]]));
|
|
282
|
+
const mat = new THREE.ShaderMaterial({
|
|
283
|
+
vertexShader: vertex,
|
|
284
|
+
fragmentShader: POINT_FRAG,
|
|
285
|
+
uniforms: { uGrid: { value: new THREE.Vector4(grid.scale, grid.x0, grid.z0, 0) }, uSize: { value: new THREE.Vector2(grid.w, grid.h) }, ...uniforms },
|
|
286
|
+
blending: THREE.CustomBlending,
|
|
287
|
+
blendEquation: THREE.AddEquation,
|
|
288
|
+
blendSrc: THREE.OneFactor,
|
|
289
|
+
blendDst: THREE.OneFactor,
|
|
290
|
+
depthTest: false,
|
|
291
|
+
depthWrite: false,
|
|
292
|
+
transparent: true
|
|
293
|
+
});
|
|
294
|
+
const mesh = new THREE.Points(geo, mat);
|
|
295
|
+
mesh.frustumCulled = false;
|
|
296
|
+
points.add(mesh);
|
|
297
|
+
const prevTarget = renderer.getRenderTarget();
|
|
298
|
+
const prevAuto = renderer.autoClear;
|
|
299
|
+
renderer.setRenderTarget(target);
|
|
300
|
+
renderer.autoClear = !keep;
|
|
301
|
+
renderer.render(points, cam);
|
|
302
|
+
renderer.autoClear = prevAuto;
|
|
303
|
+
renderer.setRenderTarget(prevTarget);
|
|
304
|
+
points.remove(mesh);
|
|
305
|
+
geo.dispose();
|
|
306
|
+
mat.dispose();
|
|
307
|
+
};
|
|
308
|
+
const sun = (blocks, n, dir, absorb, straight, pixelPerArea) => {
|
|
309
|
+
const common = { uDir: { value: new THREE.Vector3(...dir) }, uN: { value: n }, uAbsorb: { value: absorb }, uStraight: { value: straight }, uPerArea: { value: pixelPerArea } };
|
|
310
|
+
draw(blocks, n * n, SUN_VERT, { ...common, uFree: { value: 0 } }, false);
|
|
311
|
+
draw(blocks, n * n, SUN_VERT, { ...common, uFree: { value: 1 } }, true);
|
|
312
|
+
};
|
|
313
|
+
const stamps = (blocks, templates) => {
|
|
314
|
+
const geo = new THREE.InstancedBufferGeometry();
|
|
315
|
+
const plane = new THREE.PlaneGeometry(1, 1);
|
|
316
|
+
geo.setAttribute("position", plane.getAttribute("position"));
|
|
317
|
+
geo.setIndex(plane.getIndex());
|
|
318
|
+
geo.instanceCount = blocks.length;
|
|
319
|
+
const pos = new Float32Array(blocks.length * 2);
|
|
320
|
+
const base = new Float32Array(blocks.length * 3);
|
|
321
|
+
const idx = new Float32Array(blocks.length * 4);
|
|
322
|
+
const poolBase = new Float32Array(blocks.length * 3);
|
|
323
|
+
const poolR = new Float32Array(blocks.length);
|
|
324
|
+
const place = (v, classes) => {
|
|
325
|
+
if (v <= classes[0]) return [0, 0];
|
|
326
|
+
for (let i = 1; i < classes.length; i++) if (v <= classes[i]) return [i - 1, (v - classes[i - 1]) / (classes[i] - classes[i - 1])];
|
|
327
|
+
return [classes.length - 1, 0];
|
|
328
|
+
};
|
|
329
|
+
blocks.forEach((b, i) => {
|
|
330
|
+
pos.set([b.x, b.z], i * 2);
|
|
331
|
+
base.set(b.col, i * 3);
|
|
332
|
+
const [h0, fh] = place(b.height, templates.heights);
|
|
333
|
+
const [f0, ff] = place(b.foot, templates.feet);
|
|
334
|
+
idx.set([h0, fh, f0, ff], i * 4);
|
|
335
|
+
poolBase.set(b.poolCol, i * 3);
|
|
336
|
+
poolR[i] = b.poolRadius;
|
|
337
|
+
});
|
|
338
|
+
const poolColours = new THREE.InstancedBufferAttribute(poolBase.slice(), 3);
|
|
339
|
+
const colours = new THREE.InstancedBufferAttribute(base.slice(), 3);
|
|
340
|
+
geo.setAttribute("iPos", new THREE.InstancedBufferAttribute(pos, 2));
|
|
341
|
+
geo.setAttribute("iCol", colours);
|
|
342
|
+
geo.setAttribute("iIdx", new THREE.InstancedBufferAttribute(idx, 4));
|
|
343
|
+
geo.setAttribute("iPoolCol", poolColours);
|
|
344
|
+
geo.setAttribute("iPoolR", new THREE.InstancedBufferAttribute(poolR, 1));
|
|
345
|
+
const mat = new THREE.ShaderMaterial({
|
|
346
|
+
vertexShader: STAMP_VERT,
|
|
347
|
+
fragmentShader: STAMP_FRAG,
|
|
348
|
+
uniforms: {
|
|
349
|
+
uGrid: { value: new THREE.Vector4(grid.scale, grid.x0, grid.z0, 0) },
|
|
350
|
+
uSize: { value: new THREE.Vector2(grid.w, grid.h) },
|
|
351
|
+
uExtent: { value: templates.extent },
|
|
352
|
+
atlas: { value: templates.texture },
|
|
353
|
+
uContrast: { value: STAMP_CONTRAST },
|
|
354
|
+
uFoot: { value: STAMP_FOOT },
|
|
355
|
+
uCells: { value: new THREE.Vector2(templates.feet.length, templates.heights.length) },
|
|
356
|
+
uQuarter: { value: TEMPLATE_SIZE }
|
|
357
|
+
},
|
|
358
|
+
blending: THREE.CustomBlending,
|
|
359
|
+
blendEquation: THREE.AddEquation,
|
|
360
|
+
blendSrc: THREE.OneFactor,
|
|
361
|
+
blendDst: THREE.OneFactor,
|
|
362
|
+
depthTest: false,
|
|
363
|
+
depthWrite: false,
|
|
364
|
+
transparent: true,
|
|
365
|
+
side: THREE.DoubleSide
|
|
366
|
+
});
|
|
367
|
+
const mesh = new THREE.Mesh(geo, mat);
|
|
368
|
+
mesh.frustumCulled = false;
|
|
369
|
+
const scene = new THREE.Scene();
|
|
370
|
+
scene.add(mesh);
|
|
371
|
+
const draw2 = () => {
|
|
372
|
+
const prevTarget = renderer.getRenderTarget();
|
|
373
|
+
renderer.setRenderTarget(target);
|
|
374
|
+
renderer.render(scene, cam);
|
|
375
|
+
renderer.setRenderTarget(prevTarget);
|
|
376
|
+
};
|
|
377
|
+
disposables.push(geo, plane, mat);
|
|
378
|
+
draw2();
|
|
379
|
+
return {
|
|
380
|
+
update(levels) {
|
|
381
|
+
const a = colours.array;
|
|
382
|
+
for (let i = 0; i < blocks.length; i++) {
|
|
383
|
+
const k = levels[i];
|
|
384
|
+
a[i * 3] = base[i * 3] * k;
|
|
385
|
+
a[i * 3 + 1] = base[i * 3 + 1] * k;
|
|
386
|
+
a[i * 3 + 2] = base[i * 3 + 2] * k;
|
|
387
|
+
const p = poolColours.array;
|
|
388
|
+
p[i * 3] = poolBase[i * 3] * k;
|
|
389
|
+
p[i * 3 + 1] = poolBase[i * 3 + 1] * k;
|
|
390
|
+
p[i * 3 + 2] = poolBase[i * 3 + 2] * k;
|
|
391
|
+
}
|
|
392
|
+
colours.needsUpdate = true;
|
|
393
|
+
poolColours.needsUpdate = true;
|
|
394
|
+
draw2();
|
|
395
|
+
}
|
|
396
|
+
};
|
|
397
|
+
};
|
|
398
|
+
const smooth = (passes) => {
|
|
399
|
+
const prevTarget = renderer.getRenderTarget();
|
|
400
|
+
quad.material = blurMat;
|
|
401
|
+
for (let i = 0; i < passes; i++) {
|
|
402
|
+
for (const step of [new THREE.Vector2(1 / grid.w, 0), new THREE.Vector2(0, 1 / grid.h)]) {
|
|
403
|
+
blurMat.uniforms.map.value = target.texture;
|
|
404
|
+
blurMat.uniforms.stepv.value.copy(step);
|
|
405
|
+
renderer.setRenderTarget(spare);
|
|
406
|
+
renderer.render(full, cam);
|
|
407
|
+
[target, spare] = [spare, target];
|
|
408
|
+
}
|
|
409
|
+
}
|
|
410
|
+
renderer.setRenderTarget(prevTarget);
|
|
411
|
+
};
|
|
412
|
+
return {
|
|
413
|
+
stamps,
|
|
414
|
+
sun,
|
|
415
|
+
smooth,
|
|
416
|
+
get texture() {
|
|
417
|
+
return target.texture;
|
|
418
|
+
},
|
|
419
|
+
dispose() {
|
|
420
|
+
target.dispose();
|
|
421
|
+
spare.dispose();
|
|
422
|
+
disposables.forEach((d) => d.dispose());
|
|
423
|
+
}
|
|
424
|
+
};
|
|
425
|
+
}
|
|
426
|
+
|
|
427
|
+
// src/neon.ts
|
|
428
|
+
var AREAS = 8;
|
|
429
|
+
var FLICKERING = AREAS;
|
|
430
|
+
var SPAN_MS = 2600;
|
|
431
|
+
var NEON_FPS = 20;
|
|
432
|
+
var PARTIALS = [[1, 1, 0.3], [2.76, 0.35, 0.14], [5.4, 0.12, 0.07]];
|
|
433
|
+
function bell(c, dest, when, f0, pan, level) {
|
|
434
|
+
const out = c.createGain();
|
|
435
|
+
out.gain.value = 0.05 * level;
|
|
436
|
+
const panner = c.createStereoPanner();
|
|
437
|
+
panner.pan.value = pan * 0.8;
|
|
438
|
+
out.connect(panner).connect(dest);
|
|
439
|
+
for (const [ratio, gain, decay] of PARTIALS) {
|
|
440
|
+
const f = f0 * ratio;
|
|
441
|
+
if (f > 16e3) continue;
|
|
442
|
+
const o = c.createOscillator();
|
|
443
|
+
o.type = "sine";
|
|
444
|
+
o.frequency.value = f;
|
|
445
|
+
const g = c.createGain();
|
|
446
|
+
g.gain.setValueAtTime(0, when);
|
|
447
|
+
g.gain.linearRampToValueAtTime(gain, when + 1e-3);
|
|
448
|
+
g.gain.exponentialRampToValueAtTime(1e-4, when + decay);
|
|
449
|
+
o.connect(g).connect(out);
|
|
450
|
+
o.start(when);
|
|
451
|
+
o.stop(when + decay + 0.02);
|
|
452
|
+
}
|
|
453
|
+
}
|
|
454
|
+
function createNeon({ blocks, apply, done, sound, fps = NEON_FPS, wobbleFps = 40, seed = 7, canPlay = () => true }) {
|
|
455
|
+
if (blocks.length === 0) return { levels: new Float32Array(0), count: 0, start: () => done(), stop: () => {
|
|
456
|
+
} };
|
|
457
|
+
let s = seed;
|
|
458
|
+
const random = () => (s = s * 16807 % 2147483647) / 2147483647;
|
|
459
|
+
const levels = new Float32Array(blocks.length).fill(1);
|
|
460
|
+
const centres = [];
|
|
461
|
+
const picks = blocks.map((_, i) => i);
|
|
462
|
+
const first = Math.floor(random() * blocks.length);
|
|
463
|
+
const spread = (i) => Math.min(...centres.map((c) => Math.hypot(blocks[i].x - c.x, blocks[i].z - c.z)));
|
|
464
|
+
centres.push({ x: blocks[first].x, z: blocks[first].z, ax: 1, cos: 1, sin: 0 });
|
|
465
|
+
while (centres.length < Math.min(AREAS, blocks.length)) {
|
|
466
|
+
let best = -1;
|
|
467
|
+
let bestD = -1;
|
|
468
|
+
for (let k = 0; k < 6; k++) {
|
|
469
|
+
const i = picks[Math.floor(random() * picks.length)];
|
|
470
|
+
const d = spread(i);
|
|
471
|
+
if (d > bestD) {
|
|
472
|
+
best = i;
|
|
473
|
+
bestD = d;
|
|
474
|
+
}
|
|
475
|
+
}
|
|
476
|
+
const angle = random() * Math.PI;
|
|
477
|
+
centres.push({ x: blocks[best].x, z: blocks[best].z, ax: 0.55 + random() * 1.1, cos: Math.cos(angle), sin: Math.sin(angle) });
|
|
478
|
+
}
|
|
479
|
+
const areaOf = blocks.map((b) => {
|
|
480
|
+
let best = 0;
|
|
481
|
+
let bestD = Infinity;
|
|
482
|
+
centres.forEach((c, k) => {
|
|
483
|
+
const dx = b.x - c.x;
|
|
484
|
+
const dz = b.z - c.z;
|
|
485
|
+
const u = (dx * c.cos + dz * c.sin) * c.ax;
|
|
486
|
+
const v = (-dx * c.sin + dz * c.cos) / c.ax;
|
|
487
|
+
const d = Math.hypot(u, v);
|
|
488
|
+
if (d < bestD) {
|
|
489
|
+
bestD = d;
|
|
490
|
+
best = k;
|
|
491
|
+
}
|
|
492
|
+
});
|
|
493
|
+
return best;
|
|
494
|
+
});
|
|
495
|
+
const flickering = new Set([...centres.keys()].sort(() => random() - 0.5).slice(0, FLICKERING));
|
|
496
|
+
const areaPlans = /* @__PURE__ */ new Map();
|
|
497
|
+
flickering.forEach((k) => {
|
|
498
|
+
const start = random() * (SPAN_MS - 1100);
|
|
499
|
+
const count = 4 + Math.floor(random() * 5);
|
|
500
|
+
const stutters = [];
|
|
501
|
+
let at = start;
|
|
502
|
+
for (let j = 0; j < count; j++) {
|
|
503
|
+
const length = 30 + random() * 110;
|
|
504
|
+
stutters.push({ at, length, level: 0.4 + random() * 0.6 });
|
|
505
|
+
at += length + (50 + random() * 240) * (1 - j / count * 0.6);
|
|
506
|
+
}
|
|
507
|
+
areaPlans.set(k, { start, stutters, steady: at + 60 });
|
|
508
|
+
});
|
|
509
|
+
const plans = /* @__PURE__ */ new Map();
|
|
510
|
+
blocks.forEach((_, i) => {
|
|
511
|
+
const base = areaPlans.get(areaOf[i]);
|
|
512
|
+
if (base) plans.set(i, { ...base, shift: random() * 70, scale: 0.8 + random() * 0.2, area: areaOf[i] });
|
|
513
|
+
});
|
|
514
|
+
const end = Math.max(0, ...[...areaPlans.values()].map((p) => p.steady + 380 + 70));
|
|
515
|
+
const levelAt = (plan, at) => {
|
|
516
|
+
const ms = at - plan.shift;
|
|
517
|
+
if (ms < plan.start) return 0;
|
|
518
|
+
if (ms >= plan.steady + 380) return 1;
|
|
519
|
+
if (ms >= plan.steady) return 0.6 + 0.4 * ((ms - plan.steady) / 380);
|
|
520
|
+
for (const st of plan.stutters) if (ms >= st.at && ms < st.at + st.length) return st.level * plan.scale;
|
|
521
|
+
return 0;
|
|
522
|
+
};
|
|
523
|
+
plans.forEach((_, i) => levels[i] = 0);
|
|
524
|
+
let raf = 0;
|
|
525
|
+
let t0 = 0;
|
|
526
|
+
let last = -1;
|
|
527
|
+
let running = false;
|
|
528
|
+
let ctx = null;
|
|
529
|
+
let closeTimer = 0;
|
|
530
|
+
const closeSound = () => {
|
|
531
|
+
window.clearTimeout(closeTimer);
|
|
532
|
+
document.removeEventListener("visibilitychange", onVisibility);
|
|
533
|
+
const c = ctx;
|
|
534
|
+
ctx = null;
|
|
535
|
+
if (c && c.state !== "closed") c.close().catch(() => {
|
|
536
|
+
});
|
|
537
|
+
};
|
|
538
|
+
const onVisibility = () => {
|
|
539
|
+
if (document.hidden) closeSound();
|
|
540
|
+
};
|
|
541
|
+
const schedule = async () => {
|
|
542
|
+
if (!sound || typeof AudioContext === "undefined" || document.hidden) return;
|
|
543
|
+
let c;
|
|
544
|
+
try {
|
|
545
|
+
c = new AudioContext();
|
|
546
|
+
await Promise.race([c.resume(), new Promise((r) => setTimeout(r, 300))]);
|
|
547
|
+
} catch {
|
|
548
|
+
return;
|
|
549
|
+
}
|
|
550
|
+
if (c.state !== "running" || !running || document.hidden) {
|
|
551
|
+
c.close().catch(() => {
|
|
552
|
+
});
|
|
553
|
+
return;
|
|
554
|
+
}
|
|
555
|
+
ctx = c;
|
|
556
|
+
const now = c.currentTime + 0.05 - (performance.now() - t0) / 1e3;
|
|
557
|
+
const master = c.createGain();
|
|
558
|
+
master.gain.value = 0.5;
|
|
559
|
+
const limiter = c.createDynamicsCompressor();
|
|
560
|
+
master.connect(limiter).connect(c.destination);
|
|
561
|
+
const lit = [];
|
|
562
|
+
for (let ms = 0; ms <= end + 200; ms += 25) {
|
|
563
|
+
let sum = 0;
|
|
564
|
+
plans.forEach((p) => sum += levelAt(p, ms));
|
|
565
|
+
lit.push(sum / Math.max(1, plans.size));
|
|
566
|
+
}
|
|
567
|
+
const settled = now + (end + 200) / 1e3;
|
|
568
|
+
const FADE = 6;
|
|
569
|
+
const hum = c.createOscillator();
|
|
570
|
+
hum.type = "sawtooth";
|
|
571
|
+
hum.frequency.value = 100;
|
|
572
|
+
const lowpass = c.createBiquadFilter();
|
|
573
|
+
lowpass.type = "lowpass";
|
|
574
|
+
lowpass.frequency.value = 520;
|
|
575
|
+
const humGain = c.createGain();
|
|
576
|
+
humGain.gain.setValueAtTime(0, c.currentTime);
|
|
577
|
+
lit.forEach((v, i) => humGain.gain.linearRampToValueAtTime(4e-3 * v, Math.max(now + i * 25 / 1e3, c.currentTime + 1e-3)));
|
|
578
|
+
humGain.gain.setTargetAtTime(0, Math.max(settled, c.currentTime), FADE / 3);
|
|
579
|
+
hum.connect(lowpass).connect(humGain).connect(master);
|
|
580
|
+
hum.start(Math.max(now, c.currentTime));
|
|
581
|
+
const stopAt = settled + FADE * 1.6;
|
|
582
|
+
hum.stop(stopAt);
|
|
583
|
+
let clicks = 0;
|
|
584
|
+
const members = /* @__PURE__ */ new Map();
|
|
585
|
+
plans.forEach((p, i) => (members.get(p.area) ?? members.set(p.area, []).get(p.area)).push(i));
|
|
586
|
+
const click = (at, pan, level) => {
|
|
587
|
+
if (clicks >= 110) return;
|
|
588
|
+
clicks++;
|
|
589
|
+
const when = Math.max(now + at / 1e3, c.currentTime);
|
|
590
|
+
bell(c, master, when, random() < 0.35 ? 800 + random() * 700 : 2300 + random() * 1500, pan, level);
|
|
591
|
+
};
|
|
592
|
+
areaPlans.forEach((plan, area) => {
|
|
593
|
+
const own = members.get(area) ?? [];
|
|
594
|
+
if (!own.length) return;
|
|
595
|
+
plan.stutters.forEach((st) => {
|
|
596
|
+
const n = 1 + Math.floor(random() * 3);
|
|
597
|
+
for (let k = 0; k < n; k++) {
|
|
598
|
+
const i = own[Math.floor(random() * own.length)];
|
|
599
|
+
click(st.at + random() * 60, blocks[i].pan, st.level);
|
|
600
|
+
if (random() < 0.6) click(st.at + st.length + random() * 40, blocks[i].pan, st.level * 0.35);
|
|
601
|
+
}
|
|
602
|
+
});
|
|
603
|
+
});
|
|
604
|
+
closeTimer = window.setTimeout(closeSound, (stopAt - c.currentTime) * 1e3 + 500);
|
|
605
|
+
};
|
|
606
|
+
let idleTimer = 0;
|
|
607
|
+
let idleRaf = 0;
|
|
608
|
+
let idleCtx = null;
|
|
609
|
+
let idleClose = 0;
|
|
610
|
+
let idleOn = false;
|
|
611
|
+
let idleSince = 0;
|
|
612
|
+
const idleRandom = () => Math.random();
|
|
613
|
+
const busy = /* @__PURE__ */ new Set();
|
|
614
|
+
const fMax = wobbleFps * 0.4;
|
|
615
|
+
const wobbleSeed = blocks.map(() => ({ s: random() < 0.18 ? 0.4 + random() * 0.6 : 0, f1: fMax * (0.25 + random() * 0.25), f2: fMax * (0.5 + random() * 0.5), p1: random() * 6.283, p2: random() * 6.283 }));
|
|
616
|
+
const rate = Math.max(fps, wobbleFps);
|
|
617
|
+
const HUM_STEP = 25;
|
|
618
|
+
const humEnd = end + 200;
|
|
619
|
+
const humLit = [];
|
|
620
|
+
for (let ms = 0; ms <= humEnd; ms += HUM_STEP) {
|
|
621
|
+
let sum = 0;
|
|
622
|
+
plans.forEach((p) => sum += levelAt(p, ms));
|
|
623
|
+
humLit.push(sum / Math.max(1, plans.size));
|
|
624
|
+
}
|
|
625
|
+
const humAt = (ms) => ms <= humEnd ? humLit[Math.min(humLit.length - 1, Math.floor(ms / HUM_STEP))] ?? 0 : Math.exp(-(ms - humEnd) / 2e3);
|
|
626
|
+
const WOBBLE_DEPTH = 0.45;
|
|
627
|
+
const wob = (i, ms, hum) => {
|
|
628
|
+
if (hum <= 5e-3) return 1;
|
|
629
|
+
const w = wobbleSeed[i];
|
|
630
|
+
const sec = ms / 1e3;
|
|
631
|
+
const n = 0.5 + 0.5 * (0.6 * Math.sin(6.283 * w.f1 * sec + w.p1) + 0.4 * Math.sin(6.283 * w.f2 * sec + w.p2));
|
|
632
|
+
return 1 - WOBBLE_DEPTH * hum * w.s * n;
|
|
633
|
+
};
|
|
634
|
+
let tailing = false;
|
|
635
|
+
let tailRaf = 0;
|
|
636
|
+
let tailLast = -1;
|
|
637
|
+
const tail = (stamp) => {
|
|
638
|
+
tailRaf = 0;
|
|
639
|
+
if (!tailing) return;
|
|
640
|
+
const ms = performance.now() - t0;
|
|
641
|
+
const hum = humAt(ms);
|
|
642
|
+
if (tailLast < 0 || stamp - tailLast >= 1e3 / rate) {
|
|
643
|
+
tailLast = stamp;
|
|
644
|
+
if (canPlay() && !document.hidden) {
|
|
645
|
+
for (let i = 0; i < blocks.length; i++) if (!busy.has(i)) levels[i] = wob(i, ms, hum);
|
|
646
|
+
apply(levels);
|
|
647
|
+
}
|
|
648
|
+
}
|
|
649
|
+
if (hum < 0.015) {
|
|
650
|
+
tailing = false;
|
|
651
|
+
for (let i = 0; i < blocks.length; i++) if (!busy.has(i)) levels[i] = 1;
|
|
652
|
+
apply(levels);
|
|
653
|
+
done();
|
|
654
|
+
return;
|
|
655
|
+
}
|
|
656
|
+
tailRaf = requestAnimationFrame(tail);
|
|
657
|
+
};
|
|
658
|
+
const stopIdle = () => {
|
|
659
|
+
idleOn = false;
|
|
660
|
+
tailing = false;
|
|
661
|
+
cancelAnimationFrame(tailRaf);
|
|
662
|
+
busy.clear();
|
|
663
|
+
window.clearTimeout(idleTimer);
|
|
664
|
+
window.clearTimeout(idleClose);
|
|
665
|
+
cancelAnimationFrame(idleRaf);
|
|
666
|
+
const c = idleCtx;
|
|
667
|
+
idleCtx = null;
|
|
668
|
+
if (c && c.state !== "closed") c.close().catch(() => {
|
|
669
|
+
});
|
|
670
|
+
};
|
|
671
|
+
const idleSound = async (edges, pan) => {
|
|
672
|
+
if (!sound || typeof AudioContext === "undefined") return;
|
|
673
|
+
let c;
|
|
674
|
+
try {
|
|
675
|
+
c = new AudioContext();
|
|
676
|
+
await Promise.race([c.resume(), new Promise((r) => setTimeout(r, 300))]);
|
|
677
|
+
} catch {
|
|
678
|
+
return;
|
|
679
|
+
}
|
|
680
|
+
if (c.state !== "running" || !idleOn) {
|
|
681
|
+
c.close().catch(() => {
|
|
682
|
+
});
|
|
683
|
+
return;
|
|
684
|
+
}
|
|
685
|
+
idleCtx = c;
|
|
686
|
+
const master = c.createGain();
|
|
687
|
+
master.gain.value = 0.5;
|
|
688
|
+
master.connect(c.createDynamicsCompressor()).connect(c.destination);
|
|
689
|
+
const base = c.currentTime + 0.03;
|
|
690
|
+
const outHz = 650 + idleRandom() * 450;
|
|
691
|
+
const onHz = 2400 + idleRandom() * 1e3;
|
|
692
|
+
edges.forEach((e) => bell(c, master, base + e.at / 1e3, e.on ? onHz : outHz, pan, e.level));
|
|
693
|
+
window.clearTimeout(idleClose);
|
|
694
|
+
idleClose = window.setTimeout(() => {
|
|
695
|
+
const x = idleCtx;
|
|
696
|
+
idleCtx = null;
|
|
697
|
+
if (x && x.state !== "closed") x.close().catch(() => {
|
|
698
|
+
});
|
|
699
|
+
}, (edges[edges.length - 1]?.at ?? 0) + 1500);
|
|
700
|
+
};
|
|
701
|
+
const flicker = () => {
|
|
702
|
+
const slow = Math.exp((performance.now() - idleSince) / 45e3);
|
|
703
|
+
idleTimer = window.setTimeout(flicker, (3e3 + idleRandom() ** 1.6 * 17e3) * slow);
|
|
704
|
+
if (!idleOn || document.hidden || !canPlay()) return;
|
|
705
|
+
const r = idleRandom();
|
|
706
|
+
const want = r < 0.2 ? 1 : r < 0.45 ? 2 + Math.floor(idleRandom() * 3) : r < 0.8 ? 5 + Math.floor(idleRandom() * 5) : 10 + Math.floor(idleRandom() * 9);
|
|
707
|
+
const first2 = Math.floor(idleRandom() * blocks.length);
|
|
708
|
+
const ranked = blocks.map((b, i) => ({ i, d: Math.hypot(b.x - blocks[first2].x, b.z - blocks[first2].z) })).filter((o) => o.d <= 5).sort((a, b) => a.d - b.d).slice(0, want);
|
|
709
|
+
const batch = ranked.map((o) => o.i);
|
|
710
|
+
batch.forEach((i) => busy.add(i));
|
|
711
|
+
const dark = 120 + idleRandom() ** 2 * 2400;
|
|
712
|
+
let at = dark;
|
|
713
|
+
const glows = [];
|
|
714
|
+
const stutters = idleRandom() < 0.55 ? 1 + Math.floor(idleRandom() * 3) : 0;
|
|
715
|
+
for (let j = 0; j < stutters; j++) {
|
|
716
|
+
const len = 40 + idleRandom() * 60;
|
|
717
|
+
glows.push([at, at + len, 0.55 + idleRandom() * 0.3]);
|
|
718
|
+
at += len + 40 + idleRandom() * 110;
|
|
719
|
+
}
|
|
720
|
+
const onAt = at;
|
|
721
|
+
const shift = ranked.map((o) => o.d * 12 + idleRandom() * 30);
|
|
722
|
+
const t02 = performance.now();
|
|
723
|
+
const total = onAt + 40 + 40;
|
|
724
|
+
const edges = [{ at: 0, on: false, level: 1 }];
|
|
725
|
+
glows.forEach(([a, b, v]) => edges.push({ at: a, on: true, level: 0.5 * v + 0.2 }, { at: b, on: false, level: 0.6 }));
|
|
726
|
+
edges.push({ at: onAt, on: true, level: 0.8 });
|
|
727
|
+
void idleSound(edges, blocks[first2].pan);
|
|
728
|
+
let last2 = -1;
|
|
729
|
+
const step = (stamp) => {
|
|
730
|
+
idleRaf = 0;
|
|
731
|
+
if (!idleOn) return;
|
|
732
|
+
const ms = stamp - t02;
|
|
733
|
+
if (last2 < 0 || stamp - last2 >= 1e3 / fps) {
|
|
734
|
+
last2 = stamp;
|
|
735
|
+
batch.forEach((i, k) => {
|
|
736
|
+
const m = ms - shift[k];
|
|
737
|
+
let v = 1;
|
|
738
|
+
if (m >= 0 && m < onAt) v = glows.find(([a, b]) => m >= a && m < b)?.[2] ?? 0;
|
|
739
|
+
levels[i] = v;
|
|
740
|
+
});
|
|
741
|
+
apply(levels, true);
|
|
742
|
+
}
|
|
743
|
+
if (ms >= total) {
|
|
744
|
+
batch.forEach((i) => {
|
|
745
|
+
levels[i] = 1;
|
|
746
|
+
busy.delete(i);
|
|
747
|
+
});
|
|
748
|
+
apply(levels, true);
|
|
749
|
+
done();
|
|
750
|
+
return;
|
|
751
|
+
}
|
|
752
|
+
idleRaf = requestAnimationFrame(step);
|
|
753
|
+
};
|
|
754
|
+
idleRaf = requestAnimationFrame(step);
|
|
755
|
+
};
|
|
756
|
+
const startIdle = () => {
|
|
757
|
+
idleOn = true;
|
|
758
|
+
idleSince = performance.now();
|
|
759
|
+
window.clearTimeout(idleTimer);
|
|
760
|
+
idleTimer = window.setTimeout(flicker, 2500 + idleRandom() * 3500);
|
|
761
|
+
};
|
|
762
|
+
const tick = (stamp) => {
|
|
763
|
+
raf = 0;
|
|
764
|
+
if (!running) return;
|
|
765
|
+
const ms = stamp - t0;
|
|
766
|
+
if (last < 0 || stamp - last >= 1e3 / rate) {
|
|
767
|
+
last = stamp;
|
|
768
|
+
let changed = false;
|
|
769
|
+
const hum = humAt(ms);
|
|
770
|
+
for (let i = 0; i < blocks.length; i++) {
|
|
771
|
+
const plan = plans.get(i);
|
|
772
|
+
const v = (plan ? levelAt(plan, ms) : 1) * wob(i, ms, hum);
|
|
773
|
+
if (Math.abs(v - levels[i]) > 1e-3) {
|
|
774
|
+
levels[i] = v;
|
|
775
|
+
changed = true;
|
|
776
|
+
}
|
|
777
|
+
}
|
|
778
|
+
if (changed) apply(levels);
|
|
779
|
+
}
|
|
780
|
+
if (ms >= end) {
|
|
781
|
+
running = false;
|
|
782
|
+
if (!ctx) document.removeEventListener("visibilitychange", onVisibility);
|
|
783
|
+
done();
|
|
784
|
+
startIdle();
|
|
785
|
+
tailing = true;
|
|
786
|
+
tailLast = -1;
|
|
787
|
+
tailRaf = requestAnimationFrame(tail);
|
|
788
|
+
return;
|
|
789
|
+
}
|
|
790
|
+
raf = requestAnimationFrame(tick);
|
|
791
|
+
};
|
|
792
|
+
return {
|
|
793
|
+
/** The levels as they stand (the scene reads them at once, to build the first frame with the flickering rods off). */
|
|
794
|
+
levels,
|
|
795
|
+
/** How many rods flicker. */
|
|
796
|
+
count: plans.size,
|
|
797
|
+
start() {
|
|
798
|
+
if (running) return;
|
|
799
|
+
running = true;
|
|
800
|
+
last = -1;
|
|
801
|
+
t0 = performance.now();
|
|
802
|
+
apply(levels);
|
|
803
|
+
document.addEventListener("visibilitychange", onVisibility);
|
|
804
|
+
void schedule();
|
|
805
|
+
raf = requestAnimationFrame(tick);
|
|
806
|
+
},
|
|
807
|
+
stop() {
|
|
808
|
+
running = false;
|
|
809
|
+
cancelAnimationFrame(raf);
|
|
810
|
+
document.removeEventListener("visibilitychange", onVisibility);
|
|
811
|
+
levels.fill(1);
|
|
812
|
+
closeSound();
|
|
813
|
+
stopIdle();
|
|
814
|
+
}
|
|
815
|
+
};
|
|
816
|
+
}
|
|
817
|
+
|
|
818
|
+
// src/size.ts
|
|
819
|
+
function renderSize(input) {
|
|
820
|
+
const { cssWidth, cssHeight, lite, maxPixelRatio = 2, maxPixels = 8e6, maxSize = 8192 } = input;
|
|
821
|
+
let ratio = lite ? 1 : Math.min(input.devicePixelRatio || 1, maxPixelRatio);
|
|
822
|
+
const area = Math.max(1, cssWidth) * Math.max(1, cssHeight);
|
|
823
|
+
ratio = Math.min(ratio, Math.sqrt(maxPixels / area), maxSize / Math.max(1, cssWidth, cssHeight));
|
|
824
|
+
return { width: Math.max(1, Math.round(cssWidth * ratio)), height: Math.max(1, Math.round(cssHeight * ratio)), ratio };
|
|
825
|
+
}
|
|
826
|
+
|
|
827
|
+
// src/graph.ts
|
|
828
|
+
var SAMPLES = 96;
|
|
829
|
+
var DEFAULT_COLORS = {
|
|
830
|
+
// each source has its own hue and the level of the day is the brightness: a quiet day is a dim dark shade, a busy one the brightest
|
|
831
|
+
top: { light: [692012, 54844], dark: [1018412, 1031998] },
|
|
832
|
+
bottom: { light: [1464504, 1740031], dark: [1006248, 2071551] }
|
|
833
|
+
};
|
|
834
|
+
function resolveLite(lite) {
|
|
835
|
+
if (typeof lite === "boolean") return lite;
|
|
836
|
+
const nav = navigator;
|
|
837
|
+
return window.matchMedia("(pointer: coarse)").matches || (nav.hardwareConcurrency ?? 8) <= 4 || (nav.deviceMemory ?? 8) < 4;
|
|
838
|
+
}
|
|
839
|
+
function resolveBackground(el, option, theme) {
|
|
840
|
+
const given = typeof option === "function" ? option(theme) : option;
|
|
841
|
+
if (given) return given;
|
|
842
|
+
for (let n = el; n; n = n.parentElement) {
|
|
843
|
+
const c = getComputedStyle(n).backgroundColor;
|
|
844
|
+
if (c && c !== "transparent" && !/rgba\(.*,\s*0\)$/.test(c)) return c;
|
|
845
|
+
}
|
|
846
|
+
return theme === "dark" ? "#0b0b0e" : "#ffffff";
|
|
847
|
+
}
|
|
848
|
+
function mountScene(el, opts, st) {
|
|
849
|
+
const api = { stop: () => {
|
|
850
|
+
}, rethink: () => {
|
|
851
|
+
}, bounds: () => null };
|
|
852
|
+
let cancelled = false;
|
|
853
|
+
const dbg = opts.debug ?? {};
|
|
854
|
+
const mq = window.matchMedia("(prefers-color-scheme: dark)");
|
|
855
|
+
const isDark = () => st.theme === "auto" ? mq.matches : st.theme === "dark";
|
|
856
|
+
const colorOf = (layer, dark) => opts.colors?.[layer]?.[dark ? "dark" : "light"] ?? DEFAULT_COLORS[layer][dark ? "dark" : "light"];
|
|
857
|
+
el.setAttribute("role", "group");
|
|
858
|
+
el.setAttribute("aria-roledescription", "interactive chart");
|
|
859
|
+
el.setAttribute("aria-label", opts.label ?? "Activity graph, one column a day. Use the arrow keys to move between days.");
|
|
860
|
+
const ready = (async () => {
|
|
861
|
+
const THREE = await import("three");
|
|
862
|
+
const { RoundedBoxGeometry } = await import("three/examples/jsm/geometries/RoundedBoxGeometry.js");
|
|
863
|
+
const { mergeGeometries } = await import("three/examples/jsm/utils/BufferGeometryUtils.js");
|
|
864
|
+
const { RoomEnvironment } = await import("three/examples/jsm/environments/RoomEnvironment.js");
|
|
865
|
+
let templates = null;
|
|
866
|
+
let templatesFailed = false;
|
|
867
|
+
const templatesSource = async () => opts.templatesUrl ?? (await import("./templates-data-2RIHMIOJ.js")).TEMPLATES_DATA_URI;
|
|
868
|
+
const wantTemplates = () => templatesFailed ? Promise.resolve() : templatesSource().then((url) => loadCausticTemplates(THREE, url)).then((t) => void (templates = t)).catch(() => void (templatesFailed = true));
|
|
869
|
+
if (isDark()) await wantTemplates();
|
|
870
|
+
if (cancelled) return;
|
|
871
|
+
const cm = (fn) => {
|
|
872
|
+
const prev = THREE.ColorManagement.enabled;
|
|
873
|
+
THREE.ColorManagement.enabled = true;
|
|
874
|
+
try {
|
|
875
|
+
return fn();
|
|
876
|
+
} finally {
|
|
877
|
+
THREE.ColorManagement.enabled = prev;
|
|
878
|
+
}
|
|
879
|
+
};
|
|
880
|
+
cm(() => {
|
|
881
|
+
const { onReady, onLit, onHover } = opts;
|
|
882
|
+
const strips = opts.strips ?? 1;
|
|
883
|
+
const layout = layoutGraph(opts.data, opts.weeks ?? 53);
|
|
884
|
+
const lite = resolveLite(opts.lite);
|
|
885
|
+
const samples = lite ? 32 : SAMPLES;
|
|
886
|
+
const t0 = performance.now();
|
|
887
|
+
const renderer = new THREE.WebGLRenderer({ antialias: false, alpha: true, powerPreference: "high-performance" });
|
|
888
|
+
renderer.setClearColor(0, 0);
|
|
889
|
+
renderer.shadowMap.enabled = true;
|
|
890
|
+
renderer.shadowMap.type = THREE.PCFShadowMap;
|
|
891
|
+
el.appendChild(renderer.domElement);
|
|
892
|
+
renderer.domElement.style.cssText = "display:block;width:100%;height:100%;transition:filter .4s ease,opacity .4s ease";
|
|
893
|
+
let settling = false;
|
|
894
|
+
const soften = (opacity = "0.85") => {
|
|
895
|
+
settling = true;
|
|
896
|
+
renderer.domElement.style.filter = "blur(7px)";
|
|
897
|
+
renderer.domElement.style.opacity = opacity;
|
|
898
|
+
};
|
|
899
|
+
let announced = false;
|
|
900
|
+
let neonStart = null;
|
|
901
|
+
const sharpen = () => {
|
|
902
|
+
settling = false;
|
|
903
|
+
if (!announced) {
|
|
904
|
+
announced = true;
|
|
905
|
+
onReady?.();
|
|
906
|
+
}
|
|
907
|
+
renderer.domElement.style.filter = "";
|
|
908
|
+
renderer.domElement.style.opacity = "";
|
|
909
|
+
const go = neonStart;
|
|
910
|
+
neonStart = null;
|
|
911
|
+
go?.();
|
|
912
|
+
};
|
|
913
|
+
soften("0");
|
|
914
|
+
const ROOM = roomFor(strips);
|
|
915
|
+
const weigh = /* @__PURE__ */ new Map();
|
|
916
|
+
for (const m of [layout.top, layout.bottom]) for (const c of m.cells) weigh.set(c.week * 7 + c.day, (weigh.get(c.week * 7 + c.day) ?? 0) + 0.18 + c.t * 2.2);
|
|
917
|
+
const { width, total, at, corners } = slabFor(layout.top.weeks, strips, stripShifts(layout.top.weeks, strips, (week, day) => weigh.get(week * 7 + day) ?? 0.18));
|
|
918
|
+
const scene = new THREE.Scene();
|
|
919
|
+
const pmrem = new THREE.PMREMGenerator(renderer);
|
|
920
|
+
const env = pmrem.fromScene(new RoomEnvironment(), 0.04).texture;
|
|
921
|
+
scene.environment = env;
|
|
922
|
+
scene.environmentIntensity = 0.9;
|
|
923
|
+
const GRAIN = opts.grain ?? 0.012;
|
|
924
|
+
const LIGHT_ENV = 0.85;
|
|
925
|
+
const LIGHT_COAT = 0.4;
|
|
926
|
+
const blockMaterial = new THREE.MeshPhysicalMaterial({
|
|
927
|
+
vertexColors: true,
|
|
928
|
+
roughness: 0.04,
|
|
929
|
+
metalness: 0,
|
|
930
|
+
transmission: 1,
|
|
931
|
+
thickness: 1.6,
|
|
932
|
+
ior: 1.5,
|
|
933
|
+
dispersion: 0.35,
|
|
934
|
+
attenuationColor: new THREE.Color(16777215),
|
|
935
|
+
attenuationDistance: 4,
|
|
936
|
+
clearcoat: 1,
|
|
937
|
+
clearcoatRoughness: 0.03,
|
|
938
|
+
specularIntensity: 1,
|
|
939
|
+
envMapIntensity: 1.4
|
|
940
|
+
});
|
|
941
|
+
const tileUnlit = new THREE.MeshBasicMaterial({ vertexColors: true, toneMapped: false });
|
|
942
|
+
const pageColour = () => {
|
|
943
|
+
const css = resolveBackground(el, opts.background, isDark() ? "dark" : "light");
|
|
944
|
+
const probe = document.createElement("canvas");
|
|
945
|
+
probe.width = probe.height = 1;
|
|
946
|
+
const ctx = probe.getContext("2d");
|
|
947
|
+
ctx.fillStyle = css;
|
|
948
|
+
ctx.fillRect(0, 0, 1, 1);
|
|
949
|
+
const [r, g, b] = ctx.getImageData(0, 0, 1, 1).data;
|
|
950
|
+
return new THREE.Color().setRGB(r / 255, g / 255, b / 255, THREE.SRGBColorSpace);
|
|
951
|
+
};
|
|
952
|
+
const coreMaterial = new THREE.MeshStandardMaterial({ vertexColors: true, roughness: 0.45, metalness: 0 });
|
|
953
|
+
const glowMaterial = new THREE.MeshBasicMaterial({ vertexColors: true, toneMapped: false });
|
|
954
|
+
const OFF_EMISSIVE = 0.0115;
|
|
955
|
+
const OFF_ENV = 0.029;
|
|
956
|
+
const MAX_LEVELS = 1024;
|
|
957
|
+
const levelData = new Float32Array(MAX_LEVELS * 2).fill(1);
|
|
958
|
+
const levelTex = new THREE.DataTexture(levelData, MAX_LEVELS, 1, THREE.RGFormat, THREE.FloatType);
|
|
959
|
+
levelTex.needsUpdate = true;
|
|
960
|
+
glowMaterial.onBeforeCompile = (shader) => {
|
|
961
|
+
shader.uniforms.uLevels = { value: levelTex };
|
|
962
|
+
shader.vertexShader = shader.vertexShader.replace("#include <common>", "#include <common>\nattribute float aBlock;\nattribute vec3 aInc;\nuniform highp sampler2D uLevels;").replace("#include <color_vertex>", "#include <color_vertex>\n#ifdef USE_COLOR\n vec2 lv = texelFetch(uLevels, ivec2(int(aBlock + 0.5), 0), 0).rg;\n vColor.rgb = vColor.rgb * lv.r + vec3(0.029, 0.037, 0.053) * (1.0 - lv.r) + aInc * lv.g;\n#endif");
|
|
963
|
+
};
|
|
964
|
+
glowMaterial.customProgramCacheKey = () => "rod-levels";
|
|
965
|
+
const paint = (g, col, glow = 0, shade = false) => {
|
|
966
|
+
const n2 = g.getAttribute("position").count;
|
|
967
|
+
const colors = new Float32Array(n2 * 3);
|
|
968
|
+
const pos = g.getAttribute("position");
|
|
969
|
+
const nor = g.getAttribute("normal");
|
|
970
|
+
let y0 = Infinity;
|
|
971
|
+
let y1 = -Infinity;
|
|
972
|
+
if (shade) for (let i = 0; i < n2; i++) {
|
|
973
|
+
y0 = Math.min(y0, pos.getY(i));
|
|
974
|
+
y1 = Math.max(y1, pos.getY(i));
|
|
975
|
+
}
|
|
976
|
+
for (let i = 0; i < n2; i++) {
|
|
977
|
+
col.toArray(colors, i * 3);
|
|
978
|
+
if (!shade || !nor) continue;
|
|
979
|
+
const nx = nor.getX(i);
|
|
980
|
+
const ny = nor.getY(i);
|
|
981
|
+
const nz = nor.getZ(i);
|
|
982
|
+
const face = 0.5 + 0.62 * Math.max(0, ny) + 0.3 * Math.max(0, -nx) + 0.08 * Math.max(0, -nz);
|
|
983
|
+
const foot = 0.7 + 0.3 * (y1 > y0 ? (pos.getY(i) - y0) / (y1 - y0) : 1);
|
|
984
|
+
const k = face * foot;
|
|
985
|
+
colors[i * 3] = colors[i * 3] * k;
|
|
986
|
+
colors[i * 3 + 1] = colors[i * 3 + 1] * k;
|
|
987
|
+
colors[i * 3 + 2] = colors[i * 3 + 2] * k;
|
|
988
|
+
}
|
|
989
|
+
g.setAttribute("color", new THREE.BufferAttribute(colors, 3));
|
|
990
|
+
g.setAttribute("aGlow", new THREE.BufferAttribute(new Float32Array(n2).fill(glow), 1));
|
|
991
|
+
g.deleteAttribute("uv");
|
|
992
|
+
};
|
|
993
|
+
const GLOW_PAD = 9;
|
|
994
|
+
const GROUND_REACH = 1.75;
|
|
995
|
+
const GROUND_LIGHT = 0.5;
|
|
996
|
+
const POOL = 0.15;
|
|
997
|
+
const CAUSTIC_NEAR = 7;
|
|
998
|
+
const CAUSTIC_FAR = 18;
|
|
999
|
+
const CAUSTIC_POWER = 0.055;
|
|
1000
|
+
const ABSORB = 1.1;
|
|
1001
|
+
const LIGHT_CAUSTIC = 1;
|
|
1002
|
+
const STRAIGHT = 0.65;
|
|
1003
|
+
const SHADOW = 0.5;
|
|
1004
|
+
const GLEAM = 2.2;
|
|
1005
|
+
const NOISE_FLOOR = 0.03;
|
|
1006
|
+
const GLEAM_MAX = 0.45;
|
|
1007
|
+
const SUN_NEAR = 3.4;
|
|
1008
|
+
const SUN_FAR = 6;
|
|
1009
|
+
const PX = 22;
|
|
1010
|
+
const LPX = PX / 2;
|
|
1011
|
+
let neonNeighbours = [];
|
|
1012
|
+
let neonBlocks = [];
|
|
1013
|
+
let stampCtl = null;
|
|
1014
|
+
const customOn = () => !!opts.rodColor && isDark();
|
|
1015
|
+
const WHITE_ROD = 0.62;
|
|
1016
|
+
const customHue = (cell, src, t) => {
|
|
1017
|
+
const rgb = opts.rodColor({ layer: src, index: cell, date: layout.top.cells[cell].date, t });
|
|
1018
|
+
return rgb ? new THREE.Color(rgb[0], rgb[1], rgb[2]) : null;
|
|
1019
|
+
};
|
|
1020
|
+
const groundLayers = (stack2, tones, dark) => {
|
|
1021
|
+
const cw = Math.ceil((width + GLOW_PAD * 2) * PX);
|
|
1022
|
+
const ch = Math.ceil((total + GLOW_PAD * 2) * PX);
|
|
1023
|
+
const lw = Math.ceil((width + GLOW_PAD * 2) * LPX);
|
|
1024
|
+
const lh = Math.ceil((total + GLOW_PAD * 2) * LPX);
|
|
1025
|
+
const canvas = () => {
|
|
1026
|
+
const c2 = document.createElement("canvas");
|
|
1027
|
+
c2.width = cw;
|
|
1028
|
+
c2.height = ch;
|
|
1029
|
+
return c2;
|
|
1030
|
+
};
|
|
1031
|
+
const ao = canvas();
|
|
1032
|
+
const actx = ao.getContext("2d");
|
|
1033
|
+
const occlude = (x, z, height) => {
|
|
1034
|
+
const cx = (x + GLOW_PAD) * PX;
|
|
1035
|
+
const cy = (z + GLOW_PAD) * PX;
|
|
1036
|
+
const r = (0.75 + 0.22 * height) * PX;
|
|
1037
|
+
const g = actx.createRadialGradient(cx, cy, 0.3 * PX, cx, cy, r);
|
|
1038
|
+
const a = Math.min(0.85, (dark ? 0.5 : 0.28) + 0.06 * height);
|
|
1039
|
+
g.addColorStop(0, `rgba(0,0,0,${a})`);
|
|
1040
|
+
g.addColorStop(0.5, `rgba(0,0,0,${a * 0.4})`);
|
|
1041
|
+
g.addColorStop(1, "rgba(0,0,0,0)");
|
|
1042
|
+
actx.fillStyle = g;
|
|
1043
|
+
actx.fillRect(cx - r, cy - r, r * 2, r * 2);
|
|
1044
|
+
};
|
|
1045
|
+
stack2.top.cells.forEach((g, i) => {
|
|
1046
|
+
const w2 = stack2.bottom.cells[i];
|
|
1047
|
+
const { x, z } = at(g.week, g.day);
|
|
1048
|
+
if (w2.value > 0 || g.value > 0) occlude(x, z, (w2.value > 0 ? 0.18 + w2.t * LAYER_MAX : 0) + (g.value > 0 ? 0.18 + g.t * LAYER_MAX : 0));
|
|
1049
|
+
});
|
|
1050
|
+
const t02 = performance.now();
|
|
1051
|
+
const glass = [];
|
|
1052
|
+
neonBlocks = [];
|
|
1053
|
+
const variety = /* @__PURE__ */ (() => {
|
|
1054
|
+
let seed = 987654;
|
|
1055
|
+
return () => (seed = seed * 16807 % 2147483647) / 2147483647;
|
|
1056
|
+
})();
|
|
1057
|
+
stack2.top.cells.forEach((g, i) => {
|
|
1058
|
+
const w2 = stack2.bottom.cells[i];
|
|
1059
|
+
const { x, z } = at(g.week, g.day);
|
|
1060
|
+
let top = 0;
|
|
1061
|
+
const add = (src, y0, y1, t, [low, high], gain) => {
|
|
1062
|
+
const hy = (y1 - y0) / 2;
|
|
1063
|
+
const hue = (customOn() ? customHue(i, src, t) : null) ?? low.clone().lerp(high, t);
|
|
1064
|
+
const rod = customOn() ? (
|
|
1065
|
+
// (`rodColor`: the light on the ground is the light's own colour, not lifted toward white as a busy rod is in the usual picture)
|
|
1066
|
+
hue.clone()
|
|
1067
|
+
) : src === "bottom" ? hue.clone().multiplyScalar(0.5).add(new THREE.Color(0.4, 0.56, 0.6).multiplyScalar(0.38 + 0.98 * t)) : hue.clone().multiplyScalar(1.25).add(new THREE.Color(0.22, 0.4, 0.24).multiplyScalar(0.15 + 0.7 * t));
|
|
1068
|
+
const col = dark ? rod.multiplyScalar(1 / Math.max(1e-4, rod.r, rod.g, rod.b)) : hue;
|
|
1069
|
+
const whiteLight = customOn() && Math.max(hue.r, hue.g, hue.b) - Math.min(hue.r, hue.g, hue.b) < 0.15 * Math.max(hue.r, hue.g, hue.b) ? 0.5 : 1;
|
|
1070
|
+
const tilt = () => (variety() - 0.5) * 0.22;
|
|
1071
|
+
const luck = 0.6 + 0.8 * variety();
|
|
1072
|
+
const near = dark ? CAUSTIC_NEAR : SUN_NEAR;
|
|
1073
|
+
const far = dark ? CAUSTIC_FAR : SUN_FAR;
|
|
1074
|
+
neonBlocks.push({ x, z, pan: x / width * 2 - 1, t, cell: i });
|
|
1075
|
+
glass.push({
|
|
1076
|
+
c: [x, y0 + hy, z],
|
|
1077
|
+
h: [0.46, hy, 0.46],
|
|
1078
|
+
r: Math.min(0.16, 2 * hy / 2.2),
|
|
1079
|
+
bias: [tilt(), tilt() * 0.4, tilt()],
|
|
1080
|
+
col: [col.r, col.g, col.b],
|
|
1081
|
+
power: (0.05 + t * t) * gain * luck * CAUSTIC_POWER * whiteLight,
|
|
1082
|
+
near,
|
|
1083
|
+
far,
|
|
1084
|
+
// (the rod, as drawn: its width)
|
|
1085
|
+
rod: (0.5 - 0.2 * t ** 0.85) / 2,
|
|
1086
|
+
seed: [variety(), variety(), variety(), variety(), variety()],
|
|
1087
|
+
// (the soft pool: a haze under the block, as bright as its day was busy; it goes out with its rod)
|
|
1088
|
+
pool: (() => {
|
|
1089
|
+
const peak = POOL * GROUND_LIGHT * gain * (4e-3 + 0.26 * t * t + 0.03 * t) * whiteLight;
|
|
1090
|
+
return { col: [hue.r * peak, hue.g * peak, hue.b * peak], r: 0.9 + GROUND_REACH * (0.5 + t * 1.5) };
|
|
1091
|
+
})()
|
|
1092
|
+
});
|
|
1093
|
+
};
|
|
1094
|
+
if (w2.value > 0) {
|
|
1095
|
+
add("bottom", 0, 0.18 + w2.t * LAYER_MAX, w2.t, tones.bottom, 1);
|
|
1096
|
+
top = 0.18 + w2.t * LAYER_MAX + 0.04;
|
|
1097
|
+
}
|
|
1098
|
+
if (g.value > 0) add("top", top, top + 0.18 + g.t * LAYER_MAX, g.t, tones.top, 1.8);
|
|
1099
|
+
});
|
|
1100
|
+
const ground2 = dark ? createGroundLight(THREE, renderer, { w: cw, h: ch, scale: PX, x0: -GLOW_PAD, z0: -GLOW_PAD }) : createGroundLight(THREE, renderer, { w: lw, h: lh, scale: LPX, x0: -GLOW_PAD, z0: -GLOW_PAD });
|
|
1101
|
+
if (dark) {
|
|
1102
|
+
stampCtl = !templates ? null : ground2.stamps(
|
|
1103
|
+
glass.map((g) => ({ x: g.c[0], z: g.c[2], height: 2 * g.h[1], foot: g.c[1] - g.h[1], col: [g.col[0] * g.power, g.col[1] * g.power, g.col[2] * g.power], poolCol: g.pool.col, poolRadius: g.pool.r })),
|
|
1104
|
+
templates
|
|
1105
|
+
);
|
|
1106
|
+
} else {
|
|
1107
|
+
const sunDir = new THREE.Vector3().copy(sunBase).normalize().negate();
|
|
1108
|
+
ground2.sun(glass, lite ? 40 : 64, [sunDir.x, sunDir.y, sunDir.z], ABSORB, STRAIGHT, LPX * LPX / -sunDir.y);
|
|
1109
|
+
ground2.smooth(3);
|
|
1110
|
+
}
|
|
1111
|
+
if (dbg.metrics) console.info(`[activity] ground light drawn in ${Math.round(performance.now() - t02)} ms (${dark ? "dark" : "light"}, ${glass.length} blocks)`);
|
|
1112
|
+
const layers = new THREE.Group();
|
|
1113
|
+
const disposers = [];
|
|
1114
|
+
const plane = (tex, material, order) => {
|
|
1115
|
+
const mat = material(tex);
|
|
1116
|
+
const mesh = new THREE.Mesh(new THREE.PlaneGeometry(cw / PX, ch / PX), mat);
|
|
1117
|
+
mesh.rotation.x = -Math.PI / 2;
|
|
1118
|
+
mesh.position.set(width / 2, 0.11 + order * 2e-3, total / 2);
|
|
1119
|
+
mesh.renderOrder = order;
|
|
1120
|
+
layers.add(mesh);
|
|
1121
|
+
disposers.push(() => {
|
|
1122
|
+
tex.dispose();
|
|
1123
|
+
mat.dispose();
|
|
1124
|
+
});
|
|
1125
|
+
};
|
|
1126
|
+
if (dark) plane(ground2.texture, (map) => new THREE.MeshBasicMaterial({ map, transparent: true, blending: THREE.AdditiveBlending, depthWrite: false, toneMapped: false }), 1);
|
|
1127
|
+
else {
|
|
1128
|
+
const resolve = (shade) => new THREE.ShaderMaterial({
|
|
1129
|
+
uniforms: { map: { value: ground2.texture } },
|
|
1130
|
+
vertexShader: "varying vec2 vUv; void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.); }",
|
|
1131
|
+
fragmentShader: `uniform sampler2D map; varying vec2 vUv;
|
|
1132
|
+
void main() {
|
|
1133
|
+
vec3 v = texture2D(map, vUv).rgb;
|
|
1134
|
+
// (the differences of overlapping shadows are summed, but light that has been through two blocks has lost the share of each, not both shares: the product, which the exponential of the sum is) (below a small difference there is only the noise of the rays: it is not light)
|
|
1135
|
+
vec3 f = exp(${(LIGHT_CAUSTIC * 1.2).toFixed(3)} * sign(v) * max(abs(v) - ${NOISE_FLOOR.toFixed(3)}, 0.));
|
|
1136
|
+
${shade ? `gl_FragColor = vec4(vec3(1. - ${SHADOW.toFixed(3)} * (1. - min(f, vec3(1.)))), 1.);` : `vec3 g = max(f - 1., 0.) * ${GLEAM.toFixed(3)}; gl_FragColor = vec4(${GLEAM_MAX.toFixed(3)} * tanh(g / ${GLEAM_MAX.toFixed(3)}), 1.);`}
|
|
1137
|
+
}`,
|
|
1138
|
+
transparent: true,
|
|
1139
|
+
blending: shade ? THREE.MultiplyBlending : THREE.AdditiveBlending,
|
|
1140
|
+
premultipliedAlpha: shade,
|
|
1141
|
+
depthWrite: false
|
|
1142
|
+
});
|
|
1143
|
+
plane(ground2.texture, () => resolve(true), 0);
|
|
1144
|
+
plane(ground2.texture, () => resolve(false), 1);
|
|
1145
|
+
}
|
|
1146
|
+
const aoTex = new THREE.CanvasTexture(ao);
|
|
1147
|
+
aoTex.colorSpace = THREE.SRGBColorSpace;
|
|
1148
|
+
plane(aoTex, (map) => new THREE.MeshBasicMaterial({ map, transparent: true, depthWrite: false, toneMapped: false }), 2);
|
|
1149
|
+
disposers.push(() => ground2.dispose());
|
|
1150
|
+
layers.userData.dispose = () => disposers.forEach((d) => d());
|
|
1151
|
+
return layers;
|
|
1152
|
+
};
|
|
1153
|
+
const LAYER_MAX = 2.3;
|
|
1154
|
+
const roundedSquare = (() => {
|
|
1155
|
+
const half = 0.46;
|
|
1156
|
+
const r = 0.16;
|
|
1157
|
+
const sh = new THREE.Shape();
|
|
1158
|
+
sh.moveTo(-half + r, -half);
|
|
1159
|
+
sh.lineTo(half - r, -half);
|
|
1160
|
+
sh.absarc(half - r, -half + r, r, -Math.PI / 2, 0, false);
|
|
1161
|
+
sh.lineTo(half, half - r);
|
|
1162
|
+
sh.absarc(half - r, half - r, r, 0, Math.PI / 2, false);
|
|
1163
|
+
sh.lineTo(-half + r, half);
|
|
1164
|
+
sh.absarc(-half + r, half - r, r, Math.PI / 2, Math.PI, false);
|
|
1165
|
+
sh.lineTo(-half, -half + r);
|
|
1166
|
+
sh.absarc(-half + r, -half + r, r, Math.PI, Math.PI * 1.5, false);
|
|
1167
|
+
return sh;
|
|
1168
|
+
})();
|
|
1169
|
+
let tallest = 1;
|
|
1170
|
+
let bounds = null;
|
|
1171
|
+
api.bounds = () => bounds;
|
|
1172
|
+
let picks = [];
|
|
1173
|
+
const LIFT = 0.04;
|
|
1174
|
+
const build = (stack2, tones, dark) => {
|
|
1175
|
+
picks = [];
|
|
1176
|
+
const shellsBy = /* @__PURE__ */ new Map();
|
|
1177
|
+
const shellTier = /* @__PURE__ */ new Map();
|
|
1178
|
+
const cores = [];
|
|
1179
|
+
const tiles = [];
|
|
1180
|
+
const specs = [];
|
|
1181
|
+
const emit = (t) => 1.3 * (0.3 + 0.1 * (1 - t) ** 3 + 1.3 * t * t + 0.4 * t);
|
|
1182
|
+
const layer = (cell, src, x, z, y0, t, [low, high]) => {
|
|
1183
|
+
const h2 = 0.18 + t * LAYER_MAX;
|
|
1184
|
+
picks.push({ cell, x, z, y0, y1: y0 + h2 });
|
|
1185
|
+
specs.push({ src, x, z, y0, h: h2, t, hue: (customOn() ? customHue(cell, src, t) : null) ?? low.clone().lerp(high, t) });
|
|
1186
|
+
tallest = Math.max(tallest, y0 + h2);
|
|
1187
|
+
return y0 + h2;
|
|
1188
|
+
};
|
|
1189
|
+
stack2.top.cells.forEach((g, i) => {
|
|
1190
|
+
const w2 = stack2.bottom.cells[i];
|
|
1191
|
+
const { x, z } = at(g.week, g.day);
|
|
1192
|
+
if (w2.value <= 0 && g.value <= 0) {
|
|
1193
|
+
const tile = new THREE.ExtrudeGeometry(roundedSquare, { depth: 0.04, bevelEnabled: false, curveSegments: lite ? 3 : 6 });
|
|
1194
|
+
tile.rotateX(-Math.PI / 2);
|
|
1195
|
+
tile.deleteAttribute("uv");
|
|
1196
|
+
tile.translate(x, 0, z);
|
|
1197
|
+
paint(tile, dark ? pageColour().add(new THREE.Color(6e-3, 6e-3, 6e-3)) : pageColour().multiplyScalar(0.93));
|
|
1198
|
+
tiles.push(tile);
|
|
1199
|
+
picks.push({ cell: i, x, z, y0: 0, y1: 0.04 });
|
|
1200
|
+
return;
|
|
1201
|
+
}
|
|
1202
|
+
let y = 0;
|
|
1203
|
+
if (w2.value > 0) y = layer(i, "bottom", x, z, 0, w2.t, tones.bottom) + LIFT;
|
|
1204
|
+
if (g.value > 0) layer(i, "top", x, z, y, g.t, tones.top);
|
|
1205
|
+
});
|
|
1206
|
+
let blockIndex = 0;
|
|
1207
|
+
neonNeighbours = [];
|
|
1208
|
+
for (const sp of specs) {
|
|
1209
|
+
const { src, x, z, y0, h: h2, t, hue: hue0 } = sp;
|
|
1210
|
+
let hue = hue0;
|
|
1211
|
+
const inc = new THREE.Color(0, 0, 0);
|
|
1212
|
+
const nb = { j: [], m: [] };
|
|
1213
|
+
if (dark) {
|
|
1214
|
+
for (let oi = 0; oi < specs.length; oi++) {
|
|
1215
|
+
const o = specs[oi];
|
|
1216
|
+
if (o === sp) continue;
|
|
1217
|
+
const dx = o.x - x;
|
|
1218
|
+
const dz = o.z - z;
|
|
1219
|
+
if (Math.abs(dx) > 4 || Math.abs(dz) > 4) continue;
|
|
1220
|
+
const dy = o.y0 + o.h / 2 - (y0 + h2 / 2);
|
|
1221
|
+
const k = Math.exp(-(dx * dx + dz * dz + dy * dy) / (2 * 1.2 * 1.2)) * 0.11;
|
|
1222
|
+
inc.add(o.hue.clone().multiplyScalar(emit(o.t) * k));
|
|
1223
|
+
nb.j.push(oi);
|
|
1224
|
+
nb.m.push(emit(o.t) * k * (o.hue.r + o.hue.g + o.hue.b));
|
|
1225
|
+
}
|
|
1226
|
+
}
|
|
1227
|
+
neonNeighbours.push(nb);
|
|
1228
|
+
if (dark && customOn() && Math.max(hue.r, hue.g, hue.b) - Math.min(hue.r, hue.g, hue.b) < 0.15 * Math.max(hue.r, hue.g, hue.b)) {
|
|
1229
|
+
const m = Math.max(inc.r, inc.g, inc.b);
|
|
1230
|
+
if (m > 1e-4) hue = hue.clone().lerp(inc.clone().multiplyScalar(1 / m).multiplyScalar(Math.max(hue.r, hue.g, hue.b)), Math.min(0.75, m * 3));
|
|
1231
|
+
}
|
|
1232
|
+
inc.r = Math.min(inc.r, 0.6);
|
|
1233
|
+
inc.g = Math.min(inc.g, 0.6);
|
|
1234
|
+
inc.b = Math.min(inc.b, 0.6);
|
|
1235
|
+
const incLum = (inc.r + inc.g + inc.b) / 3;
|
|
1236
|
+
const tEff = t + (1 - t) * Math.min(1, Math.sqrt(incLum * 1.2));
|
|
1237
|
+
const shell = new RoundedBoxGeometry(0.92, h2, 0.92, lite ? 2 : 3, Math.min(0.16, h2 / 2.2));
|
|
1238
|
+
shell.translate(x, y0 + h2 / 2, z);
|
|
1239
|
+
paint(shell, hue.clone().lerp(new THREE.Color(16777215), dark ? 0.14 : 0.12).multiplyScalar(dark ? 0.3 + 0.7 * tEff : 1).add(inc.clone().multiplyScalar(dark && customOn() ? 0.35 : 0.08)), 0, dark);
|
|
1240
|
+
shell.setAttribute("aBlock", new THREE.BufferAttribute(new Float32Array(shell.getAttribute("position").count).fill(blockIndex), 1));
|
|
1241
|
+
const tier = tEff < 0.34 ? 0 : tEff < 0.67 ? 1 : 2;
|
|
1242
|
+
const key = `${src}${tier}`;
|
|
1243
|
+
(shellsBy.get(key) ?? shellsBy.set(key, []).get(key)).push(shell);
|
|
1244
|
+
shellTier.set(key, [src, tier]);
|
|
1245
|
+
const hc = h2 * 0.8;
|
|
1246
|
+
const cw = dark ? 0.5 - 0.2 * t ** 0.85 : 0.5;
|
|
1247
|
+
const core = new RoundedBoxGeometry(cw, hc, cw, lite ? 1 : 2, Math.min(0.1, cw / 2.4, hc / 2.2));
|
|
1248
|
+
core.translate(x, y0 + h2 / 2, z);
|
|
1249
|
+
const level = emit(t) * (1 + 1.1 * t);
|
|
1250
|
+
const rod = dark && customOn() ? hue0.clone().multiplyScalar(level * 0.55 * (Math.max(hue0.r, hue0.g, hue0.b) - Math.min(hue0.r, hue0.g, hue0.b) < 0.15 * Math.max(hue0.r, hue0.g, hue0.b) ? WHITE_ROD : 1)) : dark && src === "bottom" ? hue.clone().multiplyScalar(level * 0.5).add(new THREE.Color(0.4, 0.56, 0.6).multiplyScalar(level * (0.38 + 0.98 * t))) : dark ? hue.clone().multiplyScalar(level * 1.25).add(new THREE.Color(0.22, 0.4, 0.24).multiplyScalar(level * (0.15 + 0.7 * t))) : hue;
|
|
1251
|
+
paint(core, dark ? rod : hue);
|
|
1252
|
+
{
|
|
1253
|
+
const count = core.getAttribute("position").count;
|
|
1254
|
+
const incs = new Float32Array(count * 3);
|
|
1255
|
+
if (dark) for (let q = 0; q < count; q++) inc.toArray(incs, q * 3);
|
|
1256
|
+
core.setAttribute("aInc", new THREE.BufferAttribute(incs, 3));
|
|
1257
|
+
}
|
|
1258
|
+
core.setAttribute("aBlock", new THREE.BufferAttribute(new Float32Array(core.getAttribute("position").count).fill(blockIndex++), 1));
|
|
1259
|
+
cores.push(core);
|
|
1260
|
+
}
|
|
1261
|
+
const group = new THREE.Group();
|
|
1262
|
+
group.add(groundLayers(stack2, tones, dark));
|
|
1263
|
+
if (tiles.length) {
|
|
1264
|
+
const tile = new THREE.Mesh(mergeGeometries(tiles), tileUnlit);
|
|
1265
|
+
group.add(tile);
|
|
1266
|
+
}
|
|
1267
|
+
const materials = [];
|
|
1268
|
+
for (const [key, list] of shellsBy) {
|
|
1269
|
+
const [src, tier] = shellTier.get(key);
|
|
1270
|
+
const mat = blockMaterial.clone();
|
|
1271
|
+
if (dbg.wireframe) {
|
|
1272
|
+
mat.wireframe = true;
|
|
1273
|
+
mat.transmission = 0;
|
|
1274
|
+
mat.transparent = true;
|
|
1275
|
+
mat.opacity = 0.9;
|
|
1276
|
+
}
|
|
1277
|
+
mat.emissive.copy(customOn() ? new THREE.Color(0) : tones[src][1]);
|
|
1278
|
+
if (dark) {
|
|
1279
|
+
mat.attenuationColor.copy(customOn() ? new THREE.Color(16777215) : tones[src][1]);
|
|
1280
|
+
mat.attenuationDistance = src === "bottom" ? 3.6 : 2.2;
|
|
1281
|
+
if (src === "top" && !customOn()) {
|
|
1282
|
+
mat.attenuationColor.r *= 0.2;
|
|
1283
|
+
mat.attenuationColor.b *= 0.15;
|
|
1284
|
+
mat.attenuationDistance = 1.6;
|
|
1285
|
+
}
|
|
1286
|
+
}
|
|
1287
|
+
mat.emissiveIntensity = dark ? [0.02, 0.08, 0.15][tier] : 0;
|
|
1288
|
+
if (dark) {
|
|
1289
|
+
mat.onBeforeCompile = (shader) => {
|
|
1290
|
+
shader.uniforms.uLevels = { value: levelTex };
|
|
1291
|
+
shader.uniforms.uFloorEm = { value: OFF_EMISSIVE / Math.max(mat.emissiveIntensity, 1e-4) };
|
|
1292
|
+
shader.uniforms.uFloorEnv = { value: OFF_ENV / Math.max(mat.envMapIntensity, 1e-4) };
|
|
1293
|
+
shader.vertexShader = shader.vertexShader.replace("#include <common>", "#include <common>\nattribute float aBlock;\nuniform highp sampler2D uLevels;\nuniform float uFloorEm;\nuniform float uFloorEnv;\nvarying float vLevelEm;\nvarying float vLevelEnv;\nvarying float vOn;").replace("#include <begin_vertex>", "#include <begin_vertex>\n vec2 lv = texelFetch(uLevels, ivec2(int(aBlock + 0.5), 0), 0).rg;\n float own = max(lv.r, 0.3 * lv.g);\n vOn = clamp(own, 0.0, 1.0);\n vLevelEm = max(own, uFloorEm);\n vLevelEnv = max(own, uFloorEnv);");
|
|
1294
|
+
shader.fragmentShader = shader.fragmentShader.replace("#include <common>", "#include <common>\nvarying float vLevelEm;\nvarying float vLevelEnv;\nvarying float vOn;").replace("#include <emissivemap_fragment>", "#include <emissivemap_fragment>\n // (off, the glass glows the same cool grey whatever its source; on, its own colour)\n totalEmissiveRadiance = mix(vec3(dot(totalEmissiveRadiance, vec3(0.333))) * vec3(0.85, 0.95, 1.15), totalEmissiveRadiance, vOn) * vLevelEm;").replace("#include <lights_fragment_maps>", "#include <lights_fragment_maps>\n#if defined( RE_IndirectSpecular )\n radiance *= vLevelEnv;\n#ifdef USE_CLEARCOAT\n clearcoatRadiance *= vLevelEnv;\n#endif\n#endif\n#if defined( RE_IndirectDiffuse )\n iblIrradiance *= vLevelEnv;\n#endif");
|
|
1295
|
+
};
|
|
1296
|
+
mat.customProgramCacheKey = () => "glass-levels";
|
|
1297
|
+
}
|
|
1298
|
+
mat.envMap = dark ? env : null;
|
|
1299
|
+
mat.envMapIntensity = dark ? [0.02, 0.18, 0.55][tier] : LIGHT_ENV;
|
|
1300
|
+
if (!dark) {
|
|
1301
|
+
mat.clearcoat = LIGHT_COAT;
|
|
1302
|
+
mat.specularColor = tones[src][1].clone().lerp(new THREE.Color(16777215), 0.35);
|
|
1303
|
+
}
|
|
1304
|
+
materials.push(mat);
|
|
1305
|
+
const glass = new THREE.Mesh(mergeGeometries(list), mat);
|
|
1306
|
+
glass.castShadow = true;
|
|
1307
|
+
glass.receiveShadow = true;
|
|
1308
|
+
group.add(glass);
|
|
1309
|
+
list.forEach((p) => p.dispose());
|
|
1310
|
+
}
|
|
1311
|
+
group.userData.dispose = () => materials.forEach((m) => m.dispose());
|
|
1312
|
+
if (cores.length) {
|
|
1313
|
+
const core = new THREE.Mesh(mergeGeometries(cores), dark ? glowMaterial : coreMaterial);
|
|
1314
|
+
core.castShadow = !dark;
|
|
1315
|
+
group.add(core);
|
|
1316
|
+
}
|
|
1317
|
+
[...cores, ...tiles].forEach((p) => p.dispose());
|
|
1318
|
+
return group;
|
|
1319
|
+
};
|
|
1320
|
+
const blocks = new THREE.Group();
|
|
1321
|
+
scene.add(blocks);
|
|
1322
|
+
const ground0 = () => ground.material.opacity = isDark() ? 0 : 0.05;
|
|
1323
|
+
const buildBlocks = () => {
|
|
1324
|
+
showMat.uniforms.bloom.value = isDark() ? customOn() ? 0.4 : 1 : 0;
|
|
1325
|
+
showMat.uniforms.veil.value = customOn() ? 0.75 : 0;
|
|
1326
|
+
scene.environmentIntensity = isDark() ? 0 : 0.9;
|
|
1327
|
+
sun.intensity = isDark() ? 0 : 2.2;
|
|
1328
|
+
ground0();
|
|
1329
|
+
blocks.traverse((o) => {
|
|
1330
|
+
o.geometry?.dispose();
|
|
1331
|
+
o.userData.dispose?.();
|
|
1332
|
+
});
|
|
1333
|
+
blocks.clear();
|
|
1334
|
+
const dark = isDark();
|
|
1335
|
+
const pair = (layer) => {
|
|
1336
|
+
const [low, high] = colorOf(layer, dark);
|
|
1337
|
+
return [new THREE.Color(low), new THREE.Color(high)];
|
|
1338
|
+
};
|
|
1339
|
+
blocks.add(build({ bottom: layout.bottom, top: layout.top }, { bottom: pair("bottom"), top: pair("top") }, dark));
|
|
1340
|
+
};
|
|
1341
|
+
const floor = new THREE.Mesh(new THREE.PlaneGeometry(1200, 1200), new THREE.MeshBasicMaterial({ color: pageColour() }));
|
|
1342
|
+
floor.rotation.x = -Math.PI / 2;
|
|
1343
|
+
floor.position.set(width / 2, -0.02, total / 2);
|
|
1344
|
+
scene.add(floor);
|
|
1345
|
+
const ground = new THREE.Mesh(new THREE.PlaneGeometry(1200, 1200), new THREE.ShadowMaterial({ opacity: 0.32 }));
|
|
1346
|
+
ground.rotation.x = -Math.PI / 2;
|
|
1347
|
+
ground.position.set(width / 2, 0.06, total / 2);
|
|
1348
|
+
ground.receiveShadow = true;
|
|
1349
|
+
scene.add(ground);
|
|
1350
|
+
const sun = new THREE.DirectionalLight(16777215, 2.2);
|
|
1351
|
+
const sunBase = new THREE.Vector3(-0.45, 1, 0.55).normalize().multiplyScalar(60);
|
|
1352
|
+
sun.castShadow = true;
|
|
1353
|
+
sun.shadow.mapSize.set(lite ? 2048 : 4096, lite ? 2048 : 4096);
|
|
1354
|
+
sun.shadow.bias = -4e-4;
|
|
1355
|
+
sun.shadow.normalBias = 0.03;
|
|
1356
|
+
const sc = sun.shadow.camera;
|
|
1357
|
+
sc.left = -width * 1.4;
|
|
1358
|
+
sc.right = width * 1.4;
|
|
1359
|
+
sc.top = total * 6;
|
|
1360
|
+
sc.bottom = -total * 6;
|
|
1361
|
+
sc.near = 1;
|
|
1362
|
+
sc.far = 160;
|
|
1363
|
+
sun.target.position.set(width / 2, 0, total / 2);
|
|
1364
|
+
scene.add(sun, sun.target);
|
|
1365
|
+
const camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 1, 1900);
|
|
1366
|
+
const centre = new THREE.Vector3(width / 2, 1.2, total / 2);
|
|
1367
|
+
camera.position.copy(centre).add(new THREE.Vector3(...CAMERA_DIR).normalize().multiplyScalar(900));
|
|
1368
|
+
camera.up.set(0, 1, 0);
|
|
1369
|
+
camera.lookAt(centre);
|
|
1370
|
+
const sceneRT = new THREE.WebGLRenderTarget(1, 1, { type: THREE.HalfFloatType });
|
|
1371
|
+
const accumRT = new THREE.WebGLRenderTarget(1, 1, { type: THREE.HalfFloatType });
|
|
1372
|
+
const quadGeo = new THREE.PlaneGeometry(2, 2);
|
|
1373
|
+
const quadCam = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
|
|
1374
|
+
const addMat = new THREE.ShaderMaterial({
|
|
1375
|
+
uniforms: { map: { value: sceneRT.texture } },
|
|
1376
|
+
vertexShader: "varying vec2 vUv; void main(){ vUv = uv; gl_Position = vec4(position.xy, 0., 1.); }",
|
|
1377
|
+
fragmentShader: "uniform sampler2D map; varying vec2 vUv; void main(){ gl_FragColor = texture2D(map, vUv); }",
|
|
1378
|
+
// a running average (new * k + old * (1 - k), k = 1 / (n + 1)): the values stay in 0..1, where a half float is precise; a plain sum grows to ~100 and its rounding errors tint the whole picture
|
|
1379
|
+
blending: THREE.CustomBlending,
|
|
1380
|
+
blendEquation: THREE.AddEquation,
|
|
1381
|
+
blendSrc: THREE.ConstantAlphaFactor,
|
|
1382
|
+
blendDst: THREE.OneMinusConstantAlphaFactor,
|
|
1383
|
+
blendSrcAlpha: THREE.ConstantAlphaFactor,
|
|
1384
|
+
blendDstAlpha: THREE.OneMinusConstantAlphaFactor,
|
|
1385
|
+
depthTest: false,
|
|
1386
|
+
depthWrite: false
|
|
1387
|
+
});
|
|
1388
|
+
const VERT = "varying vec2 vUv; void main(){ vUv = uv; gl_Position = vec4(position.xy, 0., 1.); }";
|
|
1389
|
+
const rt = () => new THREE.WebGLRenderTarget(1, 1, { type: THREE.HalfFloatType, depthBuffer: false });
|
|
1390
|
+
const halfA = rt();
|
|
1391
|
+
const halfB = rt();
|
|
1392
|
+
const quarterA = rt();
|
|
1393
|
+
const quarterB = rt();
|
|
1394
|
+
const brightMat = new THREE.ShaderMaterial({
|
|
1395
|
+
uniforms: { map: { value: accumRT.texture } },
|
|
1396
|
+
vertexShader: VERT,
|
|
1397
|
+
fragmentShader: "uniform sampler2D map; varying vec2 vUv; void main(){ vec3 c = texture2D(map, vUv).rgb; gl_FragColor = vec4(max(c - 1.0, 0.), 1.); }",
|
|
1398
|
+
depthTest: false,
|
|
1399
|
+
depthWrite: false
|
|
1400
|
+
});
|
|
1401
|
+
const blurMat = new THREE.ShaderMaterial({
|
|
1402
|
+
uniforms: { map: { value: halfA.texture }, stepv: { value: new THREE.Vector2() } },
|
|
1403
|
+
vertexShader: VERT,
|
|
1404
|
+
fragmentShader: `uniform sampler2D map; uniform vec2 stepv; varying vec2 vUv;
|
|
1405
|
+
void main(){
|
|
1406
|
+
vec3 c = texture2D(map, vUv).rgb * 0.227027;
|
|
1407
|
+
c += (texture2D(map, vUv + stepv * 1.3846154).rgb + texture2D(map, vUv - stepv * 1.3846154).rgb) * 0.3162162;
|
|
1408
|
+
c += (texture2D(map, vUv + stepv * 3.2307692).rgb + texture2D(map, vUv - stepv * 3.2307692).rgb) * 0.0702703;
|
|
1409
|
+
gl_FragColor = vec4(c, 1.);
|
|
1410
|
+
}`,
|
|
1411
|
+
depthTest: false,
|
|
1412
|
+
depthWrite: false
|
|
1413
|
+
});
|
|
1414
|
+
const showMat = new THREE.ShaderMaterial({
|
|
1415
|
+
uniforms: { map: { value: accumRT.texture }, bloom: { value: 0 }, veil: { value: 0 }, grain: { value: GRAIN }, near: { value: halfA.texture }, far: { value: quarterA.texture } },
|
|
1416
|
+
vertexShader: VERT,
|
|
1417
|
+
fragmentShader: `uniform sampler2D map; uniform sampler2D near; uniform sampler2D far; uniform float bloom; uniform float veil; uniform float grain; varying vec2 vUv;
|
|
1418
|
+
void main(){
|
|
1419
|
+
vec4 c = texture2D(map, vUv);
|
|
1420
|
+
if (bloom > 0.) {
|
|
1421
|
+
vec3 halo = texture2D(near, vUv).rgb * 0.24 + texture2D(far, vUv).rgb * 0.17;
|
|
1422
|
+
// The halo is cut out of the picture before the rods are taken toward white, so it keeps the saturated blue of their raw light: a near-white rod would glow deep blue. It takes the rod's colour (the same pull toward white), only dimmer; green is left as it is.
|
|
1423
|
+
float hm = max(max(halo.r, halo.g), halo.b);
|
|
1424
|
+
float haloBlue = smoothstep(0., 0.25, (halo.b - halo.g) / max(hm, 1e-4));
|
|
1425
|
+
halo = mix(halo, vec3(hm), haloBlue * 0.6);
|
|
1426
|
+
// (the blue's halo is fainter, the green's a little stronger)
|
|
1427
|
+
c.rgb += bloom * halo * mix(1.3, 0.38, haloBlue);
|
|
1428
|
+
}
|
|
1429
|
+
// (rodColor: the grey-white veil that the glass's reflections, the halo and the emissive add to every channel is taken off: what is left is the rod's own colour, as saturated as it is, at the same brightness)
|
|
1430
|
+
if (veil > 0.) { float mx = max(c.r, max(c.g, c.b)); float mn = min(c.r, min(c.g, c.b)); float k = smoothstep(0.12, 0.5, (mx - mn) / max(mx, 1e-4)); c.rgb -= mn * veil * k; c.rgb *= mix(1., mix(0.15, 1., k), smoothstep(0.04, 0.2, mx) * (1. - smoothstep(0.2, 0.4, mx))); }
|
|
1431
|
+
// A hue-preserving soft clip: a channel past 1 (a busy blue: its blue is far over, its green and red are not) would clip alone and turn the colour pale; the whole colour is brought back so that its brightest channel
|
|
1432
|
+
// only just passes 1, and the hue and the saturation stay.
|
|
1433
|
+
float m = max(max(c.r, c.g), c.b);
|
|
1434
|
+
// A blue light far over 1 (a busy day's rod) is taken toward white as it rises, so the rod is whiter than the blue glass around it (whose reflections and refractions stay under 1); green is left as it is.
|
|
1435
|
+
float blueish = smoothstep(0., 0.25, (c.b - c.g) / max(m, 1e-4));
|
|
1436
|
+
float hot = smoothstep(1., 3., m);
|
|
1437
|
+
c.rgb = mix(c.rgb, vec3(m), blueish * hot * 0.55 * step(veil, 0.));
|
|
1438
|
+
if (m > 1.) c.rgb *= (1. + (m - 1.) * 0.12) / m;
|
|
1439
|
+
gl_FragColor = c;
|
|
1440
|
+
#include <colorspace_fragment>
|
|
1441
|
+
// Camera grain: a fine, fixed noise over the whole picture, added after the lighting (on what is shown, not in it). It is meant to read as the noise of a good camera, not as rendering noise: soft (the sum of three
|
|
1442
|
+
// uniform numbers, so close to a gaussian and not the harsh specks of a single one), the same for every colour of the picture (it is not gated by brightness: a coloured block gets as much as a grey one), growing with the light (as a sensor's does: the dark glows stay clean) and easing off in the highlights (so that a bright surface does not burn); brightness only, no colour noise.
|
|
1443
|
+
if (grain > 0.) {
|
|
1444
|
+
vec3 q = fract(vec3(gl_FragCoord.xyx) * vec3(.1031, .1030, .0973));
|
|
1445
|
+
q += dot(q, q.yzx + 33.33);
|
|
1446
|
+
vec3 h = fract((q.xxy + q.yzz) * q.zyx);
|
|
1447
|
+
float g = (h.x + h.y + h.z - 1.5) * 0.7;
|
|
1448
|
+
float lum = dot(gl_FragColor.rgb, vec3(0.2126, 0.7152, 0.0722));
|
|
1449
|
+
// (the noise of a sensor grows with the light it gets, as its square root: the dark glows stay clean, the lit surfaces carry the grain)
|
|
1450
|
+
// (and none at all in the near-blacks: in an 8-bit picture a tiny noise there only flips single pixels between two levels, which is a speckle, not a grain)
|
|
1451
|
+
float tone = sqrt(clamp(lum, 0., 1.)) * smoothstep(0.08, 0.3, lum) * (1. - smoothstep(0.7, 1.0, lum) * 0.8);
|
|
1452
|
+
// (a soft rise or loss of brightness, a few per cent, never a dark speck: the colour is scaled, its hue kept, and there is no colour noise)
|
|
1453
|
+
gl_FragColor.rgb *= 1. + g * grain * 5. * tone;
|
|
1454
|
+
}
|
|
1455
|
+
}`,
|
|
1456
|
+
depthTest: false,
|
|
1457
|
+
depthWrite: false
|
|
1458
|
+
});
|
|
1459
|
+
const fsMesh = new THREE.Mesh(quadGeo, brightMat);
|
|
1460
|
+
const fsScene = new THREE.Scene();
|
|
1461
|
+
fsScene.add(fsMesh);
|
|
1462
|
+
const pass = (material, target) => {
|
|
1463
|
+
fsMesh.material = material;
|
|
1464
|
+
renderer.setRenderTarget(target);
|
|
1465
|
+
renderer.render(fsScene, quadCam);
|
|
1466
|
+
};
|
|
1467
|
+
const blur = (from, to, size, radius) => {
|
|
1468
|
+
blurMat.uniforms.map.value = from.texture;
|
|
1469
|
+
blurMat.uniforms.stepv.value.set(radius / size[0], 0);
|
|
1470
|
+
pass(blurMat, to);
|
|
1471
|
+
blurMat.uniforms.map.value = to.texture;
|
|
1472
|
+
blurMat.uniforms.stepv.value.set(0, radius / size[1]);
|
|
1473
|
+
pass(blurMat, from);
|
|
1474
|
+
};
|
|
1475
|
+
const addQuad = new THREE.Mesh(quadGeo, addMat);
|
|
1476
|
+
const showQuad = new THREE.Mesh(quadGeo, showMat);
|
|
1477
|
+
const quadScene = new THREE.Scene();
|
|
1478
|
+
quadScene.add(addQuad);
|
|
1479
|
+
let w = 1;
|
|
1480
|
+
let h = 1;
|
|
1481
|
+
let n = 0;
|
|
1482
|
+
let samplesCap = samples;
|
|
1483
|
+
let raf = 0;
|
|
1484
|
+
const halton = (i, b) => {
|
|
1485
|
+
let f = 1;
|
|
1486
|
+
let r = 0;
|
|
1487
|
+
for (let k = i + 1; k > 0; k = Math.floor(k / b)) {
|
|
1488
|
+
f /= b;
|
|
1489
|
+
r += f * (k % b);
|
|
1490
|
+
}
|
|
1491
|
+
return r;
|
|
1492
|
+
};
|
|
1493
|
+
const fit = () => {
|
|
1494
|
+
const size = renderSize({ cssWidth: el.clientWidth, cssHeight: el.clientHeight, devicePixelRatio: window.devicePixelRatio, lite, maxPixelRatio: opts.maxPixelRatio, maxPixels: opts.maxPixels, maxSize: renderer.capabilities.maxTextureSize });
|
|
1495
|
+
w = size.width;
|
|
1496
|
+
h = size.height;
|
|
1497
|
+
renderer.setPixelRatio(1);
|
|
1498
|
+
renderer.setSize(w, h, false);
|
|
1499
|
+
sceneRT.setSize(w, h);
|
|
1500
|
+
accumRT.setSize(w, h);
|
|
1501
|
+
halfA.setSize(Math.max(1, w >> 1), Math.max(1, h >> 1));
|
|
1502
|
+
halfB.setSize(Math.max(1, w >> 1), Math.max(1, h >> 1));
|
|
1503
|
+
quarterA.setSize(Math.max(1, w >> 1), Math.max(1, h >> 1));
|
|
1504
|
+
quarterB.setSize(Math.max(1, w >> 1), Math.max(1, h >> 1));
|
|
1505
|
+
camera.updateMatrixWorld();
|
|
1506
|
+
const inv = camera.matrixWorldInverse;
|
|
1507
|
+
let x0 = Infinity, x1 = -Infinity, y0 = Infinity, y1 = -Infinity;
|
|
1508
|
+
for (const [cx, cz] of corners(ROOM)) for (const cy of [0, tallest]) {
|
|
1509
|
+
const p = new THREE.Vector3(cx, cy, cz).applyMatrix4(inv);
|
|
1510
|
+
x0 = Math.min(x0, p.x);
|
|
1511
|
+
x1 = Math.max(x1, p.x);
|
|
1512
|
+
y0 = Math.min(y0, p.y);
|
|
1513
|
+
y1 = Math.max(y1, p.y);
|
|
1514
|
+
}
|
|
1515
|
+
if (dbg.metrics) el.dataset.fit = ((x1 - x0) / (y1 - y0)).toFixed(3);
|
|
1516
|
+
const aspect = w / h;
|
|
1517
|
+
let gx = (x0 + x1) / 2;
|
|
1518
|
+
if (strips > 1) {
|
|
1519
|
+
const perStrip = Math.ceil(layout.top.weeks / strips);
|
|
1520
|
+
let sum = 0;
|
|
1521
|
+
for (let k = 0; k < strips; k++) {
|
|
1522
|
+
const c = at(k * perStrip + (perStrip - 1) / 2, 3);
|
|
1523
|
+
sum += new THREE.Vector3(c.x, 0, c.z).applyMatrix4(inv).x;
|
|
1524
|
+
}
|
|
1525
|
+
gx = sum / strips;
|
|
1526
|
+
}
|
|
1527
|
+
const halfH = Math.max((y1 - y0) / 2, Math.max(x1 - gx, gx - x0) / aspect) * 1.04;
|
|
1528
|
+
const mx = gx;
|
|
1529
|
+
const my = (y0 + y1) / 2;
|
|
1530
|
+
camera.left = mx - halfH * aspect;
|
|
1531
|
+
camera.right = mx + halfH * aspect;
|
|
1532
|
+
camera.top = my + halfH;
|
|
1533
|
+
camera.bottom = my - halfH;
|
|
1534
|
+
camera.updateProjectionMatrix();
|
|
1535
|
+
publishBounds();
|
|
1536
|
+
restart();
|
|
1537
|
+
};
|
|
1538
|
+
const publishBounds = () => {
|
|
1539
|
+
camera.updateMatrixWorld();
|
|
1540
|
+
let l = Infinity, r = -Infinity, t = Infinity, b = -Infinity;
|
|
1541
|
+
const cw = el.clientWidth;
|
|
1542
|
+
const ch = el.clientHeight;
|
|
1543
|
+
const px = (x, y, z) => {
|
|
1544
|
+
const p = new THREE.Vector3(x, y, z).project(camera);
|
|
1545
|
+
return { x: (p.x + 1) / 2 * cw, y: (1 - p.y) / 2 * ch };
|
|
1546
|
+
};
|
|
1547
|
+
layout.top.cells.forEach((g, i) => {
|
|
1548
|
+
if (g.value <= 0 && layout.bottom.cells[i].value <= 0) return;
|
|
1549
|
+
const { x, z } = at(g.week, g.day);
|
|
1550
|
+
for (const [dx, dz] of [[-0.46, -0.46], [0.46, -0.46], [-0.46, 0.46], [0.46, 0.46]]) {
|
|
1551
|
+
const foot = px(x + dx, 0, z + dz);
|
|
1552
|
+
l = Math.min(l, foot.x);
|
|
1553
|
+
r = Math.max(r, foot.x);
|
|
1554
|
+
b = Math.max(b, foot.y);
|
|
1555
|
+
}
|
|
1556
|
+
t = Math.min(t, px(x, topOf(i), z).y);
|
|
1557
|
+
});
|
|
1558
|
+
if (!Number.isFinite(l)) return;
|
|
1559
|
+
bounds = { left: l, right: r, top: t, bottom: b };
|
|
1560
|
+
for (const [k, v] of Object.entries(bounds)) el.style.setProperty(`--nag-content-${k}`, `${v.toFixed(1)}px`);
|
|
1561
|
+
opts.onLayout?.(bounds);
|
|
1562
|
+
};
|
|
1563
|
+
const frames = [];
|
|
1564
|
+
const frame = () => cm(() => frameBody());
|
|
1565
|
+
const frameBody = (count = 1) => {
|
|
1566
|
+
raf = 0;
|
|
1567
|
+
const f0 = performance.now();
|
|
1568
|
+
for (let c = 0; c < count; c++) {
|
|
1569
|
+
const a = halton(n, 2) * Math.PI * 2;
|
|
1570
|
+
const r = Math.sqrt(halton(n, 3)) * 9;
|
|
1571
|
+
sun.position.copy(sunBase).add(new THREE.Vector3(Math.cos(a) * r, 0, Math.sin(a) * r)).add(sun.target.position);
|
|
1572
|
+
camera.setViewOffset(w, h, halton(n, 5) - 0.5, halton(n, 7) - 0.5, w, h);
|
|
1573
|
+
renderer.setRenderTarget(sceneRT);
|
|
1574
|
+
renderer.setClearColor(0, 0);
|
|
1575
|
+
renderer.clear();
|
|
1576
|
+
renderer.render(scene, camera);
|
|
1577
|
+
renderer.setRenderTarget(accumRT);
|
|
1578
|
+
renderer.autoClear = false;
|
|
1579
|
+
addMat.blendAlpha = 1 / (n + 1);
|
|
1580
|
+
renderer.render(quadScene, quadCam);
|
|
1581
|
+
renderer.autoClear = true;
|
|
1582
|
+
n++;
|
|
1583
|
+
}
|
|
1584
|
+
if (settling && n >= Math.min(10, samples)) sharpen();
|
|
1585
|
+
if (showMat.uniforms.bloom.value > 0) {
|
|
1586
|
+
pass(brightMat, halfA);
|
|
1587
|
+
blur(halfA, halfB, [w >> 1, h >> 1], 1.5);
|
|
1588
|
+
blur(halfA, halfB, [w >> 1, h >> 1], 3);
|
|
1589
|
+
blurMat.uniforms.map.value = halfA.texture;
|
|
1590
|
+
blurMat.uniforms.stepv.value.set(0, 0);
|
|
1591
|
+
pass(blurMat, quarterA);
|
|
1592
|
+
blur(quarterA, quarterB, [w >> 1, h >> 1], 3);
|
|
1593
|
+
if (!lite) blur(quarterA, quarterB, [w >> 1, h >> 1], 5);
|
|
1594
|
+
}
|
|
1595
|
+
renderer.setRenderTarget(null);
|
|
1596
|
+
renderer.clear();
|
|
1597
|
+
renderer.render(showQuad, quadCam);
|
|
1598
|
+
if (dbg.metrics) {
|
|
1599
|
+
renderer.getContext().finish();
|
|
1600
|
+
frames.push(performance.now() - f0);
|
|
1601
|
+
el.dataset.frameMs = (frames.reduce((x, y) => x + y, 0) / frames.length).toFixed(1);
|
|
1602
|
+
}
|
|
1603
|
+
if (n < samplesCap) raf = requestAnimationFrame(frame);
|
|
1604
|
+
else if (dbg.metrics) el.dataset.renderMs = String(Math.round(performance.now() - t0));
|
|
1605
|
+
};
|
|
1606
|
+
function restart() {
|
|
1607
|
+
n = 0;
|
|
1608
|
+
if (!raf) raf = requestAnimationFrame(frame);
|
|
1609
|
+
}
|
|
1610
|
+
const burst = (k) => {
|
|
1611
|
+
cancelAnimationFrame(raf);
|
|
1612
|
+
raf = 0;
|
|
1613
|
+
n = 0;
|
|
1614
|
+
samplesCap = k;
|
|
1615
|
+
cm(() => frameBody(k));
|
|
1616
|
+
};
|
|
1617
|
+
let neon = null;
|
|
1618
|
+
let neonApplyMs = 0;
|
|
1619
|
+
let neonTicks = 0;
|
|
1620
|
+
const neonAllowed = () => !(opts.reducedMotion === "auto" || opts.reducedMotion === void 0 ? window.matchMedia("(prefers-reduced-motion: reduce)").matches : opts.reducedMotion);
|
|
1621
|
+
let inView = true;
|
|
1622
|
+
const viewObserver = typeof IntersectionObserver === "undefined" ? null : new IntersectionObserver((entries) => inView = entries.some((e) => e.isIntersecting));
|
|
1623
|
+
viewObserver?.observe(el);
|
|
1624
|
+
let hook = null;
|
|
1625
|
+
const stopNeon = () => {
|
|
1626
|
+
hook?.stop?.();
|
|
1627
|
+
hook = null;
|
|
1628
|
+
neon?.stop();
|
|
1629
|
+
neon = null;
|
|
1630
|
+
neonStart = null;
|
|
1631
|
+
samplesCap = samples;
|
|
1632
|
+
levelData.fill(1);
|
|
1633
|
+
levelTex.needsUpdate = true;
|
|
1634
|
+
};
|
|
1635
|
+
const uploadLevels = (levels, idle = false) => {
|
|
1636
|
+
for (let i = 0; i < neonNeighbours.length && i < MAX_LEVELS; i++) {
|
|
1637
|
+
const nb = neonNeighbours[i];
|
|
1638
|
+
let on = 0;
|
|
1639
|
+
let all = 0;
|
|
1640
|
+
for (let k = 0; k < nb.j.length; k++) {
|
|
1641
|
+
on += nb.m[k] * levels[nb.j[k]];
|
|
1642
|
+
all += nb.m[k];
|
|
1643
|
+
}
|
|
1644
|
+
levelData[i * 2] = levels[i];
|
|
1645
|
+
levelData[i * 2 + 1] = all > 0 ? idle ? 0.55 * (on / all) + 0.45 * Math.min(1, levels[i]) : on / all : 1;
|
|
1646
|
+
}
|
|
1647
|
+
levelTex.needsUpdate = true;
|
|
1648
|
+
};
|
|
1649
|
+
const FOCUS_ON = 1.7;
|
|
1650
|
+
const FOCUS_OFF = 0.42;
|
|
1651
|
+
let focusCtl = null;
|
|
1652
|
+
let focus = new Float32Array(0);
|
|
1653
|
+
let focusTo = new Float32Array(0);
|
|
1654
|
+
let effective = new Float32Array(0);
|
|
1655
|
+
let lastLevels = new Float32Array(0);
|
|
1656
|
+
let idleLook = false;
|
|
1657
|
+
let focusRaf = 0;
|
|
1658
|
+
let focusTimer = 0;
|
|
1659
|
+
const applyLevels = (levels) => {
|
|
1660
|
+
lastLevels = levels;
|
|
1661
|
+
const n2 = neonBlocks.length;
|
|
1662
|
+
if (effective.length !== n2) effective = new Float32Array(n2).fill(1);
|
|
1663
|
+
for (let i = 0; i < n2; i++) effective[i] = levels[i] * (focus[i] ?? 1);
|
|
1664
|
+
uploadLevels(effective, idleLook);
|
|
1665
|
+
focusCtl?.update(effective);
|
|
1666
|
+
};
|
|
1667
|
+
const stepFocus = () => {
|
|
1668
|
+
focusRaf = 0;
|
|
1669
|
+
let moving = false;
|
|
1670
|
+
for (let i = 0; i < focus.length; i++) {
|
|
1671
|
+
const d = focusTo[i] - focus[i];
|
|
1672
|
+
if (Math.abs(d) > 0.01) {
|
|
1673
|
+
focus[i] += d * 0.28;
|
|
1674
|
+
moving = true;
|
|
1675
|
+
} else focus[i] = focusTo[i];
|
|
1676
|
+
}
|
|
1677
|
+
applyLevels(lastLevels);
|
|
1678
|
+
samplesCap = Math.min(samplesCap, lite ? 2 : 3);
|
|
1679
|
+
restart();
|
|
1680
|
+
if (moving) focusRaf = window.setTimeout(stepFocus, 1e3 / (lite ? 20 : 30));
|
|
1681
|
+
else {
|
|
1682
|
+
samplesCap = samples;
|
|
1683
|
+
restart();
|
|
1684
|
+
}
|
|
1685
|
+
};
|
|
1686
|
+
const GHOST = 0.12;
|
|
1687
|
+
const focusOn = (cell, ghosts = []) => {
|
|
1688
|
+
window.clearTimeout(focusTimer);
|
|
1689
|
+
if (!focusCtl) return;
|
|
1690
|
+
focusTimer = window.setTimeout(() => {
|
|
1691
|
+
for (let i = 0; i < focusTo.length; i++) focusTo[i] = cell < 0 ? 1 : neonBlocks[i].cell === cell ? FOCUS_ON : ghosts.includes(neonBlocks[i].cell) ? GHOST : FOCUS_OFF;
|
|
1692
|
+
window.clearTimeout(focusRaf);
|
|
1693
|
+
stepFocus();
|
|
1694
|
+
}, cell < 0 ? 140 : 70);
|
|
1695
|
+
};
|
|
1696
|
+
const prepareNeon = () => {
|
|
1697
|
+
stopNeon();
|
|
1698
|
+
onLit?.(false);
|
|
1699
|
+
window.clearTimeout(focusTimer);
|
|
1700
|
+
window.clearTimeout(focusRaf);
|
|
1701
|
+
focusCtl = isDark() && stampCtl && neonBlocks.length > 0 && neonBlocks.length <= MAX_LEVELS ? stampCtl : null;
|
|
1702
|
+
focus = new Float32Array(neonBlocks.length).fill(1);
|
|
1703
|
+
focusTo = new Float32Array(neonBlocks.length).fill(1);
|
|
1704
|
+
effective = new Float32Array(neonBlocks.length).fill(1);
|
|
1705
|
+
lastLevels = new Float32Array(neonBlocks.length).fill(1);
|
|
1706
|
+
idleLook = false;
|
|
1707
|
+
if (focusCtl) applyLevels(lastLevels);
|
|
1708
|
+
if (!isDark() || !neonAllowed() || !stampCtl || neonBlocks.length === 0 || neonBlocks.length > MAX_LEVELS) return void onLit?.(true);
|
|
1709
|
+
const ctl = stampCtl;
|
|
1710
|
+
neonApplyMs = 0;
|
|
1711
|
+
neonTicks = 0;
|
|
1712
|
+
neon = createNeon({
|
|
1713
|
+
blocks: neonBlocks,
|
|
1714
|
+
sound: opts.sound ?? true,
|
|
1715
|
+
canPlay: () => inView,
|
|
1716
|
+
// (a weak device, a phone: half the updates, so half the redraws of the picture while the lights flicker)
|
|
1717
|
+
fps: lite ? 10 : 20,
|
|
1718
|
+
// (the wobble is redrawn more often than the flickers: 40 a second, 15 on a weak device)
|
|
1719
|
+
wobbleFps: lite ? 15 : 40,
|
|
1720
|
+
apply: (levels, idle) => {
|
|
1721
|
+
const a0 = performance.now();
|
|
1722
|
+
idleLook = !!idle;
|
|
1723
|
+
applyLevels(levels);
|
|
1724
|
+
neonApplyMs += performance.now() - a0;
|
|
1725
|
+
neonTicks++;
|
|
1726
|
+
if (dbg.metrics) {
|
|
1727
|
+
let mn = 1;
|
|
1728
|
+
let sum = 0;
|
|
1729
|
+
for (let q = 0; q < levels.length; q++) {
|
|
1730
|
+
mn = Math.min(mn, levels[q]);
|
|
1731
|
+
sum += levels[q];
|
|
1732
|
+
}
|
|
1733
|
+
el.dataset.neonMin = mn.toFixed(2);
|
|
1734
|
+
el.dataset.neonMean = (sum / levels.length).toFixed(3);
|
|
1735
|
+
}
|
|
1736
|
+
burst(lite ? 2 : 3);
|
|
1737
|
+
},
|
|
1738
|
+
done: () => {
|
|
1739
|
+
onLit?.(true);
|
|
1740
|
+
samplesCap = samples;
|
|
1741
|
+
restart();
|
|
1742
|
+
if (dbg.metrics) {
|
|
1743
|
+
el.dataset.neonTicks = String(neonTicks);
|
|
1744
|
+
el.dataset.neonApplyMs = (neonApplyMs / Math.max(1, neonTicks)).toFixed(2);
|
|
1745
|
+
el.dataset.neonFrameMs = (frames.reduce((x, y) => x + y, 0) / Math.max(1, frames.length)).toFixed(1);
|
|
1746
|
+
el.dataset.neonDone = "1";
|
|
1747
|
+
}
|
|
1748
|
+
}
|
|
1749
|
+
});
|
|
1750
|
+
hook = opts.startup?.({ inView: () => inView }) ?? null;
|
|
1751
|
+
if (dbg.metrics) el.dataset.neonRods = String(neon.count);
|
|
1752
|
+
applyLevels(neon.levels);
|
|
1753
|
+
neonStart = () => {
|
|
1754
|
+
frames.length = 0;
|
|
1755
|
+
hook?.start?.();
|
|
1756
|
+
neon?.start();
|
|
1757
|
+
};
|
|
1758
|
+
if (dbg.neonHold) {
|
|
1759
|
+
neonStart = null;
|
|
1760
|
+
const half = Float32Array.from(neonBlocks, (b) => b.pan < 0.1 ? 1 : 0);
|
|
1761
|
+
uploadLevels(half);
|
|
1762
|
+
ctl.update(half);
|
|
1763
|
+
}
|
|
1764
|
+
};
|
|
1765
|
+
buildBlocks();
|
|
1766
|
+
prepareNeon();
|
|
1767
|
+
const dom = renderer.domElement;
|
|
1768
|
+
const ray = new THREE.Raycaster();
|
|
1769
|
+
const ndc = new THREE.Vector2();
|
|
1770
|
+
let current = -1;
|
|
1771
|
+
let pinned = false;
|
|
1772
|
+
const cells = layout.top.cells;
|
|
1773
|
+
const topOf = (cell) => picks.filter((b) => b.cell === cell).reduce((m, b) => Math.max(m, b.y1), 0);
|
|
1774
|
+
const pickAll = (cx, cy) => {
|
|
1775
|
+
const r = dom.getBoundingClientRect();
|
|
1776
|
+
ndc.set((cx - r.left) / r.width * 2 - 1, -((cy - r.top) / r.height) * 2 + 1);
|
|
1777
|
+
camera.updateMatrixWorld();
|
|
1778
|
+
ray.setFromCamera(ndc, camera);
|
|
1779
|
+
const o = ray.ray.origin;
|
|
1780
|
+
const d = ray.ray.direction;
|
|
1781
|
+
const hits = /* @__PURE__ */ new Map();
|
|
1782
|
+
for (const b of picks) {
|
|
1783
|
+
let t02 = -Infinity;
|
|
1784
|
+
let t1 = Infinity;
|
|
1785
|
+
for (const [oo, dd, lo, hi] of [[o.x, d.x, b.x - 0.46, b.x + 0.46], [o.y, d.y, b.y0, b.y1], [o.z, d.z, b.z - 0.46, b.z + 0.46]]) {
|
|
1786
|
+
if (Math.abs(dd) < 1e-9) {
|
|
1787
|
+
if (oo < lo || oo > hi) t02 = Infinity;
|
|
1788
|
+
continue;
|
|
1789
|
+
}
|
|
1790
|
+
const a = (lo - oo) / dd;
|
|
1791
|
+
const c = (hi - oo) / dd;
|
|
1792
|
+
t02 = Math.max(t02, Math.min(a, c));
|
|
1793
|
+
t1 = Math.min(t1, Math.max(a, c));
|
|
1794
|
+
}
|
|
1795
|
+
if (t02 <= t1 && t02 < (hits.get(b.cell) ?? Infinity)) hits.set(b.cell, t02);
|
|
1796
|
+
}
|
|
1797
|
+
return [...hits.entries()].sort((x, y) => x[1] - y[1]).map(([cell]) => cell);
|
|
1798
|
+
};
|
|
1799
|
+
const toCss = (v) => {
|
|
1800
|
+
const p = v.clone().project(camera);
|
|
1801
|
+
return { x: (p.x + 1) / 2 * el.clientWidth, y: (1 - p.y) / 2 * el.clientHeight };
|
|
1802
|
+
};
|
|
1803
|
+
const hull = (pts) => {
|
|
1804
|
+
const s2 = [...pts].sort((a, b) => a.x - b.x || a.y - b.y);
|
|
1805
|
+
const cr = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
|
|
1806
|
+
const lower = [];
|
|
1807
|
+
for (const p of s2) {
|
|
1808
|
+
while (lower.length >= 2 && cr(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) lower.pop();
|
|
1809
|
+
lower.push(p);
|
|
1810
|
+
}
|
|
1811
|
+
const upper = [];
|
|
1812
|
+
for (const p of [...s2].reverse()) {
|
|
1813
|
+
while (upper.length >= 2 && cr(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) upper.pop();
|
|
1814
|
+
upper.push(p);
|
|
1815
|
+
}
|
|
1816
|
+
return [...lower.slice(0, -1), ...upper.slice(0, -1)];
|
|
1817
|
+
};
|
|
1818
|
+
const resample = (poly, n2) => {
|
|
1819
|
+
let start = 0;
|
|
1820
|
+
poly.forEach((p, i) => {
|
|
1821
|
+
if (p.y < poly[start].y) start = i;
|
|
1822
|
+
});
|
|
1823
|
+
const ring = [...poly.slice(start), ...poly.slice(0, start)];
|
|
1824
|
+
const lens = ring.map((p, i) => Math.hypot(ring[(i + 1) % ring.length].x - p.x, ring[(i + 1) % ring.length].y - p.y));
|
|
1825
|
+
const total2 = lens.reduce((x, y) => x + y, 0);
|
|
1826
|
+
const out = [];
|
|
1827
|
+
let seg = 0;
|
|
1828
|
+
let acc = 0;
|
|
1829
|
+
for (let k = 0; k < n2; k++) {
|
|
1830
|
+
const target = k / n2 * total2;
|
|
1831
|
+
while (acc + lens[seg] < target && seg < ring.length - 1) acc += lens[seg++];
|
|
1832
|
+
const f = lens[seg] > 0 ? (target - acc) / lens[seg] : 0;
|
|
1833
|
+
const a2 = ring[seg];
|
|
1834
|
+
const b2 = ring[(seg + 1) % ring.length];
|
|
1835
|
+
out.push({ x: a2.x + (b2.x - a2.x) * f, y: a2.y + (b2.y - a2.y) * f });
|
|
1836
|
+
}
|
|
1837
|
+
return out;
|
|
1838
|
+
};
|
|
1839
|
+
let stack = [];
|
|
1840
|
+
let stackAt = { x: 0, y: 0 };
|
|
1841
|
+
let cycling = false;
|
|
1842
|
+
const announce = (cell, behind) => {
|
|
1843
|
+
current = cell;
|
|
1844
|
+
focusOn(cell, behind ? stack.slice(0, behind.index) : []);
|
|
1845
|
+
if (cell < 0 || !onHover) return onHover?.(null);
|
|
1846
|
+
const g = cells[cell];
|
|
1847
|
+
const { x, z } = at(g.week, g.day);
|
|
1848
|
+
const top = topOf(cell);
|
|
1849
|
+
camera.updateMatrixWorld();
|
|
1850
|
+
const right = new THREE.Vector3().setFromMatrixColumn(camera.matrixWorld, 0);
|
|
1851
|
+
const origin = toCss(new THREE.Vector3(x, 0, z));
|
|
1852
|
+
const unit = Math.hypot(toCss(new THREE.Vector3(x, 0, z).add(right)).x - origin.x, toCss(new THREE.Vector3(x, 0, z).add(right)).y - origin.y);
|
|
1853
|
+
const corners2 = [];
|
|
1854
|
+
for (const b of picks) {
|
|
1855
|
+
if (b.cell !== cell) continue;
|
|
1856
|
+
const r = Math.min(0.16, (b.y1 - b.y0) / 2.2);
|
|
1857
|
+
for (const dx of [-1, 1]) for (const dz of [-1, 1]) for (const y of [b.y0 + r, b.y1 - r]) {
|
|
1858
|
+
const p = toCss(new THREE.Vector3(x + dx * (0.46 - r), y, z + dz * (0.46 - r)));
|
|
1859
|
+
for (let k = 0; k < 10; k++) corners2.push({ x: p.x + r * unit * Math.cos(k / 10 * Math.PI * 2), y: p.y + r * unit * Math.sin(k / 10 * Math.PI * 2) });
|
|
1860
|
+
}
|
|
1861
|
+
}
|
|
1862
|
+
const c = toCss(new THREE.Vector3(x, top, z));
|
|
1863
|
+
onHover({ index: cell, date: g.date, top: g.value, bottom: layout.bottom.cells[cell]?.value ?? 0, outline: resample(hull(corners2), 64).map((p) => `${p.x.toFixed(1)},${p.y.toFixed(1)}`).join(" "), x: c.x, y: c.y, behind });
|
|
1864
|
+
};
|
|
1865
|
+
const onMove = (e) => {
|
|
1866
|
+
if (e.pointerType === "touch" || settling) return;
|
|
1867
|
+
if (cycling && Math.hypot(e.clientX - stackAt.x, e.clientY - stackAt.y) > 8) {
|
|
1868
|
+
cycling = false;
|
|
1869
|
+
pinned = false;
|
|
1870
|
+
}
|
|
1871
|
+
if (pinned) return;
|
|
1872
|
+
const here = pickAll(e.clientX, e.clientY);
|
|
1873
|
+
const cell = here[0] ?? -1;
|
|
1874
|
+
if (cell !== current) {
|
|
1875
|
+
stack = here;
|
|
1876
|
+
stackAt = { x: e.clientX, y: e.clientY };
|
|
1877
|
+
announce(cell, here.length > 1 ? { index: 0, count: here.length } : void 0);
|
|
1878
|
+
}
|
|
1879
|
+
};
|
|
1880
|
+
const onLeave = () => {
|
|
1881
|
+
if (!pinned && current !== -1) announce(-1);
|
|
1882
|
+
};
|
|
1883
|
+
const onDown = (e) => {
|
|
1884
|
+
if (settling) return;
|
|
1885
|
+
const here = pickAll(e.clientX, e.clientY);
|
|
1886
|
+
const sameSpot = Math.hypot(e.clientX - stackAt.x, e.clientY - stackAt.y) <= 8 && stack.length > 1;
|
|
1887
|
+
if (e.pointerType !== "touch") {
|
|
1888
|
+
if (here.length < 2) return;
|
|
1889
|
+
if (!sameSpot || !stack.includes(current)) {
|
|
1890
|
+
stack = here;
|
|
1891
|
+
stackAt = { x: e.clientX, y: e.clientY };
|
|
1892
|
+
}
|
|
1893
|
+
const next = (Math.max(0, stack.indexOf(current)) + 1) % stack.length;
|
|
1894
|
+
cycling = true;
|
|
1895
|
+
pinned = true;
|
|
1896
|
+
announce(stack[next], { index: next, count: stack.length });
|
|
1897
|
+
return;
|
|
1898
|
+
}
|
|
1899
|
+
if (pinned && sameSpot && current >= 0) {
|
|
1900
|
+
const next = stack.indexOf(current) + 1;
|
|
1901
|
+
if (next < stack.length) return announce(stack[next], { index: next, count: stack.length });
|
|
1902
|
+
pinned = false;
|
|
1903
|
+
return announce(-1);
|
|
1904
|
+
}
|
|
1905
|
+
const cell = here[0] ?? -1;
|
|
1906
|
+
stack = here;
|
|
1907
|
+
stackAt = { x: e.clientX, y: e.clientY };
|
|
1908
|
+
pinned = cell !== -1 && cell !== current;
|
|
1909
|
+
announce(pinned ? cell : -1, pinned && here.length > 1 ? { index: 0, count: here.length } : void 0);
|
|
1910
|
+
};
|
|
1911
|
+
const onKey = (e) => {
|
|
1912
|
+
const last = cells.length - 1;
|
|
1913
|
+
let next = current;
|
|
1914
|
+
if (e.key === "Escape") {
|
|
1915
|
+
pinned = false;
|
|
1916
|
+
return announce(-1);
|
|
1917
|
+
}
|
|
1918
|
+
const step = { ArrowLeft: -7, ArrowRight: 7, ArrowUp: -1, ArrowDown: 1 }[e.key];
|
|
1919
|
+
if (step === void 0) return;
|
|
1920
|
+
e.preventDefault();
|
|
1921
|
+
next = current < 0 ? last : Math.min(last, Math.max(0, current + step));
|
|
1922
|
+
pinned = true;
|
|
1923
|
+
announce(next);
|
|
1924
|
+
};
|
|
1925
|
+
el.tabIndex = -1;
|
|
1926
|
+
dom.addEventListener("pointermove", onMove);
|
|
1927
|
+
dom.addEventListener("pointerleave", onLeave);
|
|
1928
|
+
dom.addEventListener("pointerdown", onDown);
|
|
1929
|
+
el.addEventListener("keydown", onKey);
|
|
1930
|
+
el.addEventListener("blur", onLeave);
|
|
1931
|
+
let first = true;
|
|
1932
|
+
let resizeTimer = 0;
|
|
1933
|
+
const ro = new ResizeObserver(() => {
|
|
1934
|
+
if (first) {
|
|
1935
|
+
first = false;
|
|
1936
|
+
fit();
|
|
1937
|
+
return;
|
|
1938
|
+
}
|
|
1939
|
+
soften();
|
|
1940
|
+
pinned = false;
|
|
1941
|
+
if (current !== -1) announce(-1);
|
|
1942
|
+
window.clearTimeout(resizeTimer);
|
|
1943
|
+
resizeTimer = window.setTimeout(fit, 180);
|
|
1944
|
+
});
|
|
1945
|
+
ro.observe(el);
|
|
1946
|
+
const rethink = () => cm(rethinkBody);
|
|
1947
|
+
const rethinkBody = () => {
|
|
1948
|
+
soften();
|
|
1949
|
+
pinned = false;
|
|
1950
|
+
if (current !== -1) announce(-1);
|
|
1951
|
+
floor.material.color.copy(pageColour());
|
|
1952
|
+
if (isDark() && !templates && !templatesFailed) void wantTemplates().then(() => !cancelled && templates && rethink());
|
|
1953
|
+
buildBlocks();
|
|
1954
|
+
prepareNeon();
|
|
1955
|
+
restart();
|
|
1956
|
+
};
|
|
1957
|
+
const onScheme = () => st.theme === "auto" && rethink();
|
|
1958
|
+
mq.addEventListener("change", onScheme);
|
|
1959
|
+
api.rethink = rethink;
|
|
1960
|
+
api.stop = () => {
|
|
1961
|
+
stopNeon();
|
|
1962
|
+
window.clearTimeout(focusTimer);
|
|
1963
|
+
window.clearTimeout(focusRaf);
|
|
1964
|
+
cancelAnimationFrame(raf);
|
|
1965
|
+
window.clearTimeout(resizeTimer);
|
|
1966
|
+
dom.removeEventListener("pointermove", onMove);
|
|
1967
|
+
dom.removeEventListener("pointerleave", onLeave);
|
|
1968
|
+
dom.removeEventListener("pointerdown", onDown);
|
|
1969
|
+
el.removeEventListener("keydown", onKey);
|
|
1970
|
+
el.removeEventListener("blur", onLeave);
|
|
1971
|
+
onHover?.(null);
|
|
1972
|
+
ro.disconnect();
|
|
1973
|
+
mq.removeEventListener("change", onScheme);
|
|
1974
|
+
el.removeAttribute("tabindex");
|
|
1975
|
+
blocks.traverse((o) => {
|
|
1976
|
+
o.geometry?.dispose();
|
|
1977
|
+
o.userData.dispose?.();
|
|
1978
|
+
});
|
|
1979
|
+
blockMaterial.dispose();
|
|
1980
|
+
coreMaterial.dispose();
|
|
1981
|
+
glowMaterial.dispose();
|
|
1982
|
+
levelTex.dispose();
|
|
1983
|
+
viewObserver?.disconnect();
|
|
1984
|
+
templates?.texture.dispose();
|
|
1985
|
+
tileUnlit.dispose();
|
|
1986
|
+
sceneRT.dispose();
|
|
1987
|
+
accumRT.dispose();
|
|
1988
|
+
[halfA, halfB, quarterA, quarterB].forEach((t) => t.dispose());
|
|
1989
|
+
env.dispose();
|
|
1990
|
+
pmrem.dispose();
|
|
1991
|
+
renderer.dispose();
|
|
1992
|
+
renderer.domElement.remove();
|
|
1993
|
+
};
|
|
1994
|
+
});
|
|
1995
|
+
})().catch((e) => console.error("[neon-activity-graph]", e));
|
|
1996
|
+
return {
|
|
1997
|
+
stop() {
|
|
1998
|
+
cancelled = true;
|
|
1999
|
+
api.stop();
|
|
2000
|
+
el.removeAttribute("role");
|
|
2001
|
+
el.removeAttribute("aria-roledescription");
|
|
2002
|
+
el.removeAttribute("aria-label");
|
|
2003
|
+
},
|
|
2004
|
+
rethink: () => api.rethink(),
|
|
2005
|
+
bounds: () => api.bounds(),
|
|
2006
|
+
ready
|
|
2007
|
+
};
|
|
2008
|
+
}
|
|
2009
|
+
|
|
2010
|
+
// src/overlay-math.ts
|
|
2011
|
+
function outlinePath(outline) {
|
|
2012
|
+
const pts = outline.trim().split(/\s+/).filter(Boolean);
|
|
2013
|
+
return pts.length ? `M${pts.join("L").replaceAll(",", " ")}Z` : "";
|
|
2014
|
+
}
|
|
2015
|
+
function formatDay(date, locale) {
|
|
2016
|
+
return (/* @__PURE__ */ new Date(`${date}T00:00:00Z`)).toLocaleDateString(locale, { weekday: "short", day: "numeric", month: "short", year: "numeric", timeZone: "UTC" });
|
|
2017
|
+
}
|
|
2018
|
+
function cardPosition(info, box, card, gap = 14, margin = 8) {
|
|
2019
|
+
const half = card.width / 2;
|
|
2020
|
+
const x = box.width > card.width + 2 * margin ? Math.min(Math.max(info.x, half + margin), box.width - half - margin) : box.width / 2;
|
|
2021
|
+
const below = info.y - card.height - gap < 0;
|
|
2022
|
+
return { x: x - half, y: below ? info.y + gap : info.y - card.height - gap, below };
|
|
2023
|
+
}
|
|
2024
|
+
function formatValue(v) {
|
|
2025
|
+
return Number.isInteger(v) ? String(v) : v.toFixed(1);
|
|
2026
|
+
}
|
|
2027
|
+
|
|
2028
|
+
// src/overlay.ts
|
|
2029
|
+
function createHoverOverlay(container, options = {}, labels = () => ({})) {
|
|
2030
|
+
const { outline = true, card = true, locale } = options;
|
|
2031
|
+
if (getComputedStyle(container).position === "static") container.style.position = "relative";
|
|
2032
|
+
const root = document.createElement("div");
|
|
2033
|
+
root.className = "nag-overlay";
|
|
2034
|
+
root.style.cssText = "position:absolute;inset:0;pointer-events:none;z-index:2";
|
|
2035
|
+
root.innerHTML = `<style>
|
|
2036
|
+
.nag-overlay{--nag-top-default:#0a8f2c;--nag-bottom-default:#1a6fe0}
|
|
2037
|
+
@media (prefers-color-scheme:dark){.nag-overlay{--nag-top-default:#3ddc6a;--nag-bottom-default:#5aa9ff}}
|
|
2038
|
+
.nag-outline{fill:var(--nag-outline-fill,color-mix(in srgb,currentColor 7%,transparent));stroke:var(--nag-outline,currentColor);stroke-width:1.5;stroke-linejoin:round}
|
|
2039
|
+
.nag-card{position:absolute;left:0;top:0;padding:10px 14px;min-width:9.5em;border-radius:var(--nag-card-radius,12px);color:var(--nag-card-fg,inherit);font:13px/1.35 system-ui,sans-serif;white-space:nowrap;background:var(--nag-card-bg,color-mix(in srgb,Canvas 70%,transparent));-webkit-backdrop-filter:blur(12px);backdrop-filter:blur(12px);box-shadow:inset 0 0 0 1px color-mix(in srgb,currentColor 11%,transparent),0 14px 44px -12px rgb(0 0 0/.38),0 2px 10px -4px rgb(0 0 0/.22);transition:opacity .16s,transform .3s cubic-bezier(.2,.7,.2,1)}
|
|
2040
|
+
.nag-card .nag-day{font-size:11px;letter-spacing:.06em;text-transform:uppercase;color:var(--nag-card-muted,color-mix(in srgb,currentColor 60%,transparent))}
|
|
2041
|
+
.nag-card .nag-figs{display:flex;gap:22px;margin-top:8px}
|
|
2042
|
+
.nag-card .nag-v{font-size:26px;font-weight:600;line-height:1;font-variant-numeric:tabular-nums}
|
|
2043
|
+
.nag-card .nag-l{margin-top:4px;font-size:11px;text-transform:uppercase;letter-spacing:.06em;color:var(--nag-card-muted,color-mix(in srgb,currentColor 60%,transparent))}
|
|
2044
|
+
.nag-card .nag-top{color:var(--nag-top,var(--nag-top-default))}.nag-card .nag-bottom{color:var(--nag-bottom,var(--nag-bottom-default))}
|
|
2045
|
+
.nag-card .nag-behind{margin-top:10px;font-size:11px;text-transform:uppercase;letter-spacing:.06em;color:var(--nag-card-muted,color-mix(in srgb,currentColor 60%,transparent))}
|
|
2046
|
+
@media (prefers-reduced-motion:reduce){.nag-card{transition:opacity .16s}}
|
|
2047
|
+
</style>`;
|
|
2048
|
+
const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
|
|
2049
|
+
svg.setAttribute("aria-hidden", "true");
|
|
2050
|
+
svg.style.cssText = "position:absolute;inset:0;width:100%;height:100%;overflow:visible;opacity:0;transition:opacity .12s";
|
|
2051
|
+
const path = document.createElementNS("http://www.w3.org/2000/svg", "path");
|
|
2052
|
+
path.setAttribute("class", "nag-outline");
|
|
2053
|
+
svg.append(path);
|
|
2054
|
+
if (outline) root.append(svg);
|
|
2055
|
+
const cardEl = document.createElement("div");
|
|
2056
|
+
cardEl.className = "nag-card";
|
|
2057
|
+
cardEl.style.opacity = "0";
|
|
2058
|
+
if (card) root.append(cardEl);
|
|
2059
|
+
const live = document.createElement("p");
|
|
2060
|
+
live.setAttribute("aria-live", "polite");
|
|
2061
|
+
live.style.cssText = "position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;margin:0";
|
|
2062
|
+
root.append(live);
|
|
2063
|
+
container.append(root);
|
|
2064
|
+
const fill = (info) => {
|
|
2065
|
+
if (typeof card === "function") {
|
|
2066
|
+
const c = card(info);
|
|
2067
|
+
return void (typeof c === "string" ? cardEl.textContent = c : cardEl.replaceChildren(c));
|
|
2068
|
+
}
|
|
2069
|
+
const l = labels();
|
|
2070
|
+
const fig = (cls, v, name, unit) => `<div class="${cls}"><div class="nag-v">${formatValue(v)}${unit && unit.length <= 2 ? `<span style="font-size:13px;font-weight:400"> ${unit}</span>` : ""}</div><div class="nag-l">${name ?? ""}</div></div>`;
|
|
2071
|
+
const esc = (s) => (s ?? "").replace(/[&<>"]/g, (c) => ({ "&": "&", "<": "<", ">": ">", '"': """ })[c]);
|
|
2072
|
+
cardEl.innerHTML = `<div class="nag-day">${esc(formatDay(info.date, locale))}</div><div class="nag-figs">${fig("nag-top", info.top, esc(l.top?.label), l.top?.unit)}${fig("nag-bottom", info.bottom, esc(l.bottom?.label), l.bottom?.unit)}</div>${info.behind && info.behind.count > 1 ? `<div class="nag-behind">${info.behind.index + 1} of ${info.behind.count} \xB7 click for next</div>` : ""}`;
|
|
2073
|
+
};
|
|
2074
|
+
let seen = false;
|
|
2075
|
+
return {
|
|
2076
|
+
update(info) {
|
|
2077
|
+
if (!info) {
|
|
2078
|
+
svg.style.opacity = "0";
|
|
2079
|
+
cardEl.style.opacity = "0";
|
|
2080
|
+
live.textContent = "";
|
|
2081
|
+
return;
|
|
2082
|
+
}
|
|
2083
|
+
path.setAttribute("d", outlinePath(info.outline));
|
|
2084
|
+
svg.style.opacity = "1";
|
|
2085
|
+
if (card) {
|
|
2086
|
+
fill(info);
|
|
2087
|
+
const p = cardPosition(info, { width: container.clientWidth, height: container.clientHeight }, { width: cardEl.offsetWidth, height: cardEl.offsetHeight });
|
|
2088
|
+
if (!seen) cardEl.style.transition = "opacity .16s";
|
|
2089
|
+
cardEl.style.transform = `translate(${p.x}px, ${p.y}px)`;
|
|
2090
|
+
cardEl.style.opacity = "1";
|
|
2091
|
+
if (!seen) requestAnimationFrame(() => cardEl.style.transition = "");
|
|
2092
|
+
seen = true;
|
|
2093
|
+
}
|
|
2094
|
+
live.textContent = `${formatDay(info.date, locale)}: ${formatValue(info.top)} and ${formatValue(info.bottom)}`;
|
|
2095
|
+
},
|
|
2096
|
+
destroy() {
|
|
2097
|
+
root.remove();
|
|
2098
|
+
}
|
|
2099
|
+
};
|
|
2100
|
+
}
|
|
2101
|
+
|
|
2102
|
+
// src/index.ts
|
|
2103
|
+
function createActivityGraph(container, options) {
|
|
2104
|
+
const state = { theme: options.theme ?? "auto" };
|
|
2105
|
+
let opts = options;
|
|
2106
|
+
const holder = options.placeholder === false ? null : mountPlaceholder(container, { weeks: options.weeks, strips: options.strips });
|
|
2107
|
+
const overlay = options.overlay ? createHoverOverlay(container, options.overlay === true ? {} : options.overlay, () => ({ top: opts.data?.top, bottom: opts.data?.bottom })) : null;
|
|
2108
|
+
const wrap = (o) => ({
|
|
2109
|
+
...o,
|
|
2110
|
+
onReady: () => {
|
|
2111
|
+
holder?.fadeOut();
|
|
2112
|
+
o.onReady?.();
|
|
2113
|
+
},
|
|
2114
|
+
onHover: (i) => {
|
|
2115
|
+
overlay?.update(i);
|
|
2116
|
+
o.onHover?.(i);
|
|
2117
|
+
}
|
|
2118
|
+
});
|
|
2119
|
+
const start = () => opts.data ? mountScene(container, wrap({ ...opts, data: opts.data }), state) : { stop() {
|
|
2120
|
+
}, rethink() {
|
|
2121
|
+
}, bounds: () => null, ready: Promise.resolve() };
|
|
2122
|
+
let handle = start();
|
|
2123
|
+
let destroyed = false;
|
|
2124
|
+
return {
|
|
2125
|
+
get bounds() {
|
|
2126
|
+
return handle.bounds();
|
|
2127
|
+
},
|
|
2128
|
+
get ready() {
|
|
2129
|
+
return handle.ready;
|
|
2130
|
+
},
|
|
2131
|
+
update(data) {
|
|
2132
|
+
if (destroyed) return;
|
|
2133
|
+
handle.stop();
|
|
2134
|
+
opts = { ...opts, data };
|
|
2135
|
+
handle = start();
|
|
2136
|
+
},
|
|
2137
|
+
setTheme(theme) {
|
|
2138
|
+
if (destroyed) return;
|
|
2139
|
+
state.theme = theme;
|
|
2140
|
+
handle.rethink();
|
|
2141
|
+
},
|
|
2142
|
+
destroy() {
|
|
2143
|
+
destroyed = true;
|
|
2144
|
+
handle.stop();
|
|
2145
|
+
holder?.remove();
|
|
2146
|
+
overlay?.destroy();
|
|
2147
|
+
}
|
|
2148
|
+
};
|
|
2149
|
+
}
|
|
2150
|
+
|
|
2151
|
+
export {
|
|
2152
|
+
renderSize,
|
|
2153
|
+
DEFAULT_COLORS,
|
|
2154
|
+
outlinePath,
|
|
2155
|
+
formatDay,
|
|
2156
|
+
cardPosition,
|
|
2157
|
+
createHoverOverlay,
|
|
2158
|
+
createActivityGraph
|
|
2159
|
+
};
|
|
2160
|
+
//# sourceMappingURL=chunk-5FJXKHZ7.js.map
|