@3driseai/3drise-viewer 0.1.28 → 0.1.30

package/dist/utils/textureArrays.d.ts

@@ -0,0 +1,29 @@
+import * as THREE from 'three';
+export declare function loadArrayImage(url: string): Promise<HTMLImageElement>;
+/** Loads a URL, or resolves to null for a missing / failing one — a layer with a
+ *  missing map degrades to its fallback rather than taking the whole array down. */
+export declare function loadArrayImageOrNull(url: string | undefined | null): Promise<HTMLImageElement | null>;
+/** Where one output channel of one layer comes from. */
+export interface ChannelSource {
+    image: HTMLImageElement | null;
+    /** Source channel to read, 0..3. Grayscale maps: 0. */
+    channel?: number;
+    /** Byte written when there is no image. */
+    fallback: number;
+}
+/** One layer: four channel sources, R G B A. */
+export type LayerChannels = [ChannelSource, ChannelSource, ChannelSource, ChannelSource];
+export interface ChannelArrayResult {
+    texture: THREE.DataArrayTexture;
+    /** Mean RGB per layer, in the space the shader samples it in: linear for an
+     *  sRGB array, raw 0..1 otherwise. */
+    means: THREE.Vector3[];
+}
+/**
+ * Pack layers into one `DataArrayTexture`, each output channel taken from any
+ * channel of any image. Every image is redrawn at `size` — array layers must
+ * match and source maps never reliably do. An image used by several channels is
+ * read once.
+ */
+export declare function buildChannelArray(layers: LayerChannels[], size: number, colorSpace: THREE.ColorSpace): ChannelArrayResult;
+//# sourceMappingURL=textureArrays.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"textureArrays.d.ts","sourceRoot":"","sources":["../../src/utils/textureArrays.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAyB9B,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAerE;AAED;oFACoF;AACpF,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAQ3G;AA6BD,wDAAwD;AACxD,MAAM,WAAW,aAAa;IAC1B,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAA;IAC9B,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,2CAA2C;IAC3C,QAAQ,EAAE,MAAM,CAAA;CACnB;AAED,gDAAgD;AAChD,MAAM,MAAM,aAAa,GAAG,CAAC,aAAa,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,CAAC,CAAA;AAExF,MAAM,WAAW,kBAAkB;IAC/B,OAAO,EAAE,KAAK,CAAC,gBAAgB,CAAA;IAC/B;0CACsC;IACtC,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,CAAA;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC7B,MAAM,EAAE,aAAa,EAAE,EACvB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,KAAK,CAAC,UAAU,GAC7B,kBAAkB,CAwDpB"}

package/dist/utils/textureArrays.js

@@ -0,0 +1,140 @@
+import * as THREE from 'three';
+/**
+ * Texture arrays for splat-textured ground — shared by the terrain surface.
+ *
+ * Moved out of the landscape module (`landscapeTextures.ts`), which keeps its own
+ * copy until it is retired. Two changes on the way:
+ *
+ * - **Packing is per channel.** A layer's RGBA can be assembled from several
+ *   source images — the normal map's RGB with the displacement map's red in
+ *   alpha, or AO and roughness side by side in one ORM layer — so the terrain
+ *   pays for three arrays instead of five.
+ * - **Means are linear.** An sRGB array is decoded to linear by the sampler, so
+ *   the mean the variance-preserving stochastic blend subtracts from those samples
+ *   has to be linear too. The landscape computed it in sRGB, which biases every
+ *   stochastic blend toward a slightly wrong grey.
+ *
+ * Every image is read through a 2D canvas, so it must be CORS-clean: an image
+ * served without `Access-Control-Allow-Origin` taints the canvas and
+ * `getImageData` throws. The texture itself would render fine and only the
+ * packing fails, which is confusing — hence the explicit error.
+ */
+const imageCache = new Map();
+export function loadArrayImage(url) {
+    const cached = imageCache.get(url);
+    if (cached)
+        return cached;
+    const promise = new Promise((resolve, reject) => {
+        const image = new window.Image();
+        image.crossOrigin = 'anonymous';
+        image.onload = () => resolve(image);
+        image.onerror = () => {
+            imageCache.delete(url);
+            reject(new Error(`texture array: failed to load ${url}`));
+        };
+        image.src = url;
+    });
+    imageCache.set(url, promise);
+    return promise;
+}
+/** Loads a URL, or resolves to null for a missing / failing one — a layer with a
+ *  missing map degrades to its fallback rather than taking the whole array down. */
+export async function loadArrayImageOrNull(url) {
+    if (!url)
+        return null;
+    try {
+        return await loadArrayImage(url);
+    }
+    catch (error) {
+        console.warn(String(error));
+        return null;
+    }
+}
+function readPixels(image, size) {
+    const canvas = document.createElement('canvas');
+    canvas.width = size;
+    canvas.height = size;
+    const ctx = canvas.getContext('2d', { willReadFrequently: true });
+    if (!ctx)
+        throw new Error('texture array: no 2d context');
+    ctx.drawImage(image, 0, 0, size, size);
+    try {
+        return ctx.getImageData(0, 0, size, size).data;
+    }
+    catch {
+        throw new Error(`texture array: cannot read pixels from ${image.src} — the canvas is tainted. `
+            + 'The asset host must send Access-Control-Allow-Origin.');
+    }
+}
+/** sRGB byte -> linear float, once. */
+const SRGB_TO_LINEAR = (() => {
+    const lut = new Float32Array(256);
+    for (let i = 0; i < 256; i++) {
+        const c = i / 255;
+        lut[i] = c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+    }
+    return lut;
+})();
+/**
+ * Pack layers into one `DataArrayTexture`, each output channel taken from any
+ * channel of any image. Every image is redrawn at `size` — array layers must
+ * match and source maps never reliably do. An image used by several channels is
+ * read once.
+ */
+export function buildChannelArray(layers, size, colorSpace) {
+    const stride = size * size * 4;
+    const data = new Uint8Array(stride * Math.max(layers.length, 1));
+    const means = [];
+    const pixelCache = new Map();
+    const pixelsOf = (image) => {
+        let px = pixelCache.get(image);
+        if (!px) {
+            px = readPixels(image, size);
+            pixelCache.set(image, px);
+        }
+        return px;
+    };
+    const srgb = colorSpace === THREE.SRGBColorSpace;
+    layers.forEach((channels, layer) => {
+        const offset = layer * stride;
+        for (let c = 0; c < 4; c++) {
+            const source = channels[c];
+            if (source.image) {
+                const px = pixelsOf(source.image);
+                const from = source.channel ?? 0;
+                for (let p = 0; p < stride; p += 4)
+                    data[offset + p + c] = px[p + from];
+            }
+            else {
+                for (let p = 0; p < stride; p += 4)
+                    data[offset + p + c] = source.fallback;
+            }
+        }
+        let r = 0, g = 0, b = 0;
+        for (let p = 0; p < stride; p += 4) {
+            if (srgb) {
+                r += SRGB_TO_LINEAR[data[offset + p]];
+                g += SRGB_TO_LINEAR[data[offset + p + 1]];
+                b += SRGB_TO_LINEAR[data[offset + p + 2]];
+            }
+            else {
+                r += data[offset + p] / 255;
+                g += data[offset + p + 1] / 255;
+                b += data[offset + p + 2] / 255;
+            }
+        }
+        const n = size * size || 1;
+        means.push(new THREE.Vector3(r / n, g / n, b / n));
+    });
+    const texture = new THREE.DataArrayTexture(data, size, size, Math.max(layers.length, 1));
+    texture.format = THREE.RGBAFormat;
+    texture.type = THREE.UnsignedByteType;
+    texture.colorSpace = colorSpace;
+    texture.minFilter = THREE.LinearMipMapLinearFilter;
+    texture.magFilter = THREE.LinearFilter;
+    texture.wrapS = THREE.RepeatWrapping;
+    texture.wrapT = THREE.RepeatWrapping;
+    texture.generateMipmaps = true;
+    texture.needsUpdate = true;
+    return { texture, means };
+}

package/package.json

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