rayzee 9.4.2 → 9.5.0

package/src/TSL/Struct.js

@@ -68,6 +68,11 @@ export const RayTracingMaterial = struct( {
 	iridescenceThicknessMapIndex: 'int',
 	specularIntensityMapIndex: 'int',
 	specularColorMapIndex: 'int',
+	// KHR_materials_diffuse_transmission: the diffuse lobe's share sent through to the other side, and its tint.
+	diffuseTransmission: 'float',
+	diffuseTransmissionColor: 'vec3',
+	diffuseTransmissionMapIndex: 'int',
+	diffuseTransmissionColorMapIndex: 'int',
 } );
 
 // Result of folding the glTF extension textures into their scalar factors (applyExtensionMaps).
@@ -82,6 +87,8 @@ export const ExtMapResult = struct( {
 	iridescenceThickness: 'float', // resolved thin-film thickness → written into iridescenceThicknessRange.y
 	specularIntensity: 'float',
 	specularColor: 'vec3',
+	diffuseTransmission: 'float',
+	diffuseTransmissionColor: 'vec3',
 } );
 
 // Lightweight material for shadow ray evaluation — only the fields needed
@@ -159,6 +166,8 @@ export const DirectionSample = struct( {
 	isTransmission: 'bool',
 	// Spectral tint from the transmission sampler; vec3(1) for every reflection lobe.
 	colorWeight: 'vec3',
+	// Drawn from the diffuse transmission lobe: `value` is its BTDF and the direction is below N.
+	isDiffuseTransmission: 'bool',
 } );
 
 export const BRDFWeights = struct( {
@@ -168,6 +177,7 @@ export const BRDFWeights = struct( {
 	clearcoat: 'float',
 	transmission: 'float',
 	iridescence: 'float',
+	diffuseTransmission: 'float',
 } );
 
 

package/src/TSL/Sun.js

@@ -1,6 +1,6 @@
 import { Fn, float, vec3, sqrt, max, dot, cross, pow, cos, sin, abs, normalize, select, If } from 'three/tsl';
 
-import { LIMB_DARKENING_EXPONENT } from '../Processor/AtmosphereModel.js';
+import { LIMB_DARKENING_EXPONENT } from '../Processor/SolarLimb.js';
 
 const LIMB_EXPONENT = vec3( ...LIMB_DARKENING_EXPONENT );
 // µ^α averages to 2 / (α + 2) over the disc, so this keeps the mean at `sunRadiance`.

package/src/TSL/TextureSampling.js

@@ -1,3 +1,4 @@
+import { sceneResources, materialLayers } from './SceneResources.js';
 import { Fn, wgslFn, float, vec2, vec3, vec4, int, If, normalize, cross, dot, length, sign, abs, atan, mix, clamp, texture, textureSize, uintBitsToFloat } from 'three/tsl';
 import { DataArrayTexture, LinearFilter } from 'three';
 
@@ -18,30 +19,11 @@ import { TEXTURE_CONSTANTS } from '../EngineDefaults.js';
 // footprint. Bucket shapes are planned per scene (planTextureBuckets) — not powers of two.
 // A map's stored index encodes (bucket, layer) as bucket * BUCKET_LAYER_STRIDE + layer.
 //
-// The bucket texture nodes live at module level (same pattern as gobo/IES/shadowAlbedo):
-// each stage sets them via setMaterialBucketTextures() right before building its graph,
-// so each pipeline bakes in its own fresh nodes (avoiding cross-pipeline TextureNode
-// caching, just like the per-type nodes did before).
+// The bucket texture nodes are the kernel's own (SceneResources.js): each pipeline builds fresh nodes,
+// avoiding cross-pipeline TextureNode caching, and hands them to its kernels' build context.
 
 const _STRIDE = TEXTURE_CONSTANTS.BUCKET_LAYER_STRIDE;
 
-// Array<MATERIAL_BUCKET_COUNT> of texture nodes (never null — empty buckets get placeholders).
-let _srgbBuckets = null;
-let _linearBuckets = null;
-
-/**
- * Set the bucket texture node arrays read by the sampling functions. Call before building
- * any graph that samples material textures (Shade / NormalDepth / Debug kernels).
- * @param {Array} srgb   sRGB pool nodes (albedo + emissive)
- * @param {Array} linear linear pool nodes (normal/bump/roughness/metalness/displacement)
- */
-export function setMaterialBucketTextures( srgb, linear ) {
-
-	_srgbBuckets = srgb;
-	_linearBuckets = linear;
-
-}
-
 // Run `fn(node, layer)` inside a runtime branch that selects the bucket node a packed
 // index points to. Emits one If/ElseIf arm per bucket; only the matching arm executes.
 // Caller must guard packedIndex >= 0.
@@ -89,13 +71,6 @@ export const bucketTexelSize = ( buckets, packedIndex ) => {
 
 };
 
-// The linear-pool node set (displacement lives here) — for Displacement.js texel sizing.
-export function getLinearBucketTextures() {
-
-	return _linearBuckets;
-
-}
-
 // 1×1 white placeholder array so empty-bucket branches always reference a valid node.
 export function makeBucketPlaceholder() {
 
@@ -334,13 +309,15 @@ export const computeUVCache = Fn( ( [ baseUV, material ] ) => {
 // PROCESSING FUNCTIONS
 // ================================================================================
 
-export const processAlbedo = Fn( ( [ material, uvCache ] ) => {
+export const processAlbedo = Fn( ( [ material, uvCache ], builder ) => {
+
+	const { srgbBuckets } = sceneResources( builder );
 
 	const result = material.color.toVar();
 
 	If( material.albedoMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
-		const albedoSample = sampleBucket( _srgbBuckets, material.albedoMapIndex, uvCache.albedoUV ).toVar();
+		const albedoSample = sampleBucket( srgbBuckets, material.albedoMapIndex, uvCache.albedoUV ).toVar();
 		// sRGB→linear handled by GPU hardware (sRGB bucket arrays carry SRGBColorSpace → rgba8unorm-srgb)
 		result.assign( vec4( material.color.rgb.mul( albedoSample.rgb ), material.color.a.mul( albedoSample.a ) ) );
 
@@ -350,7 +327,9 @@ export const processAlbedo = Fn( ( [ material, uvCache ] ) => {
 
 } );
 
-export const processMetalnessRoughness = Fn( ( [ material, uvCache ] ) => {
+export const processMetalnessRoughness = Fn( ( [ material, uvCache ], builder ) => {
+
+	const { linearBuckets } = sceneResources( builder );
 
 	const metalness = material.metalness.toVar();
 	const roughness = material.roughness.toVar();
@@ -358,7 +337,7 @@ export const processMetalnessRoughness = Fn( ( [ material, uvCache ] ) => {
 	If( material.metalnessMapIndex.greaterThanEqual( int( 0 ) ).and( material.metalnessMapIndex.equal( material.roughnessMapIndex ) ), () => {
 
 		// Same packed index → same bucket layer (e.g. ORM) → sample once.
-		const sample = sampleBucket( _linearBuckets, material.metalnessMapIndex, uvCache.metalnessUV );
+		const sample = sampleBucket( linearBuckets, material.metalnessMapIndex, uvCache.metalnessUV );
 		metalness.assign( material.metalness.mul( sample.b ) );
 		roughness.assign( material.roughness.mul( sample.g ) );
 
@@ -366,14 +345,14 @@ export const processMetalnessRoughness = Fn( ( [ material, uvCache ] ) => {
 
 		If( material.metalnessMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
-			const metSample = sampleBucket( _linearBuckets, material.metalnessMapIndex, uvCache.metalnessUV );
+			const metSample = sampleBucket( linearBuckets, material.metalnessMapIndex, uvCache.metalnessUV );
 			metalness.assign( material.metalness.mul( metSample.b ) );
 
 		} );
 
 		If( material.roughnessMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
-			const rghSample = sampleBucket( _linearBuckets, material.roughnessMapIndex, uvCache.roughnessUV );
+			const rghSample = sampleBucket( linearBuckets, material.roughnessMapIndex, uvCache.roughnessUV );
 			roughness.assign( material.roughness.mul( rghSample.g ) );
 
 		} );
@@ -471,13 +450,15 @@ export const triangleUVTangent = Fn( ( [ triangleBuffer, triIndex, geometryNorma
  * arbitrary frame comes out 90 deg off, so the rib normals tilt up/down instead of across
  * the ribs.
  */
-export const processNormal = Fn( ( [ geometryNormal, material, uvCache, uvTangent ] ) => {
+export const processNormal = Fn( ( [ geometryNormal, material, uvCache, uvTangent ], builder ) => {
+
+	const { linearBuckets } = sceneResources( builder );
 
 	const result = geometryNormal.toVar();
 
 	If( material.normalMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
-		const normalSample = sampleBucket( _linearBuckets, material.normalMapIndex, uvCache.normalUV );
+		const normalSample = sampleBucket( linearBuckets, material.normalMapIndex, uvCache.normalUV );
 		const normalMap = normalSample.xyz.mul( 2.0 ).sub( 1.0 ).toVar();
 		normalMap.x.mulAssign( material.normalScale.x );
 		normalMap.y.assign( normalMap.y.negate().mul( material.normalScale.x ) );
@@ -512,7 +493,9 @@ export const processNormal = Fn( ( [ geometryNormal, material, uvCache, uvTangen
 
 } );
 
-export const processBump = Fn( ( [ currentNormal, material, uvCache ] ) => {
+export const processBump = Fn( ( [ currentNormal, material, uvCache ], builder ) => {
+
+	const { linearBuckets } = sceneResources( builder );
 
 	const result = currentNormal.toVar();
 
@@ -521,7 +504,7 @@ export const processBump = Fn( ( [ currentNormal, material, uvCache ] ) => {
 		// Taps + texel size come from the SELECTED bucket node (its real dimensions), so the
 		// finite-difference step is correct per bucket — done inside one bucket-branch.
 		const bumpNormal = vec3( 0.0, 0.0, 1.0 ).toVar();
-		withBucket( _linearBuckets, material.bumpMapIndex, ( node, layer ) => {
+		withBucket( linearBuckets, material.bumpMapIndex, ( node, layer ) => {
 
 			const texelSize = vec2( 1.0 ).div( vec2( textureSize( node ) ) ).toVar();
 			const h_c = texture( node, uvCache.bumpUV ).depth( layer ).r;
@@ -549,11 +532,13 @@ export const processBump = Fn( ( [ currentNormal, material, uvCache ] ) => {
 // Fold the glTF anisotropyTexture (RG = tangent-space direction, B = strength) into scalar
 // (strength, rotationRadians) per three.js: anisotropy · R(rotation) · (normalize(rg·2−1)·b).
 // Caller guarantees anisotropyMapIndex >= 0. `uv` is pre-transformed by the caller (albedo transform).
-export const processAnisotropyMap = Fn( ( [ material, uv ] ) => {
+export const processAnisotropyMap = Fn( ( [ material, uv ], builder ) => {
+
+	const { linearBuckets } = sceneResources( builder );
 
 	const result = vec2( material.anisotropy, material.anisotropyRotation ).toVar();
 
-	const s = sampleBucket( _linearBuckets, material.anisotropyMapIndex, uv ).toVar();
+	const s = sampleBucket( linearBuckets, material.anisotropyMapIndex, uv ).toVar();
 	const texDir = s.rg.mul( 2.0 ).sub( 1.0 ).toVar();
 	const dlen = texDir.length().toVar();
 
@@ -581,7 +566,10 @@ export const processAnisotropyMap = Fn( ( [ material, uv ] ) => {
 // pre-transformed by the caller with the material's albedo KHR_texture_transform (extension maps
 // share the base UV set/transform in practice). Color maps (sheenColor, specularColor) read the
 // sRGB pool; data maps read the linear pool.
-export const applyExtensionMaps = Fn( ( [ material, uv ] ) => {
+export const applyExtensionMaps = Fn( ( [ material, uv ], builder ) => {
+
+	const { srgbBuckets, linearBuckets } = sceneResources( builder );
+	const layers = materialLayers( builder );
 
 	const r = ExtMapResult( {
 		transmission: material.transmission,
@@ -593,53 +581,66 @@ export const applyExtensionMaps = Fn( ( [ material, uv ] ) => {
 		iridescenceThickness: material.iridescenceThicknessRange.y, // default = max (no-texture behavior)
 		specularIntensity: material.specularIntensity,
 		specularColor: material.specularColor,
+		diffuseTransmission: material.diffuseTransmission,
+		diffuseTransmissionColor: material.diffuseTransmissionColor,
 	} ).toVar();
 
 	If( material.transmissionMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
-		r.transmission.assign( r.transmission.mul( sampleBucket( _linearBuckets, material.transmissionMapIndex, uv ).r ) );
+		r.transmission.assign( r.transmission.mul( sampleBucket( linearBuckets, material.transmissionMapIndex, uv ).r ) );
 
 	} );
-	If( material.clearcoatMapIndex.greaterThanEqual( int( 0 ) ), () => {
+	if ( layers.clearcoat ) If( material.clearcoatMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
-		r.clearcoat.assign( r.clearcoat.mul( sampleBucket( _linearBuckets, material.clearcoatMapIndex, uv ).r ) );
+		r.clearcoat.assign( r.clearcoat.mul( sampleBucket( linearBuckets, material.clearcoatMapIndex, uv ).r ) );
 
 	} );
-	If( material.clearcoatRoughnessMapIndex.greaterThanEqual( int( 0 ) ), () => {
+	if ( layers.clearcoat ) If( material.clearcoatRoughnessMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
-		r.clearcoatRoughness.assign( r.clearcoatRoughness.mul( sampleBucket( _linearBuckets, material.clearcoatRoughnessMapIndex, uv ).g ) );
+		r.clearcoatRoughness.assign( r.clearcoatRoughness.mul( sampleBucket( linearBuckets, material.clearcoatRoughnessMapIndex, uv ).g ) );
 
 	} );
-	If( material.sheenColorMapIndex.greaterThanEqual( int( 0 ) ), () => {
+	if ( layers.sheen ) If( material.sheenColorMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
-		r.sheenColor.assign( r.sheenColor.mul( sampleBucket( _srgbBuckets, material.sheenColorMapIndex, uv ).rgb ) );
+		r.sheenColor.assign( r.sheenColor.mul( sampleBucket( srgbBuckets, material.sheenColorMapIndex, uv ).rgb ) );
 
 	} );
-	If( material.sheenRoughnessMapIndex.greaterThanEqual( int( 0 ) ), () => {
+	if ( layers.sheen ) If( material.sheenRoughnessMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
 		// clamp to [0.05,1] to keep parity with the sample/PDF floor applied in ShadeKernel
-		r.sheenRoughness.assign( clamp( r.sheenRoughness.mul( sampleBucket( _linearBuckets, material.sheenRoughnessMapIndex, uv ).a ), 0.05, 1.0 ) );
+		r.sheenRoughness.assign( clamp( r.sheenRoughness.mul( sampleBucket( linearBuckets, material.sheenRoughnessMapIndex, uv ).a ), 0.05, 1.0 ) );
 
 	} );
-	If( material.iridescenceMapIndex.greaterThanEqual( int( 0 ) ), () => {
+	if ( layers.iridescence ) If( material.iridescenceMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
-		r.iridescence.assign( r.iridescence.mul( sampleBucket( _linearBuckets, material.iridescenceMapIndex, uv ).r ) );
+		r.iridescence.assign( r.iridescence.mul( sampleBucket( linearBuckets, material.iridescenceMapIndex, uv ).r ) );
 
 	} );
-	If( material.iridescenceThicknessMapIndex.greaterThanEqual( int( 0 ) ), () => {
+	if ( layers.iridescence ) If( material.iridescenceThicknessMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
-		const g = sampleBucket( _linearBuckets, material.iridescenceThicknessMapIndex, uv ).g;
+		const g = sampleBucket( linearBuckets, material.iridescenceThicknessMapIndex, uv ).g;
 		r.iridescenceThickness.assign( mix( material.iridescenceThicknessRange.x, material.iridescenceThicknessRange.y, g ) );
 
 	} );
 	If( material.specularIntensityMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
-		r.specularIntensity.assign( r.specularIntensity.mul( sampleBucket( _linearBuckets, material.specularIntensityMapIndex, uv ).a ) );
+		r.specularIntensity.assign( r.specularIntensity.mul( sampleBucket( linearBuckets, material.specularIntensityMapIndex, uv ).a ) );
 
 	} );
 	If( material.specularColorMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
-		r.specularColor.assign( r.specularColor.mul( sampleBucket( _srgbBuckets, material.specularColorMapIndex, uv ).rgb ) );
+		r.specularColor.assign( r.specularColor.mul( sampleBucket( srgbBuckets, material.specularColorMapIndex, uv ).rgb ) );
+
+	} );
+	// KHR_materials_diffuse_transmission: the factor from the map's alpha, the colour from its RGB.
+	if ( layers.diffuseTransmission ) If( material.diffuseTransmissionMapIndex.greaterThanEqual( int( 0 ) ), () => {
+
+		r.diffuseTransmission.assign( r.diffuseTransmission.mul( sampleBucket( linearBuckets, material.diffuseTransmissionMapIndex, uv ).a ) );
+
+	} );
+	if ( layers.diffuseTransmission ) If( material.diffuseTransmissionColorMapIndex.greaterThanEqual( int( 0 ) ), () => {
+
+		r.diffuseTransmissionColor.assign( r.diffuseTransmissionColor.mul( sampleBucket( srgbBuckets, material.diffuseTransmissionColorMapIndex, uv ).rgb ) );
 
 	} );
 
@@ -647,13 +648,15 @@ export const applyExtensionMaps = Fn( ( [ material, uv ] ) => {
 
 } );
 
-export const processEmissive = Fn( ( [ material, uvCache ] ) => {
+export const processEmissive = Fn( ( [ material, uvCache ], builder ) => {
+
+	const { srgbBuckets } = sceneResources( builder );
 
 	const emissionBase = material.emissive.mul( material.emissiveIntensity ).toVar();
 
 	If( material.emissiveMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
-		const emissiveSample = sampleBucket( _srgbBuckets, material.emissiveMapIndex, uvCache.emissiveUV ).toVar();
+		const emissiveSample = sampleBucket( srgbBuckets, material.emissiveMapIndex, uvCache.emissiveUV ).toVar();
 		// sRGB→linear handled by GPU hardware (sRGB bucket arrays carry SRGBColorSpace → rgba8unorm-srgb)
 		emissionBase.assign( emissionBase.mul( emissiveSample.rgb ) );
 
@@ -707,14 +710,16 @@ export const sampleAllMaterialTextures = Fn( ( [ material, uv, geometryNormal, u
 } );
 
 // Sample displacement map (linear pool) at given UV coordinates.
-export const sampleDisplacementMap = Fn( ( [ displacementMapIndex, uv, transform ] ) => {
+export const sampleDisplacementMap = Fn( ( [ displacementMapIndex, uv, transform ], builder ) => {
+
+	const { linearBuckets } = sceneResources( builder );
 
 	const result = float( 0.0 ).toVar();
 
 	If( displacementMapIndex.greaterThanEqual( int( 0 ) ), () => {
 
 		const transformedUV = getTransformedUV( { uv, transform } );
-		result.assign( sampleBucket( _linearBuckets, displacementMapIndex, transformedUV ).r );
+		result.assign( sampleBucket( linearBuckets, displacementMapIndex, transformedUV ).r );
 
 	} );
 

package/src/addons/archives.js

@@ -0,0 +1,14 @@
+/**
+ * Scene archives (.zip, .tar, .tar.gz) and the pbrt-v4 scenes in them — `rayzee/addons/archives`. PathTracerApp
+ * installs it itself; on the renderer core, install it once:
+ *
+ * @example
+ * import { RayzeeRenderer } from 'rayzee/core';
+ * import { ArchiveImporter } from 'rayzee/addons/archives';
+ *
+ * renderer.assetLoader.setArchiveImporter( new ArchiveImporter( renderer.assetLoader ) );
+ * await renderer.loadFile( 'scene.tar' );
+ */
+
+export { ArchiveImporter, ARCHIVE_ELEMENT_PROMPT_BYTES } from '../Processor/ArchiveImporter.js';
+export { openZip, readZipDirectory } from '../Processor/ZipReader.js';

package/src/addons/bidirectional.js

@@ -0,0 +1,13 @@
+/**
+ * Bidirectional path tracing and vertex merging — `rayzee/addons/bidirectional`: the path tracer's 'bidirectional'
+ * and 'vcm' integrators. PathTracerApp registers them itself; on the renderer core, register them once:
+ *
+ * @example
+ * import { RayzeeRenderer } from 'rayzee/core';
+ * import { BidirectionalIntegrator } from 'rayzee/addons/bidirectional';
+ *
+ * renderer.stages.pathTracer.registerIntegrator( [ 'bidirectional', 'vcm' ], pt => new BidirectionalIntegrator( pt ) );
+ * renderer.settings.set( 'integrator', 'bidirectional' );
+ */
+
+export { BidirectionalIntegrator } from '../integrators/BidirectionalIntegrator.js';

package/src/addons/color.js

@@ -0,0 +1,32 @@
+/**
+ * The OCIO colour pipeline — `rayzee/addons/color`: colour configs, OCIO views and looks, working spaces, input
+ * colour spaces and export spaces. The renderer core renders in linear Rec.709 through three.js's own view transforms
+ * (BasicColor); PathTracerApp installs this itself. On the core, install it once — before or after init():
+ *
+ * @example
+ * import { RayzeeRenderer, configureAssets } from 'rayzee/core';
+ * import { ColorManagement } from 'rayzee/addons/color';
+ *
+ * configureAssets( { ocioRuntimeFactory: () => import( '@bb-studio/ocio' ) } );
+ * renderer.setColorManagement( ColorManagement );
+ * await renderer.loadColorConfig( { builtin: 'ocio://cg-config-v4.0.0_aces-v2.0_ocio-v2.5' } );
+ */
+
+export {
+	ColorManagement, getActiveColorManagement, setActiveColorManagement,
+	isColorManaged, DEFAULT_WORKING_SPACE, findNativeLinearSpace, canvasColorSpaceFor,
+} from '../Color/ColorManagement.js';
+export { displayCanvasFit } from '../Color/Displays.js';
+export {
+	buildOcioView, addOcioView, addAllOcioViews,
+	DEFAULT_LUT_SIZE, DEFAULT_MIN_EV, DEFAULT_MAX_EV,
+} from '../Color/OcioViews.js';
+export {
+	resolveInputSpace, textureInputSpace, setInputOverride, clearInputOverrides,
+	listInputOverrides, listFileRules, isDataTexture,
+} from '../Color/InputColorSpaces.js';
+export {
+	convertColor, convertPixelsF32, convertEncodedRGBA8, applyMatrixRGBA8, extractMatrix,
+	hasColorSpace, isDataSpace, srgbToLinear, linearToSrgb,
+} from '../Color/ColorSpaces.js';
+export { measureBakeError, bakeLut, makeCpuSampler } from '../Color/LutBake.js';

package/src/addons/formats.js

@@ -0,0 +1,16 @@
+/**
+ * File formats beyond glTF and .hdr — `rayzee/addons/formats`: FBX, OBJ, STL, PLY, Collada, 3MF and USD models, and
+ * EXR environments. PathTracerApp registers all of them itself; on the renderer core, register the ones you read (each
+ * three.js loader is downloaded the first time its format is read, and a bundler drops the formats you leave out):
+ *
+ * @example
+ * import { RayzeeRenderer } from 'rayzee/core';
+ * import { objFormat, exrFormat } from 'rayzee/addons/formats';
+ *
+ * renderer.assetLoader.registerFormat( objFormat, exrFormat );
+ * await renderer.loadFile( objFile );
+ */
+
+export {
+	fbxFormat, objFormat, stlFormat, plyFormat, colladaFormat, threeMFFormat, usdFormat, exrFormat, allFormats,
+} from '../Processor/FileFormats.js';

package/src/addons/physicalSky.js

@@ -0,0 +1,14 @@
+/**
+ * The physical sky — `rayzee/addons/physical-sky`: Bruneton's atmosphere baked on the GPU for environment mode
+ * 'procedural', with its importance-sampling table and analytic sun. PathTracerApp installs it itself; on the renderer
+ * core, install it once:
+ *
+ * @example
+ * import { RayzeeRenderer } from 'rayzee/core';
+ * import { PhysicalSky } from 'rayzee/addons/physical-sky';
+ *
+ * renderer.environmentManager.setProceduralSky( PhysicalSky );
+ * await renderer.environmentManager.setMode( 'procedural' );
+ */
+
+export { PhysicalSky } from '../Processor/PhysicalSky.js';

package/src/addons/storage.js

@@ -0,0 +1,19 @@
+/**
+ * On-disk storage — `rayzee/addons/storage`: the origin private file system behind the download, environment and
+ * scene caches and the memory spill. The renderer core runs without it (downloads land in memory, nothing is cached);
+ * PathTracerApp installs it itself. On the core, install it before init():
+ *
+ * @example
+ * import { RayzeeRenderer } from 'rayzee/core';
+ * import { acquireSharedStorage } from 'rayzee/addons/storage';
+ *
+ * const renderer = new RayzeeRenderer( canvas );
+ * renderer.setStorageOpener( acquireSharedStorage );
+ * await renderer.init();
+ */
+
+export { openStorage, acquireSharedStorage } from '../Storage/openStorage.js';
+export {
+	StorageManager, StorageArea, StorageEntry, EntryWriter, STORAGE_KIND, ENGINE_AREAS, openInlineStorage,
+} from '../Storage/StorageManager.js';
+export { acquireLock, heldLockNames } from '../Storage/locks.js';

package/src/core.js

@@ -0,0 +1,35 @@
+/**
+ * Rayzee renderer core — `rayzee/core`.
+ *
+ * A scene and camera in, path-traced samples accumulated, the image out. No denoisers, camera controls,
+ * gizmo, overlays or timeline: `rayzee` adds those (PathTracerApp). See docs/CORE_AND_ADDONS.md.
+ *
+ * @example
+ * const renderer = await new RayzeeRenderer( canvas ).init();
+ * await renderer.loadObject3D( gltf.scene );
+ * await renderer.renderFrames( 256 );
+ * const image = await renderer.renderToBuffer( { colorSpace: 'srgb' } );
+ * renderer.dispose();
+ */
+
+import './TSL/patches.js';
+
+export { RayzeeRenderer, describeAdapter } from './RayzeeRenderer.js';
+export { EngineEvents, LEGACY_EVENT_NAMES } from './EngineEvents.js';
+export { ISSUE_CODES, ISSUE_SEVERITY, IssueLog, EngineIssueError } from './EngineIssues.js';
+export { RenderSettings, SETTING_SOURCE } from './RenderSettings.js';
+export { configureAssets, getAssetConfig } from './AssetConfig.js';
+export { configurePlatform, getPlatform } from './Platform.js';
+export { LightManager } from './managers/LightManager.js';
+export { listViewTransforms, getViewTransform, onRegistryChange } from './Color/ViewTransforms.js';
+export { ARCHIVE_FORMATS } from './Processor/archiveFormats.js';
+export {
+	ENGINE_DEFAULTS,
+	MATERIAL_DEFAULTS,
+	RENDER_PROFILES,
+	getRenderProfile,
+	MAX_RESERVABLE_RENDER_SIZE,
+	TRIANGLE_DATA_LAYOUT,
+} from './EngineDefaults.js';
+export { Logger, createLogger, fmt, LOG_LEVELS } from './utils/Logger.js';
+export { VERSION } from './version.js';

package/src/index.js

@@ -8,8 +8,9 @@
 // Patches (side-effect imports — must run before any StorageTexture usage)
 import './TSL/patches.js';
 
-// Main application
+// Main application: the viewer, built on the renderer core (also `rayzee/core`)
 export { PathTracerApp, describeAdapter } from './PathTracerApp.js';
+export { RayzeeRenderer } from './RayzeeRenderer.js';
 
 // Event types
 export { EngineEvents, LEGACY_EVENT_NAMES } from './EngineEvents.js';
@@ -35,6 +36,7 @@ export {
 
 // Archives read in place: one entry at a time, never the whole file in memory
 export { openZip, readZipDirectory } from './Processor/ZipReader.js';
+export { ARCHIVE_FORMATS } from './Processor/archiveFormats.js';
 
 // Engine package version, as built
 export { VERSION } from './version.js';