@carbonenginejs/runtime 0.1.0-alpha.6 → 0.1.0-alpha.7

package/dist/trinity/core/lighting/Tr2LightManager.js

@@ -5,6 +5,12 @@ import { num } from '#math/num';
 import { vec3 } from '#math/vec3';
 import { ShadowQuality } from '../../generated/trinityCore/enums.js';
 import { Tr2TextureArray as _Tr2TextureArray } from '../Tr2TextureArray/Tr2TextureArray.js';
+import { Tr2GpuStructuredBuffer as _Tr2GpuStructuredBuff } from '../device/Tr2GpuStructuredBuffer.js';
+import { TriDevice as _TriDevice } from '../device/TriDevice.js';
+import { Tr2Renderer as _Tr2Renderer } from '../Tr2Renderer.js';
+import { Tr2RenderContext_GetMainThreadRenderContext } from '../context/Tr2RenderContext.js';
+import { Tr2VariableStore as _Tr2VariableStore } from '../variable/Tr2VariableStore.js';
+import { Succeeded } from '#trinityal';
 
 let _initStatic, _initProto, _initClass;
 
@@ -19,6 +25,13 @@ const HIGH_QUALITY_ATLAS_SIZE_LOG2 = 14;
 const HIGH_QUALITY_ATLAS_ENTRY_MAX_SIZE = 1 << 13;
 const INFINITE_SIZE_CLAMP = 1 << 14; // 1 << HIGH_QUALITY_ATLAS_SIZE_LOG2
 const FLOATS_PER_LIGHT = 12; // 48 bytes / 3 RGBA32 texels
+const BYTES_PER_LIGHT = FLOATS_PER_LIGHT * 4;
+// Tr2LightManager.cpp:39-40 - the light-list tiles, 16x16 pixels.
+const TILE_WIDTH = 16;
+const TILE_HEIGHT = 16;
+// Header words per tile: list0 head, list1 head, particle-list head
+// (computelightlists writes all three; the hull shaders read +0).
+const HEADER_WORDS_PER_TILE = 3;
 
 /** CCP_ALIGN: round up to a power-of-two alignment. */
 function align(value, alignment) {
@@ -88,39 +101,39 @@ new class extends _identity {
       } = _applyDecs2311(this, [type.define({
         className: "Tr2LightManager",
         family: "trinityCore"
-      })], [[[carbon, carbon.method, impl, impl.implemented], 26, "areLightFlagsValid"], [[carbon, carbon.method, impl, impl.implemented], 18, "SetShadowQuality"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetShadowMapAtlasSettings"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetUnpackedShadowMapData"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("ClearLightIndices' UAV clear is AL realization; the vector clears are ported. The render-context parameter is accepted for signature parity and unused.")], 18, "Clear"], [[carbon, carbon.method, impl, impl.implemented], 18, "SetFrustum"], [[carbon, carbon.method, impl, impl.implemented], 18, "AdjustLightCutoff"], [[carbon, carbon.method, impl, impl.implemented], 18, "AddPointLight"], [[carbon, carbon.method, impl, impl.implemented], 18, "AddLight"], [[carbon, carbon.method, impl, impl.implemented], 18, "ResolveLightData"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetCurrentSpaceSceneShadowQuality"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetLightData"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetVolumetricLights"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetShadowCastingLights"], [[impl, impl.custom, void 0, impl.reason("AL seam: Trinity owns the packed description bytes; the AL realizes LightBuffer from this view. Carbon has no such seam; Tr2DataTextureManager now writes its own texture, so this has no precedent.")], 18, "GetLightBufferData"], [[impl, impl.custom, void 0, impl.reason("AL seam companion to GetLightBufferData.")], 18, "GetLightCount"], [[impl, impl.custom, void 0, impl.reason("Non-Carbon extension: cheaper than the AL diffing a typed array; Carbon re-uploads unconditionally.")], 18, "GetDataRevision"]], 0, void 0, CjsModel));
+      })], [[[carbon, carbon.method, impl, impl.implemented], 26, "areLightFlagsValid"], [[carbon, carbon.method, impl, impl.implemented], 18, "SetShadowQuality"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetShadowMapAtlasSettings"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetUnpackedShadowMapData"], [[carbon, carbon.method, impl, impl.implemented], 18, "Clear"], [[carbon, carbon.method, impl, impl.implemented], 18, "SetFrustum"], [[carbon, carbon.method, impl, impl.implemented], 18, "AdjustLightCutoff"], [[carbon, carbon.method, impl, impl.implemented], 18, "AddPointLight"], [[carbon, carbon.method, impl, impl.implemented], 18, "AddLight"], [[carbon, carbon.method, impl, impl.implemented], 18, "ResolveLightData"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetCurrentSpaceSceneShadowQuality"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetLightData"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetVolumetricLights"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetShadowCastingLights"], [[carbon, carbon.method, impl, impl.implemented], 26, "getOrCreateInstance"], [[carbon, carbon.method, impl, impl.implemented], 26, "getInstance"], [[carbon, carbon.method, impl, impl.adapted], 26, "deleteInstance"], [[carbon, carbon.method, impl, impl.implemented], 18, "SetVariableStore"], [[carbon, carbon.method, impl, impl.implemented], 18, "PrepareResources"], [[carbon, carbon.method, impl, impl.adapted], 18, "OnPrepareResources"], [[carbon, carbon.method, impl, impl.implemented], 18, "ReleaseResources"], [[carbon, carbon.method, impl, impl.adapted], 18, "ClearLightIndices"], [[carbon, carbon.method, impl, impl.implemented], 18, "UpdateLightBuffer"], [[carbon, carbon.method, impl, impl.implemented], 18, "UpdateLists"], [[carbon, carbon.method, impl, impl.adapted], 18, "DoUpdateLists"], [[impl, impl.custom, void 0, impl.reason("AL seam: Trinity owns the packed description bytes; the AL realizes LightBuffer from this view. Carbon has no such seam; Tr2DataTextureManager now writes its own texture, so this has no precedent.")], 18, "GetLightBufferData"], [[impl, impl.custom, void 0, impl.reason("AL seam companion to GetLightBufferData.")], 18, "GetLightCount"], [[impl, impl.custom, void 0, impl.reason("Non-Carbon extension: cheaper than the AL diffing a typed array; Carbon re-uploads unconditionally.")], 18, "GetDataRevision"]], 0, void 0, CjsModel));
       _initStatic(this);
     }
     // Carbon m_lightData after the TLS flatten: the frame's accepted records,
     // plain-object copies (every producer reuses a static scratch record, so
     // AddLight copies by value exactly as std::vector::push_back does).
-    #records = (_initProto(this), []);
+    _records = (_initProto(this), []);
 
-    // Carbon m_volumetricLights / m_shadowCastingLights: indices into #records.
-    #volumetricLights = [];
-    #shadowCastingLights = [];
+    // Carbon m_volumetricLights / m_shadowCastingLights: indices into _records.
+    _volumetricLights = [];
+    _shadowCastingLights = [];
 
     // Carbon m_frustum, by reference (SetFrustum copies by value in C++; the
     // stamped frame frustum is not mutated during the gather, so a reference
     // carries the same guarantee here).
-    #frustum = null;
+    _frustum = null;
 
     // Carbon m_adjustedCutoff (cpp:249-252).
-    #adjustedCutoff = CUTOFF_PIXEL_SIZE;
+    _adjustedCutoff = CUTOFF_PIXEL_SIZE;
 
     // Carbon m_currentSpaceSceneShadowQuality (h:197).
-    #currentSpaceSceneShadowQuality = ShadowQuality.SHADOW_DISABLED;
+    _currentSpaceSceneShadowQuality = ShadowQuality.SHADOW_DISABLED;
 
     // Carbon nextFrameShadowQuality (h:196) - a bitmask collecting every
     // scene's requested quality during the current frame.
-    #nextFrameShadowQuality = 0;
+    _nextFrameShadowQuality = 0;
 
     // Carbon m_currentFrameCounter (h:198; ctor sets -1, cpp:164).
-    #currentFrameCounter = -1;
+    _currentFrameCounter = -1;
 
     // Carbon's anonymous m_ShadowMap block (h:200-205): the atlas settings,
     // the guillotine node tree, and the quality the atlas was last sized for.
-    #shadowMap = {
+    _shadowMap = {
       atlasSettings: calculateShadowMapAtlasSettings(ShadowQuality.SHADOW_DISABLED),
       atlasNodes: [],
       qualityUsedByAtlas: ShadowQuality.SHADOW_DISABLED
@@ -129,16 +142,16 @@ new class extends _identity {
     // Non-Carbon: profile-object -> slice index, assigned on first sight. The
     // slot registry is description-side (Carbon assigns slices through the
     // manager-owned Tr2TextureArray, cpp:682-686, whose realization is AL).
-    #profileSlots = new Map();
+    _profileSlots = new Map();
 
     // The packed PerLightData buffer (contract: 48 bytes / 3 RGBA32 texels per
     // light), built by ResolveLightData, uploaded by the AL.
-    #packed = new Float32Array(LIGHT_BUFFER_SIZE * FLOATS_PER_LIGHT);
-    #packedBits = new Uint32Array(this.#packed.buffer);
-    #packedCount = 0;
+    _packed = new Float32Array(LIGHT_BUFFER_SIZE * FLOATS_PER_LIGHT);
+    _packedBits = new Uint32Array(this._packed.buffer);
+    _packedCount = 0;
 
     // Non-Carbon: bumped by ResolveLightData so the AL can skip re-uploads.
-    #revision = 0;
+    _revision = 0;
 
     /** Tr2LightManager.h:100-105 - the light flag bits, Carbon's raw uint16 spelling. */
 
@@ -175,30 +188,30 @@ new class extends _identity {
      */
     SetShadowQuality(quality, frameCounter = 0) {
       const shadowQuality = Number(quality) || 0;
-      this.#currentSpaceSceneShadowQuality = shadowQuality;
-      if (this.#currentFrameCounter !== frameCounter) {
+      this._currentSpaceSceneShadowQuality = shadowQuality;
+      if (this._currentFrameCounter !== frameCounter) {
         if (!_Tr2LightManager.useDynamicLightsShadows) {
-          this.#nextFrameShadowQuality = 0;
+          this._nextFrameShadowQuality = 0;
         }
-        if (this.#nextFrameShadowQuality & 1 << ShadowQuality.SHADOW_HIGH) {
-          this.#shadowMap.qualityUsedByAtlas = ShadowQuality.SHADOW_HIGH;
-        } else if (this.#nextFrameShadowQuality & 1 << ShadowQuality.SHADOW_LOW) {
-          this.#shadowMap.qualityUsedByAtlas = ShadowQuality.SHADOW_LOW;
+        if (this._nextFrameShadowQuality & 1 << ShadowQuality.SHADOW_HIGH) {
+          this._shadowMap.qualityUsedByAtlas = ShadowQuality.SHADOW_HIGH;
+        } else if (this._nextFrameShadowQuality & 1 << ShadowQuality.SHADOW_LOW) {
+          this._shadowMap.qualityUsedByAtlas = ShadowQuality.SHADOW_LOW;
         } else {
-          this.#shadowMap.qualityUsedByAtlas = ShadowQuality.SHADOW_DISABLED;
+          this._shadowMap.qualityUsedByAtlas = ShadowQuality.SHADOW_DISABLED;
         }
-        this.#nextFrameShadowQuality = 1 << shadowQuality;
-        this.#currentFrameCounter = frameCounter;
+        this._nextFrameShadowQuality = 1 << shadowQuality;
+        this._currentFrameCounter = frameCounter;
       }
-      this.#nextFrameShadowQuality |= 1 << shadowQuality;
-      const clamped = Math.min(shadowQuality, this.#shadowMap.qualityUsedByAtlas);
-      this.#shadowMap.atlasSettings = calculateShadowMapAtlasSettings(clamped);
-      this.#shadowMap.atlasSettings.actualTextureSize = calculateShadowMapAtlasSettings(this.#shadowMap.qualityUsedByAtlas).size;
+      this._nextFrameShadowQuality |= 1 << shadowQuality;
+      const clamped = Math.min(shadowQuality, this._shadowMap.qualityUsedByAtlas);
+      this._shadowMap.atlasSettings = calculateShadowMapAtlasSettings(clamped);
+      this._shadowMap.atlasSettings.actualTextureSize = calculateShadowMapAtlasSettings(this._shadowMap.qualityUsedByAtlas).size;
     }
 
     /** Carbon GetShadowMapAtlasSettings (cpp:708-711). */
     GetShadowMapAtlasSettings() {
-      return this.#shadowMap.atlasSettings;
+      return this._shadowMap.atlasSettings;
     }
 
     /**
@@ -210,7 +223,7 @@ new class extends _identity {
      * @returns {object} out
      */
     GetUnpackedShadowMapData(record, out = {}) {
-      const shift = this.#shadowMap.atlasSettings.entryMinSizeLog2;
+      const shift = this._shadowMap.atlasSettings.entryMinSizeLog2;
       out.shadowMapScale = (record.shadowMapScale ?? 0) << shift;
       out.shadowMapOffsetX = (record.shadowMapOffsetX ?? 0) << shift;
       out.shadowMapOffsetY = (record.shadowMapOffsetY ?? 0) << shift;
@@ -218,24 +231,39 @@ new class extends _identity {
     }
 
     /**
-     * Carbon Clear (cpp:220-242), the CPU half: drops the frame's records and
-     * selections. The index-buffer UAV clear (cpp:224) is device work the AL
-     * performs when it consumes the frame.
+     * Carbon Clear (cpp:220-242): re-points the light-buffer globals, clears
+     * the light indices, drops the frame's records and selections, and resets
+     * the atlas to one empty root node.
+     *
+     * Without a render context (a CPU-only caller) the index clear is skipped;
+     * there is no buffer to clear then.
      */
-    Clear(_renderContext = null) {
-      this.#records.length = 0;
-      this.#volumetricLights.length = 0;
-      this.#shadowCastingLights.length = 0;
+    Clear(renderContext = null) {
+      this.SetVariableStore();
+      if (renderContext) this.ClearLightIndices(renderContext);
+      this._records.length = 0;
+      this._volumetricLights.length = 0;
+      this._shadowCastingLights.length = 0;
+      const size = this._shadowMap.atlasSettings.size;
+      this._shadowMap.atlasNodes.length = 0;
+      this._shadowMap.atlasNodes.push({
+        children: [-1, -1],
+        lightIndex: -1,
+        x: 0,
+        y: 0,
+        width: size,
+        height: size
+      });
     }
 
     /** Carbon SetFrustum (cpp:244-247). */
     SetFrustum(frustum) {
-      this.#frustum = frustum ?? null;
+      this._frustum = frustum ?? null;
     }
 
     /** Carbon AdjustLightCutoff (cpp:249-252): the cull threshold is 7px * lodFactor. */
     AdjustLightCutoff(lodFactor) {
-      this.#adjustedCutoff = CUTOFF_PIXEL_SIZE * (Number(lodFactor) || 0);
+      this._adjustedCutoff = CUTOFF_PIXEL_SIZE * (Number(lodFactor) || 0);
     }
 
     /**
@@ -250,10 +278,10 @@ new class extends _identity {
       if (!_Tr2LightManager.areLightFlagsValid(flags)) return;
       const brightness = Math.max(color[0], color[1], color[2]);
       if (!(brightness > 0)) return;
-      const dimming = this.#CullAndDim(position, radius);
+      const dimming = this._CullAndDim(position, radius);
       if (dimming <= 0) return;
       const scale = radius * dimming;
-      this.#records.push({
+      this._records.push({
         owner: null,
         lightData: null,
         lightProfile: null,
@@ -282,19 +310,19 @@ new class extends _identity {
       if (!_Tr2LightManager.areLightFlagsValid(record.flags)) return;
       const brightness = Math.max(record.color[0], record.color[1], record.color[2]);
       if (!(brightness > 0) || !(record.radius > 0)) return;
-      const dimming = this.#CullAndDim(record.position, record.radius);
+      const dimming = this._CullAndDim(record.position, record.radius);
       if (dimming <= 0) return;
 
       // Carbon's conditional strip (cpp:359-365): shadows survive only when
       // the setting is on, the scene quality is not DISABLED, and a shadow-map
       // quality has an atlas actually sized for it (qualityUsedByAtlas lags a
       // frame behind). Always taken under the shipping default.
-      const usingShadowMap = this.#currentSpaceSceneShadowQuality === ShadowQuality.SHADOW_LOW || this.#currentSpaceSceneShadowQuality === ShadowQuality.SHADOW_HIGH;
-      if (this.#currentSpaceSceneShadowQuality === ShadowQuality.SHADOW_DISABLED || usingShadowMap && this.#shadowMap.qualityUsedByAtlas === ShadowQuality.SHADOW_DISABLED || !_Tr2LightManager.useDynamicLightsShadows) {
+      const usingShadowMap = this._currentSpaceSceneShadowQuality === ShadowQuality.SHADOW_LOW || this._currentSpaceSceneShadowQuality === ShadowQuality.SHADOW_HIGH;
+      if (this._currentSpaceSceneShadowQuality === ShadowQuality.SHADOW_DISABLED || usingShadowMap && this._shadowMap.qualityUsedByAtlas === ShadowQuality.SHADOW_DISABLED || !_Tr2LightManager.useDynamicLightsShadows) {
         record.flags &= ~_Tr2LightManager.Flags.CASTS_SHADOWS;
       }
       const scale = record.radius * dimming;
-      this.#records.push({
+      this._records.push({
         owner: record.owner ?? null,
         lightData: record.lightData ?? null,
         lightProfile: record.lightProfile ?? null,
@@ -322,20 +350,20 @@ new class extends _identity {
      */
     ResolveLightData() {
       const volumetric = [];
-      for (let i = 0; i < this.#records.length; i++) {
-        if (this.#records[i].flags & _Tr2LightManager.Flags.IS_VOLUMETRIC) {
-          const size = this.#ScreenSize(this.#records[i]);
+      for (let i = 0; i < this._records.length; i++) {
+        if (this._records[i].flags & _Tr2LightManager.Flags.IS_VOLUMETRIC) {
+          const size = this._ScreenSize(this._records[i]);
           volumetric.push([i, Math.min(size, INFINITE_SIZE_CLAMP)]);
         }
       }
       volumetric.sort((a, b) => b[1] - a[1]);
-      this.#volumetricLights.length = 0;
+      this._volumetricLights.length = 0;
       for (let i = 0; i < volumetric.length; i++) {
-        if (i < MAX_NUM_VOLUMETRIC_LIGHTS) this.#volumetricLights.push(volumetric[i][0]);else this.#records[volumetric[i][0]].flags &= ~_Tr2LightManager.Flags.IS_VOLUMETRIC;
+        if (i < MAX_NUM_VOLUMETRIC_LIGHTS) this._volumetricLights.push(volumetric[i][0]);else this._records[volumetric[i][0]].flags &= ~_Tr2LightManager.Flags.IS_VOLUMETRIC;
       }
-      this.#ResolveShadowCasters();
-      this.#Pack();
-      this.#revision += 1;
+      this._ResolveShadowCasters();
+      this._Pack();
+      this._revision += 1;
     }
 
     /**
@@ -348,15 +376,15 @@ new class extends _identity {
      * strip FLAG_CASTS_SHADOWS from the losers, assign raytracing masks by
      * rank under SHADOW_RAYTRACED, and pack the atlas for LOW/HIGH.
      */
-    #ResolveShadowCasters() {
-      this.#shadowCastingLights.length = 0;
-      if (!_Tr2LightManager.useDynamicLightsShadows || this.#currentSpaceSceneShadowQuality === ShadowQuality.SHADOW_DISABLED) {
+    _ResolveShadowCasters() {
+      this._shadowCastingLights.length = 0;
+      if (!_Tr2LightManager.useDynamicLightsShadows || this._currentSpaceSceneShadowQuality === ShadowQuality.SHADOW_DISABLED) {
         return;
       }
       const lightTuples = [];
-      for (let i = 0; i < this.#records.length; i++) {
-        if ((this.#records[i].flags & _Tr2LightManager.Flags.CASTS_SHADOWS) !== 0) {
-          let sizeAcross = this.#frustum ? this.#frustum.GetPixelSizeAccrossEst(this.#records[i].position, this.#records[i].radius) : 0;
+      for (let i = 0; i < this._records.length; i++) {
+        if ((this._records[i].flags & _Tr2LightManager.Flags.CASTS_SHADOWS) !== 0) {
+          let sizeAcross = this._frustum ? this._frustum.GetPixelSizeAccrossEst(this._records[i].position, this._records[i].radius) : 0;
           if (!Number.isFinite(sizeAcross)) sizeAcross = 1 << HIGH_QUALITY_ATLAS_SIZE_LOG2;
           lightTuples.push({
             lightIndex: i,
@@ -365,24 +393,24 @@ new class extends _identity {
         }
       }
       lightTuples.sort((a, b) => b.sizeAcross - a.sizeAcross);
-      const raytraced = this.#currentSpaceSceneShadowQuality === ShadowQuality.SHADOW_RAYTRACED;
+      const raytraced = this._currentSpaceSceneShadowQuality === ShadowQuality.SHADOW_RAYTRACED;
       const numShadowCastingLights = Math.min(MAX_NUM_SHADOWCASTING_LIGHTS, lightTuples.length);
       let i = 0;
       for (; i < numShadowCastingLights; i++) {
-        this.#shadowCastingLights.push(lightTuples[i].lightIndex);
+        this._shadowCastingLights.push(lightTuples[i].lightIndex);
         if (raytraced) {
-          this.#records[lightTuples[i].lightIndex].raytracingShadowMask = 1 << i;
+          this._records[lightTuples[i].lightIndex].raytracingShadowMask = 1 << i;
         }
       }
       for (; i < lightTuples.length; i++) {
-        const record = this.#records[lightTuples[i].lightIndex];
+        const record = this._records[lightTuples[i].lightIndex];
         record.flags &= ~_Tr2LightManager.Flags.CASTS_SHADOWS;
         if (raytraced) {
           record.raytracingShadowMask = 0;
         }
       }
-      if (this.#currentSpaceSceneShadowQuality === ShadowQuality.SHADOW_LOW || this.#currentSpaceSceneShadowQuality === ShadowQuality.SHADOW_HIGH) {
-        this.#CreateShadowMapAtlas(numShadowCastingLights, lightTuples);
+      if (this._currentSpaceSceneShadowQuality === ShadowQuality.SHADOW_LOW || this._currentSpaceSceneShadowQuality === ShadowQuality.SHADOW_HIGH) {
+        this._CreateShadowMapAtlas(numShadowCastingLights, lightTuples);
       }
     }
 
@@ -395,8 +423,8 @@ new class extends _identity {
      * scale in entry-min-size units into the record's 10-bit fields; failures
      * zero them.
      */
-    #CreateShadowMapAtlas(numShadowCastingLights, lightTuples) {
-      const settings = this.#shadowMap.atlasSettings;
+    _CreateShadowMapAtlas(numShadowCastingLights, lightTuples) {
+      const settings = this._shadowMap.atlasSettings;
       const entry = {
         x: 0,
         y: 0
@@ -406,8 +434,8 @@ new class extends _identity {
         everythingFit = true;
         const entryInverseScaleFactorLog2 = settings.entryInverseScaleFactorLog2 + j;
         const entryMaxSize = settings.entryMaxSize >> j;
-        this.#shadowMap.atlasNodes.length = 0;
-        this.#shadowMap.atlasNodes.push({
+        this._shadowMap.atlasNodes.length = 0;
+        this._shadowMap.atlasNodes.push({
           children: [-1, -1],
           lightIndex: -1,
           x: 0,
@@ -417,7 +445,7 @@ new class extends _identity {
         });
         for (let i = 0; i < numShadowCastingLights; i++) {
           const lightIndex = lightTuples[i].lightIndex;
-          const record = this.#records[lightIndex];
+          const record = this._records[lightIndex];
           let size = lightTuples[i].sizeAcross >>> 0 >>> entryInverseScaleFactorLog2;
           size = Math.min(Math.max(size, settings.entryMinSize), entryMaxSize);
           size = align(size, settings.entryMinSize);
@@ -431,7 +459,7 @@ new class extends _identity {
             width = size;
             height = size;
           }
-          if (this.#GetShadowMapAtlasEntry(lightIndex, width, height, entry)) {
+          if (this._GetShadowMapAtlasEntry(lightIndex, width, height, entry)) {
             record.shadowMapOffsetX = entry.x >>> settings.entryMinSizeLog2;
             record.shadowMapOffsetY = entry.y >>> settings.entryMinSizeLog2;
             record.shadowMapScale = size >>> settings.entryMinSizeLog2;
@@ -451,14 +479,14 @@ new class extends _identity {
      * success - the out object is untouched on failure, exactly as Carbon
      * leaves its out-references.
      */
-    #GetShadowMapAtlasEntry(lightIndex, width, height, out) {
-      const settings = this.#shadowMap.atlasSettings;
+    _GetShadowMapAtlasEntry(lightIndex, width, height, out) {
+      const settings = this._shadowMap.atlasSettings;
       width = align(width, settings.entryMinSize);
       height = align(height, settings.entryMinSize);
-      const nodeId = this.#InsertAtlasNode(this.#shadowMap.atlasNodes, 0, lightIndex, width, height);
+      const nodeId = this._InsertAtlasNode(this._shadowMap.atlasNodes, 0, lightIndex, width, height);
       if (nodeId !== -1) {
-        out.x = this.#shadowMap.atlasNodes[nodeId].x;
-        out.y = this.#shadowMap.atlasNodes[nodeId].y;
+        out.x = this._shadowMap.atlasNodes[nodeId].x;
+        out.y = this._shadowMap.atlasNodes[nodeId].y;
       }
       return nodeId !== -1;
     }
@@ -470,14 +498,14 @@ new class extends _identity {
      * fits, otherwise split along the larger remainder axis and recurse into
      * the first child.
      */
-    #InsertAtlasNode(atlasNodes, nodeId, lightIndex, width, height) {
+    _InsertAtlasNode(atlasNodes, nodeId, lightIndex, width, height) {
       const node = atlasNodes[nodeId];
       if (node.children[0] !== -1 || node.children[1] !== -1) {
-        const newNode = this.#InsertAtlasNode(atlasNodes, node.children[0], lightIndex, width, height);
+        const newNode = this._InsertAtlasNode(atlasNodes, node.children[0], lightIndex, width, height);
         if (newNode !== -1) {
           return newNode;
         }
-        return this.#InsertAtlasNode(atlasNodes, node.children[1], lightIndex, width, height);
+        return this._InsertAtlasNode(atlasNodes, node.children[1], lightIndex, width, height);
       }
       if (node.lightIndex !== -1) {
         return -1;
@@ -529,27 +557,27 @@ new class extends _identity {
         child1.width = node.width;
         child1.height = node.height - height;
       }
-      return this.#InsertAtlasNode(atlasNodes, node.children[0], lightIndex, width, height);
+      return this._InsertAtlasNode(atlasNodes, node.children[0], lightIndex, width, height);
     }
 
     /** Carbon GetCurrentSpaceSceneShadowQuality (cpp:713-716): a bare field read; every record producer asks it before building. */
     GetCurrentSpaceSceneShadowQuality() {
-      return this.#currentSpaceSceneShadowQuality;
+      return this._currentSpaceSceneShadowQuality;
     }
 
     /** Carbon GetLightData (cpp:695-698): the frame's resolved records, borrowed. */
     GetLightData() {
-      return this.#records;
+      return this._records;
     }
 
     /** Carbon GetVolumetricLights (cpp:707-710): indices into GetLightData, borrowed. */
     GetVolumetricLights() {
-      return this.#volumetricLights;
+      return this._volumetricLights;
     }
 
     /** Carbon GetShadowCastingLights (cpp:688-691): empty under the shipping pin, kept for signature parity. */
     GetShadowCastingLights() {
-      return this.#shadowCastingLights;
+      return this._shadowCastingLights;
     }
 
     // The frame clock used to be threaded through here, as a non-Carbon seam:
@@ -559,39 +587,296 @@ new class extends _identity {
     // that here now. Nothing in src ever called the setter, so the five readers
     // had been sampling a constant zero.
 
+    /** Carbon m_effect's path, computelightlists (EveSpaceScene.cpp:1380). */
+    _effectPath = "";
+
+    /** m_lightBuffer (Tr2GpuStructuredBufferPtr): one PerLightData per light. */
+    _lightBuffer = new _Tr2GpuStructuredBuff();
+
+    /** m_indexBuffer (Tr2GpuStructuredBufferPtr): tile headers, then list nodes. */
+    _indexBuffer = new _Tr2GpuStructuredBuff();
+
+    /** m_lightBufferVariable / m_indexBufferVariable (TriVariableHandle). */
+    _lightBufferVariable = null;
+    _indexBufferVariable = null;
+
+    /** The CPU-built index list, reused across frames (see DoUpdateLists). */
+    _indexList = new Uint32Array(0);
+
+    /**
+     * Carbon's constructor half that makes this a device resource and
+     * publishes the globals (cpp:145-176): LightBuffer and LightIndexBuffer are
+     * registered once and pointed at the buffers, and the buffers are made
+     * when a device allows it. Carbon also publishes LightProfileArray; the JS
+     * texture array is not yet a texture provider, so it is not registered.
+     * Profile-less lights, most of them, never sample it.
+     *
+     * @param {string} effectPath The light-list compute effect.
+     * @returns {Tr2LightManager} This manager.
+     */
+    _InitializeDevice(effectPath) {
+      this._effectPath = String(effectPath ?? "");
+      const store = _Tr2VariableStore.GlobalStore();
+      this._lightBufferVariable = store.RegisterVariable(_Tr2LightManager.LIGHT_BUFFER_NAME, this._lightBuffer);
+      this._indexBufferVariable = store.RegisterVariable(_Tr2LightManager.LIGHT_INDEX_BUFFER_NAME, this._indexBuffer);
+      _TriDevice.RegisterResource(this);
+      this.PrepareResources();
+      return this;
+    }
+
+    /** Carbon GetOrCreateInstance (cpp:192-200): the process-wide manager. */
+    static getOrCreateInstance(effectPath) {
+      _Tr2LightManager._instance ??= new _Tr2LightManager()._InitializeDevice(effectPath);
+      return _Tr2LightManager._instance;
+    }
+
+    /** Carbon GetInstance (cpp:202-205): the manager, or null when none exists. */
+    static getInstance() {
+      return _Tr2LightManager._instance;
+    }
+
+    /**
+     * Carbon DeleteInstance (cpp:207-212). The destructor's ResetVariableStore
+     * (cpp:174-190) republishes empty buffers, so the globals stop naming this
+     * manager's.
+     *
+     * Adapted: JavaScript has no destructor, so the manager unregisters from
+     * the device and resets the variable store here. ResetVariableStore's
+     * LightProfileArray and ShadowMapAtlas re-registrations are not made; the
+     * manager does not publish either.
+     */
+    static deleteInstance() {
+      const instance = _Tr2LightManager._instance;
+      if (!instance) return;
+      _Tr2LightManager._instance = null;
+      _TriDevice.UnregisterResource(instance);
+      const store = _Tr2VariableStore.GlobalStore();
+      store.RegisterVariable(_Tr2LightManager.LIGHT_BUFFER_NAME, new _Tr2GpuStructuredBuff());
+      store.RegisterVariable(_Tr2LightManager.LIGHT_INDEX_BUFFER_NAME, new _Tr2GpuStructuredBuff());
+    }
+    /** Carbon SetVariableStore (cpp:214-218): the globals name this manager's buffers. */
+    SetVariableStore() {
+      this._lightBufferVariable?.SetValue(this._lightBuffer);
+      this._indexBufferVariable?.SetValue(this._indexBuffer);
+    }
+
+    /** Carbon Tr2DeviceResource::PrepareResources (Tr2DeviceResource.cpp:21-32). */
+    PrepareResources() {
+      if (_Tr2Renderer.IsResourceCreationAllowed()) {
+        if (!this.OnPrepareResources()) return false;
+      }
+      return true;
+    }
+
+    /**
+     * Carbon OnPrepareResources (cpp:657-675): the light buffer, and the index
+     * buffer.
+     *
+     * The index buffer is sized by UpdateLists to what the CPU list needs, and
+     * created CPU-writable; see DoUpdateLists. Carbon makes it 8M elements,
+     * GPU-writable, for the compute kernel's allocator. The counter and the
+     * per-frame constants belong to that kernel and are not made.
+     *
+     * Adapted: the light lists are filled on the CPU, not by
+     * computelightlists, so the index buffer is CPU-writable and sized per
+     * screen.
+     */
+    OnPrepareResources() {
+      const renderContext = Tr2RenderContext_GetMainThreadRenderContext();
+      const {
+        CPU_WRITABLE
+      } = _Tr2GpuStructuredBuff.CreationFlag;
+      this._lightBuffer.Create(LIGHT_BUFFER_SIZE, BYTES_PER_LIGHT, CPU_WRITABLE, renderContext);
+      this._lightBuffer.SetName("Light buffer");
+      this._indexBuffer.SetName("Light indices");
+      this.ClearLightIndices(renderContext);
+      return true;
+    }
+
+    /** Carbon ReleaseResources (cpp:641-655): nothing of the light lists is released. */
+    ReleaseResources(_storage) {}
+
+    /**
+     * Carbon ClearLightIndices (cpp:370-378): zero indices, so every tile head
+     * reads "no lights".
+     *
+     * Adapted: Carbon clears the whole buffer as a UAV; the CPU-written buffer
+     * is zeroed through a map.
+     *
+     * @param {Tr2RenderContext} renderContext The context to write through.
+     * @returns {boolean} Whether the clear was written.
+     */
+    ClearLightIndices(renderContext) {
+      const buffer = this._indexBuffer.GetGpuBuffer(0);
+      if (!buffer) return true;
+      this._indexList.fill(0);
+      return _Tr2LightManager._WriteMapped(buffer, null, renderContext);
+    }
+
+    /**
+     * Carbon UpdateLightBuffer (cpp:380-399): grows the light buffer to the
+     * frame's light count, then uploads the packed records.
+     *
+     * @param {Tr2RenderContext} renderContext The context to write through.
+     * @returns {boolean} Whether the upload succeeded.
+     */
+    UpdateLightBuffer(renderContext) {
+      const count = this._packedCount;
+      if (this._lightBuffer.GetCount() < count) {
+        const grown = Math.max(this._lightBuffer.GetCount() + 1024, count);
+        this._lightBuffer.Create(grown, BYTES_PER_LIGHT, _Tr2GpuStructuredBuff.CreationFlag.CPU_WRITABLE, renderContext);
+        this._lightBuffer.SetName("Light buffer");
+      }
+      const buffer = this._lightBuffer.GetGpuBuffer(0);
+      if (!buffer) return false;
+      // cpp:393-396: a WRITE_OFTEN buffer is written through a map.
+      return _Tr2LightManager._WriteMapped(buffer, this.GetLightBufferData(), renderContext);
+    }
+
+    /**
+     * Carbon UpdateLists (cpp:622-639): the globals name the buffers, then the
+     * lists are built - or cleared when there are no lights or the build fails.
+     *
+     * @param {object} depthMap The scene depth, the render target's size.
+     * @param {Tr2RenderContext} renderContext The frame's context.
+     * @returns {boolean} Whether the lists were built.
+     */
+    UpdateLists(depthMap, renderContext) {
+      this.SetVariableStore();
+      if (this._packedCount === 0) {
+        this.ClearLightIndices(renderContext);
+        return true;
+      }
+      const built = this.DoUpdateLists(depthMap, renderContext);
+      if (!built) this.ClearLightIndices(renderContext);
+      return built;
+    }
+
+    /**
+     * Carbon DoUpdateLists (cpp:401-440) builds each 16x16 tile's light lists
+     * on the GPU with computelightlists. Here they are built on the CPU, in
+     * the kernel's own layout (decoded from build 3498825): three header words
+     * per tile - list0 head, list1 head, particle-list head - then
+     * [lightIndex, next] nodes, 0-based light indices, 0 ending a list.
+     *
+     * Every tile's heads point at one shared chain instead of a tile-culled
+     * one. The hull shaders test each light per pixel (dist < radius and
+     * FLAG_AFFECTS_SURFACES), so the picture is the same; only the tile cull's
+     * saving is lost. The particle list holds the lights flagged
+     * AFFECTS_PARTICLES.
+     *
+     * The tile count follows the render target, as the kernel's does; the
+     * depth map is that size.
+     *
+     * Adapted: computelightlists does not translate to WebGPU yet (its UAV
+     * shapes), so the CPU builds the lists.
+     *
+     * @param {object} depthMap The scene depth.
+     * @param {Tr2RenderContext} renderContext The frame's context.
+     * @returns {boolean} Whether the lists were written.
+     */
+    DoUpdateLists(depthMap, renderContext) {
+      if (!this.UpdateLightBuffer(renderContext)) return false;
+      const width = depthMap ? depthMap.GetWidth() : 0;
+      const height = depthMap ? depthMap.GetHeight() : 0;
+      if (!width || !height) return false;
+      const tiles = Math.ceil(width / TILE_WIDTH) * Math.ceil(height / TILE_HEIGHT);
+      const headerWords = tiles * HEADER_WORDS_PER_TILE;
+      const count = this._packedCount;
+      let particleCount = 0;
+      for (let index = 0; index < count; index++) {
+        if (this._LightFlags(index) & _Tr2LightManager.Flags.AFFECTS_PARTICLES) particleCount++;
+      }
+      const words = headerWords + 2 * (count + particleCount);
+      if (this._indexList.length < words) this._indexList = new Uint32Array(words);
+      if (this._indexBuffer.GetCount() < words) {
+        this._indexBuffer.Create(words, 4, _Tr2GpuStructuredBuff.CreationFlag.CPU_WRITABLE, renderContext);
+        this._indexBuffer.SetName("Light indices");
+        this.SetVariableStore();
+      }
+      const list = this._indexList;
+      list.fill(0);
+
+      // The shared chain of every light, then the chain of particle lights.
+      let node = headerWords;
+      const surfaceHead = node;
+      for (let index = 0; index < count; index++, node += 2) {
+        list[node] = index;
+        list[node + 1] = index + 1 < count ? node + 2 : 0;
+      }
+      const particleHead = particleCount ? node : 0;
+      for (let index = 0, seen = 0; index < count; index++) {
+        if (!(this._LightFlags(index) & _Tr2LightManager.Flags.AFFECTS_PARTICLES)) continue;
+        seen++;
+        list[node] = index;
+        list[node + 1] = seen < particleCount ? node + 2 : 0;
+        node += 2;
+      }
+      for (let tile = 0; tile < tiles; tile++) {
+        const header = tile * HEADER_WORDS_PER_TILE;
+        list[header] = surfaceHead;
+        list[header + 1] = surfaceHead;
+        list[header + 2] = particleHead;
+      }
+      const buffer = this._indexBuffer.GetGpuBuffer(0);
+      if (!buffer) return false;
+      return _Tr2LightManager._WriteMapped(buffer, list.subarray(0, words), renderContext);
+    }
+
+    /**
+     * MapForWriting, copy, UnmapForWriting - Carbon's upload for a
+     * CPU_WRITABLE (WRITE_OFTEN) buffer, which UpdateBuffer refuses. A null
+     * source zeroes the mapping.
+     */
+    static _WriteMapped(buffer, source, renderContext) {
+      const {
+        result,
+        data
+      } = buffer.MapForWriting(renderContext);
+      if (!Succeeded(result)) return false;
+      if (source) data.set(new Uint8Array(source.buffer, source.byteOffset, source.byteLength));else data.fill(0);
+      buffer.UnmapForWriting(renderContext);
+      return true;
+    }
+
+    /** The packed flags of light `index`: the high 16 bits of row 1's w (contract). */
+    _LightFlags(index) {
+      return this._packedBits[index * FLOATS_PER_LIGHT + 7] >>> 16;
+    }
+
     /** The packed PerLightData bytes for the AL to upload, borrowed (contract layout, 3 RGBA32 texels per light). */
     GetLightBufferData() {
-      return this.#packed.subarray(0, this.#packedCount * FLOATS_PER_LIGHT);
+      return this._packed.subarray(0, this._packedCount * FLOATS_PER_LIGHT);
     }
 
     /** The number of packed lights in GetLightBufferData. */
     GetLightCount() {
-      return this.#packedCount;
+      return this._packedCount;
     }
 
     /** Monotonic revision of the packed data, bumped by ResolveLightData, so the AL can skip unchanged re-uploads. */
     GetDataRevision() {
-      return this.#revision;
+      return this._revision;
     }
 
     /** Frustum cull + pixel-size cutoff, returning the fade-band dimming factor (0 = rejected). Cull applies only when a frustum was set. */
-    #CullAndDim(position, radius) {
-      if (!this.#frustum) return 1;
-      if (!this.#frustum.IsSphereVisible(position, radius)) return 0;
-      const size = this.#frustum.GetPixelSizeAccross(position, radius);
-      if (!(size > this.#adjustedCutoff)) return 0;
+    _CullAndDim(position, radius) {
+      if (!this._frustum) return 1;
+      if (!this._frustum.IsSphereVisible(position, radius)) return 0;
+      const size = this._frustum.GetPixelSizeAccross(position, radius);
+      if (!(size > this._adjustedCutoff)) return 0;
       // Contract §"Colour carries the radius": the fade band sits ABOVE the
       // cutoff - absent at the cutoff, full brightness FADE_SIZE above it.
-      return Math.min((size - this.#adjustedCutoff) / FADE_SIZE, 1);
+      return Math.min((size - this._adjustedCutoff) / FADE_SIZE, 1);
     }
 
     /**
      * Returns the light's projected pixel size, or its radius when no frustum is
      * set.
      */
-    #ScreenSize(record) {
-      if (!this.#frustum) return record.radius;
-      return this.#frustum.GetPixelSizeAccross(record.position, record.radius);
+    _ScreenSize(record) {
+      if (!this._frustum) return record.radius;
+      return this._frustum.GetPixelSizeAccross(record.position, record.radius);
     }
 
     /**
@@ -611,7 +896,7 @@ new class extends _identity {
      * The first-sight map remains only for foreign profile objects that
      * expose no GetTextureIndex.
      */
-    #ProfileSlot(profile) {
+    _ProfileSlot(profile) {
       if (!profile) return 0;
       if (typeof profile.GetTextureIndex === "function") {
         let index = profile.GetTextureIndex();
@@ -628,10 +913,10 @@ new class extends _identity {
         }
         return index >= 0 ? index + 1 : 0;
       }
-      let slot = this.#profileSlots.get(profile);
+      let slot = this._profileSlots.get(profile);
       if (slot === undefined) {
-        slot = this.#profileSlots.size;
-        this.#profileSlots.set(profile, slot);
+        slot = this._profileSlots.size;
+        this._profileSlots.set(profile, slot);
       }
       return slot + 1;
     }
@@ -650,44 +935,44 @@ new class extends _identity {
      * @returns {Tr2TextureArray} The shared profile array.
      */
     static getLightProfileArray() {
-      if (!_Tr2LightManager.#lightProfileArray) {
-        _Tr2LightManager.#lightProfileArray = new _Tr2TextureArray();
+      if (!_Tr2LightManager._lightProfileArray) {
+        _Tr2LightManager._lightProfileArray = new _Tr2TextureArray();
       }
-      return _Tr2LightManager.#lightProfileArray;
+      return _Tr2LightManager._lightProfileArray;
     }
-    /** Packs #records into the 48-byte-per-light buffer per the contract layout. */
-    #Pack() {
-      const count = Math.min(this.#records.length, LIGHT_BUFFER_SIZE);
+    /** Packs _records into the 48-byte-per-light buffer per the contract layout. */
+    _Pack() {
+      const count = Math.min(this._records.length, LIGHT_BUFFER_SIZE);
       for (let i = 0; i < count; i++) {
-        const record = this.#records[i];
+        const record = this._records[i];
         const f = i * FLOATS_PER_LIGHT;
 
         // Texel 0: position + radius, four f32.
-        this.#packed[f] = record.position[0];
-        this.#packed[f + 1] = record.position[1];
-        this.#packed[f + 2] = record.position[2];
-        this.#packed[f + 3] = record.radius;
+        this._packed[f] = record.position[0];
+        this._packed[f + 1] = record.position[1];
+        this._packed[f + 2] = record.position[2];
+        this._packed[f + 3] = record.radius;
 
         // Texel 1: colour (premultiplied at Add time) + the packed word -
         // innerRadius f16 low, flags u16 high with the biased profile slot in
         // bits 4-15 (contract §"The packed flag word").
-        this.#packed[f + 4] = record.color[0];
-        this.#packed[f + 5] = record.color[1];
-        this.#packed[f + 6] = record.color[2];
-        const flagsWord = record.flags & 0xF | this.#ProfileSlot(record.lightProfile) << 4;
-        this.#packedBits[f + 7] = toHalf(record.innerRadius) | (flagsWord & 0xFFFF) << 16;
+        this._packed[f + 4] = record.color[0];
+        this._packed[f + 5] = record.color[1];
+        this._packed[f + 6] = record.color[2];
+        const flagsWord = record.flags & 0xF | this._ProfileSlot(record.lightProfile) << 4;
+        this._packedBits[f + 7] = toHalf(record.innerRadius) | (flagsWord & 0xFFFF) << 16;
 
         // Texel 2: direction as three f16, projectionPlaneDistance, the two
         // angles, then the shadow union (h:70-84, MSVC low-bit-first layout:
         // bits 0-1 padding, 2-11 scale, 12-21 offsetX, 22-31 offsetY; the
         // raytraced mask shares the word - the paths are exclusive by
         // quality). All zeros under the shipping pin, exactly as before.
-        this.#packedBits[f + 8] = toHalf(record.direction[0]) | toHalf(record.direction[1]) << 16;
-        this.#packedBits[f + 9] = toHalf(record.direction[2]) | toHalf(record.projectionPlaneDistance) << 16;
-        this.#packedBits[f + 10] = toHalf(record.outerAngle) | toHalf(record.innerAngle) << 16;
-        this.#packedBits[f + 11] = this.#currentSpaceSceneShadowQuality === ShadowQuality.SHADOW_RAYTRACED ? (record.raytracingShadowMask ?? 0) & 0xFFFF : ((record.shadowMapScale ?? 0) & 0x3FF) << 2 | ((record.shadowMapOffsetX ?? 0) & 0x3FF) << 12 | ((record.shadowMapOffsetY ?? 0) & 0x3FF) << 22;
+        this._packedBits[f + 8] = toHalf(record.direction[0]) | toHalf(record.direction[1]) << 16;
+        this._packedBits[f + 9] = toHalf(record.direction[2]) | toHalf(record.projectionPlaneDistance) << 16;
+        this._packedBits[f + 10] = toHalf(record.outerAngle) | toHalf(record.innerAngle) << 16;
+        this._packedBits[f + 11] = this._currentSpaceSceneShadowQuality === ShadowQuality.SHADOW_RAYTRACED ? (record.raytracingShadowMask ?? 0) & 0xFFFF : ((record.shadowMapScale ?? 0) & 0x3FF) << 2 | ((record.shadowMapOffsetX ?? 0) & 0x3FF) << 12 | ((record.shadowMapOffsetY ?? 0) & 0x3FF) << 22;
       }
-      this.#packedCount = count;
+      this._packedCount = count;
     }
   }];
   Flags = Object.freeze({
@@ -701,7 +986,8 @@ new class extends _identity {
   LIGHT_INDEX_BUFFER_NAME = "LightIndexBuffer";
   useDynamicLightsShadows = false;
   calculateShadowMapAtlasSettings = calculateShadowMapAtlasSettings;
-  #lightProfileArray = null;
+  _instance = null;
+  _lightProfileArray = null;
   constructor() {
     super(_Tr2LightManager), _initClass();
   }