rayzee 7.4.1 → 7.5.1

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/SortGlobalKernels.js

@@ -0,0 +1,135 @@
+/**
+ * SortGlobalKernels.js — GLOBAL material counting sort of the entering rays.
+ *
+ * Unlike a per-workgroup sort (locally coherent only), this orders rays by material
+ * ACROSS ALL workgroups, so each material's rays occupy one contiguous region of sortedIndices.
+ * For materials with many rays that means whole material-PURE workgroups/subgroups → real shading
+ * coherence. MEASURED −8% vs no-sort at 1024²/8b (per-WG sort was neutral).
+ *
+ * Four passes (counting sort): reset → histogram → exclusive prefix sum → scatter.
+ *   - histogram uses a per-workgroup local histogram (workgroup-shared atomics, patches.js §4)
+ *     flushed to the global histogram once per bin per workgroup, cutting global-atomic contention
+ *     from O(rays) to O(workgroups × bins).
+ *   - the prefix-summed histogram doubles as the per-bin running cursor in scatter.
+ *
+ * `bins` is chosen per-scene by the caller (= material count, capped). Materials ≥ bins clamp into
+ * the last bin (graceful coherence loss). Capped at SORT_GLOBAL_MAX_BINS so a single 256-thread
+ * workgroup can zero/flush exactly one bin per thread (no per-thread loop needed).
+ */
+
+import {
+	Fn, uint,
+	If, Loop,
+	instanceIndex, localId,
+	workgroupBarrier,
+	atomicAdd, atomicLoad, atomicStore,
+} from 'three/tsl';
+
+import { workgroupAtomicArray } from './patches.js';
+import { readHitMaterialIndex } from '../Processor/PackedRayBuffer.js';
+import { COUNTER } from '../Processor/QueueManager.js';
+
+const WG_SIZE = 256;
+export const SORT_GLOBAL_MAX_BINS = 256;
+
+// Pass 1 — zero the global histogram.
+export function buildResetGlobalHistKernel( { sortGlobalHistogram, bins = SORT_GLOBAL_MAX_BINS } ) {
+
+	return Fn( () => {
+
+		If( instanceIndex.lessThan( uint( bins ) ), () => {
+
+			atomicStore( sortGlobalHistogram.element( instanceIndex ), uint( 0 ) );
+
+		} );
+
+	} );
+
+}
+
+// Pass 2 — histogram: per-workgroup local count (on-chip), flushed to global once per bin/WG.
+export function buildGlobalHistKernel( { hitBufferRO, activeIndicesReadRO, sortGlobalHistogram, counters, bins = SORT_GLOBAL_MAX_BINS } ) {
+
+	return Fn( () => {
+
+		const tid = instanceIndex;
+		const lid = localId.x;
+		const local = workgroupAtomicArray( 'uint', bins );
+
+		If( lid.lessThan( uint( bins ) ), () => {
+
+			atomicStore( local.element( lid ), uint( 0 ) );
+
+		} );
+		workgroupBarrier();
+
+		const entering = atomicLoad( counters.element( uint( COUNTER.ENTERING_COUNT ) ) );
+		If( tid.lessThan( entering ), () => {
+
+			const rayID = activeIndicesReadRO.element( tid );
+			const bin = uint( readHitMaterialIndex( hitBufferRO, rayID ) ).clamp( uint( 0 ), uint( bins - 1 ) );
+			atomicAdd( local.element( bin ), uint( 1 ) );
+
+		} );
+		workgroupBarrier();
+
+		If( lid.lessThan( uint( bins ) ), () => {
+
+			const c = atomicLoad( local.element( lid ) );
+			If( c.greaterThan( uint( 0 ) ), () => {
+
+				atomicAdd( sortGlobalHistogram.element( lid ), c );
+
+			} );
+
+		} );
+
+	} );
+
+}
+
+// Pass 3 — exclusive prefix sum over global bins (single thread; dispatch [1,1,1]).
+export function buildGlobalPrefixKernel( { sortGlobalHistogram, bins = SORT_GLOBAL_MAX_BINS } ) {
+
+	return Fn( () => {
+
+		If( instanceIndex.equal( uint( 0 ) ), () => {
+
+			const running = uint( 0 ).toVar();
+			Loop( { start: uint( 0 ), end: uint( bins ), type: 'uint' }, ( { i } ) => {
+
+				const slot = sortGlobalHistogram.element( i );
+				const c = atomicLoad( slot );
+				atomicStore( slot, running );
+				running.addAssign( c );
+
+			} );
+
+		} );
+
+	} );
+
+}
+
+// Pass 4 — scatter: atomicAdd on the prefix-summed histogram gives each ray its global slot
+// within its material's contiguous region.
+export function buildGlobalScatterKernel( { hitBufferRO, activeIndicesReadRO, sortedIndicesRW, sortGlobalHistogram, counters, bins = SORT_GLOBAL_MAX_BINS } ) {
+
+	return Fn( () => {
+
+		const tid = instanceIndex;
+		const entering = atomicLoad( counters.element( uint( COUNTER.ENTERING_COUNT ) ) );
+		If( tid.lessThan( entering ), () => {
+
+			const rayID = activeIndicesReadRO.element( tid );
+			const bin = uint( readHitMaterialIndex( hitBufferRO, rayID ) ).clamp( uint( 0 ), uint( bins - 1 ) );
+			const pos = atomicAdd( sortGlobalHistogram.element( bin ), uint( 1 ) );
+			sortedIndicesRW.element( pos ).assign( rayID );
+
+		} );
+
+	} );
+
+}
+
+export { WG_SIZE as SORT_GLOBAL_WG_SIZE };

package/src/TSL/patches.js

@@ -61,6 +61,10 @@ WebGPUBackend.prototype.createNodeBuilder = function ( object, renderer ) {
 		configurable: true,
 	} );
 
+	// Install the workgroup-atomic-array codegen patch (section 4) lazily off the
+	// first builder, so we don't need to import WGSLNodeBuilder directly.
+	_installScopedArrayAtomicPatch( builder );
+
 	return builder;
 
 };
@@ -220,3 +224,89 @@ export function struct( members, name = null ) {
 	return wrappedFactory;
 
 }
+
+// ---------------------------------------------------------------------------
+// 4. Workgroup-scoped atomic arrays — var<workgroup> array<atomic<T>, N>
+// ---------------------------------------------------------------------------
+// TSL's `workgroupArray(type, count)` emits `var<workgroup> name: array<T, N>`
+// (`WGSLNodeBuilder.getScopedArrays`, r185 ~line 1773) with a NON-atomic element
+// type, so `atomicAdd(arr.element(i), v)` fails WGSL validation. AtomicFunctionNode
+// is itself address-space-agnostic — it emits `atomicAdd(&name[i], v)`, valid for
+// BOTH storage and workgroup pointers — so the ONLY missing piece is the
+// declaration. This patch adds `workgroupAtomicArray()` (a `workgroupArray` tagged
+// atomic) and overrides `getScopedArrays` to wrap the element type in `atomic<…>`
+// for tagged arrays, enabling true on-chip workgroup-shared atomics (e.g. fast
+// per-workgroup histograms) instead of the slow global-storage-atomic fallback.
+// Access tagged arrays ONLY via atomic ops (atomicAdd/atomicLoad/atomicStore).
+
+import { workgroupArray } from 'three/tsl';
+
+const _WorkgroupInfoNode = workgroupArray( 'uint', 1 ).constructor;
+
+// Tag the node so the patched getScopedArrays emits an atomic element type. The
+// array's WGSL name is only known after generate() runs, so we mark the builder's
+// scopedArrays entry there (idempotent across analyze/generate passes).
+const _origWorkgroupGenerate = _WorkgroupInfoNode.prototype.generate;
+
+_WorkgroupInfoNode.prototype.generate = function ( builder ) {
+
+	const name = _origWorkgroupGenerate.call( this, builder );
+	if ( this.isAtomicArray === true ) {
+
+		const entry = builder.scopedArrays && builder.scopedArrays.get( name );
+		if ( entry ) entry.isAtomic = true;
+
+	}
+
+	return name;
+
+};
+
+/**
+ * Like `workgroupArray(type, count)` but declares the workgroup buffer with an
+ * atomic element type: `var<workgroup> name: array<atomic<type>, count>`.
+ * Elements MUST be accessed only via atomic ops (atomicAdd/atomicLoad/atomicStore).
+ *
+ * @param {string} type - Element type (e.g. 'uint').
+ * @param {number} count - Number of elements.
+ * @returns {WorkgroupInfoNode} The tagged workgroup array node.
+ */
+export function workgroupAtomicArray( type, count ) {
+
+	const node = workgroupArray( type, count );
+	node.isAtomicArray = true;
+	return node;
+
+}
+
+let _scopedArraysPatched = false;
+
+// Override getScopedArrays on the builder's prototype (compute-stage WGSL
+// assembly) to emit `atomic<T>` element types for tagged workgroup arrays.
+// Installed once, lazily, off the first node builder created.
+function _installScopedArrayAtomicPatch( builder ) {
+
+	if ( _scopedArraysPatched ) return;
+	const proto = Object.getPrototypeOf( builder );
+	if ( ! proto || typeof proto.getScopedArrays !== 'function' ) return;
+
+	proto.getScopedArrays = function ( shaderStage ) {
+
+		if ( shaderStage !== 'compute' ) return;
+
+		const snippets = [];
+		for ( const { name, scope, bufferType, bufferCount, isAtomic } of this.scopedArrays.values() ) {
+
+			const type = this.getType( bufferType );
+			const elementType = ( isAtomic === true ) ? `atomic< ${ type } >` : type;
+			snippets.push( `var<${ scope }> ${ name }: array< ${ elementType }, ${ bufferCount } >;` );
+
+		}
+
+		return snippets.join( '\n' );
+
+	};
+
+	_scopedArraysPatched = true;
+
+}

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' ),
 		};