@selvajs/visualization 1.6.0-beta.9 → 1.6.0

package/dist/parse.d.cts

@@ -104,13 +104,26 @@ interface SerializableMaterial {
    * when the writer sent UVs in mm. Omitted: maps stretch once over the UVs.
    */
   mapSize?: number;
-  /** Procedural scratch fibres along the grain, from UVs in mm. */
-  finish?: 'brushed' | 'rolled' | 'wood' | 'concrete' | 'plaster' | 'brick' | 'corten';
+  /** A procedural surface drawn from UVs in mm: grain on metal, a whole material, or `molded` plastic grain. */
+  finish?: 'brushed' | 'rolled' | 'wood' | 'oak' | 'maple' | 'wenge' | 'walnut' | 'concrete' | 'plaster' | 'brick' | 'corten' | 'molded' | 'limestone' | 'travertine' | 'granite' | 'marble' | 'slate' | 'terrazzo' | 'paving' | 'setts' | 'gravel';
   /** Scales the finish's streaks; 0 draws none. Omitted: 1. */
   finishStrength?: number;
   /** Light passing through (glass); unlike `opacity` it keeps reflections. */
   transmission?: number;
   ior?: number;
+  /**
+   * Glass body depth, in model units. Above 0 the glass refracts and tints, at the cost of drawing
+   * the scene twice a frame. Omitted: a thin pane.
+   */
+  thickness?: number;
+  /** Hex colour light takes on after crossing `thickness` of glass. Omitted: clear. */
+  attenuationColor?: string;
+  /** 0 to 1. The soft glow at grazing angles of rubber, soft-touch plastic and cloth. Omitted: none. */
+  sheen?: number;
+  /** Hex colour of the sheen. Omitted: white. */
+  sheenColor?: string;
+  /** 0 to 1. Omitted: 0.5. */
+  sheenRoughness?: number;
 }
 /**
  * `vertexStart`/`vertexCount` and `indexStart`/`indexCount` are in **element units** of the

package/dist/parse.d.ts

@@ -104,13 +104,26 @@ interface SerializableMaterial {
    * when the writer sent UVs in mm. Omitted: maps stretch once over the UVs.
    */
   mapSize?: number;
-  /** Procedural scratch fibres along the grain, from UVs in mm. */
-  finish?: 'brushed' | 'rolled' | 'wood' | 'concrete' | 'plaster' | 'brick' | 'corten';
+  /** A procedural surface drawn from UVs in mm: grain on metal, a whole material, or `molded` plastic grain. */
+  finish?: 'brushed' | 'rolled' | 'wood' | 'oak' | 'maple' | 'wenge' | 'walnut' | 'concrete' | 'plaster' | 'brick' | 'corten' | 'molded' | 'limestone' | 'travertine' | 'granite' | 'marble' | 'slate' | 'terrazzo' | 'paving' | 'setts' | 'gravel';
   /** Scales the finish's streaks; 0 draws none. Omitted: 1. */
   finishStrength?: number;
   /** Light passing through (glass); unlike `opacity` it keeps reflections. */
   transmission?: number;
   ior?: number;
+  /**
+   * Glass body depth, in model units. Above 0 the glass refracts and tints, at the cost of drawing
+   * the scene twice a frame. Omitted: a thin pane.
+   */
+  thickness?: number;
+  /** Hex colour light takes on after crossing `thickness` of glass. Omitted: clear. */
+  attenuationColor?: string;
+  /** 0 to 1. The soft glow at grazing angles of rubber, soft-touch plastic and cloth. Omitted: none. */
+  sheen?: number;
+  /** Hex colour of the sheen. Omitted: white. */
+  sheenColor?: string;
+  /** 0 to 1. Omitted: 0.5. */
+  sheenRoughness?: number;
 }
 /**
  * `vertexStart`/`vertexCount` and `indexStart`/`indexCount` are in **element units** of the

package/dist/parse.js

@@ -1,4 +1,4 @@
-import { a as computeCombinedBoundingBox, c as EMISSIVE_LIGHT, d as OWN_ENV_MAP_INTENSITY, f as lookEnvMapIntensity, g as getLogger, i as applyOffset, n as observeMaxAnisotropy, o as parseColor, t as disposeObjectTree, u as OWN_EMISSIVE, v as ErrorCodes, y as VisualizationError } from "./gpu-dispose-Cl3RXm-v.js";
+import { S as VisualizationError, a as observeMaxAnisotropy, c as computeCombinedBoundingBox, d as EMISSIVE_LIGHT, h as lookEnvMapIntensity, i as isGlass, l as parseColor, m as OWN_ENV_MAP_INTENSITY, n as GLASS, p as OWN_EMISSIVE, s as applyOffset, t as disposeObjectTree, x as ErrorCodes, y as getLogger } from "./gpu-dispose-Di_nxeXF.js";
 import { a as shareGeometry, o as unshareGeometry } from "./gpu-ownership-Bs9l7hrU.js";
 import * as THREE from "three";
 import { Line2 } from "three/addons/lines/Line2.js";
@@ -1679,6 +1679,32 @@ function applyTexture(material, url, slot, mapSize) {
 	});
 }
 // src/parse/webdisplay/batch/surface-finish.ts
+const f$1 = (n) => n.toFixed(4);
+const PITH = 120;
+const PITH_SPREAD = 120;
+const PLANK = 180;
+const LEAN = .0105;
+const wood = ({ ring, latewood, band, pores, streaks }) => `
+		float plank = floor( uv.y / ${f$1(PLANK)} );
+		float s = uv.y - ( plank + 0.5 ) * ${f$1(PLANK)};
+		float pith = ${f$1(PITH)} + selvaHash( vec2( plank, 2.0 ) ) * ${f$1(PITH_SPREAD)};
+		// Rings wander a few mm and vary in spacing, as growth does from year to year.
+		float wander = ( selvaFbm( uv * vec2( 0.003, 0.008 ) ) - 0.5 ) * ${f$1(ring * 2)};
+		float r = sqrt( pith * pith + s * s ) + uv.x * ${f$1(LEAN)} + wander;
+		r += selvaFbm( vec2( r * 0.02, plank ) ) * ${f$1(ring * 3)} + selvaHash( vec2( plank, 1.0 ) ) * ${f$1(ring * 20)};
+		float year = fract( r / ${f$1(ring)} );
+		float late = smoothstep( ${f$1(1 - band)}, ${f$1(1 - band * .4)}, year ) * ( 1.0 - smoothstep( 0.95, 1.0, year ) );
+		// Open-pored wood shows its rings as a broken band of pores, not a clean line.
+		late *= 1.0 - ${f$1(pores * .6)} * ( 1.0 - smoothstep( 0.3, 0.7, selvaNoise( uv * vec2( 0.25, 2.0 ) ) ) );
+		late *= selvaDetail( ${f$1(ring)} );
+		float fibre = ( selvaNoise( uv * vec2( 0.04, 1.6 ) ) - 0.5 ) * selvaDetail( 1.0 );
+		float pore = smoothstep( 0.62, 0.8, selvaNoise( uv * vec2( 0.3, 2.5 ) ) ) * ( 1.0 - 0.6 * late );
+		pore *= ${f$1(pores)} * selvaDetail( 0.8 );
+		float streak = ( selvaFbm( uv * vec2( 0.0015, 0.012 ) ) - 0.5 ) * ${f$1(streaks)};
+		float shade = 1.0 + ${f$1(latewood * band)} - late * ${f$1(latewood)} + fibre * 0.1 - pore * 0.45 + streak * 0.6;
+		tone = vec3( shade );
+		gloss = 1.0 + late * 0.08 + pore * 0.4 - fibre * 0.2;
+		height = ( fibre * 0.00008 - pore * 0.00015 ) * selvaDetail( 0.6 );`;
 /**
 * Procedural surfaces, so a preset looks like its material with no texture files to ship or upload.
 * UVs are millimetres, so a brick is brick-sized at any model scale. Each recipe sets `tone` (albedo
@@ -1687,15 +1713,41 @@ function applyTexture(material, url, slot, mapSize) {
 * samples to static, so a whole building has to settle to its flat colour.
 */
 const RECIPES$1 = {
-	wood: `
-		float warp = selvaFbm( uv * vec2( 0.003, 0.02 ) );
-		float rings = 0.5 + 0.5 * sin( ( uv.y + warp * 90.0 ) * 0.28 );
-		float fibre = selvaNoise( uv * vec2( 0.03, 1.4 ) );
-		float grain = ( rings * 0.65 + fibre * 0.35 ) - 0.5;
-		grain *= selvaDetail( 4.0 );
-		tone = vec3( 1.0 + grain * 0.42 );
-		gloss = 1.0 + grain * 0.35;
-		height = fibre * 0.00012 * selvaDetail( 1.0 );`,
+	wood: wood({
+		ring: 4,
+		latewood: .3,
+		band: .4,
+		pores: .4,
+		streaks: .35
+	}),
+	walnut: wood({
+		ring: 5,
+		latewood: .2,
+		band: .4,
+		pores: 1,
+		streaks: .45
+	}),
+	oak: wood({
+		ring: 3,
+		latewood: .3,
+		band: .35,
+		pores: .9,
+		streaks: .25
+	}),
+	maple: wood({
+		ring: 3,
+		latewood: .2,
+		band: .1,
+		pores: 0,
+		streaks: .12
+	}),
+	wenge: wood({
+		ring: 1.5,
+		latewood: .7,
+		band: .5,
+		pores: .6,
+		streaks: .4
+	}),
 	concrete: `
 		float blotch = ( selvaFbm( uv * 0.0035 ) - 0.5 ) * selvaDetail( 40.0 );
 		float holes = smoothstep( 0.8, 0.88, selvaNoise( uv * 0.22 ) ) * selvaDetail( 5.0 );
@@ -1720,6 +1772,127 @@ const RECIPES$1 = {
 		tone = mix( vec3( face ), vec3( 1.5, 1.7, 1.8 ), joint );
 		gloss = 1.0 + joint * 0.15;
 		height = -joint * 0.005;`,
+	limestone: `
+		float cloud = ( selvaFbm( uv * 0.004 ) - 0.5 ) * selvaDetail( 60.0 );
+		float mottle = ( selvaFbm( uv * 0.025 + vec2( 3.0, 7.0 ) ) - 0.5 ) * selvaDetail( 12.0 );
+		float bed = ( selvaNoise( vec2( uv.x * 0.003, uv.y * 0.05 ) ) - 0.5 ) * selvaDetail( 10.0 );
+		float fleck = smoothstep( 0.8, 0.9, selvaNoise( uv * 0.5 ) ) * selvaDetail( 2.0 );
+		vec3 fossil = selvaCell( uv / 14.0 );
+		float shell = ( 1.0 - smoothstep( 0.08, 0.16, fossil.x ) ) * step( 0.85, fossil.z ) * selvaDetail( 6.0 );
+		tone = vec3( 1.0 + cloud * 0.14 + mottle * 0.1 + bed * 0.03 - fleck * 0.12 - shell * 0.1 );
+		gloss = 1.0 + cloud * 0.1;
+		height = -( fleck + shell ) * 0.00005;`,
+	travertine: `
+		float band = selvaFbm( vec2( uv.x * 0.002, uv.y * 0.012 ) );
+		float layer = ( band - 0.5 ) * selvaDetail( 25.0 );
+		float pocket = selvaNoise( uv * vec2( 0.025, 0.15 ) ) * 0.7 + selvaNoise( uv * vec2( 0.08, 0.4 ) ) * 0.3;
+		float voids = smoothstep( 0.68, 0.78, pocket ) * smoothstep( 0.35, 0.6, band ) * selvaDetail( 4.0 );
+		float grain = ( selvaNoise( uv * 0.6 ) - 0.5 ) * selvaDetail( 1.5 );
+		tone = vec3( 1.0 + layer * 0.2 + grain * 0.04 ) * mix( vec3( 1.0 ), vec3( 0.62, 0.56, 0.48 ), voids );
+		gloss = 1.0 + voids * 0.3;
+		height = -voids * 0.002;`,
+	granite: `
+		vec3 crystal = selvaCell( uv / 4.0 );
+		// Feldspar, quartz and biotite in about the shares of a grey granite. The dark crystals
+		// gather in clusters, which is what still reads as granite from a few metres.
+		float cluster = selvaFbm( uv * 0.04 ) - 0.5;
+		float dark = 0.2 + cluster * 0.2;
+		float mineral = crystal.z < dark ? 0.35 : ( crystal.z < dark + 0.3 ? 1.35 : 1.0 );
+		mineral *= 1.0 + ( selvaHash( vec2( crystal.z, 3.0 ) ) - 0.5 ) * 0.15;
+		mineral = mix( 1.0 - cluster * 0.25 * selvaDetail( 15.0 ), mineral, selvaDetail( 4.0 ) );
+		float cloud = ( selvaFbm( uv * 0.005 ) - 0.5 ) * selvaDetail( 50.0 );
+		tone = vec3( mineral + cloud * 0.06 );
+		gloss = 1.0 - ( mineral - 1.0 ) * 0.15;
+		height = ( selvaNoise( uv * 0.8 ) - 0.5 ) * 0.0002 * selvaDetail( 1.2 );`,
+	marble: `
+		vec2 w = vec2( uv.x * 0.7 + uv.y * 0.7, uv.y * 0.7 - uv.x * 0.7 ) * vec2( 0.0012, 0.004 );
+		w += vec2( selvaFbm( w * 2.0 ), selvaFbm( w * 2.0 + vec2( 4.0, 2.0 ) ) ) * 0.6;
+		float feather = smoothstep( 0.3, 0.7, selvaFbm( uv * 0.006 + vec2( 2.0, 5.0 ) ) );
+		float major = 1.0 - smoothstep( 0.0, 0.05, abs( selvaFbm( w ) - 0.5 ) );
+		float fine = 1.0 - smoothstep( 0.0, 0.02, abs( selvaFbm( w * 3.0 + vec2( 9.0, 1.0 ) ) - 0.5 ) );
+		float cloud = ( selvaFbm( uv * 0.003 ) - 0.5 ) * selvaDetail( 60.0 );
+		float vein = ( major * 0.35 * selvaDetail( 6.0 ) + fine * 0.2 * selvaDetail( 2.0 ) ) * feather;
+		tone = vec3( 1.0 + cloud * 0.06 - vein - feather * 0.04 );
+		gloss = 1.0 + vein * 0.3;`,
+	slate: `
+		float cleft = selvaFbm( uv * vec2( 0.012, 0.02 ) );
+		float flake = mix( cleft, floor( cleft * 4.0 ) / 4.0, 0.6 );
+		float seen = selvaDetail( 6.0 );
+		float glint = ( selvaNoise( uv * 0.3 ) - 0.5 ) * selvaDetail( 3.0 );
+		tone = vec3( 1.0 + ( flake - 0.5 ) * 0.18 * seen + glint * 0.06 );
+		gloss = 1.0 - ( flake - 0.5 ) * 0.3 * seen + glint * 0.2;
+		height = flake * 0.0015 * seen;`,
+	terrazzo: `
+		vec3 chipCell = selvaCell( uv / 9.0 );
+		float chip = smoothstep( 0.1, 0.16, chipCell.y - chipCell.x ) * step( 0.12, selvaHash( vec2( chipCell.z, 5.0 ) ) );
+		float k = selvaHash( vec2( chipCell.z, 7.0 ) );
+		vec3 stone = k < 0.6 ? vec3( 1.1 ) : k < 0.75 ? vec3( 0.65 ) : k < 0.85 ? vec3( 0.22 ) : k < 0.9 ? vec3( 0.85, 0.69, 0.44 ) : k < 0.95 ? vec3( 0.64, 0.35, 0.28 ) : vec3( 0.93, 0.72, 0.66 );
+		vec3 gritCell = selvaCell( uv / 2.5 );
+		float grit = smoothstep( 0.1, 0.2, gritCell.y - gritCell.x ) * step( 0.6, selvaHash( vec2( gritCell.z, 2.0 ) ) );
+		float g = selvaHash( vec2( gritCell.z, 9.0 ) ) < 0.5 ? 0.4 : 1.1;
+		vec3 near = mix( vec3( 1.0 ), stone, chip );
+		near = mix( near, vec3( g ), grit * ( 1.0 - chip ) * selvaDetail( 2.5 ) );
+		// From afar the chips average to a slightly darker matrix.
+		tone = mix( vec3( 0.92 ), near, selvaDetail( 9.0 ) );
+		gloss = 1.0 + chip * 0.1;`,
+	paving: `
+		vec2 size = vec2( 600.0, 400.0 );
+		float row = floor( uv.y / size.y );
+		vec2 laid = vec2( uv.x + mod( row, 2.0 ) * size.x * 0.5, uv.y );
+		vec2 id = floor( laid / size );
+		vec2 edge = abs( fract( laid / size ) - 0.5 ) * size;
+		float inset = min( size.x * 0.5 - edge.x, size.y * 0.5 - edge.y );
+		float joint = ( 1.0 - smoothstep( 2.5, 3.5, inset ) ) * selvaDetail( 5.0 );
+		float chamfer = ( 1.0 - smoothstep( 2.5, 6.0, inset ) ) * selvaDetail( 4.0 );
+		float slab = ( selvaHash( id ) - 0.5 ) * 0.12 * selvaDetail( 100.0 );
+		float blotch = ( selvaFbm( uv * 0.006 ) - 0.5 ) * 0.12 * selvaDetail( 40.0 );
+		float speck = ( selvaNoise( uv * 0.7 ) - 0.5 ) * 0.06 * selvaDetail( 1.5 );
+		tone = vec3( 1.0 + slab + blotch + speck ) * mix( 1.0, 0.55, joint );
+		gloss = 1.0 + joint * 0.1;
+		height = -chamfer * 0.002 - joint * 0.003;`,
+	setts: `
+		vec2 size = vec2( 110.0, 100.0 );
+		vec2 warped = uv + ( vec2( selvaNoise( uv * 0.03 ), selvaNoise( uv * 0.03 + vec2( 3.0, 8.0 ) ) ) - 0.5 ) * 10.0;
+		float row = floor( warped.y / size.y );
+		vec2 laid = vec2( warped.x + selvaHash( vec2( row, 4.0 ) ) * size.x, warped.y );
+		vec2 id = floor( laid / size );
+		vec2 edge = abs( fract( laid / size ) - 0.5 ) * size;
+		float inset = min( size.x * 0.5 - edge.x, size.y * 0.5 - edge.y );
+		float joint = ( 1.0 - smoothstep( 4.0, 6.0, inset ) ) * selvaDetail( 10.0 );
+		float dome = smoothstep( 4.0, 25.0, inset );
+		vec3 crystal = selvaCell( uv / 4.0 );
+		// Feldspar, quartz and biotite in about the shares of a grey granite. The dark crystals
+		// gather in clusters, which is what still reads as granite from a few metres.
+		float cluster = selvaFbm( uv * 0.04 ) - 0.5;
+		float dark = 0.2 + cluster * 0.2;
+		float mineral = crystal.z < dark ? 0.35 : ( crystal.z < dark + 0.3 ? 1.35 : 1.0 );
+		mineral *= 1.0 + ( selvaHash( vec2( crystal.z, 3.0 ) ) - 0.5 ) * 0.15;
+		mineral = mix( 1.0 - cluster * 0.25 * selvaDetail( 15.0 ), mineral, selvaDetail( 4.0 ) );
+		float tint = selvaHash( id + vec2( 5.0, 2.0 ) ) - 0.5;
+		vec3 sett = ( 1.0 + ( selvaHash( id ) - 0.5 ) * 0.16 ) * ( 1.0 + vec3( 0.05, 0.0, -0.06 ) * tint * 2.0 );
+		sett = mix( vec3( 1.0 ), sett, selvaDetail( 100.0 ) );
+		tone = mix( sett * mineral, vec3( 1.05, 0.97, 0.82 ), joint );
+		gloss = 1.0 + joint * 0.1;
+		height = ( dome * 0.006 + ( selvaNoise( uv * 0.15 ) - 0.5 ) * 0.001 ) * selvaDetail( 10.0 );`,
+	gravel: `
+		vec3 pebble = selvaCell( uv / 12.0 );
+		float gap = 1.0 - smoothstep( 0.04, 0.18, pebble.y - pebble.x );
+		float dome = sqrt( clamp( 1.0 - pebble.x * 1.4, 0.0, 1.0 ) );
+		float k = selvaHash( vec2( pebble.z, 3.0 ) );
+		vec3 stone = k < 0.3 ? vec3( 1.13, 1.14, 1.11 ) : k < 0.55 ? vec3( 0.96, 0.85, 0.71 ) : k < 0.7 ? vec3( 0.84, 0.64, 0.59 ) : k < 0.9 ? vec3( 0.74, 0.8, 0.89 ) : vec3( 0.47, 0.5, 0.56 );
+		stone *= 1.0 + ( selvaHash( vec2( pebble.z, 8.0 ) ) - 0.5 ) * 0.15;
+		float seen = selvaDetail( 12.0 );
+		tone = mix( vec3( 0.85 ), stone * mix( 1.0, 0.35, gap ) * ( 0.85 + 0.15 * dome ), seen );
+		gloss = 1.0 + gap * 0.1 - dome * 0.1;
+		height = dome * 0.004 * seen;`,
+	molded: `
+		float pit = selvaNoise( uv * 1.6 );
+		float mottle = selvaNoise( uv * 0.5 + vec2( 7.0, 3.0 ) );
+		float grit = ( pit * 0.65 + mottle * 0.35 ) - 0.5;
+		float seen = selvaDetail( 0.6 );
+		tone = vec3( 1.0 + grit * 0.1 * seen );
+		gloss = 1.0 + grit * 0.9 * seen;
+		height = ( grit + 0.5 ) * 0.00008 * seen;`,
 	corten: `
 		float bloom = 0.5 + ( selvaFbm( uv * vec2( 0.006, 0.0025 ) ) - 0.5 ) * selvaDetail( 25.0 );
 		float scale = 0.5 + ( selvaFbm( uv * 0.06 ) - 0.5 ) * selvaDetail( 8.0 );
@@ -1728,7 +1901,6 @@ const RECIPES$1 = {
 		gloss = 1.0 + ( scale - 0.5 ) * 0.25;
 		height = scale * 0.0004;`
 };
-const f$1 = (n) => n.toFixed(4);
 /** Null for the finishes `finish.ts` draws itself. */
 function surfacePatch(finish, strength) {
 	const recipe = RECIPES$1[finish];
@@ -1762,6 +1934,30 @@ function surfacePatch(finish, strength) {
 					}
 					return sum / 0.9375;
 				}
+				// Cellular noise: distance to the nearest and second-nearest jittered point, and the
+				// nearest one's id. y - x is small along a cell border.
+				vec3 selvaCell( vec2 p ) {
+					vec2 i = floor( p );
+					vec2 fp = fract( p );
+					float f1 = 8.0;
+					float f2 = 8.0;
+					float id = 0.0;
+					for ( int y = -1; y <= 1; y ++ ) {
+						for ( int x = -1; x <= 1; x ++ ) {
+							vec2 g = vec2( float( x ), float( y ) );
+							vec2 o = vec2( selvaHash( i + g ), selvaHash( i + g + vec2( 19.0, 7.0 ) ) );
+							float d = length( g + o * 0.8 + 0.1 - fp );
+							if ( d < f1 ) {
+								f2 = f1;
+								f1 = d;
+								id = selvaHash( i + g + vec2( 3.0, 11.0 ) );
+							} else if ( d < f2 ) {
+								f2 = d;
+							}
+						}
+					}
+					return vec3( f1, f2, id );
+				}
 				float selvaDetail( float featureMm ) {
 					return 1.0 - smoothstep( 0.5, 1.5, selvaFootprint / featureMm );
 				}`).replace("#include <color_fragment>", `#include <color_fragment>
@@ -1898,6 +2094,10 @@ function cullsBackFaces(matData, options) {
 	if (options?.appearance?.cullBackfaces) return true;
 	return (options?.closed ?? false) && !matData.transparent && matData.opacity >= 1;
 }
+const FROSTED = .2;
+function isPane(matData) {
+	return (matData.transmission ?? 0) > 0 && !((matData.thickness ?? 0) > 0) && matData.roughness < FROSTED;
+}
 function createMaterialPicker(materialsSrc, options) {
 	const built = /* @__PURE__ */ new Map();
 	return (materialId, closed) => {
@@ -1950,15 +2150,18 @@ function createMaterial(matData, options) {
 		material.clearcoat = matData.clearcoat;
 		material.clearcoatRoughness = matData.clearcoatRoughness ?? 0;
 	}
+	if (matData.sheen != null && matData.sheen > 0) {
+		material.sheen = matData.sheen;
+		material.sheenColor.set(matData.sheenColor ?? "#ffffff");
+		material.sheenRoughness = matData.sheenRoughness ?? .5;
+	}
 	if (matData.anisotropy != null && matData.anisotropy > 0 && options?.hasUvs) {
 		material.anisotropy = matData.anisotropy;
 		material.anisotropyRotation = matData.anisotropyRotation ?? 0;
 	}
-	if (matData.transmission != null) {
-		material.transmission = matData.transmission;
-		material.thickness = 0;
-	}
 	if (matData.ior != null) material.ior = matData.ior;
+	if (matData.transmission != null && matData.transmission > 0) applyGlass(material, matData);
+	if (matData.metalness > 0) dimSunOnMetal(material);
 	if (vertexColors) applyVertexColorSRGBDecode(material);
 	const finish = matData.finish && options?.hasUvs ? finishPatch(matData.finish, matData.finishStrength ?? 1) : null;
 	if (finish) {
@@ -1974,6 +2177,50 @@ function createMaterial(matData, options) {
 	if (matData.normalMap) applyTexture(material, matData.normalMap, "normalMap", mapSize);
 	return material;
 }
+const SUN_ON_METAL = .1;
+const SUN_BEGIN = "#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )";
+const SUN_END = "#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )";
+/** Scales the directional lights' specular by metalness; point lights keep theirs. */
+function dimSunOnMetal(material) {
+	addShaderPatch(material, "sun-on-metal", (shader) => {
+		shader.fragmentShader = shader.fragmentShader.replace("#include <lights_fragment_begin>", THREE.ShaderChunk.lights_fragment_begin.replace(SUN_BEGIN, `vec3 specularBeforeSun = reflectedLight.directSpecular;
+${SUN_BEGIN}`).replace(SUN_END, `reflectedLight.directSpecular = specularBeforeSun + ( reflectedLight.directSpecular - specularBeforeSun ) * mix( 1.0, ${SUN_ON_METAL.toFixed(2)}, metalnessFactor );
+${SUN_END}`));
+	});
+}
+/**
+* three's transmission draws every opaque object a second time into its own buffer each frame, and
+* that buffer never holds other glass: one pane seen through another vanishes. So only glass that
+* needs it gets it: with a thickness, to refract and tint, or frosted, to blur. A pane blends
+* instead: cheap, and panes stack.
+*/
+function applyGlass(material, matData) {
+	const transmission = Math.min(1, matData.transmission);
+	material.userData[GLASS] = true;
+	if (!isPane(matData)) {
+		const thickness = matData.thickness ?? 0;
+		material.transmission = transmission;
+		material.thickness = thickness;
+		if (matData.attenuationColor && thickness > 0) {
+			material.attenuationColor.set(matData.attenuationColor);
+			material.attenuationDistance = thickness;
+			addShaderPatch(material, "glass-attenuation", (shader) => {
+				shader.fragmentShader = shader.fragmentShader.replace("#include <transmission_fragment>", THREE.ShaderChunk.transmission_fragment.replace("material.attenuationDistance = attenuationDistance;", "material.attenuationDistance = attenuationDistance * length( modelMatrix[ 0 ].xyz );"));
+			});
+		}
+		return;
+	}
+	material.transparent = true;
+	material.opacity = matData.opacity * (1 - transmission * .96);
+	material.depthWrite = false;
+	material.blending = THREE.CustomBlending;
+	material.blendSrc = THREE.OneFactor;
+	material.blendDst = THREE.OneMinusSrcAlphaFactor;
+	addShaderPatch(material, "glass-pane", (shader) => {
+		shader.fragmentShader = shader.fragmentShader.replace("#include <opaque_fragment>", `vec3 paneSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;
+			gl_FragColor = vec4( ( outgoingLight - paneSpecular ) * diffuseColor.a + paneSpecular, diffuseColor.a );`);
+	});
+}
 /**
 * Chains `patch` after any earlier one. three caches compiled programs by `customProgramCacheKey`,
 * which defaults to the `onBeforeCompile` source; a chained wrapper's source is the same whatever
@@ -2208,7 +2455,7 @@ function finalizeMergedMesh(geometry, group, material) {
 	const firstMesh = group.meshes[0];
 	const meshNames = group.meshes.map((m) => m.name).filter((name) => name && name.length > 0);
 	threeMesh.name = meshNames.length > 0 ? meshNames[0] : `merged_material_${group.materialId}`;
-	threeMesh.castShadow = true;
+	threeMesh.castShadow = !isGlass(material);
 	threeMesh.receiveShadow = true;
 	threeMesh.userData = {
 		source: "compute",
@@ -2259,7 +2506,7 @@ function finalizeSingleMesh(geometry, meshMeta, material) {
 		trackingKey: meshMeta.id,
 		metadata: meshMeta.metadata ?? {}
 	};
-	mesh.castShadow = true;
+	mesh.castShadow = !isGlass(material);
 	mesh.receiveShadow = true;
 	return mesh;
 }