@3driseai/3drise-viewer 0.1.42 → 0.1.43

package/dist/components/urban/core/traffic.js

@@ -0,0 +1,305 @@
+// Emitted from Claude outputs/urban-lab/traffic.mjs by emit_object.mjs — edit the lab module and re-emit.
+// =============================================================================
+// urban/traffic — headlight and tail-light streams along a road at night, and small cars (showCars)
+// =============================================================================
+// Construction. The polyline (points, curve — the same path as a road) is sampled and
+// baked into a small float texture: row 0 the positions, row 1 the tangents, over the
+// arc length. Every car is four camera-facing sprites (two white head lamps, two red tail
+// lamps) in ONE instanced draw: the vertex shader advances the car's phase along the path
+// at `speed`, wraps it, reads position and tangent from the texture, offsets it to its lane
+// (right-hand traffic: the two halves of the road run opposite ways), puts the head pair
+// at the front and the tail pair at the back, and sizes the sprite in pixels. The fragment
+// is a soft disc with a halo (premultiplied, additive-looking), brighter than 1 so bloom
+// picks it up. Nothing is drawn by day (the night factor gates it), the motion is along the
+// object's own path (internal).
+// Cars (showCars): the family's low-poly crowd car (common buildCarGeometry, ~80 triangles) as ONE
+// more instanced draw per stream, one instance per car; lamps and body share ONE car frame in the
+// vertex shader (GLSL_CAR_FRAME: the centre on the path, the ends at fixed offsets along its forward —
+// the lamps at the ends, the body between them; hidden while crossing the path's ends), painted from
+// CAR_PALETTE, shaded like the street furniture (sun + the lamp list / a street grid's lamp field).
+// Visible day and night; no CPU per frame, no shadows.
+import * as THREE from 'three';
+import { mulberry32, createSunUniforms, createLampUniforms, GLSL_FOG_PARS, GLSL_FOG_VERT_PARS, samplePath, FIXTURE_FRAG, buildCarGeometry, CAR_PALETTE } from '../urbanCore.js';
+export const LIGHTING = ['auto', 'day', 'night'];
+export const STRUCTURAL = ['points', 'curve', 'lanes', 'laneWidth', 'density', 'jitter', 'showCars', 'seed'];
+export function createUniforms() {
+    // the sun block for the sprites' night factor, plus the lamp list and the fixture knobs the cars' shading reads
+    return Object.assign(createSunUniforms(), createLampUniforms(), {
+        uPaint: { value: new THREE.Color('#ffffff') },
+        uAccent: { value: new THREE.Color('#15171a') },
+        uLampColor: { value: new THREE.Color('#ffd9a0') },
+        uLampGlow: { value: 0 },
+        uRough: { value: 0.35 },
+        uPath: { value: null },
+        uPathLength: { value: 1 },
+        uTime: { value: 0 },
+        uSpeed: { value: 12.5 }, // m/s
+        uLaneWidth: { value: 3.5 },
+        uWidth: { value: 7 },
+        uHead: { value: new THREE.Color() },
+        uTail: { value: new THREE.Color() },
+        uIntensity: { value: 1 },
+        uSize: { value: 1 },
+    });
+}
+export function applyConfig(u, c) {
+    if (c.speed !== undefined)
+        u.uSpeed.value = c.speed / 3.6;
+    if (c.headlightColor !== undefined)
+        u.uHead.value.set(c.headlightColor);
+    if (c.taillightColor !== undefined)
+        u.uTail.value.set(c.taillightColor);
+    if (c.intensity !== undefined)
+        u.uIntensity.value = c.intensity;
+    if (c.size !== undefined)
+        u.uSize.value = c.size;
+    if (c.lanes !== undefined && c.laneWidth !== undefined) {
+        u.uLaneWidth.value = c.laneWidth;
+        u.uWidth.value = Math.max(1, Math.round(c.lanes)) * c.laneWidth;
+    }
+}
+// ONE car frame, shared by the lamps and the car body (so they can never drift apart): the car's
+// centre on the path in its lane, read ONCE, and its forward from the path's tangent there; its two
+// ends (where its head and tail lamps sit) are fixed offsets 2.3 m either way along that forward.
+// The path texture is not evenly spaced (cars slow near junctions — wanted), so reading the two ends
+// from the path on their own squeezed and stretched a car's lamps (0.2–10 m apart instead of 4.6 m).
+// A car crossing either end of the path is hidden (lamps and body together).
+const GLSL_CAR_FRAME = /* glsl */ `
+uniform sampler2D uPath; uniform float uPathLength; uniform float uTime; uniform float uSpeed;
+const float CAR_HALF = 2.3;
+vec3 pathAt(float s, float lane) {
+    float f = clamp(s / uPathLength, 0.0, 1.0);
+    vec3 p = texture2D(uPath, vec2(f, 0.25)).xyz;
+    vec3 t = normalize(texture2D(uPath, vec2(f, 0.75)).xyz);
+    return p + vec3(-t.z, 0.0, t.x) * lane;              // to the lane: right of the path's +s direction
+}
+bool carFrame(float phase, float dir, float lane, out vec3 head, out vec3 tail) {
+    float c = phase * uPathLength + dir * uSpeed * uTime;
+    c = mod(mod(c, uPathLength) + uPathLength, uPathLength);
+    if (c < CAR_HALF || c > uPathLength - CAR_HALF) return false;
+    vec3 centre = pathAt(c, lane);
+    vec3 t = texture2D(uPath, vec2(clamp(c / uPathLength, 0.0, 1.0), 0.75)).xyz;
+    vec3 fx = normalize(vec3(t.x, 0.0, t.z) * dir);       // the car's forward (flat)
+    head = centre + fx * CAR_HALF;
+    tail = centre - fx * CAR_HALF;
+    return true;
+}`;
+export const VERT = /* glsl */ `
+attribute vec2 corner;        // quad corner -1..1
+attribute float aLane;        // lane centre offset across the road (metres, signed)
+attribute float aDir;         // +1 along the path, -1 against
+attribute float aPhase;       // 0..1 the car's start along the path
+attribute float aKind;        // 0 head, 1 tail
+attribute float aSide;        // -1 left lamp, +1 right lamp
+uniform float uSize; uniform float uNight;
+varying vec2 vUv; varying float vKind;
+${GLSL_FOG_VERT_PARS}
+${GLSL_CAR_FRAME}
+void main() {
+    vUv = corner; vKind = aKind;
+    vec3 head, tail;
+    if (!carFrame(aPhase, aDir, aLane, head, tail)) { gl_Position = vec4(0.0, 0.0, 2.0, 1.0); return; }   // past the path's end: clipped
+    // the lamp pair at the car's end, 0.75 m either side of its axis, at lamp height
+    vec3 fx = normalize(vec3(head.x - tail.x, 0.0, head.z - tail.z));
+    vec3 fz = vec3(-fx.z, 0.0, fx.x);
+    vec3 p = (aKind < 0.5 ? head : tail) + fz * (aSide * 0.75) + vec3(0.0, 0.65, 0.0);
+    vec4 mvPosition = modelViewMatrix * vec4(p, 1.0);
+    // Camera-facing quad with a constant size on screen: px pixels on a 900 px tall viewport
+    // (bigger for head lamps). projectionMatrix[1][1] is 1 / tan(fov / 2), so the half-size in
+    // view space at depth d is px / 900 * d / P11. Clamped below so a close lamp stays a lamp.
+    // The floor scales with the object (a city scaled down keeps its lamps lamp-sized).
+    float sc = length(modelMatrix[0].xyz);
+    float px = (aKind < 0.5 ? 11.0 : 7.0) * uSize;
+    float d = max(-mvPosition.z, 0.5 * sc);
+    float h = max(px / 900.0 * d / projectionMatrix[1][1], 0.09 * sc);
+    mvPosition.xy += corner * h;
+    gl_Position = projectionMatrix * mvPosition;
+    #include <fog_vertex>
+}`;
+export const FRAG = /* glsl */ `
+precision highp float;
+uniform vec3 uHead; uniform vec3 uTail; uniform float uIntensity; uniform float uNight;
+varying vec2 vUv; varying float vKind;
+${GLSL_FOG_PARS}
+void main() {
+    float r = length(vUv);
+    if (r > 1.0) discard;
+    // A hot core with a soft halo; premultiplied, so it adds light without a square.
+    float core = 1.0 / exp(r * r * 9.0);
+    float halo = 1.0 / exp(r * 2.2) * 0.35;
+    float a = clamp(core + halo, 0.0, 1.0);
+    vec3 c = mix(uHead, uTail, vKind) * (vKind < 0.5 ? 2.4 : 1.6) * uIntensity * uNight;
+    vec3 col = c * (core * 1.0 + halo);
+    gl_FragColor = vec4(col, a * uNight);
+    #include <tonemapping_fragment>
+    #include <colorspace_fragment>
+    #include <fog_fragment>
+}`;
+// The cars: the low-poly car geometry (+x forward, y up) carried along the path like the lamps.
+export const CAR_VERT = /* glsl */ `
+attribute float aEmissive; attribute float aAccent;
+attribute float aLane; attribute float aDir; attribute float aPhase; attribute vec3 aPaint;
+varying vec3 vN; varying vec3 vP; varying float vE; varying float vA; varying vec3 vIC;
+${GLSL_FOG_VERT_PARS}
+${GLSL_CAR_FRAME}
+void main() {
+    vE = aEmissive; vA = aAccent; vIC = aPaint; vN = vec3(0.0, 1.0, 0.0); vP = vec3(0.0);
+    vec3 head, tail;
+    if (!carFrame(aPhase, aDir, aLane, head, tail)) { gl_Position = vec4(0.0, 0.0, 2.0, 1.0); return; }   // past the path's end: clipped
+    // the body between its lamps: centred on them, facing from tail to head (so a turn bends both alike)
+    vec3 fx = normalize(vec3(head.x - tail.x, 0.0, head.z - tail.z));
+    vec3 fz = vec3(-fx.z, 0.0, fx.x);
+    vec3 c = (head + tail) * 0.5;
+    vec3 local = fx * position.x + vec3(0.0, position.y, 0.0) + fz * position.z;
+    vec4 wp = modelMatrix * vec4(c + local, 1.0);
+    vP = wp.xyz;
+    vN = normalize(mat3(modelMatrix) * (fx * normal.x + vec3(0.0, normal.y, 0.0) + fz * normal.z));
+    vec4 mvPosition = viewMatrix * wp;
+    gl_Position = projectionMatrix * mvPosition;
+    #include <fog_vertex>
+}`;
+export function createCarMaterial(u) {
+    return new THREE.ShaderMaterial({ uniforms: Object.assign(THREE.UniformsUtils.clone(THREE.UniformsLib.fog), u), vertexShader: CAR_VERT, fragmentShader: FIXTURE_FRAG, fog: true });
+}
+export function createMaterial(u) {
+    return new THREE.ShaderMaterial({
+        uniforms: Object.assign(THREE.UniformsUtils.clone(THREE.UniformsLib.fog), u), vertexShader: VERT, fragmentShader: FRAG, fog: true,
+        transparent: true, depthWrite: false, blending: THREE.CustomBlending, blendSrc: THREE.OneFactor, blendDst: THREE.OneMinusSrcAlphaFactor,
+    });
+}
+/** The path as a 2-row float texture: positions and tangents sampled uniformly over the arc length. */
+export function pathTexture(samples) {
+    const n = Math.max(2, samples.length);
+    const data = new Float32Array(n * 2 * 4);
+    for (let i = 0; i < n; i++) {
+        const S = samples[Math.min(i, samples.length - 1)];
+        data.set([S.p.x, S.p.y, S.p.z, S.s], i * 4);
+        data.set([S.t.x, S.t.y, S.t.z, 0], (n + i) * 4);
+    }
+    const tex = new THREE.DataTexture(data, n, 2, THREE.RGBAFormat, THREE.FloatType);
+    tex.minFilter = THREE.LinearFilter;
+    tex.magFilter = THREE.LinearFilter;
+    tex.wrapS = THREE.ClampToEdgeWrapping;
+    tex.wrapT = THREE.ClampToEdgeWrapping;
+    tex.needsUpdate = true;
+    return tex;
+}
+/** The cars as instance attributes: per lane, density x length / 100 cars with jittered spacing; 4 sprites each. */
+export function carInstances(c, length) {
+    const rng = mulberry32(c.seed * 2713 + 1);
+    const lanes = Math.max(1, Math.round(c.lanes)), W = lanes * c.laneWidth;
+    const lane = [], dir = [], phase = [], kind = [], side = [];
+    const car = { lane: [], dir: [], phase: [], paint: [] }; // one per car (showCars)
+    const col = new THREE.Color();
+    for (let l = 0; l < lanes; l++) {
+        const t = -W / 2 + (l + 0.5) * c.laneWidth;
+        // Right-hand traffic: lanes right of the centre line (t > 0) travel +s, the others -s.
+        const d = t > 0 ? 1 : -1;
+        const k = Math.max(1, Math.round(c.density * length / 100));
+        for (let i = 0; i < k; i++) {
+            const ph = (i + 0.5 + (rng() - 0.5) * c.jitter * 0.9) / k;
+            for (const kd of [0, 1])
+                for (const sd of [-1, 1]) {
+                    lane.push(t);
+                    dir.push(d);
+                    phase.push(ph);
+                    kind.push(kd);
+                    side.push(sd);
+                }
+            col.set(CAR_PALETTE[Math.floor(rng() * CAR_PALETTE.length)]);
+            car.lane.push(t);
+            car.dir.push(d);
+            car.phase.push(ph);
+            car.paint.push(col.r, col.g, col.b);
+        }
+    }
+    return { lane, dir, phase, kind, side, count: lane.length, car };
+}
+export function build(u, c) {
+    const group = new THREE.Group();
+    // The path uniforms are this stream's own; everything else (sun, knobs, time) stays the SHARED
+    // objects of `u`, so a grid can hand one set to every street and the ring alike.
+    const pu = Object.assign({}, u, { uPath: { value: null }, uPathLength: { value: 1 } });
+    const mat = createMaterial(pu);
+    const carMat = createCarMaterial(pu);
+    let mesh = null, tex = null, carMesh = null, carGeo = null;
+    const rebuild = (cfg) => {
+        if (mesh) {
+            group.remove(mesh);
+            mesh.geometry.dispose();
+            mesh = null;
+        }
+        if (carMesh) {
+            group.remove(carMesh);
+            carMesh.geometry.dispose();
+            carMesh = null;
+        }
+        if (tex) {
+            tex.dispose();
+            tex = null;
+        }
+        const samples = samplePath(cfg.points, cfg.curve);
+        if (samples.length < 2)
+            return;
+        const L = samples[samples.length - 1].s;
+        tex = pathTexture(samples);
+        pu.uPath.value = tex;
+        pu.uPathLength.value = L;
+        const cars = carInstances(cfg, L);
+        const geo = new THREE.InstancedBufferGeometry();
+        geo.setAttribute('position', new THREE.BufferAttribute(new Float32Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 3));
+        geo.setAttribute('corner', new THREE.BufferAttribute(new Float32Array([-1, -1, 1, -1, 1, 1, -1, 1]), 2));
+        geo.setIndex([0, 1, 2, 0, 2, 3]);
+        geo.setAttribute('aLane', new THREE.InstancedBufferAttribute(new Float32Array(cars.lane), 1));
+        geo.setAttribute('aDir', new THREE.InstancedBufferAttribute(new Float32Array(cars.dir), 1));
+        geo.setAttribute('aPhase', new THREE.InstancedBufferAttribute(new Float32Array(cars.phase), 1));
+        geo.setAttribute('aKind', new THREE.InstancedBufferAttribute(new Float32Array(cars.kind), 1));
+        geo.setAttribute('aSide', new THREE.InstancedBufferAttribute(new Float32Array(cars.side), 1));
+        geo.instanceCount = cars.count;
+        // Bounds: the path's box (selection + culling); the sprites sit on it.
+        const box = new THREE.Box3();
+        for (const s of samples)
+            box.expandByPoint(s.p);
+        box.expandByVector(new THREE.Vector3(cfg.lanes * cfg.laneWidth, 2, cfg.lanes * cfg.laneWidth));
+        geo.boundingBox = box;
+        geo.boundingSphere = box.getBoundingSphere(new THREE.Sphere());
+        mesh = new THREE.Mesh(geo, mat);
+        mesh.frustumCulled = false;
+        mesh.renderOrder = 10;
+        group.add(mesh);
+        // the cars under the lamps: one instance per car, the same phase / lane / direction
+        if (cfg.showCars && cars.car.lane.length) {
+            carGeo ??= buildCarGeometry();
+            const cg = new THREE.InstancedBufferGeometry();
+            for (const name of ['position', 'normal', 'aEmissive', 'aAccent'])
+                cg.setAttribute(name, carGeo.getAttribute(name));
+            cg.setIndex(carGeo.getIndex());
+            cg.setAttribute('aLane', new THREE.InstancedBufferAttribute(new Float32Array(cars.car.lane), 1));
+            cg.setAttribute('aDir', new THREE.InstancedBufferAttribute(new Float32Array(cars.car.dir), 1));
+            cg.setAttribute('aPhase', new THREE.InstancedBufferAttribute(new Float32Array(cars.car.phase), 1));
+            cg.setAttribute('aPaint', new THREE.InstancedBufferAttribute(new Float32Array(cars.car.paint), 3));
+            cg.instanceCount = cars.car.lane.length;
+            cg.boundingBox = box.clone();
+            cg.boundingSphere = geo.boundingSphere.clone();
+            carMesh = new THREE.Mesh(cg, carMat);
+            carMesh.frustumCulled = false;
+            group.add(carMesh);
+        }
+    };
+    rebuild(c);
+    applyConfig(u, c);
+    return {
+        object: group,
+        materials: [mat, carMat],
+        uniformSets: [u],
+        apply(cfg) { applyConfig(u, cfg); },
+        rebuild(cfg) { rebuild(cfg); applyConfig(u, cfg); },
+        bounds() { return mesh ? mesh.geometry.boundingBox.clone() : new THREE.Box3(); },
+        update(dt) { u.uTime.value += dt; },
+        dispose() { if (mesh)
+            mesh.geometry.dispose(); if (carMesh)
+            carMesh.geometry.dispose(); if (carGeo)
+            carGeo.dispose(); if (tex)
+            tex.dispose(); mat.dispose(); carMat.dispose(); },
+    };
+}

package/dist/components/urban/index.d.ts

@@ -0,0 +1,29 @@
+export * from './urbanCore';
+export * from './textureSetResolver';
+export { useUrbanInstance, resolveUrbanTextures } from './useUrbanInstance';
+export type { UrbanInstance, UrbanVariantProps, UrbanCore } from './useUrbanInstance';
+export type { UrbanBuildingProps } from './UrbanBuilding';
+export { default as UrbanBuilding } from './UrbanBuilding';
+export type { UrbanRoadProps } from './UrbanRoad';
+export { default as UrbanRoad } from './UrbanRoad';
+export type { UrbanBlockProps } from './UrbanBlock';
+export { default as UrbanBlock } from './UrbanBlock';
+export type { UrbanStreetFurnitureProps } from './UrbanStreetFurniture';
+export { default as UrbanStreetFurniture } from './UrbanStreetFurniture';
+export type { UrbanSkylineProps } from './UrbanSkyline';
+export { default as UrbanSkyline } from './UrbanSkyline';
+export type { UrbanPlazaProps } from './UrbanPlaza';
+export { default as UrbanPlaza } from './UrbanPlaza';
+export type { UrbanJunctionProps } from './UrbanJunction';
+export { default as UrbanJunction } from './UrbanJunction';
+export type { UrbanTrafficProps } from './UrbanTraffic';
+export { default as UrbanTraffic } from './UrbanTraffic';
+export type { UrbanSignageProps } from './UrbanSignage';
+export { default as UrbanSignage } from './UrbanSignage';
+export type { UrbanParkProps } from './UrbanPark';
+export { default as UrbanPark } from './UrbanPark';
+export type { UrbanParkingLotProps } from './UrbanParkingLot';
+export { default as UrbanParkingLot } from './UrbanParkingLot';
+export type { UrbanStreetGridProps } from './UrbanStreetGrid';
+export { default as UrbanStreetGrid } from './UrbanStreetGrid';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/urban/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/urban/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC5E,YAAY,EAAE,aAAa,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACtF,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC3D,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AACrD,YAAY,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACzE,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACzD,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AACrD,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC3D,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACzD,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACzD,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/components/urban/index.js

@@ -0,0 +1,16 @@
+// Urban variants (type 'urban', config.type set). One line per variant, written by the integrator.
+export * from './urbanCore.js';
+export * from './textureSetResolver.js';
+export { useUrbanInstance, resolveUrbanTextures } from './useUrbanInstance.js';
+export { default as UrbanBuilding } from './UrbanBuilding.js';
+export { default as UrbanRoad } from './UrbanRoad.js';
+export { default as UrbanBlock } from './UrbanBlock.js';
+export { default as UrbanStreetFurniture } from './UrbanStreetFurniture.js';
+export { default as UrbanSkyline } from './UrbanSkyline.js';
+export { default as UrbanPlaza } from './UrbanPlaza.js';
+export { default as UrbanJunction } from './UrbanJunction.js';
+export { default as UrbanTraffic } from './UrbanTraffic.js';
+export { default as UrbanSignage } from './UrbanSignage.js';
+export { default as UrbanPark } from './UrbanPark.js';
+export { default as UrbanParkingLot } from './UrbanParkingLot.js';
+export { default as UrbanStreetGrid } from './UrbanStreetGrid.js';

package/dist/components/urban/textureSetResolver.d.ts

@@ -0,0 +1,8 @@
+import type { UrbanTextureRef } from '@3driseai/3drise-core';
+export type TextureSetResolver = (set: string) => UrbanTextureRef['maps'] | null;
+export declare function setTextureSetResolver(fn: TextureSetResolver | null): void;
+/** Bumps whenever the resolver (the library) changes, so a component can re-resolve. */
+export declare function textureResolverVersion(): number;
+/** The maps to draw with: the stored ones when there, else the library's (studio only). */
+export declare function resolveTextureMaps(ref: UrbanTextureRef | undefined | null): UrbanTextureRef['maps'] | null;
+//# sourceMappingURL=textureSetResolver.d.ts.map

package/dist/components/urban/textureSetResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textureSetResolver.d.ts","sourceRoot":"","sources":["../../../src/components/urban/textureSetResolver.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,MAAM,MAAM,kBAAkB,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,eAAe,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;AAKjF,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,kBAAkB,GAAG,IAAI,GAAG,IAAI,CAGzE;AACD,wFAAwF;AACxF,wBAAgB,sBAAsB,IAAI,MAAM,CAAoB;AAEpE,2FAA2F;AAC3F,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,eAAe,GAAG,SAAS,GAAG,IAAI,GAAG,eAAe,CAAC,MAAM,CAAC,GAAG,IAAI,CAI1G"}

package/dist/components/urban/textureSetResolver.js

@@ -0,0 +1,16 @@
+let resolver = null;
+let version = 0;
+export function setTextureSetResolver(fn) {
+    resolver = fn;
+    version++;
+}
+/** Bumps whenever the resolver (the library) changes, so a component can re-resolve. */
+export function textureResolverVersion() { return version; }
+/** The maps to draw with: the stored ones when there, else the library's (studio only). */
+export function resolveTextureMaps(ref) {
+    if (!ref || !ref.set)
+        return null;
+    if (ref.maps && ref.maps.color)
+        return ref.maps;
+    return resolver ? resolver(ref.set) : null;
+}