rayzee 4.8.4 → 4.8.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "4.8.4",
+  "version": "4.8.7",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",

package/src/Passes/AIUpscaler.js

@@ -1,5 +1,4 @@
 import { EventDispatcher, ACESFilmicToneMapping } from 'three';
-import { createWorker } from '../Processor/createWorker.js';
 import { TONE_MAP_FNS, SRGB_GAMMA, applySaturation } from '../Processor/ToneMapCPU.js';
 
 
@@ -138,7 +137,7 @@ export class AIUpscaler extends EventDispatcher {
 			// Create worker on first use
 			if ( ! this._worker ) {
 
-				this._worker = createWorker(
+				this._worker = new Worker(
 					new URL( '../Processor/Workers/AIUpscalerWorker.js', import.meta.url ),
 					{ type: 'module' }
 				);

package/src/PathTracerApp.js

@@ -54,17 +54,16 @@ export class PathTracerApp extends EventDispatcher {
 
 	/**
 	 * @param {HTMLCanvasElement} canvas - Canvas element for rendering
-	 * @param {HTMLCanvasElement} [denoiserCanvas] - Optional canvas for OIDN denoiser output
 	 * @param {Object} [options] - Engine options
 	 * @param {boolean} [options.autoResize=true] - Automatically listen for window resize events
 	 * @param {HTMLElement} [options.statsContainer] - DOM element to append the stats panel to (defaults to document.body)
 	 */
-	constructor( canvas, denoiserCanvas = null, options = {} ) {
+	constructor( canvas, options = {} ) {
 
 		super();
 
 		this.canvas = canvas;
-		this.denoiserCanvas = denoiserCanvas;
+		this.denoiserCanvas = null;
 		this._autoResize = options.autoResize !== false;
 		this._statsContainer = options.statsContainer || null;
 
@@ -295,6 +294,7 @@ export class PathTracerApp extends EventDispatcher {
 		// ── Managers ──
 		this.cameraManager = new CameraManager( this._camera, this._controls, this._interactionManager );
 		this.lightManager = new LightManager( this.scene, this._sceneHelpers, this.stages.pathTracer );
+		this._createDenoiserCanvas();
 		this._setupDenoisingManager();
 		this._setupOverlayManager();
 
@@ -640,6 +640,14 @@ export class PathTracerApp extends EventDispatcher {
 		this.overlayManager?.dispose();
 		this._sceneHelpers?.clear();
 		this.denoisingManager?.dispose();
+
+		if ( this.denoiserCanvas?.parentNode ) {
+
+			this.denoiserCanvas.parentNode.removeChild( this.denoiserCanvas );
+			this.denoiserCanvas = null;
+
+		}
+
 		this.pipeline?.dispose();
 		this._interactionManager?.dispose();
 		this._controls?.dispose();
@@ -1102,6 +1110,13 @@ export class PathTracerApp extends EventDispatcher {
 		this._camera.aspect = width / height;
 		this._camera.updateProjectionMatrix();
 
+		if ( this.denoiserCanvas ) {
+
+			this.denoiserCanvas.style.width = `${width}px`;
+			this.denoiserCanvas.style.height = `${height}px`;
+
+		}
+
 		// Overlay helpers always render at display resolution
 		const dpr = window.devicePixelRatio || 1;
 		this.overlayManager?.setSize(
@@ -1955,6 +1970,24 @@ export class PathTracerApp extends EventDispatcher {
 
 	}
 
+	_createDenoiserCanvas() {
+
+		if ( this.denoiserCanvas ) return; // guard against double init
+
+		const parent = this.canvas.parentNode;
+		if ( ! parent ) return; // headless / detached canvas — skip
+
+		const dc = document.createElement( 'canvas' );
+		dc.width = this.canvas.width;
+		dc.height = this.canvas.height;
+		dc.style.width = `${this.canvas.clientWidth}px`;
+		dc.style.height = `${this.canvas.clientHeight}px`;
+
+		parent.insertBefore( dc, this.canvas );
+		this.denoiserCanvas = dc;
+
+	}
+
 	_setupDenoisingManager() {
 
 		this.denoisingManager = new DenoisingManager( {

package/src/Processor/AssetLoader.js

@@ -1200,7 +1200,7 @@ export class AssetLoader extends EventDispatcher {
 
 			if ( object.isRectAreaLight && ! visitedAreaLights.includes( object.uuid ) ) {
 
-				object.intensity *= 100 / 4; // Compensate for Three.js's dimming of RectAreaLights
+				visitedAreaLights.push( object.uuid );
 
 			}
 
@@ -1214,7 +1214,7 @@ export class AssetLoader extends EventDispatcher {
 
 					const light = new RectAreaLight(
 						new Color( ...userData.color ),
-						userData.intensity * 0.1 / 4,
+						userData.intensity,
 						userData.width,
 						userData.height
 					);

package/src/Processor/BVHBuilder.js

@@ -1,6 +1,5 @@
 import { TreeletOptimizer } from './TreeletOptimizer.js';
 import { ReinsertionOptimizer } from './ReinsertionOptimizer.js';
-import { createWorker } from './createWorker.js';
 
 // Inline copy of TRIANGLE_DATA_LAYOUT (mirrors Constants.js).
 // Cannot import Constants.js because BVHBuilder runs inside BVHWorker
@@ -400,7 +399,7 @@ export class BVHBuilder {
 
 				try {
 
-					const worker = createWorker(
+					const worker = new Worker(
 						new URL( './Workers/BVHWorker.js', import.meta.url ),
 						{ type: 'module' }
 					);

package/src/Processor/EquirectHDRInfo.js

@@ -1,5 +1,4 @@
 import { DataUtils, HalfFloatType, FloatType } from 'three';
-import { createWorker } from './createWorker.js';
 
 /**
  * Binary search to find the closest index
@@ -185,7 +184,7 @@ export class EquirectHDRInfo {
 		// Reuse worker across calls; create on first use
 		if ( ! this._worker ) {
 
-			this._worker = createWorker(
+			this._worker = new Worker(
 				new URL( './Workers/CDFWorker.js', import.meta.url ),
 				{ type: 'module' }
 			);

package/src/Processor/LightSerializer.js

@@ -65,21 +65,35 @@ export class LightSerializer {
 
 		if ( light.intensity <= 0.0 ) return; // Skip zero intensity lights
 
-		// Convert world position to direction
 		light.updateMatrixWorld();
 		const position = light.getWorldPosition( new Vector3() );
 
+		// Compute direction toward the light source.
+		// Three.js convention: light shines from position toward target.
+		// For shadow rays we need the reverse: direction from target toward position.
+		let direction;
+		if ( light.target ) {
+
+			light.target.updateMatrixWorld();
+			const targetPos = light.target.getWorldPosition( new Vector3() );
+			direction = position.sub( targetPos ).normalize();
+
+		} else {
+
+			direction = position.normalize();
+
+		}
+
 		// Calculate importance for sorting
 		const importance = this.calculateLightImportance( light, 'directional' );
 
 		// Get angle parameter from light (default to 0 for sharp shadows)
-		// You can add this as a custom property to your DirectionalLight
 		const angle = light.userData.angle || light.angle || 0.0; // In radians
 
 		// Store in cache with importance
 		this.directionalLightCache.push( {
 			data: [
-				position.x, position.y, position.z, // position (3)
+				direction.x, direction.y, direction.z, // direction toward light (3)
 				light.color.r, light.color.g, light.color.b, // color (3)
 				light.intensity, // intensity (1)
 				angle // angular diameter in radians (1)
@@ -139,7 +153,9 @@ export class LightSerializer {
 			data: [
 				position.x, position.y, position.z, // position (3)
 				light.color.r, light.color.g, light.color.b, // color (3)
-				light.intensity // intensity (1)
+				light.intensity, // intensity (1)
+				light.distance || 0.0, // cutoff distance (0 = infinite) (1)
+				light.decay !== undefined ? light.decay : 2.0 // decay exponent (1)
 			],
 			importance: importance,
 			light: light
@@ -167,7 +183,10 @@ export class LightSerializer {
 				direction.x, direction.y, direction.z, // direction (3)
 				light.color.r, light.color.g, light.color.b, // color (3)
 				light.intensity, // intensity (1)
-				light.angle || Math.PI / 4 // cone half-angle in radians (1)
+				light.angle || Math.PI / 4, // cone half-angle in radians (1)
+				light.penumbra || 0.0, // penumbra [0,1] (1)
+				light.distance || 0.0, // cutoff distance (0 = infinite) (1)
+				light.decay !== undefined ? light.decay : 2.0 // decay exponent (1)
 			],
 			importance: importance,
 			light: light
@@ -244,8 +263,8 @@ export class LightSerializer {
 		// Divide flat array lengths by per-light stride to get actual light counts
 		const directionalCount = Math.floor( this.lightData.directional.length / 8 );
 		const areaCount = Math.floor( this.lightData.rectArea.length / 13 );
-		const pointCount = Math.floor( this.lightData.point.length / 7 );
-		const spotCount = Math.floor( this.lightData.spot.length / 11 );
+		const pointCount = Math.floor( this.lightData.point.length / 9 );
+		const spotCount = Math.floor( this.lightData.spot.length / 14 );
 
 		// Update light counts in shader defines
 		material.defines.MAX_DIRECTIONAL_LIGHTS = directionalCount;

package/src/Processor/ParallelBVHBuilder.js

@@ -7,8 +7,6 @@
  * a cycle that Vite cannot resolve.
  */
 
-import { createWorker } from './createWorker.js';
-
 const FPT = 32; // FLOATS_PER_TRIANGLE
 const PARALLEL_THRESHOLD = 50000;
 const MAX_PARALLEL_WORKERS = 8;
@@ -36,11 +34,6 @@ export function buildBVHParallel( triangles, depth, progressCallback, config ) {
 
 	return new Promise( ( resolve, reject ) => {
 
-		const coordinatorWorker = createWorker(
-			new URL( './Workers/BVHWorker.js', import.meta.url ),
-			{ type: 'module' }
-		);
-
 		try {
 
 			// Allocate SharedArrayBuffers
@@ -54,6 +47,12 @@ export function buildBVHParallel( triangles, depth, progressCallback, config ) {
 			const sharedMortonCodes = new SharedArrayBuffer( triangleCount * 4 );
 			const sharedReorderBuffer = new SharedArrayBuffer( triangleCount * FPT * 4 );
 
+			// Phase 1: Coordinator worker
+			const coordinatorWorker = new Worker(
+				new URL( './Workers/BVHWorker.js', import.meta.url ),
+				{ type: 'module' }
+			);
+
 			let phase1Stats = null;
 			const allWorkers = [ coordinatorWorker ];
 
@@ -300,7 +299,7 @@ function handlePhase2(
 		const bucket = workerTaskBuckets[ w ];
 		if ( bucket.length === 0 ) continue;
 
-		const subtreeWorker = createWorker(
+		const subtreeWorker = new Worker(
 			new URL( './Workers/BVHSubtreeWorker.js', import.meta.url ),
 			{ type: 'module' }
 		);
@@ -408,7 +407,7 @@ function buildSingleWorker( triangles, depth, progressCallback, config ) {
 
 		try {
 
-			const worker = createWorker(
+			const worker = new Worker(
 				new URL( './Workers/BVHWorker.js', import.meta.url ),
 				{ type: 'module' }
 			);

package/src/Processor/SceneProcessor.js

@@ -11,7 +11,6 @@ import { EmissiveTriangleBuilder } from './EmissiveTriangleBuilder.js';
 import { updateLoading } from '../Processor/utils.js';
 import { BuildTimer } from './BuildTimer.js';
 import { TRIANGLE_DATA_LAYOUT } from '../EngineDefaults.js';
-import { createWorker } from './createWorker.js';
 
 /**
  * SceneProcessor - Processes scene geometry into GPU-ready data:
@@ -666,7 +665,7 @@ export class SceneProcessor {
 			// Spin up the pool
 			for ( let i = 0; i < poolSize; i ++ ) {
 
-				const worker = createWorker(
+				const worker = new Worker(
 					new URL( './Workers/BVHWorker.js', import.meta.url ),
 					{ type: 'module' }
 				);
@@ -1137,7 +1136,7 @@ export class SceneProcessor {
 		// Lazy-create worker
 		if ( ! this._refitWorker ) {
 
-			this._refitWorker = createWorker(
+			this._refitWorker = new Worker(
 				new URL( './Workers/BVHRefitWorker.js', import.meta.url ),
 				{ type: 'module' }
 			);
@@ -1526,7 +1525,7 @@ export class SceneProcessor {
 				( entry.triOffset + entry.triCount ) * FPT
 			);
 
-			const worker = createWorker(
+			const worker = new Worker(
 				new URL( './Workers/BVHWorker.js', import.meta.url ),
 				{ type: 'module' }
 			);

package/src/Processor/TextureCreator.js

@@ -1,6 +1,5 @@
 import { DataArrayTexture, RGBAFormat, LinearFilter, UnsignedByteType, SRGBColorSpace } from "three";
 import { TEXTURE_CONSTANTS, MEMORY_CONSTANTS, DEFAULT_TEXTURE_MATRIX } from '../EngineDefaults.js';
-import { createWorker } from './createWorker.js';
 
 // Canvas pooling for efficient reuse of canvas elements
 class CanvasPool {
@@ -596,7 +595,7 @@ export class TextureCreator {
 
 		try {
 
-			const worker = createWorker(
+			const worker = new Worker(
 				new URL( './Workers/TexturesWorker.js', import.meta.url ),
 				{ type: 'module' }
 			);

package/src/Processor/Workers/AIUpscalerWorker.js

@@ -14,11 +14,24 @@
  *     { type: 'error', message, id? }
  */
 
-import * as ort from 'onnxruntime-web/webgpu';
+// Loaded lazily via CDN to avoid bundling the 69 MB onnxruntime-web package
+const ORT_CDN_URL = 'https://cdn.jsdelivr.net/npm/onnxruntime-web@1.24.3/dist/ort.webgpu.bundle.min.mjs';
 
-// WASM paths for CDN delivery — WebGPU EP still uses WASM for lightweight shape ops
-ort.env.wasm.wasmPaths = 'https://cdn.jsdelivr.net/npm/onnxruntime-web@1.24.3/dist/';
-ort.env.logLevel = 'error';
+let ort = null;
+
+async function getOrt() {
+
+	if ( ort ) return ort;
+
+	ort = await import( /* @vite-ignore */ ORT_CDN_URL );
+
+	// WASM paths for CDN delivery — WebGPU EP still uses WASM for lightweight shape ops
+	ort.env.wasm.wasmPaths = 'https://cdn.jsdelivr.net/npm/onnxruntime-web@1.24.3/dist/';
+	ort.env.logLevel = 'error';
+
+	return ort;
+
+}
 
 const IDB_NAME = 'ai-upscaler-models';
 const IDB_STORE = 'models';
@@ -127,9 +140,9 @@ async function loadModel( url, sessionOptions ) {
 
 	}
 
-	const modelBuffer = await fetchModel( url );
+	const [ modelBuffer, ortLib ] = await Promise.all( [ fetchModel( url ), getOrt() ] );
 
-	session = await ort.InferenceSession.create( modelBuffer, sessionOptions );
+	session = await ortLib.InferenceSession.create( modelBuffer, sessionOptions );
 	currentModelUrl = url;
 
 	// Detect GPU and recommend tile size based on device type
@@ -170,9 +183,10 @@ async function loadModel( url, sessionOptions ) {
 
 async function inferTile( tileData, width, height, id ) {
 
+	const ortLib = await getOrt();
 	const inputName = session.inputNames[ 0 ];
 	const outputName = session.outputNames[ 0 ];
-	const inputTensor = new ort.Tensor( 'float32', tileData, [ 1, 3, height, width ] );
+	const inputTensor = new ortLib.Tensor( 'float32', tileData, [ 1, 3, height, width ] );
 
 	const results = await session.run( { [ inputName ]: inputTensor } );
 	const outputData = results[ outputName ].data;

package/src/README.md

@@ -20,13 +20,12 @@ engine.animate();
 ## Constructor
 
 ```js
-new PathTracerApp(canvas, denoiserCanvas?, options?)
+new PathTracerApp(canvas, options?)
 ```
 
 | Param | Type | Description |
 |-------|------|-------------|
 | `canvas` | `HTMLCanvasElement` | Render target |
-| `denoiserCanvas` | `HTMLCanvasElement \| null` | Optional canvas for OIDN output |
 | `options.autoResize` | `boolean` | Auto-listen for window resize (default `true`) |
 
 ## API Reference

package/src/Stages/PathTracer.js

@@ -26,8 +26,8 @@ import { LightSerializer } from '../Processor/LightSerializer';
 // Constants
 import { ENGINE_DEFAULTS as DEFAULT_STATE } from '../EngineDefaults.js';
 
-// Blue noise
-import blueNoiseImage from '../../assets/noise/simple_bluenoise.png';
+// Blue noise (loaded at runtime from CDN — not inlined to keep bundle small)
+const blueNoiseImage = 'https://assets.rayzee.atulmourya.com/noise/simple_bluenoise.png';
 
 /**
  * Data layout constants
@@ -361,6 +361,7 @@ export class PathTracer extends RenderStage {
 	setupBlueNoise() {
 
 		const loader = new TextureLoader();
+		loader.setCrossOrigin( 'anonymous' );
 		loader.load( blueNoiseImage, ( texture ) => {
 
 			texture.minFilter = NearestFilter;
@@ -572,11 +573,11 @@ export class PathTracer extends RenderStage {
 
 		}
 
-		// Point lights (7 floats per light)
+		// Point lights (9 floats per light)
 		if ( this.pointLightsData && this.pointLightsData.length > 0 ) {
 
 			this.pointLightsBufferNode.array = Array.from( this.pointLightsData );
-			this.numPointLights.value = Math.floor( this.pointLightsData.length / 7 );
+			this.numPointLights.value = Math.floor( this.pointLightsData.length / 9 );
 
 		} else {
 
@@ -584,11 +585,11 @@ export class PathTracer extends RenderStage {
 
 		}
 
-		// Spot lights (11 floats per light)
+		// Spot lights (14 floats per light)
 		if ( this.spotLightsData && this.spotLightsData.length > 0 ) {
 
 			this.spotLightsBufferNode.array = Array.from( this.spotLightsData );
-			this.numSpotLights.value = Math.floor( this.spotLightsData.length / 11 );
+			this.numSpotLights.value = Math.floor( this.spotLightsData.length / 14 );
 
 		} else {
 

package/src/TSL/LightsCore.js

@@ -40,6 +40,8 @@ export const PointLight = struct( {
 	position: 'vec3',
 	color: 'vec3',
 	intensity: 'float',
+	distance: 'float', // cutoff distance (0 = infinite)
+	decay: 'float', // decay exponent (2 = physically correct)
 } );
 
 export const SpotLight = struct( {
@@ -48,6 +50,9 @@ export const SpotLight = struct( {
 	color: 'vec3',
 	intensity: 'float',
 	angle: 'float', // cone half-angle in radians
+	penumbra: 'float', // penumbra factor [0,1]
+	distance: 'float', // cutoff distance (0 = infinite)
+	decay: 'float', // decay exponent (2 = physically correct)
 } );
 
 export const LightSample = struct( {
@@ -135,7 +140,7 @@ export const getAreaLight = Fn( ( [ areaLightsBuffer, index ] ) => {
 
 export const getPointLight = Fn( ( [ pointLightsBuffer, index ] ) => {
 
-	const baseIndex = index.mul( 7 );
+	const baseIndex = index.mul( 9 );
 	return PointLight( {
 		position: vec3(
 			pointLightsBuffer.element( baseIndex ),
@@ -148,13 +153,15 @@ export const getPointLight = Fn( ( [ pointLightsBuffer, index ] ) => {
 			pointLightsBuffer.element( baseIndex.add( 5 ) ),
 		),
 		intensity: pointLightsBuffer.element( baseIndex.add( 6 ) ),
+		distance: pointLightsBuffer.element( baseIndex.add( 7 ) ),
+		decay: pointLightsBuffer.element( baseIndex.add( 8 ) ),
 	} );
 
 } );
 
 export const getSpotLight = Fn( ( [ spotLightsBuffer, index ] ) => {
 
-	const baseIndex = index.mul( 11 );
+	const baseIndex = index.mul( 14 );
 	return SpotLight( {
 		position: vec3(
 			spotLightsBuffer.element( baseIndex ),
@@ -173,6 +180,9 @@ export const getSpotLight = Fn( ( [ spotLightsBuffer, index ] ) => {
 		),
 		intensity: spotLightsBuffer.element( baseIndex.add( 9 ) ),
 		angle: spotLightsBuffer.element( baseIndex.add( 10 ) ),
+		penumbra: spotLightsBuffer.element( baseIndex.add( 11 ) ),
+		distance: spotLightsBuffer.element( baseIndex.add( 12 ) ),
+		decay: spotLightsBuffer.element( baseIndex.add( 13 ) ),
 	} );
 
 } );

package/src/TSL/LightsSampling.js

@@ -145,7 +145,7 @@ export const sampleRectAreaLight = Fn( ( [ light, rayOrigin, ruv, lightSelection
 			const cosAngle = dot( direction.negate(), lightNormal ).toVar();
 
 			ls_lightType.assign( int( LIGHT_TYPE_AREA ) );
-			ls_emission.assign( light.color.mul( light.intensity ) );
+			ls_emission.assign( light.color.mul( light.intensity ).div( PI ) );
 			ls_distance.assign( dist );
 			ls_direction.assign( direction );
 			// Guard division: ensure denominator is never zero
@@ -205,7 +205,7 @@ export const sampleCircAreaLight = Fn( ( [ light, rayOrigin, ruv, lightSelection
 			const cosAngle = dot( direction.negate(), lightNormal ).toVar();
 
 			ls_lightType.assign( int( LIGHT_TYPE_AREA ) );
-			ls_emission.assign( light.color.mul( light.intensity ) );
+			ls_emission.assign( light.color.mul( light.intensity ).div( PI ) );
 			ls_distance.assign( dist );
 			ls_direction.assign( direction );
 			// Guard division
@@ -258,9 +258,11 @@ export const sampleSpotLightWithRadius = Fn( ( [ light, rayOrigin, ruv, lightSel
 
 		If( ls_valid, () => {
 
-			const penumbraCosAngle = cos( light.angle.mul( 0.9 ) ).toVar(); // 10% penumbra
+			// Penumbra: inner cone angle = outerAngle * (1 - penumbra)
+			// Clamp penumbraCosAngle > coneCosAngle to avoid smoothstep UB when penumbra = 0
+			const penumbraCosAngle = cos( light.angle.mul( float( 1.0 ).sub( light.penumbra ) ) ).max( coneCosAngle.add( 1e-5 ) ).toVar();
 			const coneAttenuation = getSpotAttenuation( { coneCosine: coneCosAngle, penumbraCosine: penumbraCosAngle, angleCosine: spotCosAngle } );
-			const distanceAttenuation = getDistanceAttenuation( { lightDistance: lightDist, cutoffDistance: float( 0.0 ), decayExponent: float( 2.0 ) } );
+			const distanceAttenuation = getDistanceAttenuation( { lightDistance: lightDist, cutoffDistance: light.distance, decayExponent: light.decay } );
 
 			ls_emission.assign( light.color.mul( light.intensity ).mul( distanceAttenuation ).mul( coneAttenuation ) );
 
@@ -297,8 +299,8 @@ export const samplePointLightWithAttenuation = Fn( ( [ light, rayOrigin, lightSe
 
 		const lightDir = toLight.div( lightDist ).toVar();
 
-		// Calculate distance attenuation
-		const distanceAttenuation = getDistanceAttenuation( { lightDistance: lightDist, cutoffDistance: float( 0.0 ), decayExponent: float( 2.0 ) } );
+		// Calculate distance attenuation using the light's actual distance and decay properties
+		const distanceAttenuation = getDistanceAttenuation( { lightDistance: lightDist, cutoffDistance: light.distance, decayExponent: light.decay } );
 
 		ls_lightType.assign( int( LIGHT_TYPE_POINT ) );
 		ls_direction.assign( lightDir );

package/src/managers/LightManager.js

@@ -166,7 +166,7 @@ export class LightManager extends EventDispatcher {
 
 			}
 
-			if ( light.isSpotLight && light.target ) {
+			if ( ( light.isSpotLight || light.isDirectionalLight ) && light.target ) {
 
 				const clonedTarget = new Object3D();
 				light.target.updateWorldMatrix( true, false );

package/src/managers/UniformManager.js

@@ -203,8 +203,8 @@ export class UniformManager {
 		this._lightBuffers = {
 			directional: uniformArray( new Float32Array( 8 * 16 ), 'float' ),
 			area: uniformArray( new Float32Array( 13 * 16 ), 'float' ),
-			point: uniformArray( new Float32Array( 7 * 16 ), 'float' ),
-			spot: uniformArray( new Float32Array( 11 * 16 ), 'float' ),
+			point: uniformArray( new Float32Array( 9 * 16 ), 'float' ),
+			spot: uniformArray( new Float32Array( 14 * 16 ), 'float' ),
 		};
 
 		// Camera matrices

package/src/Processor/createWorker.js

@@ -1,38 +0,0 @@
-/**
- * Cross-origin Worker utility.
- *
- * Browsers block `new Worker(url)` when the script is cross-origin (e.g. CDN).
- * The workaround: create a same-origin blob that `import()`s the real script.
- * This preserves the original URL as the base for relative imports inside the worker.
- */
-
-function crossOriginWorker( url, options ) {
-
-	const blob = new Blob(
-		[ `import ${JSON.stringify( url.toString() )};` ],
-		{ type: 'application/javascript' }
-	);
-	return new Worker( URL.createObjectURL( blob ), { ...options, type: 'module' } );
-
-}
-
-/**
- * Creates a Worker, falling back to a blob-based proxy for cross-origin scripts.
- * @param {URL} url - Worker script URL
- * @param {WorkerOptions} [options] - Worker options (e.g. { type: 'module' })
- * @returns {Worker}
- */
-export function createWorker( url, options = {} ) {
-
-	try {
-
-		return new Worker( url, options );
-
-	} catch ( e ) {
-
-		if ( e.name !== 'SecurityError' ) throw e;
-		return crossOriginWorker( url, options );
-
-	}
-
-}