rayzee 7.4.0 → 7.5.0

package/src/Stages/Variance.js

@@ -363,6 +363,19 @@ export class Variance extends RenderStage {
 
 	}
 
+	// Free the 2048² StorageTextures when disabled; three.js re-creates them on the next dispatch
+	// after re-enable, and reset() re-anchors the EMA. See ASVGF.releaseGPUMemory.
+	releaseGPUMemory() {
+
+		this._storageTexA?.dispose();
+		this._storageTexB?.dispose();
+		// Render-res RT texture (dispose .texture, not the RT — RT.dispose() doesn't free it here).
+		this.context?.removeTexture( 'variance:output' );
+		this._outputTarget?.texture?.dispose();
+		this.reset();
+
+	}
+
 	reset() {
 
 		this.currentMoments = 0;

package/src/TSL/GenerateKernel.js

@@ -19,7 +19,7 @@ import { Ray } from './Struct.js';
 import { RAY_FLAG } from '../Processor/QueueManager.js';
 import {
 	writeRayOriginMeta, writeRayDirFlags, writeRayThroughputPdf,
-	writeRayRadiance, writeGBuffer, writeGBufferSurfaceID,
+	writeRayRadiance, writeGBuffer,
 	writeMediumStack,
 } from '../Processor/PackedRayBuffer.js';
 
@@ -86,8 +86,6 @@ export function buildGenerateKernel( params ) {
 
 				// default: normal +Z, depth 1 (far), black albedo (background/miss)
 				writeGBuffer( gBufferRW, uint( pixelIndex ), vec3( 0.0, 0.0, 1.0 ), float( 1.0 ), vec3( 0.0 ) );
-				// surface-ID lane defaults to invalid (valid=0); Shade overwrites it at the bounce-0 hit.
-				writeGBufferSurfaceID( gBufferRW, uint( pixelIndex ), uint( 0 ), uint( 0 ), float( 0.0 ), float( 0.0 ), uint( 0 ) );
 
 			} );
 

package/src/TSL/LightsCore.js

@@ -42,12 +42,15 @@ export const DirectionalLight = struct( {
 
 export const AreaLight = struct( {
 	position: 'vec3',
-	u: 'vec3', // First axis of the rectangular light
-	v: 'vec3', // Second axis of the rectangular light
+	u: 'vec3', // First axis half-vector of the rectangular light
+	v: 'vec3', // Second axis half-vector of the rectangular light
 	color: 'vec3',
-	intensity: 'float',
-	normal: 'vec3',
-	area: 'float',
+	intensity: 'float', // radiant power (Watts), Blender-style
+	normalize: 'float', // 1 = power normalized over area (radiance ∝ 1/area), 0 = constant radiance
+	spread: 'float', // emission cone half-fan in radians, π = full Lambertian hemisphere
+	shape: 'float', // 0 = rectangle, 1 = disk/ellipse
+	normal: 'vec3', // derived
+	area: 'float', // derived (true world area: rect = w·h, ellipse = π/4·w·h)
 } );
 
 export const PointLight = struct( {
@@ -125,7 +128,7 @@ export const getDirectionalLight = Fn( ( [ directionalLightsBuffer, index ] ) =>
 
 export const getAreaLight = Fn( ( [ areaLightsBuffer, index ] ) => {
 
-	const baseIndex = index.mul( 13 );
+	const baseIndex = index.mul( 16 );
 	const u = vec3(
 		areaLightsBuffer.element( baseIndex.add( 3 ) ),
 		areaLightsBuffer.element( baseIndex.add( 4 ) ),
@@ -138,6 +141,10 @@ export const getAreaLight = Fn( ( [ areaLightsBuffer, index ] ) => {
 	).toVar();
 
 	const crossUV = cross( u, v );
+	const shape = areaLightsBuffer.element( baseIndex.add( 15 ) );
+
+	// u,v are half-vectors → full rectangle area = 4·|u×v|; disk/ellipse = π/4 of that.
+	const rectArea = length( crossUV ).mul( 4.0 );
 
 	return AreaLight( {
 		position: vec3(
@@ -153,8 +160,11 @@ export const getAreaLight = Fn( ( [ areaLightsBuffer, index ] ) => {
 			areaLightsBuffer.element( baseIndex.add( 11 ) ),
 		),
 		intensity: areaLightsBuffer.element( baseIndex.add( 12 ) ),
+		normalize: areaLightsBuffer.element( baseIndex.add( 13 ) ),
+		spread: areaLightsBuffer.element( baseIndex.add( 14 ) ),
+		shape: shape,
 		normal: normalize( crossUV ),
-		area: length( crossUV ).mul( 4.0 ),
+		area: select( shape.greaterThan( 0.5 ), rectArea.mul( 0.7853981633974483 ), rectArea ),
 	} );
 
 } );
@@ -501,12 +511,18 @@ export const intersectAreaLight = Fn( ( [ light, rayOrigin, rayDirection ] ) =>
 			const u_dir = light.u.div( uLen );
 			const v_dir = light.v.div( vLen );
 
-			// Project onto axes
-			const u_proj = dot( localPoint, u_dir );
-			const v_proj = dot( localPoint, v_dir );
+			// Project onto axes, normalized to [-1,1] across the half-extents
+			const u_proj = dot( localPoint, u_dir ).div( uLen );
+			const v_proj = dot( localPoint, v_dir ).div( vLen );
 
-			// Check within rectangle bounds (half-lengths)
-			If( abs( u_proj ).lessThanEqual( uLen ).and( abs( v_proj ).lessThanEqual( vLen ) ), () => {
+			// Rectangle: |u|≤1 ∧ |v|≤1.  Disk/ellipse: u²+v²≤1.
+			const inside = select(
+				light.shape.greaterThan( 0.5 ),
+				u_proj.mul( u_proj ).add( v_proj.mul( v_proj ) ).lessThanEqual( 1.0 ),
+				abs( u_proj ).lessThanEqual( 1.0 ).and( abs( v_proj ).lessThanEqual( 1.0 ) ),
+			);
+
+			If( inside, () => {
 
 				result.assign( t );
 
@@ -520,3 +536,114 @@ export const intersectAreaLight = Fn( ( [ light, rayOrigin, rayDirection ] ) =>
 
 } );
 
+// ================================================================================
+// SPHERICAL RECTANGLE SAMPLING (Ureña et al. 2013, "An Area-Preserving
+// Parametrization for Spherical Rectangles"). Same scheme Cycles uses for rect
+// area lights — samples the light's solid angle directly, giving pdf = 1/S in
+// solid-angle measure (much lower variance than uniform-area sampling for
+// large/near lights). Inputs:
+//   o  = shading point (ray origin)
+//   s  = rectangle corner = center - u - v
+//   ex = full edge vector along u (= 2·u)
+//   ey = full edge vector along v (= 2·v)
+// ================================================================================
+
+// Solid angle S subtended by the rectangle from o (used for the BSDF-hit MIS pdf).
+export const sphQuadSolidAngle = /*@__PURE__*/ wgslFn( `
+	fn sphQuadSolidAngle( o: vec3f, s: vec3f, ex: vec3f, ey: vec3f ) -> f32 {
+		let PI = 3.141592653589793f;
+		let exl = length( ex );
+		let eyl = length( ey );
+		let x = ex / max( exl, 1e-12f );
+		let y = ey / max( eyl, 1e-12f );
+		var z = cross( x, y );
+		let d = s - o;
+		var z0 = dot( d, z );
+		if ( z0 > 0.0f ) { z = -z; z0 = -z0; }
+		let x0 = dot( d, x );
+		let y0 = dot( d, y );
+		let x1 = x0 + exl;
+		let y1 = y0 + eyl;
+		let v00 = vec3f( x0, y0, z0 );
+		let v01 = vec3f( x0, y1, z0 );
+		let v10 = vec3f( x1, y0, z0 );
+		let v11 = vec3f( x1, y1, z0 );
+		let n0 = normalize( cross( v00, v10 ) );
+		let n1 = normalize( cross( v10, v11 ) );
+		let n2 = normalize( cross( v11, v01 ) );
+		let n3 = normalize( cross( v01, v00 ) );
+		let g0 = acos( clamp( -dot( n0, n1 ), -1.0f, 1.0f ) );
+		let g1 = acos( clamp( -dot( n1, n2 ), -1.0f, 1.0f ) );
+		let g2 = acos( clamp( -dot( n2, n3 ), -1.0f, 1.0f ) );
+		let g3 = acos( clamp( -dot( n3, n0 ), -1.0f, 1.0f ) );
+		return g0 + g1 + g2 + g3 - 2.0f * PI;
+	}
+` );
+
+// Sample a direction toward the rectangle uniformly in solid angle.
+// Returns vec4( pointOnRect.xyz, pdf ); pdf = 1/S. pdf <= 0 signals the caller
+// to fall back to uniform-area sampling (degenerate / tiny solid angle).
+export const sampleSphQuad = /*@__PURE__*/ wgslFn( `
+	fn sampleSphQuad( o: vec3f, s: vec3f, ex: vec3f, ey: vec3f, uv: vec2f ) -> vec4f {
+		let PI = 3.141592653589793f;
+		let exl = length( ex );
+		let eyl = length( ey );
+		let x = ex / max( exl, 1e-12f );
+		let y = ey / max( eyl, 1e-12f );
+		var z = cross( x, y );
+		let d = s - o;
+		var z0 = dot( d, z );
+		if ( z0 > 0.0f ) { z = -z; z0 = -z0; }
+		let z0sq = z0 * z0;
+		let x0 = dot( d, x );
+		let y0 = dot( d, y );
+		let x1 = x0 + exl;
+		let y1 = y0 + eyl;
+		let y0sq = y0 * y0;
+		let y1sq = y1 * y1;
+		let v00 = vec3f( x0, y0, z0 );
+		let v01 = vec3f( x0, y1, z0 );
+		let v10 = vec3f( x1, y0, z0 );
+		let v11 = vec3f( x1, y1, z0 );
+		let n0 = normalize( cross( v00, v10 ) );
+		let n1 = normalize( cross( v10, v11 ) );
+		let n2 = normalize( cross( v11, v01 ) );
+		let n3 = normalize( cross( v01, v00 ) );
+		let g0 = acos( clamp( -dot( n0, n1 ), -1.0f, 1.0f ) );
+		let g1 = acos( clamp( -dot( n1, n2 ), -1.0f, 1.0f ) );
+		let g2 = acos( clamp( -dot( n2, n3 ), -1.0f, 1.0f ) );
+		let g3 = acos( clamp( -dot( n3, n0 ), -1.0f, 1.0f ) );
+		let b0 = n0.z;
+		let b1 = n2.z;
+		let b0sq = b0 * b0;
+		let k = 2.0f * PI - g2 - g3;
+		let S = g0 + g1 + g2 + g3 - 2.0f * PI;
+
+		if ( S <= 1e-5f ) {
+			return vec4f( 0.0f, 0.0f, 0.0f, -1.0f );
+		}
+
+		let au = uv.x * S + k;
+		let sinAu = sin( au );
+		let fu = ( cos( au ) * b0 - b1 ) / max( abs( sinAu ), 1e-7f ) * sign( sinAu );
+		var cu = select( -1.0f, 1.0f, fu >= 0.0f ) / sqrt( fu * fu + b0sq );
+		cu = clamp( cu, -1.0f, 1.0f );
+
+		var xu = -( cu * z0 ) / max( sqrt( 1.0f - cu * cu ), 1e-7f );
+		xu = clamp( xu, x0, x1 );
+
+		let dd = sqrt( xu * xu + z0sq );
+		let h0 = y0 / sqrt( dd * dd + y0sq );
+		let h1 = y1 / sqrt( dd * dd + y1sq );
+		let hv = h0 + uv.y * ( h1 - h0 );
+		let hv2 = hv * hv;
+		var yv = y1;
+		if ( hv2 < 1.0f - 1e-6f ) {
+			yv = ( hv * dd ) / sqrt( 1.0f - hv2 );
+		}
+
+		let p = o + xu * x + yv * y + z0 * z;
+		return vec4f( p, 1.0f / S );
+	}
+` );
+

package/src/TSL/LightsSampling.js

@@ -29,6 +29,7 @@ import {
 	sqrt,
 	cos,
 	sin,
+	tan,
 	dot,
 	cross,
 	normalize,
@@ -56,6 +57,8 @@ import {
 	sampleSpotGoboMask,
 	sampleDirectionalGoboMask,
 	sampleIESProfile,
+	sampleSphQuad,
+	sphQuadSolidAngle,
 } from './LightsCore.js';
 
 import { MISStrategy, DotProducts, DirectLightingDual } from './Struct.js';
@@ -90,7 +93,49 @@ const TWO_PI = 2.0 * PI;
 // Light Sampling Functions
 // =============================================================================
 
-// Enhanced area light sampling - rectangle
+// Blender-style area-light spread: linearly attenuates emission as the receiver
+// moves off the light's axis (gridded-softbox look). cosAngle = dot(-dir, normal),
+// the emission cosine. spread = π (default) → full Lambertian hemisphere, no
+// attenuation. Mirrors Cycles' area_light_spread_attenuation.
+export const areaLightSpreadAttenuation = Fn( ( [ cosAngle, spread ] ) => {
+
+	const att = float( 1.0 ).toVar();
+
+	// Only attenuate for narrowed cones; at the π default tan(π/2)=∞ → skip.
+	If( spread.lessThan( float( PI ).sub( 1e-3 ) ).and( cosAngle.greaterThan( 0.0 ) ), () => {
+
+		const halfSpread = spread.mul( 0.5 ).toVar();
+		const tanHalf = tan( halfSpread ).toVar();
+		const sinA = sqrt( max( float( 1.0 ).sub( cosAngle.mul( cosAngle ) ), 0.0 ) );
+		const tanA = sinA.div( max( cosAngle, 1e-4 ) );
+		// Flux renormalization so narrowing the beam doesn't dim total power.
+		const normSpread = select(
+			halfSpread.greaterThan( 0.05 ),
+			float( 1.0 ).div( max( tanHalf.sub( halfSpread ), 1e-6 ) ),
+			float( 3.0 ).div( max( halfSpread.mul( halfSpread ).mul( halfSpread ), 1e-9 ) ),
+		);
+		att.assign( max( tanHalf.sub( tanA ).mul( normSpread ), 0.0 ) );
+
+	} );
+
+	return att;
+
+} );
+
+// Emitted radiance for an area light (Blender/Cycles parity):
+//   L = color · power · (1/π) · (normalize ? 1/area : 1)
+// The 1/π is the Lambertian emitter normalization; the 1/area (Normalize ON)
+// keeps total radiant power constant as the light is resized.
+export const areaLightRadiance = Fn( ( [ light ] ) => {
+
+	const invArea = select( light.normalize.greaterThan( 0.5 ), float( 1.0 ).div( max( light.area, 1e-10 ) ), float( 1.0 ) );
+	return light.color.mul( light.intensity ).mul( PI_INV ).mul( invArea );
+
+} );
+
+// Area light sampling — rectangle uses spherical-rectangle (Ureña 2013)
+// solid-angle sampling (pdf = 1/S); disk/ellipse and degenerate rects fall back
+// to uniform-area sampling with the dist²/(area·cos) area→solid-angle pdf.
 export const sampleRectAreaLight = Fn( ( [ light, rayOrigin, ruv, lightSelectionPdf ] ) => {
 
 	// Result variables (no early return in TSL)
@@ -104,12 +149,49 @@ export const sampleRectAreaLight = Fn( ( [ light, rayOrigin, ruv, lightSelection
 	// Validate light area to prevent NaN
 	If( light.area.greaterThan( 0.0 ), () => {
 
-		// Sample random position on rectangle (u/v are half-vectors, so map [0,1] → [-1,1])
-		const randomPos = light.position
-			.add( light.u.mul( ruv.x.mul( 2.0 ).sub( 1.0 ) ) )
-			.add( light.v.mul( ruv.y.mul( 2.0 ).sub( 1.0 ) ) );
+		const sampledPos = vec3( 0.0 ).toVar();
+		// >0 → pdf already in solid-angle measure (spherical-rect); <0 → use area conversion.
+		const solidAnglePdf = float( - 1.0 ).toVar();
+
+		If( light.shape.greaterThan( 0.5 ), () => {
+
+			// Disk / ellipse: uniform sample on the unit disk, mapped through the
+			// half-vectors. PDF handled via the area→solid-angle conversion below.
+			const r = sqrt( ruv.x ).toVar();
+			const theta = float( TWO_PI ).mul( ruv.y ).toVar();
+			sampledPos.assign(
+				light.position
+					.add( light.u.mul( r.mul( cos( theta ) ) ) )
+					.add( light.v.mul( r.mul( sin( theta ) ) ) )
+			);
+
+		} ).Else( () => {
+
+			// Rectangle: spherical-rectangle solid-angle sampling.
+			const corner = light.position.sub( light.u ).sub( light.v );
+			const ex = light.u.mul( 2.0 );
+			const ey = light.v.mul( 2.0 );
+			const q = sampleSphQuad( rayOrigin, corner, ex, ey, ruv ).toVar();
+
+			If( q.w.greaterThan( 0.0 ), () => {
+
+				sampledPos.assign( q.xyz );
+				solidAnglePdf.assign( q.w );
+
+			} ).Else( () => {
+
+				// Degenerate / tiny solid angle → uniform-area fallback.
+				sampledPos.assign(
+					light.position
+						.add( light.u.mul( ruv.x.mul( 2.0 ).sub( 1.0 ) ) )
+						.add( light.v.mul( ruv.y.mul( 2.0 ).sub( 1.0 ) ) )
+				);
 
-		const toLight = randomPos.sub( rayOrigin ).toVar();
+			} );
+
+		} );
+
+		const toLight = sampledPos.sub( rayOrigin ).toVar();
 		const lightDistSq = dot( toLight, toLight ).toVar();
 
 		// Guard against zero distance
@@ -117,17 +199,17 @@ export const sampleRectAreaLight = Fn( ( [ light, rayOrigin, ruv, lightSelection
 
 			const dist = sqrt( lightDistSq ).toVar();
 			const direction = toLight.div( dist ).toVar();
-			const lightNormal = normalize( cross( light.u, light.v ) ).toVar();
-			const cosAngle = dot( direction.negate(), lightNormal ).toVar();
+			const cosAngle = dot( direction.negate(), light.normal ).toVar();
 
 			ls_lightType.assign( int( LIGHT_TYPE_AREA ) );
-			ls_emission.assign( light.color.mul( light.intensity ) );
 			ls_distance.assign( dist );
 			ls_direction.assign( direction );
-			// Guard division: ensure denominator is never zero
-			ls_pdf.assign(
-				lightDistSq.div( max( light.area.mul( max( cosAngle, 0.001 ) ), 1e-10 ) ).mul( lightSelectionPdf )
-			);
+			ls_emission.assign( areaLightRadiance( light ).mul( areaLightSpreadAttenuation( cosAngle, light.spread ) ) );
+
+			// Spherical-rect: pdf = 1/S (solid angle). Else: dist²/(area·cos).
+			const areaPdf = lightDistSq.div( max( light.area.mul( max( cosAngle, 0.001 ) ), 1e-10 ) );
+			const dirPdf = select( solidAnglePdf.greaterThan( 0.0 ), solidAnglePdf, areaPdf );
+			ls_pdf.assign( dirPdf.mul( lightSelectionPdf ) );
 			ls_valid.assign( cosAngle.greaterThan( 0.0 ) );
 
 		} );
@@ -679,6 +761,91 @@ export const calculateMaterialPDF = Fn( ( [ viewDir, lightDir, normal, material
 
 } );
 
+// Total light-selection weight at a shading point, replicating the NEE reservoir's
+// importance accumulation (same per-type importance fns, same 16-light cap + order).
+// Used to reconstruct the exact NEE selection pdf for MIS on the BSDF-hit path —
+// the analogue of Cycles' light_tree_pdf re-walk. Without it, the BSDF-hit MIS
+// partner assumes uniform 1/N selection, which disagrees with the importance-
+// weighted NEE selection and biases the power-heuristic weights.
+export const computeTotalLightImportance = Fn( ( [
+	rayOrigin, normal, material, bounceIndex,
+	directionalLightsBuffer, numDirectionalLights,
+	areaLightsBuffer, numAreaLights,
+	pointLightsBuffer, numPointLights,
+	spotLightsBuffer, numSpotLights,
+] ) => {
+
+	const totalWeight = float( 0.0 ).toVar();
+	const lightIndex = int( 0 ).toVar();
+
+	If( numDirectionalLights.greaterThan( int( 0 ) ), () => {
+
+		Loop( { start: int( 0 ), end: numDirectionalLights, type: 'int', condition: '<' }, ( { i } ) => {
+
+			If( lightIndex.lessThan( int( 16 ) ), () => {
+
+				const light = DirectionalLight.wrap( getDirectionalLight( directionalLightsBuffer, i ) );
+				totalWeight.addAssign( calculateDirectionalLightImportance( light, normal, material, bounceIndex ) );
+				lightIndex.addAssign( 1 );
+
+			} );
+
+		} );
+
+	} );
+
+	If( numAreaLights.greaterThan( int( 0 ) ), () => {
+
+		Loop( { start: int( 0 ), end: numAreaLights, type: 'int', condition: '<' }, ( { i } ) => {
+
+			If( lightIndex.lessThan( int( 16 ) ), () => {
+
+				const light = AreaLight.wrap( getAreaLight( areaLightsBuffer, i ) );
+				totalWeight.addAssign( select( light.intensity.greaterThan( 0.0 ), estimateLightImportance( light, rayOrigin, normal, material ), float( 0.0 ) ) );
+				lightIndex.addAssign( 1 );
+
+			} );
+
+		} );
+
+	} );
+
+	If( numPointLights.greaterThan( int( 0 ) ), () => {
+
+		Loop( { start: int( 0 ), end: numPointLights, type: 'int', condition: '<' }, ( { i } ) => {
+
+			If( lightIndex.lessThan( int( 16 ) ), () => {
+
+				const light = PointLight.wrap( getPointLight( pointLightsBuffer, i ) );
+				totalWeight.addAssign( calculatePointLightImportance( light, rayOrigin, normal, material ) );
+				lightIndex.addAssign( 1 );
+
+			} );
+
+		} );
+
+	} );
+
+	If( numSpotLights.greaterThan( int( 0 ) ), () => {
+
+		Loop( { start: int( 0 ), end: numSpotLights, type: 'int', condition: '<' }, ( { i } ) => {
+
+			If( lightIndex.lessThan( int( 16 ) ), () => {
+
+				const light = SpotLight.wrap( getSpotLight( spotLightsBuffer, i ) );
+				totalWeight.addAssign( calculateSpotLightImportance( light, rayOrigin, normal, material ) );
+				lightIndex.addAssign( 1 );
+
+			} );
+
+		} );
+
+	} );
+
+	return totalWeight;
+
+} );
+
 // =============================================================================
 // Unified Direct Lighting System
 // =============================================================================
@@ -936,15 +1103,41 @@ export const calculateDirectLightingUnified = Fn( ( [
 									If( lightFacing.greaterThan( 0.0 ), () => {
 
 										const lightDistSq = hitDistance.mul( hitDistance );
-										// Guard division
-										const lightPdf = lightDistSq.div( max( light.area.mul( lightFacing ), EPSILON ) ).toVar();
-										lightPdf.divAssign( max( float( totalLights ), 1.0 ) );
+
+										// Directional pdf must match the NEE sampler: 1/S (spherical-rect)
+										// for rectangles, dist²/(area·cos) for disk/ellipse + degenerate rects.
+										const corner = light.position.sub( light.u ).sub( light.v );
+										const sAngle = sphQuadSolidAngle( rayOrigin, corner, light.u.mul( 2.0 ), light.v.mul( 2.0 ) ).toVar();
+										const areaPdf = lightDistSq.div( max( light.area.mul( lightFacing ), EPSILON ) );
+										const dirPdf = select(
+											light.shape.lessThan( 0.5 ).and( sAngle.greaterThan( 1e-5 ) ),
+											float( 1.0 ).div( max( sAngle, 1e-10 ) ),
+											areaPdf,
+										).toVar();
+
+										// Selection pdf consistent with the importance-weighted NEE reservoir
+										// (Cycles light_tree_pdf re-walk). Falls back to uniform 1/N only when
+										// total importance is zero, matching the NEE fallback.
+										const selImp = estimateLightImportance( light, rayOrigin, hitNormal, material );
+										const totalImp = computeTotalLightImportance(
+											rayOrigin, hitNormal, material, bounceIndex,
+											directionalLightsBuffer, numDirectionalLights,
+											areaLightsBuffer, numAreaLights,
+											pointLightsBuffer, numPointLights,
+											spotLightsBuffer, numSpotLights,
+										).toVar();
+										const selPdf = select(
+											totalImp.greaterThan( 0.0 ),
+											selImp.div( max( totalImp, 1e-10 ) ),
+											float( 1.0 ).div( max( float( totalLights ), 1.0 ) ),
+										);
+										const lightPdf = dirPdf.mul( selPdf ).toVar();
 
 										const brdfPdfWeighted = brdfSamplePdf.mul( brdfWeight );
 										const lightPdfWeighted = lightPdf.mul( lightWeight );
 										const misW = powerHeuristic( { pdf1: brdfPdfWeighted, pdf2: lightPdfWeighted } ).toVar();
 
-										const lightEmission = light.color.mul( light.intensity );
+										const lightEmission = areaLightRadiance( light ).mul( areaLightSpreadAttenuation( lightFacing, light.spread ) );
 										// Base contribution WITHOUT visibility (see discrete-light site).
 										const baseContribution = lightEmission.mul( brdfSampleValue ).mul( NoL ).mul( misW ).div( max( brdfSamplePdf, 1e-10 ) ).mul( totalSamplingWeight ).div( max( brdfWeight, 1e-10 ) );
 										totalContribution.addAssign( baseContribution.mul( visibility ) );

package/src/TSL/ShadeKernel.js

@@ -51,9 +51,9 @@ import {
 	readMediumStack, writeMediumStack, readMediumSigmaA, writeMediumSigmaA,
 	readPathBounces, readSssSteps, readSSSMedium, writeSSSMedium,
 	readHitDistance, readHitBarycentrics, readHitNormal,
-	readHitMaterialIndex, readHitTriangleIndex, readHitMeshIndex,
+	readHitMaterialIndex, readHitTriangleIndex,
 	writeRayOriginMeta, writeRayDirFlags, writeRayThroughputPdf, writeRayRadiance,
-	writeGBuffer, writeGBufferSurfaceID, readGBuffer, gbDecodeNormalDepth,
+	writeGBuffer, readGBuffer, gbDecodeNormalDepth,
 	readRayRadiance,
 } from '../Processor/PackedRayBuffer.js';
 
@@ -64,9 +64,6 @@ const MISS_DIST = 1e19;
 const CATCHER_T_MIN = 1e-4; // min ray-t for the analytic plane hit (skip behind/at the camera)
 const CATCHER_LUMA_FLOOR = 1e-4; // denominator floor for the shadow ratio
 const CATCHER_COVERAGE_MIN = 1e-3; // below this incident luma there is no shadow to catch
-// Reserved G-buffer surface ID for catcher pixels (no real triangle); stable across frames so the
-// denoiser treats the analytic plane as one coherent surface, not a background miss.
-const CATCHER_SURFACE_ID = 0xFFFFFFFE;
 
 export function buildShadeKernel( params ) {
 
@@ -297,7 +294,6 @@ export function buildShadeKernel( params ) {
 
 						const planeDepth = computeNDCDepth( { worldPos: planePoint, cameraProjectionMatrix, cameraViewMatrix } );
 						writeGBuffer( gBufferRW, pixelIndex, planeN, planeDepth, vec3( 1.0 ) );
-						writeGBufferSurfaceID( gBufferRW, pixelIndex, uint( CATCHER_SURFACE_ID ), uint( CATCHER_SURFACE_ID ), 0.5, 0.5, uint( 1 ) );
 
 					} );
 
@@ -587,9 +583,6 @@ export function buildShadeKernel( params ) {
 			// block before that capture, so a glass-then-escape pixel keeps this default aux — megakernel parity
 			// (objectNormal/objectColor stay at their init for transmissive-then-miss).
 			writeGBuffer( gBufferRW, pixelIndex, vec3( 0.0, 0.0, 1.0 ), linearDepth, vec3( 0.0 ) );
-			// Persist the primary-hit surface ID (Tier-1 A-SVGF correlated re-projection). Hit-only
-			// branch (misses Return above), so this marks the pixel valid; bary from the bounce-0 hit.
-			writeGBufferSurfaceID( gBufferRW, pixelIndex, hitTriIdx, readHitMeshIndex( hitBufferRO, rayID ), hitUV.x, hitUV.y, uint( 1 ) );
 
 		} );
 

package/src/managers/DenoisingManager.js

@@ -370,6 +370,16 @@ export class DenoisingManager extends EventDispatcher {
 		// MRT read-targets directly). When none are active the wavefront skips those writes entirely.
 		s.pathTracer?.setAuxGBufferEnabled?.( normalNeeded || !! this.denoiser?.enabled );
 
+		// Reclaim VRAM: free the big 2048² StorageTextures of any denoiser/G-buffer stage that ended up
+		// disabled (lazily re-created on the next dispatch after re-enable). Every strategy/denoiser
+		// toggle funnels through here after the enabled flags above are settled, so this is the one
+		// choke point. dispose() is idempotent, so re-running it for an already-released stage is a no-op.
+		for ( const stage of [ s.asvgf, s.variance, s.bilateralFilter, s.ssrc, s.edgeFilter, nd, mv ] ) {
+
+			if ( stage && ! stage.enabled ) stage.releaseGPUMemory?.();
+
+		}
+
 	}
 
 	// ── Render Completion Chain ───────────────────────────────────

package/src/managers/LightManager.js

@@ -38,10 +38,11 @@ export class LightManager extends EventDispatcher {
 	addLight( type ) {
 
 		const defaults = {
+			// Power in Watts (Blender-style) for point/spot/area; Sun is W/m² strength.
 			DirectionalLight: { position: [ 1, 1, 1 ], intensity: 1.0, color: '#ffffff' },
-			PointLight: { position: [ 0, 2, 0 ], intensity: 100, color: '#ffffff' },
-			SpotLight: { position: [ 0, 1, 0 ], intensity: 300, color: '#ffffff', angle: 15 },
-			RectAreaLight: { position: [ 0, 2, 0 ], intensity: 500, color: '#ffffff', width: 2, height: 2 }
+			PointLight: { position: [ 0, 2, 0 ], intensity: 1000, color: '#ffffff' },
+			SpotLight: { position: [ 0, 1, 0 ], intensity: 1000, color: '#ffffff', angle: 15 },
+			RectAreaLight: { position: [ 0, 2, 0 ], intensity: 100, color: '#ffffff', width: 2, height: 2 }
 		};
 
 		const props = defaults[ type ];
@@ -73,9 +74,19 @@ export class LightManager extends EventDispatcher {
 			light = new RectAreaLight( props.color, props.intensity, props.width, props.height );
 			light.position.fromArray( props.position );
 			light.lookAt( 0, 0, 0 );
+			// Blender-style emission defaults: power-normalized, full Lambertian
+			// hemisphere (spread = π), rectangular shape.
+			light.userData.normalize = true;
+			light.userData.spread = Math.PI;
+			light.userData.shape = 'rectangle';
 
 		}
 
+		// Blender-style emission controls common to every light type.
+		light.userData.temperature = 6500;
+		light.userData.useTemperature = false;
+		light.userData.exposure = 0;
+
 		const count = this.scene.getObjectsByProperty( 'isLight', true ).length;
 		light.name = `${type.replace( 'Light', '' )} ${count + 1}`;
 		this.scene.add( light );
@@ -322,13 +333,24 @@ export class LightManager extends EventDispatcher {
 			intensity: light.intensity,
 			color: `#${light.color.getHexString()}`,
 			position: [ light.position.x, light.position.y, light.position.z ],
-			angle
+			angle,
+			// Emission controls common to all light types.
+			temperature: light.userData?.temperature ?? 6500,
+			useTemperature: light.userData?.useTemperature ?? false,
+			exposure: light.userData?.exposure ?? 0
 		};
 
 		if ( light.type === 'RectAreaLight' ) {
 
 			descriptor.width = light.width;
 			descriptor.height = light.height;
+			descriptor.normalize = light.userData?.normalize ?? true;
+			descriptor.spread = MathUtils.radToDeg( light.userData?.spread ?? Math.PI ); // degrees for UI
+			const rawShape = light.userData?.shape;
+			descriptor.shape = ( rawShape === 'square' || rawShape === 'rectangle' || rawShape === 'disk' || rawShape === 'ellipse' )
+				? rawShape
+				: rawShape === 1 ? 'ellipse'
+					: 'rectangle'; // 'rect', undefined, 0 → rectangle
 			const dir = light.getWorldDirection( light.position.clone() );
 			descriptor.target = [ light.position.x + dir.x, light.position.y + dir.y, light.position.z + dir.z ];
 

package/src/managers/UniformManager.js

@@ -212,7 +212,7 @@ export class UniformManager {
 		// Light buffer nodes - pre-allocate for up to 16 lights per type (shader hard cap)
 		this._lightBuffers = {
 			directional: uniformArray( new Float32Array( 12 * 16 ), 'float' ),
-			area: uniformArray( new Float32Array( 13 * 16 ), 'float' ),
+			area: uniformArray( new Float32Array( 16 * 16 ), 'float' ),
 			point: uniformArray( new Float32Array( 9 * 16 ), 'float' ),
 			spot: uniformArray( new Float32Array( 20 * 16 ), 'float' ),
 		};