phoria2 1.2.0 → 1.4.0

package/dist/passes.js.map

@@ -1 +1 @@
-{"version":3,"file":"passes.js","names":["mat4.invert","mat4.create","mat4.multiply","TONE_MAP","CLIP_ONLY_FRAGMENT","FULLSCREEN_VERTEX","invert","multiply","create","MESH_VERTEX","CLIP","EQUIRECT","SPOT_ATLAS_SIZE","POINT_SHADOW_SIZE","COMMON","uvMatrix","SHADOW_MAP_SIZE","irradianceSH","sh","sx","width","sy","height","dPhi","dTheta","y","theta","sinT","dy","weight","x","phi","dx","dz","basis","i","k","w","data","norm","band","out","c","BACKGROUND_FRAGMENT","PREFILTER_FRAGMENT","OUTLINE_MASK_FRAGMENT","OUTLINE_MAX","WIDEN","OUTLINE_WIDEN_FRAGMENT","OUTLINE_COMPOSITE_FRAGMENT","OUTLINE_COVER_FRAGMENT","SMOOTH","OUTLINE_SMOOTH_WIDEN_FRAGMENT","OUTLINE_SMOOTH_COMPOSITE_FRAGMENT","OUTLINE_MASK","OUTLINE_WIDEN","OUTLINE_COMPOSITE","OUTLINE_COVER","OUTLINE_SMOOTH_WIDEN","OUTLINE_SMOOTH_COMPOSITE","DEPTH","BACKGROUND","PREFILTER","ENV_WIDTH","ENV_LEVELS","Passes","gl","programs","resources","#environments","#shadow","#spotShadow","#pointShadow","#outline","texture","env","e","image","source","#floatTexture","prefiltered","program","framebuffer","level","hdr","blur","frame","tone","#depthTarget","#beginDepth","#drawDepth","shadow","#endDepth","toTexture","matrices","tiles","bias","half","spot","spots","toTile","#depthCube","point","face","item","casters","instances","defines","material","cutout","triplanar","viewProjection","map","targets","#outlineTargets","smooth","radius","outline","outlines","px","pixelRatio","attachment","target","widen","t","buffer","make","format","msaa","samples","size","framebuffers","levels"],"sources":["../src/irradiance.js"],"sourcesContent":["// Diffuse light from an environment image, for the renderer: computed once per environment.\n\n/** @import { DataImage } from './material/Texture.js' */\n\n/**\n * Diffuse light from an equirectangular environment, as nine spherical harmonic coefficients (RGB\n * each, flattened), scaled so the shader evaluates them with plain polynomial terms and gets\n * irradiance divided by PI - the light a white matte surface facing that way reflects.\n * @param {DataImage} image linear RGBA floats\n * @returns {Float32Array} 27 numbers\n */\nexport function irradianceSH({ data, width, height }) {\n  const sh = new Float64Array(27)\n  // sample a grid of at most 128 x 64 - plenty for the lowest frequencies\n  const sx = Math.max(1, Math.floor(width / 128)), sy = Math.max(1, Math.floor(height / 64))\n  const dPhi = (2 * Math.PI * sx) / width, dTheta = (Math.PI * sy) / height\n  for (let y = 0; y < height; y += sy) {\n    const theta = ((y + 0.5 * sy) / height) * Math.PI\n    const sinT = Math.sin(theta), dy = Math.cos(theta)\n    const weight = dPhi * dTheta * sinT\n    for (let x = 0; x < width; x += sx) {\n      const phi = ((x + 0.5 * sx) / width - 0.5) * 2 * Math.PI\n      const dx = Math.cos(phi) * sinT, dz = Math.sin(phi) * sinT\n      const basis = [1, dy, dz, dx, dx * dy, dy * dz, 3 * dz * dz - 1, dx * dz, dx * dx - dy * dy]\n      const i = (y * width + x) * 4\n      for (let k = 0; k < 9; k++) {\n        const w = basis[k] * weight\n        sh[k * 3] += data[i] * w\n        sh[k * 3 + 1] += data[i + 1] * w\n        sh[k * 3 + 2] += data[i + 2] * w\n      }\n    }\n  }\n  // projection uses the normalised basis Y = norm * polynomial, and evaluation multiplies by the\n  // cosine lobe's band factors (PI, 2PI/3, PI/4) and norm again; then divide by PI\n  const norm = [0.282095, 0.488603, 0.488603, 0.488603, 1.092548, 1.092548, 0.315392, 1.092548, 0.546274]\n  const band = [1, 2 / 3, 2 / 3, 2 / 3, 1 / 4, 1 / 4, 1 / 4, 1 / 4, 1 / 4]\n  const out = new Float32Array(27)\n  for (let k = 0; k < 9; k++) {\n    for (let c = 0; c < 3; c++) out[k * 3 + c] = sh[k * 3 + c] * norm[k] * norm[k] * band[k]\n  }\n  return out\n}\n"],"mappings":";;AAWA,SAAgBiB,EAAa,EAAE,SAAM,UAAO,aAAU;CACpD,IAAMC,oBAAK,IAAI,aAAa,EAAE,GAExBC,IAAK,KAAK,IAAI,GAAG,KAAK,MAAMC,IAAQ,GAAG,CAAC,GAAGC,IAAK,KAAK,IAAI,GAAG,KAAK,MAAMC,IAAS,EAAE,CAAC,GACnFC,IAAQ,IAAI,KAAK,KAAKJ,IAAMC,GAAOI,IAAU,KAAK,KAAKH,IAAMC;CACnE,KAAK,IAAIG,IAAI,GAAGA,IAAIH,GAAQ,KAAKD,GAAI;EACnC,IAAMK,KAAUD,IAAI,KAAMJ,KAAMC,IAAU,KAAK,IACzCK,IAAO,KAAK,IAAID,CAAK,GAAGE,IAAK,KAAK,IAAIF,CAAK,GAC3CG,IAASN,IAAOC,IAASG;EAC/B,KAAK,IAAIG,IAAI,GAAGA,IAAIV,GAAO,KAAKD,GAAI;GAClC,IAAMY,MAAQD,IAAI,KAAMX,KAAMC,IAAQ,MAAO,IAAI,KAAK,IAChDY,IAAK,KAAK,IAAID,CAAG,IAAIJ,GAAMM,IAAK,KAAK,IAAIF,CAAG,IAAIJ,GAChDO,IAAQ;IAAC;IAAGN;IAAIK;IAAID;IAAIA,IAAKJ;IAAIA,IAAKK;IAAI,IAAIA,IAAKA,IAAK;IAAGD,IAAKC;IAAID,IAAKA,IAAKJ,IAAKA;GAAE,GACrFO,KAAKV,IAAIL,IAAQU,KAAK;GAC5B,KAAK,IAAIM,IAAI,GAAGA,IAAI,GAAG,KAAK;IAC1B,IAAMC,IAAIH,EAAME,KAAKP;IAGrB,AAFA,EAAGO,IAAI,MAAME,EAAKH,KAAKE,GACvB,EAAGD,IAAI,IAAI,MAAME,EAAKH,IAAI,KAAKE,GAC/B,EAAGD,IAAI,IAAI,MAAME,EAAKH,IAAI,KAAKE;GACjC;EACF;CACF;CAGA,IAAME,IAAO;EAAC;EAAU;EAAU;EAAU;EAAU;EAAU;EAAU;EAAU;EAAU;CAAQ,GAChGC,IAAO;EAAC;EAAG,IAAI;EAAG,IAAI;EAAG,IAAI;EAAG,IAAI;EAAG,IAAI;EAAG,IAAI;EAAG,IAAI;EAAG,IAAI;CAAC,GACjEC,oBAAM,IAAI,aAAa,EAAE;CAC/B,KAAK,IAAIL,IAAI,GAAGA,IAAI,GAAG,KACrB,KAAK,IAAIM,IAAI,GAAGA,IAAI,GAAG,KAAK,EAAIN,IAAI,IAAIM,KAAKxB,EAAGkB,IAAI,IAAIM,KAAKH,EAAKH,KAAKG,EAAKH,KAAKI,EAAKJ;CAExF,OAAOK;AACT"}
+{"version":3,"file":"passes.js","names":["mat4.invert","mat4.create","mat4.multiply","invert","passDefines","POINT_SHADOW_SIZE","COMMON","CLIP_ONLY_FRAGMENT","TONE_MAP","EQUIRECT","create","hookFor","CLIP","SPOT_ATLAS_SIZE","multiply","MESH_VERTEX","FULLSCREEN_VERTEX","setHookUniforms","SHADOW_MAP_SIZE","uvMatrix","irradianceSH","sh","sx","width","sy","height","dPhi","dTheta","y","theta","sinT","dy","weight","x","phi","dx","dz","basis","i","k","w","data","norm","band","out","c","BACKGROUND_FRAGMENT","PREFILTER_FRAGMENT","OUTLINE_MASK_FRAGMENT","OUTLINE_MAX","WIDEN","OUTLINE_WIDEN_FRAGMENT","OUTLINE_COMPOSITE_FRAGMENT","OUTLINE_COVER_FRAGMENT","SMOOTH","OUTLINE_SMOOTH_WIDEN_FRAGMENT","OUTLINE_SMOOTH_COMPOSITE_FRAGMENT","OUTLINE_MASK","OUTLINE_WIDEN","OUTLINE_COMPOSITE","OUTLINE_COVER","OUTLINE_SMOOTH_WIDEN","OUTLINE_SMOOTH_COMPOSITE","DEPTH","BACKGROUND","PREFILTER","ENV_WIDTH","ENV_LEVELS","Passes","gl","programs","resources","#environments","#shadow","#spotShadow","#pointShadow","#outline","texture","env","e","image","source","#floatTexture","prefiltered","program","framebuffer","level","hdr","blur","frame","tone","#depthTarget","#beginDepth","#drawDepth","shadow","#endDepth","toTexture","matrices","tiles","bias","half","spot","spots","toTile","#depthCube","point","face","item","casters","instances","defines","material","cutout","triplanar","hook","t","viewProjection","map","targets","#outlineTargets","smooth","radius","outline","outlines","px","pixelRatio","attachment","target","widen","buffer","make","format","msaa","samples","size","framebuffers","levels"],"sources":["../src/irradiance.js"],"sourcesContent":["// Diffuse light from an environment image, for the renderer: computed once per environment.\n\n/** @import { DataImage } from './material/Texture.js' */\n\n/**\n * Diffuse light from an equirectangular environment, as nine spherical harmonic coefficients (RGB\n * each, flattened), scaled so the shader evaluates them with plain polynomial terms and gets\n * irradiance divided by PI - the light a white matte surface facing that way reflects.\n * @param {DataImage} image linear RGBA floats\n * @returns {Float32Array} 27 numbers\n */\nexport function irradianceSH({ data, width, height }) {\n  const sh = new Float64Array(27)\n  // sample a grid of at most 128 x 64 - plenty for the lowest frequencies\n  const sx = Math.max(1, Math.floor(width / 128)), sy = Math.max(1, Math.floor(height / 64))\n  const dPhi = (2 * Math.PI * sx) / width, dTheta = (Math.PI * sy) / height\n  for (let y = 0; y < height; y += sy) {\n    const theta = ((y + 0.5 * sy) / height) * Math.PI\n    const sinT = Math.sin(theta), dy = Math.cos(theta)\n    const weight = dPhi * dTheta * sinT\n    for (let x = 0; x < width; x += sx) {\n      const phi = ((x + 0.5 * sx) / width - 0.5) * 2 * Math.PI\n      const dx = Math.cos(phi) * sinT, dz = Math.sin(phi) * sinT\n      const basis = [1, dy, dz, dx, dx * dy, dy * dz, 3 * dz * dz - 1, dx * dz, dx * dx - dy * dy]\n      const i = (y * width + x) * 4\n      for (let k = 0; k < 9; k++) {\n        const w = basis[k] * weight\n        sh[k * 3] += data[i] * w\n        sh[k * 3 + 1] += data[i + 1] * w\n        sh[k * 3 + 2] += data[i + 2] * w\n      }\n    }\n  }\n  // projection uses the normalised basis Y = norm * polynomial, and evaluation multiplies by the\n  // cosine lobe's band factors (PI, 2PI/3, PI/4) and norm again; then divide by PI\n  const norm = [0.282095, 0.488603, 0.488603, 0.488603, 1.092548, 1.092548, 0.315392, 1.092548, 0.546274]\n  const band = [1, 2 / 3, 2 / 3, 2 / 3, 1 / 4, 1 / 4, 1 / 4, 1 / 4, 1 / 4]\n  const out = new Float32Array(27)\n  for (let k = 0; k < 9; k++) {\n    for (let c = 0; c < 3; c++) out[k * 3 + c] = sh[k * 3 + c] * norm[k] * norm[k] * band[k]\n  }\n  return out\n}\n"],"mappings":";;AAWA,SAAgBoB,EAAa,EAAE,SAAM,UAAO,aAAU;CACpD,IAAMC,oBAAK,IAAI,aAAa,EAAE,GAExBC,IAAK,KAAK,IAAI,GAAG,KAAK,MAAMC,IAAQ,GAAG,CAAC,GAAGC,IAAK,KAAK,IAAI,GAAG,KAAK,MAAMC,IAAS,EAAE,CAAC,GACnFC,IAAQ,IAAI,KAAK,KAAKJ,IAAMC,GAAOI,IAAU,KAAK,KAAKH,IAAMC;CACnE,KAAK,IAAIG,IAAI,GAAGA,IAAIH,GAAQ,KAAKD,GAAI;EACnC,IAAMK,KAAUD,IAAI,KAAMJ,KAAMC,IAAU,KAAK,IACzCK,IAAO,KAAK,IAAID,CAAK,GAAGE,IAAK,KAAK,IAAIF,CAAK,GAC3CG,IAASN,IAAOC,IAASG;EAC/B,KAAK,IAAIG,IAAI,GAAGA,IAAIV,GAAO,KAAKD,GAAI;GAClC,IAAMY,MAAQD,IAAI,KAAMX,KAAMC,IAAQ,MAAO,IAAI,KAAK,IAChDY,IAAK,KAAK,IAAID,CAAG,IAAIJ,GAAMM,IAAK,KAAK,IAAIF,CAAG,IAAIJ,GAChDO,IAAQ;IAAC;IAAGN;IAAIK;IAAID;IAAIA,IAAKJ;IAAIA,IAAKK;IAAI,IAAIA,IAAKA,IAAK;IAAGD,IAAKC;IAAID,IAAKA,IAAKJ,IAAKA;GAAE,GACrFO,KAAKV,IAAIL,IAAQU,KAAK;GAC5B,KAAK,IAAIM,IAAI,GAAGA,IAAI,GAAG,KAAK;IAC1B,IAAMC,IAAIH,EAAME,KAAKP;IAGrB,AAFA,EAAGO,IAAI,MAAME,EAAKH,KAAKE,GACvB,EAAGD,IAAI,IAAI,MAAME,EAAKH,IAAI,KAAKE,GAC/B,EAAGD,IAAI,IAAI,MAAME,EAAKH,IAAI,KAAKE;GACjC;EACF;CACF;CAGA,IAAME,IAAO;EAAC;EAAU;EAAU;EAAU;EAAU;EAAU;EAAU;EAAU;EAAU;CAAQ,GAChGC,IAAO;EAAC;EAAG,IAAI;EAAG,IAAI;EAAG,IAAI;EAAG,IAAI;EAAG,IAAI;EAAG,IAAI;EAAG,IAAI;EAAG,IAAI;CAAC,GACjEC,oBAAM,IAAI,aAAa,EAAE;CAC/B,KAAK,IAAIL,IAAI,GAAGA,IAAI,GAAG,KACrB,KAAK,IAAIM,IAAI,GAAGA,IAAI,GAAG,KAAK,EAAIN,IAAI,IAAIM,KAAKxB,EAAGkB,IAAI,IAAIM,KAAKH,EAAKH,KAAKG,EAAKH,KAAKI,EAAKJ;CAExF,OAAOK;AACT"}

package/dist/phoria2.js

@@ -1 +1 @@
-export { j as AmbientLight, xt as Box3, H as CAMERA_PRESETS, W as Camera, gt as Clip, _t as Color, r as Curve, M as DirectionalLight, X as Drawable, ht as Euler, R as Fog, ct as Geometry, nt as Group, N as HemisphereLight, Z as InstancedMesh, J as LIGHT_LIMITS, Q as Label, P as Light, $ as Lines, St as Mat4, at as Material, et as Mesh, it as Node, Y as NullRenderer, q as OrbitControl, G as OrthographicCamera, K as PerspectiveCamera, wt as PhoriaError, F as PointLight, tt as Points, lt as Quat, B as Ray, z as Raycaster, L as Scene, I as SpotLight, ot as Texture, Ct as Vec3, y as View, b as WebGLRenderer, c as axes, l as box, U as cameraPreset, t as create, i as curve, u as cylinder, d as edges, a as ellipse, f as extrude, o as fromPolygons, p as grid, m as icosphere, h as lathe, st as loadTexture, s as outline, g as plane, n as registerType, _ as sphere, v as torus } from "./core.js";
+export { P as AmbientLight, Et as Box3, G as CAMERA_PRESETS, q as Camera, xt as Clip, St as Color, r as Curve, F as DirectionalLight, et as Drawable, bt as Euler, V as Fog, pt as Geometry, st as Group, I as HemisphereLight, tt as InstancedMesh, Z as LIGHT_LIMITS, nt as Label, L as Light, rt as Lines, Dt as Mat4, ut as Material, it as Mesh, lt as Node, Q as NullRenderer, X as OrbitControl, J as OrthographicCamera, Y as PerspectiveCamera, kt as PhoriaError, R as PointLight, at as Points, mt as Quat, U as Ray, H as Raycaster, B as Scene, z as SpotLight, dt as Texture, Ot as Vec3, y as View, b as WebGLRenderer, c as axes, l as box, K as cameraPreset, t as create, i as curve, u as cylinder, d as edges, a as ellipse, f as extrude, o as fromPolygons, p as grid, m as icosphere, h as lathe, ft as loadTexture, s as outline, g as plane, n as registerType, _ as sphere, v as torus } from "./core.js";

package/dist/picking.js

@@ -1,30 +1,50 @@
-import { D as e, It as t, O as n, Pt as r, S as i, k as a, w as o } from "./core.js";
+import { A as e, C as t, D as n, M as r, S as i, T as a, Vt as o, j as s, w as c, zt as l } from "./core.js";
 // src/webgl/picking.js
-var s = 33, c = 4, l = `precision highp float;
+var u = 33, d = 4, f = `precision highp float;
 precision highp int;
 flat in uint vPickElement;
-#ifdef CLIP
+#ifdef SPRITES
+in vec2 vUv;
+#endif
+#if defined(CLIP) || defined(HOOK_FRAGMENT)
 in vec3 vWorldPosition;
 #endif
+#ifdef HOOK_FRAGMENT
+in vec3 vNormal;
+in vec2 vUv;
+in vec3 vColor;
+#endif
 uniform uint uPickId;
 layout(location = 0) out uvec4 pickOut;
-${o}
-${i}
+${n}
+${a}
 void main() {
 #ifdef CLIP
 clipAway(vWorldPosition);
 #endif
+#ifdef HOOK_FRAGMENT
+{
+vec4 base = vec4(vColor, 1.0);
+vec3 emissive = vec3(0.0);
+vec3 normal = normalize(vNormal);
+if (base.a <= 0.0) discard;
+}
+#endif
 #ifdef ROUND
+#ifdef SPRITES
+vec2 p = vUv * 2.0 - 1.0;
+#else
 vec2 p = gl_PointCoord * 2.0 - 1.0;
+#endif
 if (dot(p, p) > 1.0) discard;
 #endif
 pickOut = uvec4(uPickId, vPickElement, floatBitsToUint(gl_FragCoord.z), 1u);
 }
-`, u = {
-	mesh: [n, l],
-	points: [a, l],
-	lines: [e, l]
-}, d = class {
+`, p = {
+	mesh: [s, f],
+	points: [r, f],
+	lines: [e, f]
+}, m = class {
 	#e = null;
 	#t = /* @__PURE__ */ new Uint32Array(4356);
 	#n = /* @__PURE__ */ new Float32Array(16);
@@ -39,79 +59,79 @@ pickOut = uvec4(uPickId, vPickElement, floatBitsToUint(gl_FragCoord.z), 1u);
 		this.#e = null, this.#a = null, this.#o = !1;
 	}
 	pick(e, t, n, r, i, a) {
-		let o = this.gl, c = this.#s(e, t, n, r, i, a);
-		return c ? (o.readPixels(0, 0, s, s, o.RGBA_INTEGER, o.UNSIGNED_INT, this.#t), o.bindFramebuffer(o.FRAMEBUFFER, null), this.#c(c)) : null;
+		let o = this.gl, s = this.#s(e, t, n, r, i, a);
+		return s ? (o.readPixels(0, 0, u, u, o.RGBA_INTEGER, o.UNSIGNED_INT, this.#t), o.bindFramebuffer(o.FRAMEBUFFER, null), this.#c(s)) : null;
 	}
 	pickAsync(e, t, n, r, i, a) {
 		if (this.#o) return null;
-		let o = this.gl, c = this.#s(e, t, n, r, i, a);
-		if (!c) return Promise.resolve(null);
-		let l = this.#l();
-		o.bindBuffer(o.PIXEL_PACK_BUFFER, l), o.readPixels(0, 0, s, s, o.RGBA_INTEGER, o.UNSIGNED_INT, 0), o.bindBuffer(o.PIXEL_PACK_BUFFER, null), o.bindFramebuffer(o.FRAMEBUFFER, null);
-		let u = o.fenceSync(o.SYNC_GPU_COMMANDS_COMPLETE, 0);
+		let o = this.gl, s = this.#s(e, t, n, r, i, a);
+		if (!s) return Promise.resolve(null);
+		let c = this.#l();
+		o.bindBuffer(o.PIXEL_PACK_BUFFER, c), o.readPixels(0, 0, u, u, o.RGBA_INTEGER, o.UNSIGNED_INT, 0), o.bindBuffer(o.PIXEL_PACK_BUFFER, null), o.bindFramebuffer(o.FRAMEBUFFER, null);
+		let l = o.fenceSync(o.SYNC_GPU_COMMANDS_COMPLETE, 0);
 		return o.flush(), this.#o = !0, new Promise((e) => {
 			let t = () => {
-				o.isContextLost() ? (this.#o = !1, e(null)) : o.clientWaitSync(u, 0, 0) === o.TIMEOUT_EXPIRED ? setTimeout(t, 1) : (o.deleteSync(u), o.bindBuffer(o.PIXEL_PACK_BUFFER, l), o.getBufferSubData(o.PIXEL_PACK_BUFFER, 0, this.#t), o.bindBuffer(o.PIXEL_PACK_BUFFER, null), this.#o = !1, e(this.#c(c)));
+				o.isContextLost() ? (this.#o = !1, e(null)) : o.clientWaitSync(l, 0, 0) === o.TIMEOUT_EXPIRED ? setTimeout(t, 1) : (o.deleteSync(l), o.bindBuffer(o.PIXEL_PACK_BUFFER, c), o.getBufferSubData(o.PIXEL_PACK_BUFFER, 0, this.#t), o.bindBuffer(o.PIXEL_PACK_BUFFER, null), this.#o = !1, e(this.#c(s)));
 			};
 			setTimeout(t, 0);
 		});
 	}
-	#s(e, n, r, i, a, o) {
-		let c = this.gl, l = f(e);
-		if (!l.length) return null;
-		let u = this.#d();
-		c.bindFramebuffer(c.FRAMEBUFFER, u.framebuffer), c.viewport(0, 0, s, s), c.disable(c.BLEND), c.disable(c.SCISSOR_TEST), c.enable(c.DEPTH_TEST), c.depthFunc(c.LEQUAL), c.depthMask(!0), c.clearBufferuiv(c.COLOR, 0, [
+	#s(e, t, n, r, i, a) {
+		let s = this.gl, c = h(e);
+		if (!c.length) return null;
+		let l = this.#d();
+		s.bindFramebuffer(s.FRAMEBUFFER, l.framebuffer), s.viewport(0, 0, u, u), s.disable(s.BLEND), s.disable(s.SCISSOR_TEST), s.enable(s.DEPTH_TEST), s.depthFunc(s.LEQUAL), s.depthMask(!0), s.clearBufferuiv(s.COLOR, 0, [
 			0,
 			0,
 			0,
 			0
-		]), c.clearBufferfv(c.DEPTH, 0, [1]);
-		let d = s, p = n / i * 2 - 1, m = 1 - r / a * 2, h = new Float32Array([
-			i / d,
+		]), s.clearBufferfv(s.DEPTH, 0, [1]);
+		let d = u, f = t / r * 2 - 1, p = 1 - n / i * 2, m = new Float32Array([
+			r / d,
 			0,
 			0,
 			0,
 			0,
-			a / d,
+			i / d,
 			0,
 			0,
 			0,
 			0,
 			1,
 			0,
+			-f * r / d,
 			-p * i / d,
-			-m * a / d,
 			0,
 			1
 		]);
-		return t(this.#n, h, e.camera.projection), t(this.#r, this.#n, e.camera.view), l.forEach((t, n) => this.#u(t, n + 1, e, a, o)), c.bindVertexArray(null), {
-			items: l,
-			cx: p,
-			cy: m,
-			width: i,
-			height: a
+		return o(this.#n, m, e.camera.projection), o(this.#r, this.#n, e.camera.view), c.forEach((t, n) => this.#u(t, n + 1, e, i, a)), s.bindVertexArray(null), {
+			items: c,
+			cx: f,
+			cy: p,
+			width: r,
+			height: i
 		};
 	}
 	#c({ items: e, cx: t, cy: n, width: r, height: i }) {
-		let a = this.#t, o = (e, t) => (t * s + e) * 4, l = a[o(16, 16)] ? o(16, 16) : -1, u = 0, d = 0;
-		if (l < 0) {
+		let a = this.#t, o = (e, t) => (t * u + e) * 4, s = a[o(16, 16)] ? o(16, 16) : -1, c = 0, l = 0;
+		if (s < 0) {
 			let t = Infinity;
-			for (let n = -4; n <= c; n++) for (let r = -4; r <= c; r++) {
+			for (let n = -4; n <= d; n++) for (let r = -4; r <= d; r++) {
 				let i = r * r + n * n;
 				if (i > 16 || i >= t) continue;
-				let s = o(16 + r, 16 + n), c = a[s];
-				c && e[c - 1].node.drawMode !== "triangles" && (l = s, t = i, u = r, d = n);
+				let u = o(16 + r, 16 + n), d = a[u];
+				d && e[d - 1].node.drawMode !== "triangles" && (s = u, t = i, c = r, l = n);
 			}
 		}
-		if (l < 0) return null;
-		let f = new Float32Array(new Uint32Array([a[l + 2]]).buffer)[0], p = [
-			t + u * 2 / r,
-			n + d * 2 / i,
+		if (s < 0) return null;
+		let f = new Float32Array(new Uint32Array([a[s + 2]]).buffer)[0], p = [
+			t + c * 2 / r,
+			n + l * 2 / i,
 			f * 2 - 1
 		];
 		return {
-			item: e[a[l] - 1],
-			element: a[l + 1],
+			item: e[a[s] - 1],
+			element: a[s + 1],
 			ndc: p
 		};
 	}
@@ -120,26 +140,39 @@ pickOut = uvec4(uPickId, vPickElement, floatBitsToUint(gl_FragCoord.z), 1u);
 		let e = this.gl;
 		return this.#a = e.createBuffer(), e.bindBuffer(e.PIXEL_PACK_BUFFER, this.#a), e.bufferData(e.PIXEL_PACK_BUFFER, this.#t.byteLength, e.STREAM_READ), e.bindBuffer(e.PIXEL_PACK_BUFFER, null), this.#a;
 	}
-	#u(e, t, n, i, a) {
-		let o = this.gl, { node: c, geometry: l, material: d, worldMatrix: f, instances: p } = e, m = c.drawMode, h = m === "points" ? "points" : m === "lines" ? "lines" : "mesh", g = ["PICK"];
-		p && g.push("INSTANCED"), h === "points" && (d.sizeAttenuation && g.push("SIZE_ATTENUATION"), d.map || g.push("ROUND")), h === "mesh" && e.clip && g.push("CLIP");
-		let _ = this.programs.ready(`pick-${h}`, g, u[h]);
-		if (o.useProgram(_.program), _.set("uView", n.camera.view), _.set("uProjection", this.#n), _.set("uViewProjection", this.#r), _.set("uModel", f), _.set("uPickId", t), _.set("uHighlightIndex", -2), e.clip && _.set("uClipPlane", e.clip.plane), h === "lines") {
-			o.disable(o.CULL_FACE), _.set("uResolution", [s, s]), _.set("uWidth", d.width * a), _.set("uNear", n.camera.near);
-			let e = this.resources.lines(l);
-			o.bindVertexArray(e.vao), o.drawArraysInstanced(o.TRIANGLE_STRIP, 0, 4, Math.min(e.count, Math.floor(l.drawnCount / 2)));
-		} else if (h === "points") {
-			o.disable(o.CULL_FACE), _.set("uSize", d.sizeAttenuation ? d.size : d.size * a), _.set("uScale", n.camera.projection[5] * i / 2);
-			let e = this.resources.mesh(l, null, !1);
-			o.bindVertexArray(e.vao), o.drawArrays(o.POINTS, 0, l.drawnVertices);
-		} else _.set("uNormalMatrix", this.#i), d.depthTest ? o.enable(o.DEPTH_TEST) : o.disable(o.DEPTH_TEST), d.doubleSided || e.clip?.cap ? o.disable(o.CULL_FACE) : (o.enable(o.CULL_FACE), o.cullFace(o.BACK), o.frontFace(r(f) < 0 ? o.CW : o.CCW)), this.resources.drawTriangles(l, p);
+	#u(e, n, r, a, o) {
+		let s = this.gl, { node: d, geometry: f, material: m, worldMatrix: h, instances: g } = e, _ = d.drawMode, v = _ === "points" ? "points" : _ === "lines" ? "lines" : "mesh", y = ["PICK"];
+		g && y.push("INSTANCED");
+		let b = v === "points" && d.drawsSprites;
+		v === "points" && (m.sizeAttenuation && y.push("SIZE_ATTENUATION"), m.map || y.push("ROUND"), b && y.push("SPRITES")), v === "mesh" && e.clip && y.push("CLIP");
+		let x = i(m);
+		x && y.push(...t(x, v === "mesh"));
+		let S = this.programs.ready(`pick-${v}`, y, p[v], x?.source);
+		if (!S.failed) {
+			if (s.useProgram(S.program), S.set("uView", r.camera.view), S.set("uProjection", this.#n), S.set("uViewProjection", this.#r), S.set("uModel", h), S.set("uPickId", n), S.set("uHighlightIndex", -2), e.clip && S.set("uClipPlane", e.clip.plane), x && c(S, m, r.time ?? 0, r.camera.position, (e) => this.resources.texture(e)), v === "lines") {
+				s.disable(s.CULL_FACE), S.set("uResolution", [u, u]), S.set("uWidth", m.width * o), S.set("uNear", r.camera.near);
+				let e = d.arrowBits ?? 0;
+				S.set("uArrows", e), S.set("uArrowSize", d.arrowPixels?.(m.width) * o || 0);
+				let t = this.resources.lines(f);
+				s.bindVertexArray(t.vao), s.drawArraysInstanced(s.TRIANGLES, 0, e ? 12 : 6, Math.min(t.count, Math.floor(f.drawnCount / 2)));
+			} else if (v === "points") {
+				if (s.disable(s.CULL_FACE), S.set("uSize", m.sizeAttenuation ? m.size : m.size * o), S.set("uScale", r.camera.projection[5] * a / 2), b) {
+					S.set("uResolution", [u, u]);
+					let e = this.resources.sprites(f);
+					s.bindVertexArray(e.vao), s.drawArraysInstanced(s.TRIANGLE_STRIP, 0, 4, e.count);
+					return;
+				}
+				let e = this.resources.mesh(f, null, !1);
+				s.bindVertexArray(e.vao), s.drawArrays(s.POINTS, 0, f.drawnVertices);
+			} else S.set("uNormalMatrix", this.#i), m.depthTest ? s.enable(s.DEPTH_TEST) : s.disable(s.DEPTH_TEST), m.doubleSided || e.clip?.cap ? s.disable(s.CULL_FACE) : (s.enable(s.CULL_FACE), s.cullFace(s.BACK), s.frontFace(l(h) < 0 ? s.CW : s.CCW)), this.resources.drawTriangles(f, g);
+		}
 	}
 	#d() {
 		if (this.#e) return this.#e;
 		let e = this.gl, t = e.createTexture();
-		e.activeTexture(e.TEXTURE15), e.bindTexture(e.TEXTURE_2D, t), e.texStorage2D(e.TEXTURE_2D, 1, e.RGBA32UI, s, s);
+		e.activeTexture(e.TEXTURE15), e.bindTexture(e.TEXTURE_2D, t), e.texStorage2D(e.TEXTURE_2D, 1, e.RGBA32UI, u, u);
 		let n = e.createRenderbuffer();
-		e.bindRenderbuffer(e.RENDERBUFFER, n), e.renderbufferStorage(e.RENDERBUFFER, e.DEPTH_COMPONENT24, s, s);
+		e.bindRenderbuffer(e.RENDERBUFFER, n), e.renderbufferStorage(e.RENDERBUFFER, e.DEPTH_COMPONENT24, u, u);
 		let r = e.createFramebuffer();
 		return e.bindFramebuffer(e.FRAMEBUFFER, r), e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, t, 0), e.framebufferRenderbuffer(e.FRAMEBUFFER, e.DEPTH_ATTACHMENT, e.RENDERBUFFER, n), e.bindFramebuffer(e.FRAMEBUFFER, null), this.#e = {
 			framebuffer: r,
@@ -148,7 +181,7 @@ pickOut = uvec4(uPickId, vPickElement, floatBitsToUint(gl_FragCoord.z), 1u);
 		}, this.#e;
 	}
 };
-function f(e) {
+function h(e) {
 	let t = /* @__PURE__ */ new Map(), n = (e) => {
 		if (!e) return !0;
 		let r = t.get(e);
@@ -156,6 +189,6 @@ function f(e) {
 	}, r = [...e.opaque, ...e.transparent].filter((e) => n(e.node));
 	return [...r.filter((e) => e.material.depthTest), ...r.filter((e) => !e.material.depthTest)];
 }
-export { d as Picker };
+export { m as Picker };
 
 //# sourceMappingURL=picking.js.map

package/dist/picking.js.map

@@ -1 +1 @@
-{"version":3,"file":"picking.js","names":["mat4.determinant","LINES_VERTEX","multiply","MESH_VERTEX","determinant","CLIP","POINTS_VERTEX","COMMON","REGION","TOLERANCE","PICK_FRAGMENT","SOURCES","Picker","gl","programs","resources","#target","#pack","#waiting","region","#drawRegion","frame","x","y","width","height","pixelRatio","#pixels","#decode","buffer","#readBuffer","fence","poll","resolve","items","pickable","target","#ensureTarget","s","cx","cy","zoom","#projection","#viewProjection","#draw","item","i","p","at","py","px","best","bestX","bestY","bestD","dy","dx","d","o","id","depth","ndc","mode","node","kind","defines","instances","material","program","worldMatrix","buffers","geometry","#normal","color","framebuffer","seen","ok","n","v"],"sources":[],"mappings":""}
+{"version":3,"file":"picking.js","names":["mat4.determinant","LINES_VERTEX","passDefines","COMMON","POINTS_VERTEX","hookFor","CLIP","multiply","MESH_VERTEX","setHookUniforms","determinant","REGION","TOLERANCE","PICK_FRAGMENT","SOURCES","Picker","gl","programs","resources","#target","#pack","#waiting","region","#drawRegion","frame","x","y","width","height","pixelRatio","#pixels","#decode","buffer","#readBuffer","fence","poll","resolve","items","pickable","target","#ensureTarget","s","cx","cy","zoom","#projection","#viewProjection","#draw","item","i","p","at","py","px","best","bestX","bestY","bestD","dy","dx","d","o","id","depth","ndc","mode","node","kind","defines","instances","sprites","material","hook","program","worldMatrix","t","arrows","buffers","geometry","#normal","color","framebuffer","seen","ok","n","v"],"sources":[],"mappings":""}

package/dist/snapshot.js

@@ -1,4 +1,4 @@
-import { wt as e } from "./core.js";
+import { kt as e } from "./core.js";
 // src/snapshot.js
 function t(t, n, { type: a = "image/png", quality: o, labels: s = !0 } = {}, c = []) {
 	let l = t;

package/dist/tooltip.js

@@ -1,4 +1,4 @@
-import { At as e, Ot as t } from "./core.js";
+import { Ft as e, Nt as t } from "./core.js";
 // src/tooltip.js
 var n = "\n:where(.phoria-tooltip) { position: fixed; left: 0; top: 0; z-index: 1000; pointer-events: none; max-width: 320px;\n  padding: 6px 10px; border-radius: 6px; background: rgba(20, 20, 24, 0.92); color: #fff;\n  font: 12px/1.45 system-ui, sans-serif; box-shadow: 0 4px 16px rgba(0, 0, 0, 0.3); white-space: pre-line; }\n:where(.phoria-tooltip-title) { font-weight: 600; }\n:where(.phoria-tooltip-rows) { display: grid; grid-template-columns: auto auto; column-gap: 12px; }\n:where(.phoria-tooltip-rows > :nth-child(odd)) { opacity: 0.7; }\n:where(.phoria-tooltip-rows > :nth-child(even)) { text-align: right; font-variant-numeric: tabular-nums; }\n", r = 14, i = class {
 	el;

package/dist/types/View.d.ts

@@ -17,6 +17,7 @@ import type { CameraOptions } from './scene/cameras.js';
 import type { ColorInput, Vec3Input } from './types.js';
 import type { Node } from './scene/Node.js';
 import type { KeyboardOptions } from './keyboard.js';
+import type { DebugOptions } from './debug.js';
 export type RenderMode = 'auto' | 'always' | 'manual';
 export type ViewOptions = {
     /**
@@ -125,6 +126,11 @@ export type ViewOptions = {
      * on and no description, one is made from the scene (charts describe themselves)
      */
     description?: string | null;
+    /**
+     * pictures for checking a scene: lights, shadow cameras, bounds,
+     * normals, axes, the orbit target and a stats readout. true shows all but normals. Default false
+     */
+    debug?: boolean | DebugOptions;
 };
 export type ViewEvent = 'click' | 'hover';
 export type ViewHandler = (hit: Hit | null, event: PointerEvent | MouseEvent | null) => void;
@@ -195,6 +201,16 @@ export declare class View {
     get reducedMotion(): boolean;
     /** @param {'auto' | boolean} v */
     set reducedMotion(v: 'auto' | boolean);
+    /**
+     * Debug drawing, or false: what it shows, as DebugOptions. Assign true for everything but normals,
+     * options for some, or false. Its code loads the first time it's turned on.
+     *
+     *     view.debug = { lights: true, shadows: true, bounds: 'hovered', stats: 'bottom-right' }
+     * @returns {boolean | DebugOptions} the options in force, every one given, or false
+     */
+    get debug(): boolean | DebugOptions;
+    /** @param {boolean | DebugOptions} v */
+    set debug(v: boolean | DebugOptions);
     /**
      * What the view shows, for screen readers - the canvas's label - or null. With keyboard on and no
      * description, one is made from the scene.
@@ -339,6 +355,17 @@ export declare class View {
         width: number;
         height: number;
     } | null;
+    /**
+     * Everything inside an area of the canvas, nearest first: a box `{ x, y, width, height }` or a
+     * lasso of `[x, y]` points, CSS pixels from the canvas's top left. Each point, instance and line
+     * segment is its own hit, found by where it is (a mesh by its middle) - hidden behind others or
+     * not - so a box dragged over a scatter selects that region of it.
+     *
+     *     const picked = view.pickArea({ x: 40, y: 30, width: 200, height: 120 }).map((h) => h.datum)
+     * @param {import('./area.js').PickArea} area
+     * @returns {Hit[]}
+     */
+    pickArea(area: import('./area.js').PickArea): Hit[];
     /** Every hit under a canvas position, nearest first. @param {number | MouseEvent} x @param {number} [y] @returns {Hit[]} */
     pickAll(x: number | MouseEvent, y?: number): Hit[];
     /**

package/dist/types/area.d.ts

@@ -0,0 +1,18 @@
+import type { Hit } from './Raycaster.js';
+import type { Node } from './scene/Node.js';
+import type { Camera } from './scene/cameras.js';
+export type PickArea = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | [number, number][];
+/**
+ * Everything in the scene the camera shows, pickable, whose place falls inside the area - nearest
+ * the camera first.
+ * @param {Node} scene @param {Camera} camera @param {Float32Array} viewProjection
+ * @param {number} width @param {number} height the canvas, CSS pixels
+ * @param {PickArea} area
+ * @returns {Hit[]}
+ */
+export declare function pickArea(scene: Node, camera: Camera, viewProjection: Float32Array, width: number, height: number, area: PickArea): Hit[];

package/dist/types/debug.d.ts

@@ -0,0 +1,74 @@
+import { Box3 } from './value/Box3.js';
+import type { FrameDescription } from './frame.js';
+import type { Hit } from './Raycaster.js';
+import type { Camera } from './scene/cameras.js';
+export type DebugOptions = {
+    /**
+     * each light: an arrow for directional ones, a small sphere and its range
+     * for point lights, a cone for spot lights - in the light's colour
+     */
+    lights?: boolean;
+    /**
+     * the box or cone each shadow is drawn from - the usual reason a shadow
+     * is cut off or soft
+     */
+    shadows?: boolean;
+    /**
+     * world bounding boxes - what culling and view.frame() see
+     */
+    bounds?: boolean | 'hovered';
+    /**
+     * short lines along vertex normals (meshes up to 5,000
+     * vertices each when all are shown)
+     */
+    normals?: boolean | 'hovered';
+    /**
+     * x, y and z at the origin, red, green and blue
+     */
+    axes?: boolean;
+    /**
+     * the point the camera orbits round
+     */
+    camera?: boolean;
+    /**
+     * a readout of
+     * frame time, draw calls, triangles, programs, textures and geometries, in a corner of the canvas
+     */
+    stats?: boolean | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+};
+export declare class DebugDraw {
+    #private;
+    overlay: HTMLElement;
+    /** @param {HTMLElement | null} overlay where the stats readout goes - the layer over the canvas */
+    constructor(overlay: HTMLElement | null);
+    /**
+     * Add the helpers to a frame about to be drawn, after everything in it. Returns how many items were
+     * added to each list, to take out again once it is drawn.
+     * @param {FrameDescription} frame @param {DebugOptions} o
+     * @param {{ camera: Camera, hovered: Hit | null, bounds: Box3 }} at
+     * @returns {{ opaque: number, transparent: number }}
+     */
+    add(frame: FrameDescription, o: DebugOptions, at: {
+        camera: Camera;
+        hovered: Hit | null;
+        bounds: Box3;
+    }): {
+        opaque: number;
+        transparent: number;
+    };
+    /**
+     * The corner readout, refreshed a few times a second.
+     * @param {DebugOptions['stats']} where
+     * @param {{ drawCalls: number, triangles: number, programs: number, textures: number, geometries: number, compiling: number }} info
+     * @param {number} frameMs time between drawn frames @param {number} cpuMs time the last frame took to draw
+     */
+    stats(where: DebugOptions['stats'], info: {
+        drawCalls: number;
+        triangles: number;
+        programs: number;
+        textures: number;
+        geometries: number;
+        compiling: number;
+    }, frameMs: number, cpuMs: number): void;
+    dispose(): void;
+}

package/dist/types/explain.d.ts

@@ -44,6 +44,10 @@ export type ExplainInfo = {
      * lines from nodes that describe themselves, such as charts
      */
     notes?: string[];
+    /**
+     * what debug drawing shows, when it is on
+     */
+    debug?: Record<string, unknown> | null;
 };
 /** @param {ExplainInfo} info @returns {string} */
 export declare function explain(info: ExplainInfo): string;

package/dist/types/frame.d.ts

@@ -272,6 +272,10 @@ export type FrameDescription = {
         drawn: number;
         culled: number;
     };
+    /**
+     * the View's clock in seconds, for shader hooks that read uTime
+     */
+    time?: number;
     /**
      * set by the View for hover highlighting
      */
@@ -414,6 +418,7 @@ export type FrameDescription = {
  * @property {PointShadowFrame | null} pointShadow a point light's shadow, all round it
  * @property {FrameCap[]} caps section planes' caps to fill, after the opaque pass
  * @property {{ drawn: number, culled: number }} stats
+ * @property {number} [time] the View's clock in seconds, for shader hooks that read uTime
  * @property {FrameHighlight | null} highlight set by the View for hover highlighting
  * @property {any[]} overlays HTML elements carried by the nodes drawn (node.overlay)
  * @property {boolean} interactive some node has a tooltip, highlight or pointer handler

package/dist/types/geometry/Geometry.d.ts

@@ -21,6 +21,19 @@ export type GeometryOptions = {
      * rgb per vertex, sRGB 0-1 like every colour input
      */
     colors?: ArrayLike<number>;
+    /**
+     * points: one per vertex, a multiple of the material's size
+     */
+    sizes?: ArrayLike<number>;
+    /**
+     * points: one per vertex, 0-1, multiplying the material's opacity
+     */
+    opacities?: ArrayLike<number>;
+    /**
+     * points: one per vertex, radians anticlockwise on screen - turns
+     * each point's texture
+     */
+    angles?: ArrayLike<number>;
     /**
      * vertex indices; triangles for meshes, pairs for lines
      */
@@ -38,6 +51,9 @@ export declare class Geometry {
     /** @type {Float32Array | null} */ uvs: Float32Array | null;
     /** A second UV set, for baked occlusion and light maps. @type {Float32Array | null} */ uvs2: Float32Array | null;
     /** @type {Float32Array | null} */ colors: Float32Array | null;
+    /** Points: each one's size, as a multiple of the material's. @type {Float32Array | null} */ sizes: Float32Array | null;
+    /** Points: each one's opacity, 0-1, times the material's. @type {Float32Array | null} */ opacities: Float32Array | null;
+    /** Points: each one's turn on screen, in radians anticlockwise. @type {Float32Array | null} */ angles: Float32Array | null;
     /** @type {Uint16Array | Uint32Array | null} */ indices: Uint16Array | Uint32Array | null;
     /**
      * Draw only the first `drawCount` vertices (indices, when indexed), or all of them when null -

package/dist/types/index.d.ts

@@ -37,6 +37,7 @@ export type RenderMode = import('./View.js').RenderMode;
 export type CameraPreset = import('./presets.js').CameraPreset;
 export type TooltipContent = import('./tooltip.js').TooltipContent;
 export type Hit = import('./Raycaster.js').Hit;
+export type PickArea = import('./area.js').PickArea;
 export type LabelPlacement = import('./scene/drawables.js').LabelPlacement;
 export type LabelPlace = import('./scene/drawables.js').LabelPlace;
 export type InstanceLabels = import('./scene/drawables.js').InstanceLabels;
@@ -49,6 +50,7 @@ export type ImageOptions = import('./snapshot.js').ImageOptions;
 /** @typedef {import('./presets.js').CameraPreset} CameraPreset */
 /** @typedef {import('./tooltip.js').TooltipContent} TooltipContent */
 /** @typedef {import('./Raycaster.js').Hit} Hit */
+/** @typedef {import('./area.js').PickArea} PickArea */
 /** @typedef {import('./scene/drawables.js').LabelPlacement} LabelPlacement */
 /** @typedef {import('./scene/drawables.js').LabelPlace} LabelPlace */
 /** @typedef {import('./scene/drawables.js').InstanceLabels} InstanceLabels */

package/dist/types/material/Material.d.ts

@@ -3,6 +3,39 @@ import { Texture } from './Texture.js';
 import type { ColorInput } from '../types.js';
 import type { TextureOptions } from './Texture.js';
 export type MapInput = Texture | TextureOptions | string;
+export type ShaderUniform = number | number[] | ColorInput | Texture;
+export type ShaderHooks = {
+    /**
+     * runs on each vertex before it is placed: change `local` (vec3, the
+     * geometry's own space) - and for meshes `n`, its normal; reads `uv` (meshes), `index` (the
+     * instance, point or segment), `size` (points: change it too) and `along` (lines: 0 at a
+     * segment's start, 1 at its end)
+     */
+    vertex?: string;
+    /**
+     * runs on each pixel before lighting: change `base` (vec4: linear
+     * colour and alpha) and, on meshes, `emissive` and `normal` (the shading normal, world space - bend it for
+     * relief lit per pixel); `discard` cuts the pixel away - shadows and
+     * picking too. Reads `vUv`, `vWorldPosition`, `vNormal` (meshes), `pointUv` and `index`
+     * (points), `distance` along the line and `index` the segment (lines)
+     */
+    fragment?: string;
+    /**
+     * runs after lighting: change `color` (vec3, linear) and `base.a` - glows,
+     * scanlines and fades the light doesn't touch
+     */
+    lit?: string;
+    /**
+     * values the hooks read, by name; change them on
+     * `material.shader.uniforms` and the View redraws
+     */
+    uniforms?: Record<string, ShaderUniform>;
+    /**
+     * how far, in world units, the vertex hook can move a vertex: bounds are
+     * padded by it for culling, framing and shadows. Without it a vertex hook turns frustum culling off
+     */
+    bounds?: number;
+};
 export type MaterialOptions = {
     name?: string;
     /**
@@ -207,10 +240,27 @@ export type MaterialOptions = {
      * Points: sized in the world, so smaller with distance (default true)
      */
     sizeAttenuation?: boolean;
+    /**
+     * GLSL of your own, run at fixed points in the shader - waves,
+     * dissolves, glows (default none)
+     */
+    shader?: ShaderHooks | null;
     /**
      * Lines: width in pixels (default 1)
      */
     width?: number;
+    /**
+     * Lines: dashed, with dashes this long in the model's units; 0 is solid (default 0)
+     */
+    dash?: number;
+    /**
+     * Lines: the gaps between dashes; 0 is as long as the dashes (default 0)
+     */
+    gap?: number;
+    /**
+     * Lines: moves the dashes along the lines - animate it for flow (default 0)
+     */
+    dashOffset?: number;
 };
 /**
  * The one material: what a surface looks like. Plain objects passed as a `material` become
@@ -240,6 +290,10 @@ export declare class Material {
         colour: string;
         emissiveColor: string;
         alpha: string;
+        onBeforeCompile: string;
+        vertexShader: string;
+        fragmentShader: string;
+        uniforms: string;
     };
     /** @type {string} */ name: string;
     /** @type {number} */ opacity: number;
@@ -275,8 +329,21 @@ export declare class Material {
     /** @type {number} */ size: number;
     /** @type {boolean} */ sizeAttenuation: boolean;
     /** @type {number} */ width: number;
+    /** Lines: dash length in the model's units; 0 is solid. @type {number} */ dash: number;
+    /** Lines: gap length; 0 is the dash's. @type {number} */ gap: number;
+    /** Lines: how far the dashes have moved along. @type {number} */ dashOffset: number;
     /** @param {MaterialOptions} [options] */
     constructor(options?: MaterialOptions);
+    /**
+     * GLSL hooks run inside the shader, or null. Change its uniforms in place
+     * (`material.shader.uniforms.uAmount = 2`); assign a new object to change the code.
+     * @returns {Required<Omit<ShaderHooks, 'bounds'>> & { bounds: number | null } | null}
+     */
+    get shader(): (Required<Omit<ShaderHooks, 'bounds'>> & {
+        bounds: number | null;
+    }) | null;
+    /** @param {ShaderHooks | null} v */
+    set shader(v: ShaderHooks | null);
     /** Base colour; assign any colour input. @returns {Color} */
     get color(): Color;
     /** @param {ColorInput} v */