@3driseai/3drise-viewer 0.1.9 → 0.1.11

package/dist/utils/cloudShadowMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudShadowMap.d.ts","sourceRoot":"","sources":["../../src/utils/cloudShadowMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,mBAAmB;IAC5B,6EAA6E;;eAC1C,KAAK,CAAC,OAAO,GAAG,IAAI;;IACvD,gEAAgE;;;;IAEhE,8EAA8E;;;;CAEjF,CAAC;AAEF,4EAA4E;AAC5E,wBAAgB,qBAAqB,CACjC,OAAO,EAAE,KAAK,CAAC,OAAO,GAAG,IAAI,EAC7B,MAAM,EAAE,KAAK,CAAC,OAAO,GAAG,IAAI,EAC5B,QAAQ,EAAE,MAAM,GACjB,IAAI,CAIN;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACnC,MAAM,EAAE,KAAK,CAAC,kBAAkB,EAChC,MAAM,EAAE,KAAK,CAAC,OAAO,EACrB,OAAO,EAAE,KAAK,CAAC,OAAO,EACtB,MAAM,EAAE,KAAK,CAAC,OAAO,EACrB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GAChB,IAAI,CAkBN"}

package/dist/utils/cloudShadowMap.js

@@ -0,0 +1,60 @@
+import * as THREE from 'three';
+/**
+ * The cloud shadow map, shared with every surface material that wants it.
+ *
+ * These are three.js *shared uniform objects*: a material that spreads
+ * `cloudShadowUniforms` into its own uniforms holds a reference to the same
+ * `{ value }` boxes, so the cloud pass updates them once per frame and terrain,
+ * ocean, landscape and anything else see the new texture without knowing about each
+ * other. Same idea as THREE.UniformsLib.
+ *
+ * The alternative — threading the texture down as props, or having each material
+ * poll a registry per frame — means every new surface material has to be taught
+ * about clouds. This way it costs one line at the material and nothing at the call
+ * site, which is the only version that will actually get adopted across a codebase
+ * with three custom surface shaders and an open-ended set of object materials.
+ */
+export const cloudShadowUniforms = {
+    /** R channel is transmittance along the sun ray: 1 lit, 0 fully shadowed. */
+    u_cloudShadowMap: { value: null },
+    /** World -> shadow clip. The chunk does the 0.5 bias itself. */
+    u_cloudShadowMatrix: { value: new THREE.Matrix4() },
+    /** 0 disables the lookup entirely, so an unused material pays one compare. */
+    u_cloudShadowStrength: { value: 0 },
+};
+/** Called by the cloud pass each frame. Nothing else should write these. */
+export function publishCloudShadowMap(texture, matrix, strength) {
+    cloudShadowUniforms.u_cloudShadowMap.value = texture;
+    if (matrix)
+        cloudShadowUniforms.u_cloudShadowMatrix.value.copy(matrix);
+    cloudShadowUniforms.u_cloudShadowStrength.value = texture ? strength : 0;
+}
+/**
+ * Orthographic frame for the shadow camera, looking along the sun.
+ *
+ * Centred ahead of the viewer rather than on it: shadows behind the camera are
+ * never seen, so spending half the map on them halves the effective resolution for
+ * no reason. Snapped to texel increments — without that, the map slides
+ * continuously as the camera moves and the shadow edges crawl and shimmer, which
+ * is far more distracting than a slightly coarse edge.
+ */
+export function updateCloudShadowCamera(camera, viewer, viewDir, sunDir, extent, mapSize) {
+    const centre = new THREE.Vector3()
+        .copy(viewDir).setY(0).normalize().multiplyScalar(extent * 0.45)
+        .add(viewer);
+    centre.y = 0;
+    const texelWorld = (extent * 2) / mapSize;
+    centre.x = Math.round(centre.x / texelWorld) * texelWorld;
+    centre.z = Math.round(centre.z / texelWorld) * texelWorld;
+    // Far enough back that the near plane clears any cloud top.
+    camera.position.copy(centre).addScaledVector(sunDir, 60000);
+    camera.lookAt(centre);
+    camera.left = -extent;
+    camera.right = extent;
+    camera.top = extent;
+    camera.bottom = -extent;
+    camera.near = 1;
+    camera.far = 120000;
+    camera.updateProjectionMatrix();
+    camera.updateMatrixWorld(true);
+}

package/dist/utils/cloudUniforms.d.ts

@@ -1,7 +1,12 @@
 import * as THREE from 'three';
-import type { CloudDeckConfig, CirrusLayerConfig, CloudsQualityConfig } from '../types/cloudConfigs';
+import type { CloudDeckConfig, CirrusLayerConfig, CloudsQualityConfig, ThunderConfig } from '../types/cloudConfigs';
 import type { CloudSunState } from '../hooks/useCloudSun';
 export declare function applyDeckUniforms(material: THREE.ShaderMaterial, deck: CloudDeckConfig, quality: CloudsQualityConfig): void;
+/**
+ * Lightning uniforms. `intensity` comes from the scheduler, already through the
+ * stroke envelope — the config's own intensity is the peak it scales to.
+ */
+export declare function applyThunderUniforms(material: THREE.ShaderMaterial, thunder: ThunderConfig, intensity: number, position: THREE.Vector3): void;
 export declare function applyCirrusUniforms(material: THREE.ShaderMaterial, cirrus: CirrusLayerConfig, quality: CloudsQualityConfig): void;
 /** Sun and atmosphere. Every cloud material and the sky background share these. */
 export declare function applySunUniforms(material: THREE.ShaderMaterial, sun: CloudSunState, intensity: number): void;

package/dist/utils/cloudUniforms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloudUniforms.d.ts","sourceRoot":"","sources":["../../src/utils/cloudUniforms.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACrG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AA0B1D,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI,CA0C3H;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAAE,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAkBjI;AAED,mFAAmF;AACnF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAAE,GAAG,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAY5G;AAID;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAAE,MAAM,EAAE,KAAK,CAAC,iBAAiB,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAUhK"}
+{"version":3,"file":"cloudUniforms.d.ts","sourceRoot":"","sources":["../../src/utils/cloudUniforms.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACpH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AA0B1D,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI,CA0C3H;AAKD;;;GAGG;AACH,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAC9B,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,KAAK,CAAC,OAAO,GACxB,IAAI,CAWN;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAAE,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAkBjI;AAED,mFAAmF;AACnF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAAE,GAAG,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAY5G;AAID;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAAE,MAAM,EAAE,KAAK,CAAC,iBAAiB,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAUhK"}

package/dist/utils/cloudUniforms.js

@@ -59,6 +59,24 @@ export function applyDeckUniforms(material, deck, quality) {
     u.u_detailFade.value = inverse(quality.detailFadeDistance, 16000);
     u.u_curvature.value = quality.curvature;
 }
+/** Reused so a flash does not allocate a Color every frame. */
+const flashColor = new THREE.Color();
+/**
+ * Lightning uniforms. `intensity` comes from the scheduler, already through the
+ * stroke envelope — the config's own intensity is the peak it scales to.
+ */
+export function applyThunderUniforms(material, thunder, intensity, position) {
+    const u = material.uniforms;
+    if (!u || !u.u_flash)
+        return;
+    u.u_flash.value = thunder.enabled ? intensity : 0;
+    if (!thunder.enabled || intensity <= 0)
+        return;
+    u.u_flashPos.value.copy(position);
+    u.u_flashColor.value.copy(flashColor.set(thunder.color));
+    u.u_flashRadius.value = Math.max(thunder.radius, 1);
+    u.u_flashScatter.value = thunder.scatter;
+}
 export function applyCirrusUniforms(material, cirrus, quality) {
     const u = material.uniforms;
     if (!u)

package/dist/utils/gpuProfiler.d.ts

@@ -0,0 +1,33 @@
+import type * as THREE from 'three';
+declare class GpuProfiler {
+    private gl;
+    private ext;
+    private enabled;
+    private active;
+    private pending;
+    private samples;
+    /** Frames counted while enabled, so dump() can report per-frame cost honestly. */
+    private frames;
+    attach(renderer: THREE.WebGLRenderer): void;
+    get available(): boolean;
+    get isEnabled(): boolean;
+    enable(): string;
+    disable(): void;
+    /** Open a timed region. Only one may be open at a time — the API allows no nesting. */
+    begin(label: string): void;
+    end(): void;
+    /** Call once per frame, after the last end(). Drains whatever the GPU has retired. */
+    collect(): void;
+    private discardPending;
+    /** Rolling mean ms per pass, plus each pass's share of the measured total. */
+    results(): {
+        label: string;
+        ms: number;
+        share: string;
+        samples: number;
+    }[];
+    dump(): void;
+}
+export declare const gpuProfiler: GpuProfiler;
+export default gpuProfiler;
+//# sourceMappingURL=gpuProfiler.d.ts.map

package/dist/utils/gpuProfiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpuProfiler.d.ts","sourceRoot":"","sources":["../../src/utils/gpuProfiler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AA2BpC,cAAM,WAAW;IACb,OAAO,CAAC,EAAE,CAAuC;IACjD,OAAO,CAAC,GAAG,CAAa;IACxB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,OAAO,CAA+B;IAC9C,kFAAkF;IAClF,OAAO,CAAC,MAAM,CAAK;IAEnB,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,aAAa,GAAG,IAAI;IAQ3C,IAAI,SAAS,IAAI,OAAO,CAAuB;IAC/C,IAAI,SAAS,IAAI,OAAO,CAAuC;IAE/D,MAAM,IAAI,MAAM;IAQhB,OAAO,IAAI,IAAI;IAKf,uFAAuF;IACvF,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAS1B,GAAG,IAAI,IAAI;IAOX,sFAAsF;IACtF,OAAO,IAAI,IAAI;IA4Bf,OAAO,CAAC,cAAc;IAMtB,8EAA8E;IAC9E,OAAO,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE;IAY1E,IAAI,IAAI,IAAI;CAOf;AAED,eAAO,MAAM,WAAW,EAAE,WAA+B,CAAC;AAM1D,eAAe,WAAW,CAAC"}

package/dist/utils/gpuProfiler.js

@@ -0,0 +1,115 @@
+const AVG_WINDOW = 60;
+class GpuProfiler {
+    gl = null;
+    ext = null;
+    enabled = false;
+    active = null;
+    pending = [];
+    samples = new Map();
+    /** Frames counted while enabled, so dump() can report per-frame cost honestly. */
+    frames = 0;
+    attach(renderer) {
+        const gl = renderer.getContext();
+        if (this.gl === gl)
+            return;
+        this.gl = gl;
+        this.ext = gl.getExtension('EXT_disjoint_timer_query_webgl2')
+            ?? gl.getExtension('EXT_disjoint_timer_query');
+    }
+    get available() { return !!this.ext; }
+    get isEnabled() { return this.enabled && !!this.ext; }
+    enable() {
+        if (!this.ext)
+            return 'EXT_disjoint_timer_query_webgl2 not available in this browser';
+        this.enabled = true;
+        this.samples.clear();
+        this.frames = 0;
+        return 'GPU profiling on — let it run a second, then __cloudProfile.dump()';
+    }
+    disable() {
+        this.enabled = false;
+        this.discardPending();
+    }
+    /** Open a timed region. Only one may be open at a time — the API allows no nesting. */
+    begin(label) {
+        if (!this.isEnabled || this.active)
+            return;
+        const gl = this.gl;
+        const query = gl.createQuery();
+        if (!query)
+            return;
+        gl.beginQuery(this.ext.TIME_ELAPSED_EXT, query);
+        this.active = { label, query };
+    }
+    end() {
+        if (!this.active)
+            return;
+        this.gl.endQuery(this.ext.TIME_ELAPSED_EXT);
+        this.pending.push(this.active);
+        this.active = null;
+    }
+    /** Call once per frame, after the last end(). Drains whatever the GPU has retired. */
+    collect() {
+        if (!this.isEnabled)
+            return;
+        const gl = this.gl;
+        this.frames++;
+        // A disjoint means the GPU was interrupted (context switch, power state) and
+        // every result in flight is garbage — the spec requires discarding them.
+        if (gl.getParameter(this.ext.GPU_DISJOINT_EXT)) {
+            this.discardPending();
+            return;
+        }
+        const stillPending = [];
+        for (const p of this.pending) {
+            if (!gl.getQueryParameter(p.query, gl.QUERY_RESULT_AVAILABLE)) {
+                stillPending.push(p);
+                continue;
+            }
+            const ns = gl.getQueryParameter(p.query, gl.QUERY_RESULT);
+            gl.deleteQuery(p.query);
+            const arr = this.samples.get(p.label) ?? [];
+            arr.push(ns / 1e6); // ns -> ms
+            if (arr.length > AVG_WINDOW)
+                arr.shift();
+            this.samples.set(p.label, arr);
+        }
+        this.pending = stillPending;
+    }
+    discardPending() {
+        for (const p of this.pending)
+            this.gl.deleteQuery(p.query);
+        this.pending = [];
+        if (this.active) {
+            this.gl.endQuery(this.ext.TIME_ELAPSED_EXT);
+            this.active = null;
+        }
+    }
+    /** Rolling mean ms per pass, plus each pass's share of the measured total. */
+    results() {
+        const rows = [...this.samples.entries()].map(([label, a]) => ({
+            label,
+            ms: a.reduce((x, y) => x + y, 0) / a.length,
+            samples: a.length,
+        }));
+        const total = rows.reduce((s, r) => s + r.ms, 0);
+        return rows
+            .sort((a, b) => b.ms - a.ms)
+            .map((r) => ({ ...r, ms: +r.ms.toFixed(3), share: total > 0 ? `${Math.round((r.ms / total) * 100)}%` : '—' }));
+    }
+    dump() {
+        const rows = this.results();
+        if (!rows.length) {
+            console.log('[cloud profile] no results yet — give it a second');
+            return;
+        }
+        const total = rows.reduce((s, r) => s + r.ms, 0);
+        console.table(rows);
+        console.log(`[cloud profile] measured total ${total.toFixed(2)} ms/frame  (${(1000 / total).toFixed(0)} fps if this were the only cost)`);
+    }
+}
+export const gpuProfiler = new GpuProfiler();
+if (typeof window !== 'undefined') {
+    window.__cloudProfile = gpuProfiler;
+}
+export default gpuProfiler;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@3driseai/3drise-viewer",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -39,6 +39,6 @@
   },
   "dependencies": {
     "@3driseai/3drise-common": "^1.0.1",
-    "@3driseai/3drise-core": "^1.0.5"
+    "@3driseai/3drise-core": "^1.0.6"
   }
 }