@pascal-app/viewer 0.9.2 → 1.0.0-beta.2

package/dist/lib/snapshot-pipeline.js

@@ -0,0 +1,254 @@
+import { Color, Matrix4, UnsignedByteType } from 'three';
+import { ssgi } from 'three/addons/tsl/display/SSGINode.js';
+import { denoise } from 'three/examples/jsm/tsl/display/DenoiseNode.js';
+import { fxaa } from 'three/examples/jsm/tsl/display/FXAANode.js';
+import { convertToTexture, diffuseColor, float, mix, mrt, normalView, output, pass, sample, saturation, screenUV, smoothstep, uniform, vec3, vec4, } from 'three/tsl';
+import { RenderPipeline, RenderTarget } from 'three/webgpu';
+import { GRADE_PARAMS, SSGI_PARAMS } from '../components/viewer/post-processing';
+import { backdropGradient, deepSkyColor, horizonHazeColor } from './backdrop';
+import { edgeColorFor, edgeOpacityScaleFor } from './edge-style';
+import { inkedEdges } from './ink-edges';
+import { getSceneTheme } from './scene-themes';
+import { packNormalToRGB, unpackRGBToNormal } from './tsl-compat';
+export const THUMBNAIL_WIDTH = 1920;
+export const THUMBNAIL_HEIGHT = 1080;
+export async function createSnapshotPipeline({ renderer, scene, camera, }) {
+    try {
+        if (renderer.init)
+            await renderer.init();
+        // Backdrop compositing for scene snapshots (studio renders, project
+        // thumbnails): theme background + sky gradient, same world-ray math as the
+        // viewport backdrop in viewer's post-processing. Uniform-driven so the one
+        // cached pipeline serves both opaque and transparent (preset/item) captures.
+        const bgColorUniform = uniform(new Color('#ffffff'));
+        const bgSkyUniform = uniform(new Color('#ffffff'));
+        const bgSkyDeepUniform = uniform(new Color('#ffffff'));
+        const bgHazeUniform = uniform(new Color('#ffffff'));
+        const bgProjInvUniform = uniform(new Matrix4());
+        const bgCamWorldUniform = uniform(new Matrix4());
+        const bgMixUniform = uniform(1);
+        const gradeMixUniform = uniform(0);
+        const inkMixUniform = uniform(0);
+        const inkColorUniform = uniform(new Color('#1a1d24'));
+        const inkOpacityUniform = uniform(0.5);
+        const inkOpacityScaleUniform = uniform(1);
+        // pass() handles MRT internally for all material types, including custom
+        // shaders — unlike renderer.setMRT() which crashes on non-NodeMaterials.
+        // pass() also respects camera.layers, so caller-disabled objects are filtered.
+        const scenePass = pass(scene, camera);
+        scenePass.setMRT(mrt({
+            output,
+            diffuseColor,
+            normal: packNormalToRGB(normalView),
+        }));
+        const scenePassColor = scenePass.getTextureNode('output');
+        const scenePassDepth = scenePass.getTextureNode('depth');
+        const scenePassNormal = scenePass.getTextureNode('normal');
+        scenePass.getTexture('diffuseColor').type = UnsignedByteType;
+        scenePass.getTexture('normal').type = UnsignedByteType;
+        const sceneNormal = sample((uv) => unpackRGBToNormal(scenePassNormal.sample(uv)));
+        const giPass = ssgi(scenePassColor, scenePassDepth, sceneNormal, camera);
+        giPass.sliceCount.value = SSGI_PARAMS.sliceCount;
+        giPass.stepCount.value = SSGI_PARAMS.stepCount;
+        giPass.radius.value = SSGI_PARAMS.radius;
+        giPass.expFactor.value = SSGI_PARAMS.expFactor;
+        giPass.thickness.value = SSGI_PARAMS.thickness;
+        giPass.backfaceLighting.value = SSGI_PARAMS.backfaceLighting;
+        giPass.aoIntensity.value = SSGI_PARAMS.aoIntensity;
+        giPass.giIntensity.value = SSGI_PARAMS.giIntensity;
+        giPass.useLinearThickness.value = SSGI_PARAMS.useLinearThickness;
+        giPass.useScreenSpaceSampling.value = SSGI_PARAMS.useScreenSpaceSampling;
+        giPass.useTemporalFiltering = SSGI_PARAMS.useTemporalFiltering;
+        // r185: SSGI's AO lives in its own single-channel texture (getAONode)
+        // rather than the alpha of one packed rgba texture.
+        const aoTexture = giPass.getAONode();
+        const aoAsRgb = vec4(aoTexture.r, aoTexture.r, aoTexture.r, float(1));
+        const denoisePass = denoise(aoAsRgb, scenePassDepth, sceneNormal, camera);
+        denoisePass.index.value = 0;
+        denoisePass.radius.value = 4;
+        // Same far-field AO fade as the viewport pipeline — without it the
+        // horizon picks up a visible AO line in captures.
+        const aoFarFade = smoothstep(float(0.9994), float(0.9998), scenePassDepth.sample(screenUV).r);
+        const ao = mix(denoisePass.r, float(1), aoFarFade);
+        const aoRgb = scenePassColor.rgb.mul(ao);
+        // Ink edges, mirroring the viewport pipeline (AO → ink → grade) so
+        // captures carry the same soft/strong edge look the canvas shows.
+        // Uniform-gated like grade/backdrop: one cached pipeline serves all modes.
+        // Radius scales with render height: a supersampled capture (4K → 1080p)
+        // would otherwise halve the apparent line weight vs the viewport's 1px.
+        const inkRadius = Math.max(1, Math.round(renderer.domElement.height / 1080));
+        const inkedRgb = inkedEdges({
+            sceneRgb: aoRgb,
+            depthTex: scenePassDepth,
+            normalTex: scenePassNormal,
+            inkColor: inkColorUniform,
+            radius: inkRadius,
+            opacity: float(inkOpacityUniform).mul(inkOpacityScaleUniform),
+        });
+        const ungradedSceneRgb = mix(aoRgb, inkedRgb, inkMixUniform);
+        const gradeRgb = (rgb) => saturation(rgb.div(0.18).pow(vec3(GRADE_PARAMS.contrast)).mul(0.18), GRADE_PARAMS.saturation);
+        const sceneRgb = mix(ungradedSceneRgb, gradeRgb(ungradedSceneRgb), gradeMixUniform);
+        // Per-pixel world ray from the capture camera → sky gradient above the
+        // horizon (dir.y = 0), flat background below — mirrors the viewport
+        // backdrop. bgMix 0 bypasses it and keeps the capture transparent.
+        const ndc = vec4(screenUV.x.mul(2).sub(1), float(1).sub(screenUV.y).mul(2).sub(1), 1, 1);
+        const viewRay = bgProjInvUniform.mul(ndc);
+        const worldDir = bgCamWorldUniform.mul(vec4(viewRay.xyz, 0)).xyz.normalize();
+        const ungradedBgGradient = backdropGradient({
+            dirY: worldDir.y,
+            background: bgColorUniform,
+            haze: bgHazeUniform,
+            sky: bgSkyUniform,
+            skyDeep: bgSkyDeepUniform,
+        });
+        const bgGradient = mix(ungradedBgGradient, gradeRgb(ungradedBgGradient), gradeMixUniform);
+        const alpha = scenePassColor.a;
+        const finalOutput = vec4(mix(sceneRgb, mix(bgGradient, sceneRgb, alpha), bgMixUniform), mix(alpha, float(1), bgMixUniform));
+        // FXAA requires a texture node as input; convertToTexture renders finalOutput
+        // into an intermediate RT so FXAA can sample it with neighbour UV offsets.
+        const aaOutput = fxaa(convertToTexture(finalOutput));
+        const pipeline = new RenderPipeline(renderer);
+        pipeline.outputNode = aaOutput;
+        // Dedicated render target — pipeline outputs here instead of the canvas,
+        // so R3F's main render loop can never overwrite our capture.
+        const { width, height } = renderer.domElement;
+        const renderTarget = new RenderTarget(width, height, { depthBuffer: true });
+        return {
+            applyEnvironment: ({ theme, transparent, grade, edges, camera: captureCamera }) => {
+                const sceneTheme = getSceneTheme(theme);
+                inkMixUniform.value = edges === 'off' ? 0 : 1;
+                inkOpacityUniform.value = edges === 'strong' ? 1 : 0.5;
+                inkColorUniform.value.set(edgeColorFor(sceneTheme.background));
+                inkOpacityScaleUniform.value = edgeOpacityScaleFor(sceneTheme.background);
+                bgColorUniform.value.set(sceneTheme.background);
+                bgSkyUniform.value.set(sceneTheme.backgroundSky ?? sceneTheme.background);
+                bgSkyDeepUniform.value.set(deepSkyColor(sceneTheme.backgroundSky ?? sceneTheme.background));
+                bgHazeUniform.value.set(horizonHazeColor(sceneTheme.backgroundSky ?? sceneTheme.background, sceneTheme.appearance));
+                bgMixUniform.value = transparent ? 0 : 1;
+                gradeMixUniform.value = grade ? 1 : 0;
+                // The capture camera never joins the scene graph, so its matrixWorld
+                // is only refreshed by the render itself — too late for the backdrop
+                // uniforms below.
+                captureCamera.updateMatrixWorld();
+                bgProjInvUniform.value.copy(captureCamera.projectionMatrixInverse);
+                bgCamWorldUniform.value.copy(captureCamera.matrixWorld);
+            },
+            capture: async ({ captureMode, cropRegion, standardSize }) => {
+                const standardW = standardSize?.w ?? THUMBNAIL_WIDTH;
+                const standardH = standardSize?.h ?? THUMBNAIL_HEIGHT;
+                const { width: captureWidth, height: captureHeight } = renderer.domElement;
+                // Resize RT if the canvas dimensions changed
+                if (renderTarget.width !== captureWidth || renderTarget.height !== captureHeight) {
+                    renderTarget.setSize(captureWidth, captureHeight);
+                }
+                try {
+                    ;
+                    renderer.setClearAlpha(0);
+                    renderer.setRenderTarget(renderTarget);
+                    pipeline.render();
+                }
+                finally {
+                    renderer.setRenderTarget(null);
+                }
+                // Let callers restore visibility and other capture policy immediately
+                // after the render, before the asynchronous GPU readback begins.
+                await Promise.resolve();
+                // Read pixels from the RT asynchronously.
+                // WebGPU copyTextureToBuffer aligns each row to 256 bytes, so we must
+                // depad the rows before constructing ImageData.
+                const pixels = (await renderer.readRenderTargetPixelsAsync(renderTarget, 0, 0, captureWidth, captureHeight));
+                const actualBytesPerRow = captureWidth * 4;
+                const tightTotal = actualBytesPerRow * captureHeight;
+                const paddedBytesPerRow = Math.ceil(actualBytesPerRow / 256) * 256;
+                // Two readback shapes to handle:
+                // - WebGPU (`copyTextureToBuffer`): top-down + 256-byte row padding
+                //   when width*4 isn't already a multiple of 256.
+                // - WebGL2 fallback (iOS Chrome, etc.): tightly-packed but bottom-up
+                //   (OpenGL framebuffer convention).
+                // `isWebGPURenderer` lies — it stays true even when the renderer
+                // falls back to the WebGL backend. Inspect the actual backend
+                // instead (presence of a GPU device, or backend constructor name).
+                const backend = renderer.backend;
+                const isWebGPU = !!backend?.device ||
+                    backend?.isWebGPUBackend === true ||
+                    backend?.constructor?.name === 'WebGPUBackend';
+                let tightPixels;
+                if (isWebGPU) {
+                    // WebGPU: depad rows if needed; orientation is already top-down.
+                    if (paddedBytesPerRow === actualBytesPerRow) {
+                        tightPixels = new Uint8ClampedArray(pixels.buffer, pixels.byteOffset, Math.min(pixels.byteLength, tightTotal));
+                    }
+                    else {
+                        tightPixels = new Uint8ClampedArray(tightTotal);
+                        for (let row = 0; row < captureHeight; row++) {
+                            tightPixels.set(pixels.subarray(row * paddedBytesPerRow, row * paddedBytesPerRow + actualBytesPerRow), row * actualBytesPerRow);
+                        }
+                    }
+                }
+                else {
+                    // WebGL2: tight buffer in bottom-up order — flip rows.
+                    tightPixels = new Uint8ClampedArray(tightTotal);
+                    for (let row = 0; row < captureHeight; row++) {
+                        const srcStart = (captureHeight - 1 - row) * actualBytesPerRow;
+                        tightPixels.set(pixels.subarray(srcStart, srcStart + actualBytesPerRow), row * actualBytesPerRow);
+                    }
+                }
+                const imageData = new ImageData(tightPixels, captureWidth, captureHeight);
+                const srcCanvas = new OffscreenCanvas(captureWidth, captureHeight);
+                srcCanvas.getContext('2d').putImageData(imageData, 0, 0);
+                let outW;
+                let outH;
+                let blob;
+                if (captureMode === 'viewport') {
+                    outW = captureWidth;
+                    outH = captureHeight;
+                    const offscreen = new OffscreenCanvas(outW, outH);
+                    offscreen.getContext('2d').drawImage(srcCanvas, 0, 0);
+                    blob = await offscreen.convertToBlob({ type: 'image/png' });
+                }
+                else if (captureMode === 'area' && cropRegion) {
+                    const sx = Math.round(cropRegion.x * captureWidth);
+                    const sy = Math.round(cropRegion.y * captureHeight);
+                    outW = Math.round(cropRegion.width * captureWidth);
+                    outH = Math.round(cropRegion.height * captureHeight);
+                    const offscreen = new OffscreenCanvas(outW, outH);
+                    offscreen.getContext('2d').drawImage(srcCanvas, sx, sy, outW, outH, 0, 0, outW, outH);
+                    blob = await offscreen.convertToBlob({ type: 'image/png' });
+                }
+                else {
+                    // Standard: center-crop to the requested aspect (default 1920×1080)
+                    const srcAspect = captureWidth / captureHeight;
+                    const dstAspect = standardW / standardH;
+                    let sx = 0;
+                    let sy = 0;
+                    let sWidth = captureWidth;
+                    let sHeight = captureHeight;
+                    if (srcAspect > dstAspect) {
+                        sWidth = Math.round(captureHeight * dstAspect);
+                        sx = Math.round((captureWidth - sWidth) / 2);
+                    }
+                    else if (srcAspect < dstAspect) {
+                        sHeight = Math.round(captureWidth / dstAspect);
+                        sy = Math.round((captureHeight - sHeight) / 2);
+                    }
+                    outW = standardW;
+                    outH = standardH;
+                    const offscreen = new OffscreenCanvas(outW, outH);
+                    offscreen
+                        .getContext('2d')
+                        .drawImage(srcCanvas, sx, sy, sWidth, sHeight, 0, 0, outW, outH);
+                    blob = await offscreen.convertToBlob({ type: 'image/png' });
+                }
+                return { blob, outW, outH };
+            },
+            dispose: () => {
+                pipeline.dispose();
+                renderTarget.dispose();
+            },
+        };
+    }
+    catch (error) {
+        console.error('[thumbnail] Failed to build post-processing pipeline, will use fallback render.', error);
+        return null;
+    }
+}

package/dist/lib/terrain-perimeter-fill.d.ts

@@ -0,0 +1,7 @@
+import { BufferGeometry } from 'three';
+export type TerrainPerimeterPoint = {
+    x: number;
+    z: number;
+};
+export declare function buildTerrainPerimeterFillGeometry(points: readonly TerrainPerimeterPoint[], bottomY: readonly number[], topY: number, epsilon?: number): BufferGeometry | null;
+//# sourceMappingURL=terrain-perimeter-fill.d.ts.map

package/dist/lib/terrain-perimeter-fill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain-perimeter-fill.d.ts","sourceRoot":"","sources":["../../src/lib/terrain-perimeter-fill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAA+C,MAAM,OAAO,CAAA;AAGnF,MAAM,MAAM,qBAAqB,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAE5D,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,SAAS,qBAAqB,EAAE,EACxC,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,SAAO,GACb,cAAc,GAAG,IAAI,CA2EvB"}

package/dist/lib/terrain-perimeter-fill.js

@@ -0,0 +1,75 @@
+import { BufferGeometry, Float32BufferAttribute, ShapeUtils, Vector2 } from 'three';
+import { ensureRenderableGeometryAttributes } from './csg-utils';
+export function buildTerrainPerimeterFillGeometry(points, bottomY, topY, epsilon = 1e-6) {
+    if (points.length < 3 || bottomY.length !== points.length)
+        return null;
+    if (bottomY.every((y) => y >= topY - epsilon))
+        return null;
+    let signedArea = 0;
+    for (let index = 0; index < points.length; index += 1) {
+        const a = points[index];
+        const b = points[(index + 1) % points.length];
+        signedArea += a.x * b.z - b.x * a.z;
+    }
+    const counterClockwise = signedArea > 0;
+    const positions = [];
+    const push = (point, y) => {
+        positions.push(point.x, y, point.z);
+    };
+    for (let index = 0; index < points.length; index += 1) {
+        const next = (index + 1) % points.length;
+        const a = points[index];
+        const b = points[next];
+        const ay = bottomY[index];
+        const by = bottomY[next];
+        if (ay >= topY - epsilon && by >= topY - epsilon)
+            continue;
+        if (counterClockwise) {
+            push(a, topY);
+            push(b, by);
+            push(a, ay);
+            push(a, topY);
+            push(b, topY);
+            push(b, by);
+        }
+        else {
+            push(a, topY);
+            push(a, ay);
+            push(b, by);
+            push(a, topY);
+            push(b, by);
+            push(b, topY);
+        }
+    }
+    const faces = ShapeUtils.triangulateShape(points.map((point) => new Vector2(point.x, point.z)), []);
+    for (const face of faces) {
+        const [ia, ib, ic] = face;
+        if (ia == null || ib == null || ic == null)
+            continue;
+        if (bottomY[ia] >= topY - epsilon &&
+            bottomY[ib] >= topY - epsilon &&
+            bottomY[ic] >= topY - epsilon) {
+            continue;
+        }
+        const a = points[ia];
+        const b = points[ib];
+        const c = points[ic];
+        const cross = (b.x - a.x) * (c.z - a.z) - (b.z - a.z) * (c.x - a.x);
+        push(a, bottomY[ia]);
+        if (cross >= 0) {
+            push(b, bottomY[ib]);
+            push(c, bottomY[ic]);
+        }
+        else {
+            push(c, bottomY[ic]);
+            push(b, bottomY[ib]);
+        }
+    }
+    if (positions.length === 0)
+        return null;
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
+    geometry.computeVertexNormals();
+    ensureRenderableGeometryAttributes(geometry);
+    return geometry;
+}

package/dist/lib/texture-node-guard.d.ts

@@ -0,0 +1,13 @@
+/**
+ * three's node system pulls texture uniforms from materials each frame via
+ * reference nodes, and several override-material passes (shadow, depth/normal
+ * prepasses) copy per-object texture slots onto shared materials whose cached
+ * per-mesh node graphs can disagree about a slot's presence. When they do,
+ * `TextureNode.update` dereferences a null texture and the exception kills the
+ * whole render pass — the scene goes black. Substitute a 1×1 black fallback
+ * instead (skipping is not enough: the null would still reach the backend's
+ * texture-binding WeakMap). The slot renders black for a frame and recovers
+ * as soon as the reference pulls a real value again.
+ */
+export declare function installTextureNodeNullGuard(): void;
+//# sourceMappingURL=texture-node-guard.d.ts.map

package/dist/lib/texture-node-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"texture-node-guard.d.ts","sourceRoot":"","sources":["../../src/lib/texture-node-guard.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,IAAI,IAAI,CAiBlD"}

package/dist/lib/texture-node-guard.js

@@ -0,0 +1,39 @@
+import { DataTexture, TextureNode } from 'three/webgpu';
+let installed = false;
+let reported = 0;
+let fallbackTexture = null;
+function getFallbackTexture() {
+    if (!fallbackTexture) {
+        fallbackTexture = new DataTexture(new Uint8Array([0, 0, 0, 255]), 1, 1);
+        fallbackTexture.needsUpdate = true;
+    }
+    return fallbackTexture;
+}
+/**
+ * three's node system pulls texture uniforms from materials each frame via
+ * reference nodes, and several override-material passes (shadow, depth/normal
+ * prepasses) copy per-object texture slots onto shared materials whose cached
+ * per-mesh node graphs can disagree about a slot's presence. When they do,
+ * `TextureNode.update` dereferences a null texture and the exception kills the
+ * whole render pass — the scene goes black. Substitute a 1×1 black fallback
+ * instead (skipping is not enough: the null would still reach the backend's
+ * texture-binding WeakMap). The slot renders black for a frame and recovers
+ * as soon as the reference pulls a real value again.
+ */
+export function installTextureNodeNullGuard() {
+    if (installed)
+        return;
+    installed = true;
+    const prototype = TextureNode.prototype;
+    const originalUpdate = prototype.update;
+    prototype.update = function update() {
+        if (this.value == null) {
+            if (reported < 5) {
+                reported += 1;
+                console.warn(`[viewer] TextureNode ${this.uuid} has no texture — using fallback`);
+            }
+            this.value = getFallbackTexture();
+        }
+        originalUpdate.call(this);
+    };
+}

package/dist/lib/texture-reference.d.ts

@@ -0,0 +1,31 @@
+import type * as THREE from 'three';
+export type PascalTextureMap = 'basecolor' | 'normal' | 'roughness' | 'metalness' | 'height' | 'other';
+export type PascalTextureColorSpace = 'srgb' | 'linear';
+type PascalTextureRefBase = {
+    v: 1;
+    src: string;
+    map: PascalTextureMap;
+    colorSpace: PascalTextureColorSpace;
+};
+export type PascalTextureRef = (PascalTextureRefBase & {
+    kind: 'library-material' | 'app-material' | 'project-asset';
+}) | (PascalTextureRefBase & {
+    kind: 'item-glb';
+    imageIndex: number;
+});
+export declare function textureMapForSlot(slot: string): PascalTextureMap;
+export declare function stampPascalTextureRef(texture: THREE.Texture, input: {
+    /** 'material' resolves to library-material (storage bucket) or
+     *  app-material (static catalog on the assets CDN) by URL shape. */
+    kind: 'material' | 'project-asset';
+    src: string;
+    slot: string;
+} | {
+    kind: 'item-glb';
+    src: string;
+    slot: string;
+    imageIndex: number;
+}): PascalTextureRef | null;
+export declare function getPascalTextureRef(texture: THREE.Texture): PascalTextureRef | null;
+export {};
+//# sourceMappingURL=texture-reference.d.ts.map

package/dist/lib/texture-reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"texture-reference.d.ts","sourceRoot":"","sources":["../../src/lib/texture-reference.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AAGnC,MAAM,MAAM,gBAAgB,GACxB,WAAW,GACX,QAAQ,GACR,WAAW,GACX,WAAW,GACX,QAAQ,GACR,OAAO,CAAA;AAEX,MAAM,MAAM,uBAAuB,GAAG,MAAM,GAAG,QAAQ,CAAA;AAEvD,KAAK,oBAAoB,GAAG;IAC1B,CAAC,EAAE,CAAC,CAAA;IACJ,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,gBAAgB,CAAA;IACrB,UAAU,EAAE,uBAAuB,CAAA;CACpC,CAAA;AAED,MAAM,MAAM,gBAAgB,GACxB,CAAC,oBAAoB,GAAG;IACtB,IAAI,EAAE,kBAAkB,GAAG,cAAc,GAAG,eAAe,CAAA;CAC5D,CAAC,GACF,CAAC,oBAAoB,GAAG;IACtB,IAAI,EAAE,UAAU,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAC,CAAA;AAqDN,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,CAgBhE;AAMD,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,KAAK,CAAC,OAAO,EACtB,KAAK,EACD;IACE;wEACoE;IACpE,IAAI,EAAE,UAAU,GAAG,eAAe,CAAA;IAClC,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb,GACD;IACE,IAAI,EAAE,UAAU,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;CACnB,GACJ,gBAAgB,GAAG,IAAI,CA6BzB;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,GAAG,gBAAgB,GAAG,IAAI,CAmCnF"}

package/dist/lib/texture-reference.js

@@ -0,0 +1,139 @@
+import { ASSETS_CDN_URL } from './asset-url';
+const STORAGE_BUCKET_BY_KIND = {
+    'library-material': 'materials',
+    'item-glb': 'items',
+    'project-asset': 'project-assets',
+};
+let cachedStorageOrigin;
+function pascalStorageOrigin() {
+    if (cachedStorageOrigin !== undefined)
+        return cachedStorageOrigin;
+    try {
+        const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
+        cachedStorageOrigin = url ? new URL(url).origin : null;
+    }
+    catch {
+        cachedStorageOrigin = null;
+    }
+    return cachedStorageOrigin;
+}
+/** Static catalog materials ship in the app's public dir and resolve through
+ *  the assets CDN (`/material/{category}/{slug}/{slug}_{map}_{size}.ktx2`) —
+ *  a server-known KTX2 source like the storage buckets, just app-hosted. */
+function isAppMaterialUrl(src) {
+    try {
+        const url = new URL(src);
+        return url.origin === new URL(ASSETS_CDN_URL).origin && url.pathname.startsWith('/material/');
+    }
+    catch {
+        return false;
+    }
+}
+const TEXTURE_MAPS = new Set([
+    'basecolor',
+    'normal',
+    'roughness',
+    'metalness',
+    'height',
+    'other',
+]);
+function isPascalStorageUrl(src, kind) {
+    const origin = pascalStorageOrigin();
+    if (!origin)
+        return false;
+    try {
+        const url = new URL(src);
+        const bucket = STORAGE_BUCKET_BY_KIND[kind];
+        return url.origin === origin && url.pathname.startsWith(`/storage/v1/object/public/${bucket}/`);
+    }
+    catch {
+        return false;
+    }
+}
+export function textureMapForSlot(slot) {
+    switch (slot) {
+        case 'map':
+            return 'basecolor';
+        case 'normalMap':
+            return 'normal';
+        case 'roughnessMap':
+            return 'roughness';
+        case 'metalnessMap':
+            return 'metalness';
+        case 'displacementMap':
+        case 'bumpMap':
+            return 'height';
+        default:
+            return 'other';
+    }
+}
+function textureColorSpace(texture) {
+    return texture.colorSpace === 'srgb' ? 'srgb' : 'linear';
+}
+export function stampPascalTextureRef(texture, input) {
+    const base = {
+        v: 1,
+        src: input.src,
+        map: textureMapForSlot(input.slot),
+        colorSpace: textureColorSpace(texture),
+    };
+    let ref;
+    if (input.kind === 'item-glb') {
+        if (!isPascalStorageUrl(input.src, 'item-glb'))
+            return null;
+        if (!Number.isInteger(input.imageIndex) || input.imageIndex < 0)
+            return null;
+        ref = { ...base, kind: 'item-glb', imageIndex: input.imageIndex };
+    }
+    else {
+        const kind = input.kind === 'material'
+            ? isPascalStorageUrl(input.src, 'library-material')
+                ? 'library-material'
+                : isAppMaterialUrl(input.src)
+                    ? 'app-material'
+                    : null
+            : isPascalStorageUrl(input.src, 'project-asset')
+                ? 'project-asset'
+                : null;
+        if (!kind)
+            return null;
+        ref = { ...base, kind };
+    }
+    texture.userData.pascalTextureRef = ref;
+    return ref;
+}
+export function getPascalTextureRef(texture) {
+    const raw = texture.userData.pascalTextureRef;
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const candidate = raw;
+    const kind = candidate.kind;
+    if (candidate.v !== 1 ||
+        (kind !== 'library-material' &&
+            kind !== 'app-material' &&
+            kind !== 'item-glb' &&
+            kind !== 'project-asset') ||
+        typeof candidate.src !== 'string' ||
+        !(kind === 'app-material'
+            ? isAppMaterialUrl(candidate.src)
+            : isPascalStorageUrl(candidate.src, kind)) ||
+        typeof candidate.map !== 'string' ||
+        !TEXTURE_MAPS.has(candidate.map) ||
+        (candidate.colorSpace !== 'srgb' && candidate.colorSpace !== 'linear')) {
+        return null;
+    }
+    const base = {
+        v: 1,
+        src: candidate.src,
+        map: candidate.map,
+        colorSpace: candidate.colorSpace,
+    };
+    if (kind === 'item-glb') {
+        if (!Number.isInteger(candidate.imageIndex) || candidate.imageIndex < 0)
+            return null;
+        return { ...base, kind, imageIndex: candidate.imageIndex };
+    }
+    if (candidate.imageIndex !== undefined)
+        return null;
+    return { ...base, kind };
+}

package/dist/lib/texture-reference.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=texture-reference.test.d.ts.map

package/dist/lib/texture-reference.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"texture-reference.test.d.ts","sourceRoot":"","sources":["../../src/lib/texture-reference.test.ts"],"names":[],"mappings":""}