rayzee 8.5.0 → 8.6.1

package/src/TSL/ShadeKernel.js

@@ -7,7 +7,7 @@
 import {
 	Fn, float, vec2, vec3, vec4, int, uint,
 	bool as tslBool,
-	If, Loop, normalize, max, min, exp, log, clamp, dot, length, select, smoothstep, mix,
+	If, Loop, normalize, max, min, exp, log, clamp, dot, length, select, smoothstep,
 	instanceIndex,
 	sampler,
 	atomicAdd, atomicLoad, atomicStore, uintBitsToFloat,
@@ -15,20 +15,21 @@ import {
 } from 'three/tsl';
 
 import { sampleEnvironment, sampleEquirectProbability, sampleEquirect, groundProjectedEnvDir } from './Environment.js';
-import { getMaterial, powerHeuristic, balanceHeuristic, classifyMaterial, REC709_LUMINANCE_COEFFICIENTS, PI_INV, EPSILON, diffuseGroundMaterial } from './Common.js';
+import { getMaterial, powerHeuristic, balanceHeuristic, classifyMaterial, REC709_LUMINANCE_COEFFICIENTS, PI_INV, EPSILON, diffuseGroundMaterial, offsetRayOrigin, SHADOW_END } from './Common.js';
 import { cosineWeightedSample } from './MaterialSampling.js';
 import { sampleAllMaterialTextures, processAnisotropyMap, applyExtensionMaps, getTransformedUV, triangleUVTangent } from './TextureSampling.js';
 import { evaluateMaterialResponse } from './MaterialEvaluation.js';
 import { calculateDirectLightingUnified, calculateMaterialPDF } from './LightsSampling.js';
-import { traceShadowRay, calculateRayOffset } from './LightsDirect.js';
+import { traceShadowRay } from './LightsDirect.js';
+import { shadowTerminatorOrigin } from './ShadowTerminator.js';
+import { unpackHitFacet } from './HitFacet.js';
 import { traverseBVHShadow } from './BVHTraversal.js';
 import { handleMaterialTransparency, MaterialInteractionResult } from './MaterialTransmission.js';
 import { sampleChromaticCollision, sampleHenyeyGreenstein, subsurfaceCoefficients, CollisionSample, MediumCoeffs } from './Subsurface.js';
 import { calculateIndirectLighting } from './LightsIndirect.js';
 import { IndirectLightingResult, sampleCone } from './LightsCore.js';
 import { regularizePathContribution, generateSampledDirection, computeNDCDepth, handleRussianRoulette } from './PathTracerCore.js';
-import { evaluateDFG } from './MaterialProperties.js';
-import { dielectricF0 } from './Fresnel.js';
+import { evaluateSpecularDFG, baseFresnelParams } from './MaterialProperties.js';
 import { NRD_HIT_DIST_A, NRD_HIT_DIST_B } from '../EngineDefaults.js';
 import { sampleClearcoat, ClearcoatResult } from './Clearcoat.js';
 import { refineDisplacedIntersection, DisplacementResult } from './Displacement.js';
@@ -46,6 +47,7 @@ import {
 	MaterialCache,
 	DirectLightingDual,
 	DFGResult,
+	BaseFresnel,
 } from './Struct.js';
 import { getRandomSample, getRandomSample1D, getRandomSample2D, SAMPLER_DIMS_PER_BOUNCE, SAMPLER_DIM_AUX_BASE } from './Random.js';
 import { RAY_FLAG, COUNTER } from '../Processor/QueueManager.js';
@@ -56,7 +58,7 @@ import {
 	readTransparentCount,
 	readMisRayT,
 	readHitDistance, readHitBarycentrics, readHitNormal,
-	readHitMaterialIndex, readHitTriangleIndex, readHitInstanceLeaf,
+	readHitMaterialIndex, readHitTriangleIndex, readHitInstanceLeaf, readHitFacet,
 	writeRayOriginMeta, writeRayDirFlags, writeRayThroughputPdf, writeRayRadiance,
 	writeGBuffer, writeGBufferHitDist, readGBuffer, gbDecodeNormalDepth,
 	readRayRadiance,
@@ -96,6 +98,7 @@ export function buildShadeKernel( params ) {
 		globalIlluminationIntensity,
 		cameraProjectionMatrix, cameraViewMatrix,
 		fireflyThreshold, frame, resolution,
+		shadowTerminatorOffset, // Cycles' Shadow Terminator → Geometry Offset; 0 disables
 		// Accumulation index, NOT the free-running seed counter `frame` rides. The firefly clamp
 		// relaxes as sqrt(frame+1) so its bias decays as a render converges; keying that off the
 		// seed axis let it grow for the whole session and disabled suppression outright.
@@ -283,6 +286,7 @@ export function buildShadeKernel( params ) {
 						envTotalSum, envCompensationDelta, envResolution,
 						enableEnvironmentLight,
 						tslBool( true ), // wantUnoccluded
+						vec3( 0.0 ), planeN, float( 0.0 ),
 					) ).toVar();
 
 					const lumShad = max( dot( dual.shadowed, REC709_LUMINANCE_COEFFICIENTS ), float( 0.0 ) );
@@ -930,10 +934,9 @@ export function buildShadeKernel( params ) {
 
 			throughput.mulAssign( interaction.throughput );
 
-			// reflection stays on same side, transmission pushes through
-			const reflectOffsetDir = select( interaction.entering, N, N.negate() );
-			const offsetDir = select( interaction.didReflect, reflectOffsetDir, direction );
-			const newOrigin = hitPoint.add( offsetDir.mul( 0.001 ) );
+			// Off the side of the facet the new ray leaves on: reflection stays, transmission and alpha skip cross.
+			const Ng = unpackHitFacet( readHitFacet( hitBufferRO, rayID ) ).faceN;
+			const newOrigin = offsetRayOrigin( hitPoint, select( dot( Ng, interaction.direction ).lessThan( 0.0 ), Ng.negate(), Ng ) );
 
 			// SSS = free bounce (depth unchanged); transmission advances camera-bounce depth.
 			// Transmissive / alpha-skip / SSS-boundary are all FREE bounces — they do NOT advance camera depth (megakernel parity, gap #4). cameraDepth advances only on opaque scatter (below).
@@ -1062,6 +1065,14 @@ export function buildShadeKernel( params ) {
 		// face-forwarded geometric normal: horizon guard for NEE and the bounce continuation
 		const Ngeo = normalize( hitNormal );
 		const NgeoFF = select( dot( Ngeo, V ).lessThan( 0.0 ), Ngeo.negate(), Ngeo ).toVar();
+		// The facet on the viewer's side: every ray spawned from here is offset off it (HitFacet.js).
+		const facet = unpackHitFacet( readHitFacet( hitBufferRO, rayID ) );
+		const facetN = facet.faceN.toVar();
+		const terminatorLift = Ngeo.mul( facet.liftScale );
+		const lightShadowOrigin = L => shadowTerminatorOrigin( {
+			hitPoint, offsetNormal: facetN, lift: terminatorLift, faceN: facetN, smoothN: NgeoFF, L,
+			cutoff: shadowTerminatorOffset,
+		} );
 
 		// Two-sided shading: opaque path only (transmissive/SSS already continued). Decide the flip on the
 		// GEOMETRIC normal — an inward-normal / double-sided mesh (GLB/PBRT) faces away as a whole — so a
@@ -1094,11 +1105,11 @@ export function buildShadeKernel( params ) {
 				// smooth mirror / metal: DEFER — tint by the specular directional albedo (metal colour),
 				// matching the opaque throughput (≈ F at the near-delta mirror lobe). Achromatic energy excluded.
 				const NoV = max( dot( N, V ), float( 1e-3 ) );
-				const F0 = clamp(
-					mix( dielectricF0( material.ior ).mul( material.specularColor ), albedo, material.metalness ).mul( material.specularIntensity ),
-					vec3( 0.0 ), vec3( 1.0 ),
-				);
-				featCarry.mulAssign( DFGResult.wrap( evaluateDFG( F0, NoV, max( rawRough, float( 0.02 ) ) ) ).E_total );
+				const bf = BaseFresnel.wrap( baseFresnelParams( material, albedo ) );
+				featCarry.mulAssign( DFGResult.wrap( evaluateSpecularDFG(
+					bf.f0, bf.f90, bf.eta, bf.F0m, material.metalness, vec3( 0.0 ), float( 0.0 ), bf.F0,
+					NoV, max( rawRough, float( 0.02 ) ),
+				) ).E_total );
 
 			} );
 
@@ -1176,6 +1187,7 @@ export function buildShadeKernel( params ) {
 			envTotalSum, envCompensationDelta, envResolution,
 			enableEnvironmentLight,
 			tslBool( false ), // wantUnoccluded: false on real surfaces — dead-codes the unoccluded sum
+			terminatorLift, facetN, shadowTerminatorOffset,
 		) ).shadowed.toVar();
 
 		const giScale = select( bounceIndex.greaterThan( 0 ), globalIlluminationIntensity, float( 1.0 ) );
@@ -1230,11 +1242,12 @@ export function buildShadeKernel( params ) {
 
 							If( NoL.greaterThan( 0.0 ).and( dot( emissiveSample.direction, NgeoFF ).greaterThan( 0.0 ) ), () => {
 
-								const rayOffset = calculateRayOffset( hitPoint, NgeoFF, material );
-								const rayOrigin = hitPoint.add( rayOffset );
-								const shadowDist = emissiveSample.distance.sub( 0.001 );
+								// Aimed at the sampled point and stopped a relative hair short, as for area lights.
+								const rayOrigin = lightShadowOrigin( emissiveSample.direction ).toVar();
+								const toSample = emissiveSample.position.sub( rayOrigin ).toVar();
+								const shadowDist = length( toSample ).toVar();
 								const visibility = traceShadowRayWrapped(
-									rayOrigin, emissiveSample.direction, shadowDist,
+									rayOrigin, toSample.div( shadowDist ), shadowDist.mul( SHADOW_END ),
 								);
 
 								If( visibility.greaterThan( 0.0 ), () => {
@@ -1278,7 +1291,7 @@ export function buildShadeKernel( params ) {
 							lightBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 							triangleBuffer, bvhBuffer,
 							traceShadowRayWrapped,
-							calculateRayOffset,
+							Fn( ( [ p, , L ] ) => lightShadowOrigin( L ).sub( p ) ),
 						);
 
 						currentRadiance.assign( vec4(
@@ -1352,7 +1365,7 @@ export function buildShadeKernel( params ) {
 
 		} );
 
-		const newOrigin = hitPoint.add( N.mul( 0.001 ) );
+		const newOrigin = offsetRayOrigin( hitPoint, select( dot( facetN, bounceDir ).lessThan( 0.0 ), facetN.negate(), facetN ) );
 
 		// Opaque scatter: the only bounce that advances camera depth.
 		writeRayOriginMeta( rayBufferRW, rayID, newOrigin, cameraDepth.add( 1 ), sssSteps, transparentCount );

package/src/TSL/ShadowTerminator.js

@@ -0,0 +1,125 @@
+/**
+ * Cycles' shadow terminator geometry offset (kernel/light/sample.h, Blender 5.1).
+ *
+ * Near the terminator of a smooth-shaded low-poly surface, a light's shadow ray leaving the flat
+ * facet is blocked by that facet or its neighbours although the smooth normal says the point is lit,
+ * which draws the mesh's outline into the shading. Starting the ray on the smooth surface the vertex
+ * normals describe — lifted along the normal by a parabolic estimate, bounded by each vertex's
+ * tangent plane — removes it. Only light and environment shadow rays use it, as in Cycles.
+ *
+ * Extend computes the lift with the facet normal (HitFacet.js), where the triangle's corners were just
+ * read, and packs both into the hit record's spare lane.
+ */
+
+import { vec3, float, max, min, dot, length, clamp, select, If } from 'three/tsl';
+import { instanceRows, instanceDirToWorld, offsetRayOrigin } from './Common.js';
+
+/**
+ * The lift at full strength, as a signed length along the hit's smooth normal, from the triangle's
+ * corners (see HitFacet.js). Cycles lifts along the object-to-world image of that normal; the two
+ * agree unless the placement scales non-uniformly. Zero on a flat-shaded triangle.
+ *
+ * @param {Object} p - corners and vertex normals as stored (object space when `instanced`), and
+ *   `faceN`, the world facet normal on the viewer's side
+ */
+export function shadowTerminatorLift( { V0, V1, V2, N0, N1, N2, hitPoint, instanced, bvhBuffer, instanceLeaf, faceN } ) {
+
+	const scale = float( 0.0 ).toVar();
+
+	const P = hitPoint.toVar();
+	If( instanced, () => {
+
+		const rows = instanceRows( bvhBuffer, instanceLeaf );
+		P.assign( vec3(
+			rows[ 0 ].xyz.dot( hitPoint ).add( rows[ 0 ].w ),
+			rows[ 1 ].xyz.dot( hitPoint ).add( rows[ 1 ].w ),
+			rows[ 2 ].xyz.dot( hitPoint ).add( rows[ 2 ].w ),
+		) );
+
+	} );
+
+	// The hit record keeps texture UVs, not barycentrics.
+	const e1 = V1.sub( V0 ).toVar();
+	const e2 = V2.sub( V0 ).toVar();
+	const ep = P.sub( V0 ).toVar();
+	const d11 = dot( e1, e1 );
+	const d12 = dot( e1, e2 );
+	const d22 = dot( e2, e2 );
+	const den = d11.mul( d22 ).sub( d12.mul( d12 ) ).toVar();
+
+	If( den.greaterThan( d11.mul( d22 ).mul( 1e-12 ) ), () => {
+
+		const dp1 = dot( ep, e1 );
+		const dp2 = dot( ep, e2 );
+		const v = clamp( d22.mul( dp1 ).sub( d12.mul( dp2 ) ).div( den ), 0.0, 1.0 ).toVar();
+		const w = clamp( d11.mul( dp2 ).sub( d12.mul( dp1 ) ).div( den ), 0.0, float( 1.0 ).sub( v ) ).toVar();
+		const u = float( 1.0 ).sub( v ).sub( w ).toVar();
+
+		const Pl = V0.mul( u ).add( V1.mul( v ) ).add( V2.mul( w ) ).toVar();
+		const nLocal = N0.mul( u ).add( N1.mul( v ) ).add( N2.mul( w ) ).toVar();
+		const n = nLocal.toVar();
+		If( instanced, () => {
+
+			const rows = instanceRows( bvhBuffer, instanceLeaf );
+			n.assign( instanceDirToWorld( { r0: rows[ 0 ].xyz, r1: rows[ 1 ].xyz, r2: rows[ 2 ].xyz, v: nLocal } ) );
+
+		} );
+
+		// Parabolic approximation.
+		const a = dot( N2.sub( N0 ), V0.sub( V2 ) );
+		const b = dot( N2.sub( N1 ), V1.sub( V2 ) );
+		const c = dot( N1.sub( N0 ), V1.sub( V0 ) );
+		const h = a.mul( u ).mul( u.sub( 1.0 ) ).add( a.add( b ).add( c ).mul( u ).mul( v ) ).add( b.mul( v ).mul( v.sub( 1.0 ) ) ).toVar();
+
+		// Bounded by the local linear envelope of the vertices' tangent planes.
+		If( dot( n, faceN ).greaterThan( 0.0 ), () => {
+
+			const h0 = max( dot( V0.sub( Pl ), N0 ).add( max( max( dot( V1.sub( V0 ), N0 ), dot( V2.sub( V0 ), N0 ) ), 0.0 ) ), 0.0 );
+			const h1 = max( dot( V1.sub( Pl ), N1 ).add( max( max( dot( V0.sub( V1 ), N1 ), dot( V2.sub( V1 ), N1 ) ), 0.0 ) ), 0.0 );
+			const h2 = max( dot( V2.sub( Pl ), N2 ).add( max( max( dot( V0.sub( V2 ), N2 ), dot( V1.sub( V2 ), N2 ) ), 0.0 ) ), 0.0 );
+			h.assign( max( min( min( h0, h1 ), h2 ), h.mul( 0.5 ) ) );
+
+		} ).Else( () => {
+
+			const h0 = max( dot( Pl.sub( V0 ), N0 ).add( max( max( dot( V0.sub( V1 ), N0 ), dot( V0.sub( V2 ), N0 ) ), 0.0 ) ), 0.0 );
+			const h1 = max( dot( Pl.sub( V1 ), N1 ).add( max( max( dot( V1.sub( V0 ), N1 ), dot( V1.sub( V2 ), N1 ) ), 0.0 ) ), 0.0 );
+			const h2 = max( dot( Pl.sub( V2 ), N2 ).add( max( max( dot( V2.sub( V0 ), N2 ), dot( V2.sub( V1 ), N2 ) ), 0.0 ) ), 0.0 );
+			h.assign( min( min( min( h0, h1 ), h2 ).negate(), h.mul( 0.5 ) ) );
+
+		} );
+
+		scale.assign( length( n ).mul( h ) );
+
+	} );
+
+	return scale;
+
+}
+
+/**
+ * A shadow ray's origin towards direction `L`: lifted by the share of the lift Cycles gives a
+ * direction this close to the terminator, then offset as every spawned ray is.
+ *
+ * @param {Object} p
+ * @param {Node} p.lift - the hit's unit smooth normal times the lift's scale
+ * @param {Node} p.smoothN - the interpolated normal on the viewer's side (Cycles' sd->N)
+ * @param {Node} p.cutoff - the geometry offset setting; 0 disables
+ */
+export function shadowTerminatorOrigin( { hitPoint, offsetNormal, lift, faceN, smoothN, L, cutoff } ) {
+
+	// Cycles lifts towards the back for a transmitted direction; NEE here only lights the front.
+	const NL = dot( smoothN, L );
+	const NgL = dot( faceN, L );
+	const c = max( cutoff, 1e-6 );
+	const amount = select(
+		cutoff.greaterThan( 0.0 ).and( NL.greaterThan( 0.0 ) ),
+		select(
+			NL.lessThan( cutoff ),
+			clamp( float( 2.0 ).sub( NgL.add( NL ).div( c ) ), 0.0, 1.0 ),
+			clamp( float( 1.0 ).sub( NgL.div( c ) ), 0.0, 1.0 ),
+		),
+		float( 0.0 ),
+	);
+	return offsetRayOrigin( hitPoint.add( lift.mul( amount ) ), offsetNormal );
+
+}

package/src/TSL/Struct.js

@@ -198,6 +198,15 @@ export const DFGResult = struct( {
 	E_total: 'vec3', // clamp(E_ss * compensation, 0, 1)
 } );
 
+// Base-layer Fresnel inputs (see baseFresnelParams).
+export const BaseFresnel = struct( {
+	f0: 'vec3', // dielectric reflectance head-on: min(F0(ior) * specularColor, 1) * specularIntensity
+	f90: 'float', // dielectric reflectance at grazing: specularIntensity
+	eta: 'float', // max(ior, 1)
+	F0m: 'vec3', // metal F0: color * specularIntensity
+	F0: 'vec3', // the two blended by metalness — the multiscatter tint and the iridescence substrate
+} );
+
 export const MaterialSamples = struct( {
 	albedo: 'vec4',
 	emissive: 'vec3',

package/src/TSL/Subsurface.js

@@ -30,7 +30,7 @@ import {
 import { struct } from './patches.js';
 import { TWO_PI, EPSILON, constructTBN } from './Common.js';
 import { getRandomSample1D, getRandomSample2D } from './Random.js';
-import { iorToFresnel0, fresnelSchlickFloat } from './Fresnel.js';
+import { fresnelDielectric } from './Fresnel.js';
 import { ImportanceSampleGGX } from './MaterialSampling.js';
 
 // ================================================================================
@@ -189,8 +189,7 @@ export const handleSubsurfaceEntry = Fn( ( [
 	const sinThetaT2 = n1.mul( n1 ).div( max( n2.mul( n2 ), EPSILON ) ).mul( float( 1.0 ).sub( cosThetaI.mul( cosThetaI ) ) );
 	const tir = sinThetaT2.greaterThan( 1.0 ).toVar();
 
-	const F0 = iorToFresnel0( n2, n1 );
-	const Fr = select( tir, float( 1.0 ), fresnelSchlickFloat( cosThetaI, F0 ) ).toVar();
+	const Fr = fresnelDielectric( cosThetaI, n2.div( max( n1, EPSILON ) ) ).toVar();
 	const reflectProb = clamp( Fr, 0.02, 0.98 ).toVar();
 
 	const doReflect = tir.or( getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 11 ) ), rngState, resolution, frame ).lessThan( reflectProb ) ).toVar();

package/src/index.js

@@ -27,7 +27,7 @@ export { SETTING_SOURCE } from './RenderSettings.js';
 export { configureAssets, getAssetConfig } from './AssetConfig.js';
 
 // glTF alphaMode derivation — the one definition, shared with hosts that edit materials
-export { deriveAlphaMode } from './Processor/GeometryExtractor.js';
+export { deriveAlphaMode, MATERIAL_VALUE_SOURCE } from './Processor/GeometryExtractor.js';
 
 // Scene-level authoring metadata embedded in model files (glTF `extras`)
 export { extractSceneMetadata, parseSceneMetadata } from './Processor/SceneMetadata.js';
@@ -53,6 +53,7 @@ export {
 	BVH_LEAF_MARKERS,
 	TEXTURE_CONSTANTS,
 	DEFAULT_TEXTURE_MATRIX,
+	MATERIAL_DEFAULTS,
 	MEMORY_CONSTANTS,
 	PRODUCTION_RENDER_CONFIG,
 	INTERACTIVE_RENDER_CONFIG,
@@ -98,8 +99,35 @@ export { VideoRenderManager } from './managers/VideoRenderManager.js';
 // Interaction
 export { InteractionManager } from './managers/InteractionManager.js';
 
-// DLSS neural passes. The app drives these through `denoisingManager` — what is exported here is
+// Neural post passes. The app drives these through `denoisingManager` — what is exported here is
 // the offline entry point (`renderUpscaled`, used by the regression bench) plus the two contracts a
 // host needs to build UI against.
-export { renderUpscaled, SR_SCALE, SR_MAX_INPUT } from './dlss/DLSSSuperRes.js';
-export { DLSS_NR_DEFAULTS, DLSS_NR_RANGES, DLSS_NR_MAX_PIXELS } from './dlss/DLSSNeural.js';
+export { renderUpscaled, SR_SCALE, SR_MAX_INPUT } from './neural/NeuralSuperRes.js';
+export { RETOUCH_DEFAULTS, RETOUCH_RANGES, RETOUCH_MAX_PIXELS } from './neural/NeuralRetouch.js';
+
+// ── Colour management ───────────────────────────────────────────────────────────────────────────
+// `app.color` is the instance a host normally uses; these are for building UI against it, and for
+// code that needs the view-transform registry without an app.
+export {
+	ColorManagement, getActiveColorManagement, setActiveColorManagement,
+	isColorManaged, DEFAULT_WORKING_SPACE, findNativeLinearSpace, canvasColorSpaceFor,
+} from './Color/ColorManagement.js';
+export { displayCanvasFit } from './Color/Displays.js';
+export {
+	VIEW_TRANSFORMS, listViewTransforms, getViewTransform, addViewTransform, removeViewTransform,
+	onRegistryChange, getRegistryVersion, buildToneMapWGSL,
+	OCIO_VIEW_BASE, MAX_TABLE_TRANSFORMS,
+} from './Color/ViewTransforms.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/managers/DenoisingManager.js

@@ -4,9 +4,9 @@ import { AIUpscaler } from '../Passes/AIUpscaler.js';
 import { EngineEvents } from '../EngineEvents.js';
 import { createLogger } from '../utils/Logger.js';
 
-// The neural passes live in `../dlss/` but report through the manager that drives them, so they
-// share one namespace: `rayzee.log.only( 'dlss' )` shows the whole chain.
-const dlssLog = createLogger( 'dlss' );
+// The neural passes live in `../neural/` but report through the manager that drives them, so they
+// share one namespace: `rayzee.log.only( 'neural' )` shows the whole chain.
+const neuralLog = createLogger( 'neural' );
 import { ENGINE_DEFAULTS as DEFAULT_STATE, ASVGF_QUALITY_PRESETS, NRD_DEFAULTS, NRD_QUALITY_PRESETS, NRD_PRESET_KEYS } from '../EngineDefaults.js';
 
 // A refresh slower than this is a slideshow, not a live view, so the cadence swaps to a cheaper
@@ -112,16 +112,16 @@ export class DenoisingManager extends EventDispatcher {
 
 		this.denoiser = null;
 		this.upscaler = null;
-		// Which model the AI upscaler runs. 'esrgan' is the ONNX chain; 'dlss' is the neural
+		// Which model the AI upscaler runs. 'esrgan' is the ONNX chain; 'neural' is the neural
 		// super-resolution pass, which is fixed at 2x and needs a denoised source.
 		this.upscalerBackend = 'esrgan';
-		this._dlssUpscaler = null;
+		this._neuralUpscaler = null;
 		// The neural-rendering (detail) pass is independent of the upscaler: it changes appearance,
 		// not resolution, and runs last because its result cannot be read back.
 		this.neuralRendering = false;
 		this.neuralRenderingSettings = {};
-		this._dlssNeural = null;
-		this._dlssModule = null;
+		this._retouch = null;
+		this._superResModule = null;
 		this._neuralPostBusy = false;
 
 		// The tier the finished image uses. The loaded tier is not always this one: while the
@@ -162,6 +162,7 @@ export class DenoisingManager extends EventDispatcher {
 		// Bound event forwarding handlers (stored for removal on re-setup / dispose)
 		this._denoiserStartHandler = null;
 		this._denoiserEndHandler = null;
+		this._denoiserTileHandler = null;
 		this._upscalerResChangedHandler = null;
 		this._upscalerStartHandler = null;
 		this._upscalerProgressHandler = null;
@@ -298,8 +299,21 @@ export class DenoisingManager extends EventDispatcher {
 
 		};
 
+		// The loop has stopped by the time a final denoise runs, so each tile has to redraw the
+		// canvas itself. Not through the display-refresh callback: that restarts the loop, which a
+		// video export drives by hand.
+		this._denoiserTileHandler = e => {
+
+			if ( e.continuous ) return;
+			this._publishOutput();
+			const ctx = this.pipeline?.context;
+			if ( this._stages.compositor && ctx ) this._stages.compositor.render( ctx );
+
+		};
+
 		this.denoiser.addEventListener( 'start', this._denoiserStartHandler );
 		this.denoiser.addEventListener( 'end', this._denoiserEndHandler );
+		this.denoiser.addEventListener( 'tileProgress', this._denoiserTileHandler );
 
 	}
 
@@ -804,20 +818,20 @@ export class DenoisingManager extends EventDispatcher {
 	}
 
 	/**
-	 * Selects the AI upscaler's model. 'dlss' is fixed at 2x and reads the denoised picture, so it
+	 * Selects the AI upscaler's model. 'neural' is fixed at 2x and reads the denoised picture, so it
 	 * is a no-op without a denoiser — feeding it raw Monte-Carlo noise measurably loses to bilinear.
 	 *
-	 * @param {'esrgan'|'dlss'} backend
+	 * @param {'esrgan'|'neural'} backend
 	 */
 	setUpscalerBackend( backend ) {
 
-		const next = backend === 'dlss' ? 'dlss' : 'esrgan';
+		const next = backend === 'neural' ? 'neural' : 'esrgan';
 		if ( next === this.upscalerBackend ) return;
 
 		this.upscalerBackend = next;
 		// Whatever is on screen came from the model being switched away from.
 		this._restoreRenderDisplay();
-		if ( next !== 'dlss' ) this._releaseDLSSUpscaler();
+		if ( next !== 'neural' ) this._releaseNeuralUpscaler();
 
 	}
 
@@ -847,15 +861,15 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
-	_releaseDLSSUpscaler() {
+	_releaseNeuralUpscaler() {
 
-		this._dlssUpscaler?.dispose();
-		this._dlssUpscaler = null;
+		this._neuralUpscaler?.dispose();
+		this._neuralUpscaler = null;
 
 		// The frame packer lives on the module, not on the upscaler, and holds two buffers the size
 		// of the render. Nothing else reaches it, so this is its only release point. Guarded on the
 		// module having been loaded, so a teardown never pulls in 1 MB of runtime to call a no-op.
-		this._dlssModule?.releaseDenoisedReader();
+		this._superResModule?.releaseDenoisedReader();
 
 	}
 
@@ -866,17 +880,17 @@ export class DenoisingManager extends EventDispatcher {
 		if ( settings ) this.neuralRenderingSettings = { ...this.neuralRenderingSettings, ...settings };
 		if ( ! this.neuralRendering ) {
 
-			this._releaseDLSSNeural();
+			this._releaseNeuralRetouch();
 			this._restoreRenderDisplay();
 
 		}
 
 	}
 
-	_releaseDLSSNeural() {
+	_releaseNeuralRetouch() {
 
-		this._dlssNeural?.dispose();
-		this._dlssNeural = null;
+		this._retouch?.dispose();
+		this._retouch = null;
 
 	}
 
@@ -894,7 +908,7 @@ export class DenoisingManager extends EventDispatcher {
 	 */
 	async _runNeuralPost( isStillComplete ) {
 
-		const wantSR = this.upscaler?.enabled && this.upscalerBackend === 'dlss';
+		const wantSR = this.upscaler?.enabled && this.upscalerBackend === 'neural';
 		const wantNR = this.neuralRendering;
 		if ( ! wantSR && ! wantNR ) return;
 
@@ -904,14 +918,14 @@ export class DenoisingManager extends EventDispatcher {
 
 		if ( ! this.upscalerCanvas ) {
 
-			dlssLog.warn( 'neural pass skipped: the engine has no overlay canvas to present on' );
+			neuralLog.warn( 'neural pass skipped: the engine has no overlay canvas to present on' );
 			return;
 
 		}
 
 		if ( ! this.pipeline?.context?.getTexture( 'oidn:output' ) ) {
 
-			dlssLog.warn( 'neural pass skipped: no denoised picture — it needs OIDN' );
+			neuralLog.warn( 'neural pass skipped: no denoised picture — it needs OIDN' );
 			return;
 
 		}
@@ -921,26 +935,26 @@ export class DenoisingManager extends EventDispatcher {
 
 		try {
 
-			const sr = await import( '../dlss/DLSSSuperRes.js' );
-			this._dlssModule = sr;
+			const sr = await import( '../neural/NeuralSuperRes.js' );
+			this._superResModule = sr;
 
 			// The detail pass has a size ceiling — above it a run takes minutes and then loses every GPU
 			// device in the page. Running it FIRST is what keeps it under: at render size it sees a
 			// quarter of the pixels it would after a 2x upscale, and the render reserve already caps
 			// that at 2048. The check stays as a floor under a raised reserve.
-			const nrModule = wantNR ? await import( '../dlss/DLSSNeural.js' ) : null;
+			const nrModule = wantNR ? await import( '../neural/NeuralRetouch.js' ) : null;
 			const srcSize = this.denoiser?._outTexSize;
 			const nrPixels = ( srcSize?.width ?? 0 ) * ( srcSize?.height ?? 0 );
-			const runNR = wantNR && nrPixels <= nrModule.DLSS_NR_MAX_PIXELS;
+			const runNR = wantNR && nrPixels <= nrModule.RETOUCH_MAX_PIXELS;
 
 			if ( wantNR && ! runNR ) {
 
-				dlssLog.warn(
+				neuralLog.warn(
 					`Neural rendering skipped: the render is ${( nrPixels / 1e6 ).toFixed( 1 )} MP, above the ` +
-					`${( nrModule.DLSS_NR_MAX_PIXELS / 1e6 ).toFixed( 1 )} MP the pass survives.` +
+					`${( nrModule.RETOUCH_MAX_PIXELS / 1e6 ).toFixed( 1 )} MP the pass survives.` +
 					( wantSR ? ' The upscale still ran.' : '' )
 				);
-				this._releaseDLSSNeural();
+				this._releaseNeuralRetouch();
 
 			}
 
@@ -961,16 +975,16 @@ export class DenoisingManager extends EventDispatcher {
 
 			if ( wantSR ) {
 
-				if ( this._dlssUpscaler
-					&& ( this._dlssUpscaler.inputWidth !== source.width || this._dlssUpscaler.inputHeight !== source.height ) ) {
+				if ( this._neuralUpscaler
+					&& ( this._neuralUpscaler.inputWidth !== source.width || this._neuralUpscaler.inputHeight !== source.height ) ) {
 
-					this._releaseDLSSUpscaler();
+					this._releaseNeuralUpscaler();
 
 				}
 
-				if ( ! this._dlssUpscaler ) {
+				if ( ! this._neuralUpscaler ) {
 
-					this._dlssUpscaler = await sr.DLSSSuperRes.create( { width: source.width, height: source.height } );
+					this._neuralUpscaler = await sr.NeuralSuperRes.create( { width: source.width, height: source.height } );
 
 				}
 
@@ -979,23 +993,23 @@ export class DenoisingManager extends EventDispatcher {
 			let image = source;
 
 			// Detail first, upscale second. The detail pass hands back scene-referred light (see
-			// `app/public/dlss/PATCHES.md`), so the upscaler still gets the linear HDR it expects —
+			// the runtime's `rayzee-patch` edits), so the upscaler still gets the linear HDR it expects —
 			// which is what makes this order possible at all.
 			if ( runNR ) {
 
 				const result = await nrModule.enhanceFrame( {
 					source: image,
 					settings: this.neuralRenderingSettings,
-					instance: this._dlssNeural,
+					instance: this._retouch,
 					exposure: tone.exposure,
 					tone: wantSR ? null : tone,
 				} );
-				this._dlssNeural = result.instance;
+				this._retouch = result.instance;
 				image = result;
 
 			}
 
-			if ( wantSR ) image = await this._dlssUpscaler.upscaleToRGBA8( image, tone );
+			if ( wantSR ) image = await this._neuralUpscaler.upscaleToRGBA8( image, tone );
 
 			if ( ! isStillComplete() ) {
 
@@ -1024,7 +1038,7 @@ export class DenoisingManager extends EventDispatcher {
 
 		} catch ( error ) {
 
-			dlssLog.warn( 'neural pass failed', error );
+			neuralLog.warn( 'neural pass failed', error );
 
 		} finally {
 
@@ -1060,7 +1074,7 @@ export class DenoisingManager extends EventDispatcher {
 
 			// One owner of the overlay canvas, so the neural chain and the ONNX upscaler are
 			// exclusive. The neural chain also runs on its own when only its detail pass is on.
-			if ( this.neuralRendering || ( this.upscaler?.enabled && this.upscalerBackend === 'dlss' ) ) {
+			if ( this.neuralRendering || ( this.upscaler?.enabled && this.upscalerBackend === 'neural' ) ) {
 
 				this._runNeuralPost( isStillComplete );
 				return;
@@ -1184,8 +1198,8 @@ export class DenoisingManager extends EventDispatcher {
 		// Remove pending completion-chain listener
 		this._cleanupCompletionListener();
 		// Owns a second GPUDevice plus 3 MB of weights, so it must not outlive the manager.
-		this._releaseDLSSUpscaler();
-		this._releaseDLSSNeural();
+		this._releaseNeuralUpscaler();
+		this._releaseNeuralRetouch();
 
 		// Before the denoiser destroys the picture the Compositor would otherwise still sample.
 		this._unpublishOutput();
@@ -1194,6 +1208,7 @@ export class DenoisingManager extends EventDispatcher {
 
 			if ( this._denoiserStartHandler ) this.denoiser.removeEventListener( 'start', this._denoiserStartHandler );
 			if ( this._denoiserEndHandler ) this.denoiser.removeEventListener( 'end', this._denoiserEndHandler );
+			if ( this._denoiserTileHandler ) this.denoiser.removeEventListener( 'tileProgress', this._denoiserTileHandler );
 			this.denoiser.dispose();
 			this.denoiser = null;
 
@@ -1207,15 +1222,16 @@ export class DenoisingManager extends EventDispatcher {
 			if ( this._upscalerEndHandler ) this.upscaler.removeEventListener( 'end', this._upscalerEndHandler );
 			this.upscaler.dispose();
 			this.upscaler = null;
-			// Which model the AI upscaler runs. 'esrgan' is the ONNX chain; 'dlss' is the neural
+			// Which model the AI upscaler runs. 'esrgan' is the ONNX chain; 'neural' is the neural
 			// super-resolution pass, which is fixed at 2x and needs a denoised source.
 			this.upscalerBackend = 'esrgan';
-			this._dlssUpscaler = null;
+			this._neuralUpscaler = null;
 
 		}
 
 		this._denoiserStartHandler = null;
 		this._denoiserEndHandler = null;
+		this._denoiserTileHandler = null;
 		this._upscalerResChangedHandler = null;
 		this._upscalerStartHandler = null;
 		this._upscalerProgressHandler = null;