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

package/dist/trinity/eve/scene/EveSpaceSceneRenderDriver.js

@@ -6,7 +6,7 @@ import { mat4 } from '#math/mat4';
 import { Tr2GpuUsage, PixelFormat, TextureType, Tr2LoadAction, Tr2StoreAction } from '#consts/render-context';
 import { Tr2SubresourceData, Tr2ColorAttachment, Tr2DepthAttachment } from '#trinityal';
 import { AntiAliasingQuality, AmbientOcclusionQuality, EveVisualizeMethod } from '../../generated/eve/enums.js';
-import { ShadowQuality, Tr2VolumerticQuality } from '../../generated/trinityCore/enums.js';
+import { ShadowQuality, SSAOQuality, TR2SHADERMODEL, Tr2VolumerticQuality } from '../../generated/trinityCore/enums.js';
 import { Quality } from '../../generated/postProcess/enums.js';
 import { RenderingMode, TriBatchType } from '#consts/graphics';
 import '../../core/batch/CjsBatchManager.js';
@@ -14,6 +14,9 @@ import { TriFrustum } from '../../core/view/TriFrustum.js';
 import { GpuResourceHandle } from '../../core/Tr2GpuResourcePool/GpuResourceHandle.js';
 import { Tr2GpuResourcePool } from '../../core/Tr2GpuResourcePool/Tr2GpuResourcePool.js';
 import { Tr2Renderer as _Tr2Renderer } from '../../core/Tr2Renderer.js';
+import { Tr2ShadowMap as _Tr2ShadowMap } from '../../core/Tr2ShadowMap.js';
+import { Tr2LightManager as _Tr2LightManager } from '../../core/lighting/Tr2LightManager.js';
+import { COMPUTE_LIGHT_LISTS_EFFECT_PATH } from '#consts/effectPaths';
 import { Tr2TextureReference as _Tr2TextureReference } from '../../core/Tr2TextureReference.js';
 import { Tr2VariableStore as _Tr2VariableStore } from '../../core/variable/Tr2VariableStore.js';
 import { Tr2PostProcessRenderer as _Tr2PostProcessRender } from '../../postProcess/Tr2PostProcessRenderer.js';
@@ -155,9 +158,15 @@ new class extends _identity {
     /** The provider "DepthMap" is registered with; it holds this frame's scene depth. */
     #depthMapReference = new _Tr2TextureReference();
 
-    /** The provider "SSAOMap" is registered with: the empty SSAO, or nothing. */
+    /** The provider "SSAOMap" is registered with: the SSAO, the empty SSAO, or nothing. */
     #ssaoMapReference = new _Tr2TextureReference();
 
+    /** The provider "SpaceSceneNormalMap" is registered with: the depth pass's normals. */
+    #normalMapReference = new _Tr2TextureReference();
+
+    /** The provider "EveSpaceSceneOpaqueMap" is registered with: the opaque colour copy. */
+    _opaqueMapReference = new _Tr2TextureReference();
+
     /**
      * m_viewLast / m_projectionLast (EveSpaceSceneRenderDriver.h:147-149): the
      * previous frame's camera. The driver owns them, not the scene, because
@@ -168,12 +177,9 @@ new class extends _identity {
     _projectionLast = mat4.create();
 
     /**
-     * The batch types this driver submits, in submission order.
-     *
-     * Carbon's main pass draws OPAQUE then DECAL (EveSpaceScene.cpp:2725/2731),
-     * with transparent and additive following in the same pass (:2758). Only the
-     * first two are submitted here; the rest are a later insertion at the marked
-     * point in #Submit.
+     * The opaque family, in submission order: Carbon's RenderOpaqueBatches
+     * draws OPAQUE then DECAL (EveSpaceScene.cpp:1124-1150). The transparent
+     * family follows after the opaque copy; see _SubmitTransparent.
      */
 
     /** The standard states Carbon applies before each accumulator (EveSpaceScene.cpp:1139-1142). */
@@ -223,10 +229,10 @@ new class extends _identity {
      *
      * The spine of Carbon's Execute, in Carbon's order. NOT here, each an
      * insertion into this same sequence: the background node, the reflection
-     * pass, the depth prepass, shadows, SSAO, the light-list update, the
-     * distortion map, transparent and additive submission, the scene overlay,
-     * lensflare occlusion queries and 3D UI. The scene renders into its own
-     * colour and depth, plus TAA's velocity map and opaque copy when
+     * pass, shadows, the light-list update, the distortion map, the scene
+     * overlay and 3D UI. The scene renders into
+     * its own colour and depth, plus the depth pass's normal map when ambient
+     * occlusion is on and TAA's velocity map and opaque copy when
      * anti-aliasing is on, and the post process draws it into the destination.
      *
      * Rendering-disabled is not a no-op in Carbon either: the scene still
@@ -238,6 +244,11 @@ new class extends _identity {
       if (!renderContext || !this.Validate()) return false;
       const target = Array.isArray(destinations) ? destinations[0] ?? null : destinations;
 
+      // Step 1 of EveSpaceScene's driver order: the update context carries the
+      // frame's render context, whose view the scene's view-dependent updates
+      // read (billboards, the flare occluders' transforms).
+      this.scene.updateContext.renderContext = renderContext;
+
       // RENDERING DISABLED (cpp:408-419): camera onto the renderer and the scene
       // update, so simulation keeps running - and nothing else. No target borrow,
       // no clear, no camera update.
@@ -306,8 +317,8 @@ new class extends _identity {
           _Tr2VariableStore.GlobalStore().RegisterVariable("DepthMap", this.#depthMapReference);
         }
 
-        // cpp:550 - the shadow pass's textures as globals. No shadow pass is
-        // ported, so every resource is empty and the white fallbacks go in.
+        // The shadow globals start empty, with the white fallbacks: the shadow
+        // pass fills them for the main pass only (cpp:550, 557).
         _EveSpaceScene.registerWithVariableStore(_EveSpaceSceneRenderD.#noShadowResources, this.#gpuResourcePool);
         const submitted = this.#RenderMainPass(renderContext, offscreen);
 
@@ -344,6 +355,18 @@ new class extends _identity {
         // (cpp:625-626); the pool reclaims the depth texture after this.
         this.#RegisterSSAOMap(_EveSpaceSceneRenderD.getEmptySSAO(this.#gpuResourcePool));
         this.#depthMapReference.SetTexture(null);
+
+        // The normal map is an Execute local in Carbon (cpp:514), never handed
+        // to the post process.
+        if (offscreen?.normal) {
+          this.#gpuResourcePool.Free(offscreen.normal);
+          offscreen.normal = null;
+        }
+
+        // So are the shadow resources (cpp:526).
+        for (const handle of Object.values(offscreen?.shadows ?? {})) {
+          if (handle.IsValid()) this.#gpuResourcePool.Free(handle);
+        }
         if (offscreen && !handedOff) this.#EndOffscreen(offscreen);
       }
     }
@@ -433,6 +456,14 @@ new class extends _identity {
       renderContext.SetProjection(this.scene.jitteredProjection);
       this.scene.BlendLightingOverrides();
       this.scene.UpdateFogSettings();
+
+      // The light manager exists only while dynamic lighting is on
+      // (EveSpaceScene.cpp:1378-1388), and publishes its buffers before the gather.
+      if (this.scene.dynamicLightingEnabled) {
+        _Tr2LightManager.getOrCreateInstance(COMPUTE_LIGHT_LISTS_EFFECT_PATH).SetVariableStore();
+      } else {
+        _Tr2LightManager.deleteInstance();
+      }
       this.scene.UpdateVisibility?.(renderContext.GetInverseViewTransform?.() ?? null);
       const map = this.#Collect(this.scene.GetRenderables?.([]) ?? [], renderContext);
 
@@ -440,6 +471,10 @@ new class extends _identity {
       // reflection - go through the variable store (UpdateVariableStore,
       // EveSpaceScene.cpp:1390-1397).
       this.scene.UpdateVariableStore();
+
+      // The dynamic lights, after the gather (EveSpaceScene.cpp:1398-1416).
+      const lightManager = _Tr2LightManager.getInstance();
+      if (lightManager) this.scene.GatherLights(lightManager);
       if (offscreen) offscreen.velocity = this._GetVelocityMapIfNeeded(offscreen.size);
 
       // "The lensflares need a special pre-render update" (cpp:1419-1422): after
@@ -464,10 +499,38 @@ new class extends _identity {
       // block for compute as well, which dynamic exposure reads Time from.
       this.scene.ApplyPerFrameData(renderContext);
 
+      // THE DEPTH PASS (cpp:514-521): depth and, when AO or a forced map wants
+      // it, the normal map, before shadows and SSAO read them. The depth
+      // buffer stays bound; the scene colour is back in slot 0 afterwards.
+      if (offscreen && map) {
+        offscreen.normal = this._GetNormalMapIfNeeded(offscreen.size);
+        this.scene.RenderDepthPass(offscreen.depth.Get(), offscreen.normal?.Get() ?? null, null, renderContext, this.depthPassTechnique, map);
+      }
+      this.#normalMapReference.SetTexture(offscreen?.normal?.Get() ?? null);
+      _Tr2VariableStore.GlobalStore().RegisterVariable("SpaceSceneNormalMap", this.#normalMapReference);
+
       // Carbon gates the main pass on the scene's display flag AND this switch
       // (cpp:527).
       if (!this.mainPassRenderingEnabled || this.scene.display === false) return false;
+
+      // SHADOWS (cpp:529-532), after the depth pass: the cascaded shadow map and
+      // its screen-space factor, held until the frame ends.
+      if (offscreen) offscreen.shadows = this.scene.RenderShadows(offscreen.depth.Get(), offscreen.normal?.Get() ?? null, this.#gpuResourcePool, renderContext, this.#renderer);
+
+      // SSAO (cpp:534-537), after the shadows and before the main pass samples
+      // SSAOMap.
+      if (offscreen) this.#RegisterSSAOMap(this._RenderSSAO(offscreen.depth.Get(), offscreen.normal?.Get() ?? null, renderContext));
+
+      // The light lists, against this frame's depth read-only (cpp:539-546).
+      if (offscreen && lightManager) {
+        renderContext.SetReadOnlyDepth(true);
+        lightManager.UpdateLists(offscreen.depth.Get(), renderContext);
+        renderContext.SetReadOnlyDepth(false);
+      }
       if (offscreen) offscreen.opaque = this._GetOpaqueColorMapIfNeeded(offscreen.size);
+
+      // cpp:550 - the shadow pass's textures as globals, for the main pass.
+      if (offscreen?.shadows) _EveSpaceScene.registerWithVariableStore(offscreen.shadows, this.#gpuResourcePool);
       const velocity = offscreen?.velocity?.Get() ?? null;
       const opaque = offscreen?.opaque?.Get() ?? null;
       const esm = renderContext.GetEffectStateManager();
@@ -495,9 +558,8 @@ new class extends _identity {
       }
 
       // THE OPAQUE COLOUR COPY (EveSpaceScene.cpp:2738-2750): the scene colour
-      // after the opaque family, which TAA reads as CurrentFrameOpaque. Carbon
-      // also publishes it as EveSpaceSceneOpaqueMap in the global variable store
-      // for transparent shaders; nothing here submits those yet, so it is not.
+      // after the opaque family, which TAA reads as CurrentFrameOpaque and
+      // transparent shaders read as the global EveSpaceSceneOpaqueMap.
       if (opaque) {
         renderContext.RenderPassHint(new Tr2ColorAttachment(Tr2LoadAction.DONT_CARE, Tr2StoreAction.STORE), null);
         esm.PushDepthStencilBuffer(null);
@@ -509,29 +571,112 @@ new class extends _identity {
           esm.PopRenderTarget();
           esm.PopDepthStencilBuffer();
         }
+        this._opaqueMapReference.SetTexture(opaque);
+        _Tr2VariableStore.GlobalStore().RegisterVariable("EveSpaceSceneOpaqueMap", this._opaqueMapReference);
       }
+
+      // THE TRANSPARENT FAMILY (EveSpaceScene.cpp:2758). Carbon runs subsurface
+      // scattering, the jittered-projection refresh and the volumetrics between
+      // the opaque copy and this (cpp:2752-2757); none of those are ported.
+      submitted = this._SubmitTransparent(map, renderContext) || submitted;
+
+      // cpp:557 - the shadow globals are emptied after the main pass.
+      if (offscreen?.shadows) _EveSpaceScene.registerWithVariableStore(_EveSpaceSceneRenderD.#noShadowResources, this.#gpuResourcePool);
       return submitted;
     }
 
     /**
-     * Carbon's private PropagateSettings (cpp:212-231), the anti-aliasing part: the
-     * setting creates, updates or removes the TAA effect on the scene's default
-     * post process, whose quality is the setting's value.
+     * Carbon's private PropagateSettings (cpp:212-280), the anti-aliasing and
+     * ambient-occlusion parts. Anti-aliasing creates, updates or removes the TAA
+     * effect on the scene's default post process, whose quality is the
+     * setting's value. Ambient occlusion enables the SSAO, when there is one,
+     * at the quality the setting maps to.
      *
-     * Adapted: Carbon's shadow, AO, volumetric and upscaling propagation follows
-     * in the same method; none of those passes run in this driver yet.
+     * Adapted: Carbon's shadow propagation sits between the two, and its
+     * post-process quality, volumetric and upscaling propagation follow; none
+     * of those passes run in this driver yet.
      *
      * @returns {void}
      */
     _PropagateSettings() {
       const postprocess = this.scene.postprocess;
-      if (!postprocess) return;
-      if (this.antiAliasingQuality === AntiAliasingQuality.Disabled) {
-        postprocess.SetTaa(null);
-        return;
+      if (postprocess) {
+        if (this.antiAliasingQuality === AntiAliasingQuality.Disabled) {
+          postprocess.SetTaa(null);
+        } else {
+          if (!postprocess.GetTaaIfAvailable()) postprocess.SetTaa(new _Tr2PPTaaEffect());
+          postprocess.GetTaaIfAvailable().quality = this.antiAliasingQuality;
+        }
+      }
+
+      // Shadow quality (cpp:233-255): the cascaded shadow map exists at LOW and
+      // HIGH. Carbon's raytracing manager is not ported, so RAYTRACED has none.
+      if (this.shadowQuality === ShadowQuality.SHADOW_DISABLED || this.shadowQuality === ShadowQuality.SHADOW_RAYTRACED) {
+        this.scene.cascadedShadowMap = null;
+      } else if (!this.scene.cascadedShadowMap) {
+        this.scene.cascadedShadowMap = new _Tr2ShadowMap();
+      }
+      this.scene.shadowQualitySetting = this.shadowQuality;
+      if (this.SSAO) {
+        if (this.aoQuality === AmbientOcclusionQuality.Disabled) {
+          this.SSAO.Enable(false);
+        } else {
+          this.SSAO.Enable(true);
+          switch (this.aoQuality) {
+            case AmbientOcclusionQuality.Low:
+              this.SSAO.SetQuality(SSAOQuality.LOW, true);
+              break;
+            case AmbientOcclusionQuality.Medium:
+              this.SSAO.SetQuality(SSAOQuality.MEDIUM, false);
+              break;
+            default:
+              this.SSAO.SetQuality(SSAOQuality.HIGHEST, false);
+              break;
+          }
+        }
       }
-      if (!postprocess.GetTaaIfAvailable()) postprocess.SetTaa(new _Tr2PPTaaEffect());
-      postprocess.GetTaaIfAvailable().quality = this.antiAliasingQuality;
+    }
+
+    /**
+     * Carbon's private RenderSSAO (cpp:360-382): the SSAO filtered from the
+     * depth and normal maps with depth bound read-only, or the empty SSAO when
+     * there is none.
+     *
+     * Adapted: Carbon's `temporal` is also true under a temporal upscaler,
+     * which is not ported, so only the post process's TAA sets it.
+     *
+     * @param {object} depthMap The scene depth.
+     * @param {object|null} normalMap The depth pass's normal map.
+     * @param {object} renderContext The frame's context.
+     * @returns {GpuResourceHandle} The SSAO texture.
+     */
+    _RenderSSAO(depthMap, normalMap, renderContext) {
+      let ssao = new GpuResourceHandle();
+      if (this.scene.display && this.SSAO) {
+        renderContext.SetReadOnlyDepth(true);
+        const scenePostProcess = this.scene.postprocess;
+        const temporal = scenePostProcess !== null && scenePostProcess.GetTaaIfAvailable() !== null;
+        ssao = this.SSAO.Filter(depthMap, normalMap, this.#gpuResourcePool, renderContext, temporal);
+        renderContext.SetReadOnlyDepth(false);
+      }
+      return ssao.IsValid() ? ssao : _EveSpaceSceneRenderD.getEmptySSAO(this.#gpuResourcePool);
+    }
+
+    /**
+     * Carbon's GetNormalMapIfNeeded (cpp:672-685): an R10G10B10A2_UNORM map
+     * when ambient occlusion or ray-traced shadows want normals, on any shader
+     * model but the lowest, or when forced.
+     *
+     * Adapted: Carbon also allocates it for a named render-job output; none
+     * exists here.
+     *
+     * @param {{width: number, height: number}} size The render size.
+     * @returns {GpuResourceHandle|null} The map, or null.
+     */
+    _GetNormalMapIfNeeded(size) {
+      const wanted = (this.aoQuality !== AmbientOcclusionQuality.Disabled || this.shadowQuality === ShadowQuality.SHADOW_RAYTRACED) && _Tr2Renderer.GetShaderModel() !== TR2SHADERMODEL.TR2SM_3_0_LO;
+      if (!wanted && !this.forceNormalMap) return null;
+      return this.#TempTexture("normalMap", size, PixelFormat.PIXEL_FORMAT_R10G10B10A2_UNORM);
     }
 
     /**
@@ -615,7 +760,11 @@ new class extends _identity {
         depth: texture("depthBuffer", PixelFormat.PIXEL_FORMAT_D32_FLOAT, Tr2GpuUsage.DEPTH_STENCIL | Tr2GpuUsage.SHADER_RESOURCE),
         // Borrowed by the main pass when TAA needs them (#RenderMainPass).
         velocity: null,
-        opaque: null
+        opaque: null,
+        // Borrowed for the depth pass when AO needs it; the driver's to free.
+        normal: null,
+        // The shadow pass's ShadowResources; the driver's to free.
+        shadows: null
       };
     }
 
@@ -675,13 +824,43 @@ new class extends _identity {
         renderContext.GetEffectStateManager().ApplyStandardStates(_EveSpaceSceneRenderD.#standardStatesFor[batchType]);
         submitted = renderContext.RenderBatches(accumulator) || submitted;
       }
+      return submitted;
+    }
 
-      // Transparent, additive and distortion submission belongs here, after the
-      // opaque family and before the overlay, exactly as Carbon orders them.
-
+    /**
+     * Carbon's RenderTransparentBatches (EveSpaceScene.cpp:1156-1178): the
+     * transparent accumulator under RM_ALPHA, then the additive one under
+     * RM_ALPHA_ADDITIVE. Transparent batches were sorted back to front at
+     * collection. Carbon's whole colour pass runs with read-only depth
+     * (cpp:2710, 2771); ours makes the transparent family read-only, so these
+     * test against the scene depth without writing it.
+     *
+     * Distortion (cpp:2759-2762) follows in Carbon and is not ported.
+     *
+     * @param {object|null} map The batch map `#Collect` produced.
+     * @param {object} renderContext Recording render context.
+     * @returns {boolean} Whether anything was submitted.
+     */
+    _SubmitTransparent(map, renderContext) {
+      if (!map) return false;
+      const esm = renderContext.GetEffectStateManager();
+      let submitted = false;
+      renderContext.SetReadOnlyDepth(true);
+      try {
+        for (const [batchType, renderingMode] of _EveSpaceSceneRenderD._transparentFamily) {
+          const accumulator = map.GetAccumulator(batchType);
+          if (!accumulator) continue;
+          esm.ApplyStandardStates(renderingMode);
+          submitted = renderContext.RenderBatches(accumulator) || submitted;
+        }
+      } finally {
+        renderContext.SetReadOnlyDepth(false);
+      }
       return submitted;
     }
 
+    /** The transparent family and the standard states each is drawn under (cpp:1170-1173). */
+
     /**
      * Puts this frame's projection and view onto the render context, and derives
      * the frustum the scene culls against.
@@ -728,6 +907,7 @@ new class extends _identity {
     pointLightShadowMap: new GpuResourceHandle(),
     pointLightShadowDepth: new GpuResourceHandle()
   };
+  _transparentFamily = Object.freeze([[TriBatchType.TRIBATCHTYPE_TRANSPARENT, RenderingMode.RM_ALPHA], [TriBatchType.TRIBATCHTYPE_ADDITIVE, RenderingMode.RM_ALPHA_ADDITIVE]]);
   AmbientOcclusionQuality = AmbientOcclusionQuality;
   AntiAliasingQuality = AntiAliasingQuality;
   EveVisualizeMethod = EveVisualizeMethod;