@carbonenginejs/runtime-resource 0.12.2 → 0.14.0

package/dist/formats/webgl/core/glsl/DxbcGlslEmitter.js

@@ -45,6 +45,8 @@ const NON_COMPARISON_TEXTURE_OPCODES = new Set(["sample", "sample_l", "sample_b"
  * Filtered-sample coordinate mask per resource dimension
  * (HLSLcc `TranslateTexCoord`, toGLSLInstruction.cpp:985-1031).
  */
+/** GLSL symbol for the merged detail-map array. */
+const DETAIL_MAP_ARRAY_SYMBOL = "sDetailArrayMap";
 const COORD_MASK_BY_DIMENSION = {
   2: "x",
   3: "xy",
@@ -100,8 +102,24 @@ class DxbcGlslEmitter {
       // LightProfileArray) when `--stub-light-resources` is set, so the
       // fragment sampler count drops under MAX_TEXTURE_IMAGE_UNITS.
       stubResourceRegisters: [],
+      // Resource (t#) registers whose declaration is dropped and whose
+      // samples lower to `vec4(1.0)` rather than `vec4(0.0)`.
+      //
+      // Separate from `stubResourceRegisters` because the two are not
+      // interchangeable: a stubbed sampler reads as zero, which is right
+      // for a term that is added and wrong for one that is multiplied.
+      // `LightProfileArray` is multiplied into a light's attenuation, so
+      // stubbing it would drive every profiled light to black, whereas
+      // 1.0 is exactly what the shader's own no-profile path yields.
+      neutralResourceRegisters: [],
       lightConstantBuffer: null,
       lightPackedTexture: null,
+      // Resource (t#) registers to merge into one `sampler2DArray`, in
+      // layer order. Empty by default; the packager fills it from the
+      // backend-neutral detail-map recogniser. Merging three 2D textures
+      // into one array binding frees two texture units on shaders that
+      // sit exactly on WebGL2's 16-unit limit.
+      detailMapArrayRegisters: [],
       ...options.profile
     };
   }
@@ -207,6 +225,15 @@ class DxbcGlslEmitter {
       // declarations/bindings are dropped and every read of them lowers
       // to `uintBitsToFloat(0u)` (structured) / `vec4(0.0)` (sampled).
       stubbedResources: new Set(this.profile.stubResourceRegisters || []),
+      // Resource (t#) registers dropped to a compile-time *one*: same
+      // declaration handling as `stubbedResources`, but reads lower to
+      // `vec4(1.0)` so a multiplied term degrades to neutral instead of
+      // to black. See `neutralResourceRegisters` on the profile.
+      neutralResources: new Set(this.profile.neutralResourceRegisters || []),
+      // Resource register -> array layer for the merged detail maps, and
+      // whether the one shared array declaration has been emitted yet.
+      detailMapArrayLayers: new Map((this.profile.detailMapArrayRegisters || []).map((register, layer) => [register, layer])),
+      detailMapArrayDeclared: false,
       inputMasks: new Map(),
       outputMasks: new Map(),
       bindings: [],
@@ -263,7 +290,7 @@ class DxbcGlslEmitter {
         constantBuffer: slot => state.constantBufferNames.get(slot) || `cb${slot}`,
         constantBufferMember: this.profile.constantBufferStyle === "std140" ? "data" : "",
         resource: index => state.resourceNames.get(index) || `t${index}`,
-        uav: index => state.uavNames.get(index) || `cewgUav${index}`,
+        uav: index => state.uavNames.get(index) || `cjsUav${index}`,
         immediateConstantBuffer: state.icbName
       }
     });
@@ -409,7 +436,7 @@ class DxbcGlslEmitter {
       dataRegister,
       profileRegister: Number.isInteger(Number(profile.profileRegister)) ? Number(profile.profileRegister) : null,
       registerIndex: Number.isInteger(Number(profile.registerIndex)) ? Number(profile.registerIndex) : indexRegister,
-      name: profile.name || "cewgLocalLightTexture",
+      name: profile.name || "cjsLocalLightTexture",
       dataTexelBase: Number.isInteger(Number(profile.dataTexelBase)) ? Number(profile.dataTexelBase) : 131072
     };
   }
@@ -433,7 +460,7 @@ class DxbcGlslEmitter {
       strideBytes: 0,
       format: "RGBA32UI",
       width: this.profile.dataTextureWidth,
-      cewgSemantic: "packedLocalLights",
+      cjsSemantic: "packedLocalLights",
       lightIndexRegister: profile.indexRegister,
       lightDataRegister: profile.dataRegister,
       lightProfileRegister: profile.profileRegister,
@@ -453,14 +480,14 @@ class DxbcGlslEmitter {
     state.lightConstantBufferDeclared = true;
     const rows = 1 + profile.capacity * 3;
     state.constantBufferNames.set(profile.registerIndex, profile.name);
-    state.declarationLines.push(`uniform vec4 ${profile.name}[${rows}];`, `uint cewgLocalLightCount() { return floatBitsToUint(${profile.name}[0].x); }`, "uint cewgLocalLightIndexLoad(int element) {", "    uint count = cewgLocalLightCount();", "    if (count == 0u) return 0u;", `    const int listBase = ${profile.listBase};`, "    if (element < listBase) return uint(listBase);", "    int local = element - listBase;", "    int node = local >> 1;", "    if (node < 0 || uint(node) >= count) return 0u;", "    if ((local & 1) == 0) return uint(node + 1);", "    uint next = uint(node + 1);", "    return next < count ? uint(listBase + int(next) * 2) : 0u;", "}", "vec4 cewgLocalLightRow(int lightIndex, int row) {", "    int i = lightIndex - 1;", "    if (i < 0 || uint(i) >= cewgLocalLightCount() || row < 0 || row >= 3) return vec4(0.0);", `    return ${profile.name}[1 + i * 3 + row];`, "}");
+    state.declarationLines.push(`uniform vec4 ${profile.name}[${rows}];`, `uint cjsLocalLightCount() { return floatBitsToUint(${profile.name}[0].x); }`, "uint cjsLocalLightIndexLoad(int element) {", "    uint count = cjsLocalLightCount();", "    if (count == 0u) return 0u;", `    const int listBase = ${profile.listBase};`, "    if (element < listBase) return uint(listBase);", "    int local = element - listBase;", "    int node = local >> 1;", "    if (node < 0 || uint(node) >= count) return 0u;", "    if ((local & 1) == 0) return uint(node + 1);", "    uint next = uint(node + 1);", "    return next < count ? uint(listBase + int(next) * 2) : 0u;", "}", "vec4 cjsLocalLightRow(int lightIndex, int row) {", "    int i = lightIndex - 1;", "    if (i < 0 || uint(i) >= cjsLocalLightCount() || row < 0 || row >= 3) return vec4(0.0);", `    return ${profile.name}[1 + i * 3 + row];`, "}");
     state.bindings.push({
       kind: "constantBuffer",
       registerIndex: profile.registerIndex,
       name: profile.name,
       sizeInVec4: rows,
       style: "array",
-      cewgSemantic: "localLights",
+      cjsSemantic: "localLights",
       capacityLights: profile.capacity,
       lightIndexRegister: profile.indexRegister,
       lightDataRegister: profile.dataRegister,
@@ -723,6 +750,18 @@ class DxbcGlslEmitter {
             // this register lowers to vec4(0.0) in _textureSample.
             break;
           }
+          if (state.neutralResources.has(register)) {
+            // Same as the stub above, but its samples lower to
+            // vec4(1.0). Dropping the declaration is what frees the
+            // sampler unit; the substitution is what keeps the result
+            // correct for a multiplied term.
+            //
+            // Nothing is recorded as a binding, because nothing is
+            // bound. The pass's resource-transform section carries the
+            // statement that this resource was dropped deliberately;
+            // see `localLightProfileNeutralTransformFor`.
+            break;
+          }
           if (declaration.resourceDimension === 1) {
             // Buffer<> texel buffers (post-processing) become float data textures
             // read via width-wrapped texelFetch; no samplerBuffer in WebGL2.
@@ -748,6 +787,10 @@ class DxbcGlslEmitter {
               dimensionName: declaration.resourceDimensionName
             });
           }
+          if (state.detailMapArrayLayers.has(register)) {
+            this._declareDetailArrayMap(state, register, declaration, comparisonSamplers);
+            break;
+          }
           const name = this.profile.samplerName(register, state.stageName);
           state.resourceDimensions.set(register, declaration.resourceDimension);
           state.resourceNames.set(register, name);
@@ -840,7 +883,7 @@ class DxbcGlslEmitter {
           } else {
             // Vertex-stage structured buffers (BoneTransforms) become dedicated
             // std140 UBOs sized to the profile capacity (Carbon max 69 joints).
-            const name = `CewgSb${register}`;
+            const name = `CjsSb${register}`;
             const capacity = this.profile.vertexStructuredCapacity;
             const rows = capacity * Math.ceil(strideDwords / 4);
             state.structuredBuffers.set(register, {
@@ -882,7 +925,7 @@ class DxbcGlslEmitter {
             // framebufferTextureLayer.
             const sliceNames = new Map();
             for (const slice of plan.slices) {
-              const name = `cewgUav${register}_s${slice}`;
+              const name = `cjsUav${register}_s${slice}`;
               const location = this._allocateUavOutputLocation(state, register);
               sliceNames.set(slice, name);
               state.declarationLines.push(`layout(location = ${location}) out highp vec4 ${name};`);
@@ -898,7 +941,7 @@ class DxbcGlslEmitter {
             state.uavSliceNames.set(register, sliceNames);
             break;
           }
-          const name = `cewgUav${register}`;
+          const name = `cjsUav${register}`;
           const location = this._allocateUavOutputLocation(state, register);
           state.uavNames.set(register, name);
           state.declarationLines.push(`layout(location = ${location}) out highp vec4 ${name};`);
@@ -1103,7 +1146,7 @@ class DxbcGlslEmitter {
 
   /**
   * Emits the shared `gl_FragCoord`-derived thread-id prelude for map-style
-  * compute shaders: a `cewgDispatchOrigin` uniform (so a dispatch can be
+  * compute shaders: a `cjsDispatchOrigin` uniform (so a dispatch can be
   * tiled across more than one draw/viewport), then only the intermediate
   * and final locals this shader actually declared inputs for.
   *
@@ -1114,29 +1157,29 @@ class DxbcGlslEmitter {
     if (!used.threadId && !used.groupId && !used.tig && !used.flattened) {
       return;
     }
-    state.dispatchOriginUniform = "cewgDispatchOrigin";
-    state.declarationLines.push("uniform ivec3 cewgDispatchOrigin;");
+    state.dispatchOriginUniform = "cjsDispatchOrigin";
+    state.declarationLines.push("uniform ivec3 cjsDispatchOrigin;");
     state.bindings.push({
       kind: "dispatchUniform",
-      name: "cewgDispatchOrigin"
+      name: "cjsDispatchOrigin"
     });
-    state.earlyMainLines.push("ivec3 cewgThreadId = ivec3(ivec2(gl_FragCoord.xy), 0) + cewgDispatchOrigin;");
+    state.earlyMainLines.push("ivec3 cjsThreadId = ivec3(ivec2(gl_FragCoord.xy), 0) + cjsDispatchOrigin;");
     if (used.threadId) {
-      state.earlyMainLines.push("vec4 vThreadID = intBitsToFloat(ivec4(cewgThreadId, 0));");
+      state.earlyMainLines.push("vec4 vThreadID = intBitsToFloat(ivec4(cjsThreadId, 0));");
     }
     if (used.groupId || used.tig || used.flattened) {
       const [nx, ny, nz] = this._threadGroupSizeOrThrow(state);
-      state.earlyMainLines.push(`ivec3 cewgGroupId = cewgThreadId / ivec3(${nx}, ${ny}, ${nz});`);
+      state.earlyMainLines.push(`ivec3 cjsGroupId = cjsThreadId / ivec3(${nx}, ${ny}, ${nz});`);
       if (used.groupId) {
-        state.earlyMainLines.push("vec4 vThreadGroupID = intBitsToFloat(ivec4(cewgGroupId, 0));");
+        state.earlyMainLines.push("vec4 vThreadGroupID = intBitsToFloat(ivec4(cjsGroupId, 0));");
       }
       if (used.tig || used.flattened) {
-        state.earlyMainLines.push(`ivec3 cewgTig = cewgThreadId - cewgGroupId * ivec3(${nx}, ${ny}, ${nz});`);
+        state.earlyMainLines.push(`ivec3 cjsTig = cjsThreadId - cjsGroupId * ivec3(${nx}, ${ny}, ${nz});`);
         if (used.tig) {
-          state.earlyMainLines.push("vec4 vThreadIDInGroup = intBitsToFloat(ivec4(cewgTig, 0));");
+          state.earlyMainLines.push("vec4 vThreadIDInGroup = intBitsToFloat(ivec4(cjsTig, 0));");
         }
         if (used.flattened) {
-          state.earlyMainLines.push(`vec4 vThreadIDInGroupFlattened = intBitsToFloat(ivec4(cewgTig.z*${nx}*${ny} + cewgTig.y*${nx} + cewgTig.x, 0, 0, 0));`);
+          state.earlyMainLines.push(`vec4 vThreadIDInGroupFlattened = intBitsToFloat(ivec4(cjsTig.z*${nx}*${ny} + cjsTig.y*${nx} + cjsTig.x, 0, 0, 0));`);
         }
       }
     }
@@ -1689,6 +1732,82 @@ class DxbcGlslEmitter {
     }
   }
 
+  /**
+   * Declares the merged detail-map array, once, on the first member seen.
+   *
+   * Each member keeps its own entry in `resourceNames` pointing at the shared
+   * array, so every existing reference site resolves to it without knowing a
+   * merge happened. The declared dimension deliberately stays 2D: the layer is
+   * appended to the coordinate at each sample site rather than read out of the
+   * shader's own operand, which has no third component to give.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {number} register Resource register being declared.
+   * @param {object} declaration Decoded resource declaration.
+   * @param {Set<number>|null} comparisonSamplers Comparison samplers, when any.
+   * @private
+   */
+  _declareDetailArrayMap(state, register, declaration, comparisonSamplers) {
+    // A comparison-sampled or non-2D detail map is not the family the
+    // recogniser promised, so refuse rather than emit a wrong declaration.
+    if (comparisonSamplers || declaration.resourceDimension !== 3) {
+      throw new WebglReadError("Detail-map array merging requires plain 2D textures without comparison sampling", {
+        source: state.sourceName,
+        register,
+        dimensionName: declaration.resourceDimensionName
+      });
+    }
+    state.resourceDimensions.set(register, declaration.resourceDimension);
+    state.resourceNames.set(register, DETAIL_MAP_ARRAY_SYMBOL);
+    if (state.detailMapArrayDeclared) return;
+    state.detailMapArrayDeclared = true;
+    state.declarationLines.push(`uniform mediump sampler2DArray ${DETAIL_MAP_ARRAY_SYMBOL};`);
+    state.bindings.push({
+      kind: "resource",
+      registerIndex: register,
+      name: DETAIL_MAP_ARRAY_SYMBOL,
+      samplerType: "sampler2DArray",
+      dimensionName: "texture2darray",
+      arrayLayerCount: state.detailMapArrayLayers.size,
+      mergedFrom: [...state.detailMapArrayLayers.keys()]
+    });
+  }
+
+  /**
+   * Returns the array layer a texture operand maps to, when it was merged.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} texOperand Texture resource operand.
+   * @returns {number|null} Layer index, or null when the register was not merged.
+   * @private
+   */
+  _detailMapArrayLayer(state, texOperand) {
+    const layer = state.detailMapArrayLayers.get(texOperand.registerIndex);
+    return layer === undefined ? null : layer;
+  }
+
+  /**
+   * Refuses an operation that cannot be redirected at an array layer.
+   *
+   * Recognising the detail family proves the resources are mergeable; it does
+   * not prove every *use* is. A texel fetch or a size query against a merged
+   * register would silently mean something different once the register became
+   * one layer of an array, so those fail the build instead.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {object} texOperand Texture resource operand.
+   * @private
+   */
+  _rejectDetailArrayMapUse(state, instruction, texOperand) {
+    if (!state.detailMapArrayLayers.has(texOperand.registerIndex)) return;
+    throw new WebglReadError(`Detail map merged into an array is used by ${instruction.opcodeName}, ` + "which this emitter cannot redirect at an array layer", {
+      source: state.sourceName,
+      register: texOperand.registerIndex,
+      opcodeName: instruction.opcodeName
+    });
+  }
+
   /**
    * Resolves and validates the declared dimension of a texture operand.
    *
@@ -1763,9 +1882,24 @@ class DxbcGlslEmitter {
       });
       return;
     }
+    if (state.neutralResources.has(texOperand.registerIndex)) {
+      // Neutralised sampler (LightProfileArray): its declaration was
+      // dropped, and the value it fed is a multiplier, so lower to one.
+      // The shader's own no-profile path leaves attenuation untouched,
+      // which is what multiplying by 1.0 reproduces exactly.
+      const oneSwizzle = [...mask].map(component => texOperand.swizzle ? texOperand.swizzle["xyzw".indexOf(component)] : component).join("");
+      this._assign(state, instruction, `vec4(1.0).${oneSwizzle}`, {
+        saturate: instruction.saturate
+      });
+      return;
+    }
     const dimension = this._resourceDimension(state, instruction, texOperand);
     const coordMask = COORD_MASK_BY_DIMENSION[dimension];
-    const coord = this._vecArg(state, coordOperand, coordMask);
+    const detailLayer = this._detailMapArrayLayer(state, texOperand);
+    const baseCoord = this._vecArg(state, coordOperand, coordMask);
+    // A merged detail map keeps its 2D coordinate and gains the layer as a
+    // literal third component; the register it came from is the layer.
+    const coord = detailLayer === null ? baseCoord : `vec3(${baseCoord}, ${detailLayer}.0)`;
     const texName = state.formatter.registerReference(texOperand);
     const returnSwizzle = [...mask].map(component => texOperand.swizzle ? texOperand.swizzle["xyzw".indexOf(component)] : component).join("");
     if (comparisonRefOperandIndex !== null) {
@@ -1832,6 +1966,7 @@ class DxbcGlslEmitter {
     } = this._destMask(state, instruction);
     const coordOperand = instruction.operands[1];
     const texOperand = instruction.operands[2];
+    this._rejectDetailArrayMapUse(state, instruction, texOperand);
     const dimension = this._resourceDimension(state, instruction, texOperand);
     const texName = state.formatter.registerReference(texOperand);
     const returnSwizzle = [...mask].map(component => texOperand.swizzle ? texOperand.swizzle["xyzw".indexOf(component)] : component).join("");
@@ -2491,7 +2626,7 @@ DxbcGlslEmitter.prototype._ldStructured = function _ldStructured(state, instruct
       const texel = `(${info.dataTexelBase} + ((${dword}) >> 2))`;
       value = `uintBitsToFloat(texelFetch(${info.name}, ivec2((${texel}) & ${widthMask}, (${texel}) >> ${widthShift}), 0)[(${dword}) & 3])`;
     } else if (info.kind === "lightIndexCb") {
-      value = `uintBitsToFloat(cewgLocalLightIndexLoad(${element}))`;
+      value = `uintBitsToFloat(cjsLocalLightIndexLoad(${element}))`;
     } else if (info.kind === "lightDataCb") {
       if (!aligned) {
         throw new WebglReadError("local-light constant-buffer lowering requires aligned light rows", {
@@ -2499,7 +2634,7 @@ DxbcGlslEmitter.prototype._ldStructured = function _ldStructured(state, instruct
           offset: instruction.offset
         });
       }
-      value = `cewgLocalLightRow(${element}, ${offsetDwords / 4}).${channel}`;
+      value = `cjsLocalLightRow(${element}, ${offsetDwords / 4}).${channel}`;
     } else if (info.kind === "ubo") {
       if (aligned) {
         const row = `(${element}) * ${info.strideDwords / 4}${offsetDwords ? ` + ${offsetDwords / 4}` : ""}`;
@@ -2535,6 +2670,7 @@ DxbcGlslEmitter.prototype._resinfo = function _resinfo(state, instruction) {
     as: "int"
   });
   const texOperand = instruction.operands[2];
+  this._rejectDetailArrayMapUse(state, instruction, texOperand);
   const dimension = this._resourceDimension(state, instruction, texOperand);
   const axisCount = dimension === 5 || dimension === 8 ? 3 : 2;
   const returnType = instruction.resinfoReturnTypeName || "float";
@@ -2604,8 +2740,14 @@ DxbcGlslEmitter.prototype._gather4 = function _gather4(state, instruction) {
       offset: instruction.offset
     });
   }
-  const helper = this.helpers.require(dimension === 8 ? "hlslcc_textureGather4ArrayEmulated" : "hlslcc_textureGather4Emulated");
-  const coord = this._vecArg(state, coordOperand, dimension === 8 ? "xyz" : "xy");
+  // A merged detail map is declared 2D but sampled through an array, so the
+  // array helper and the layered coordinate are selected by the merge rather
+  // than by the declared dimension.
+  const detailLayer = this._detailMapArrayLayer(state, texOperand);
+  const asArray = dimension === 8 || detailLayer !== null;
+  const helper = this.helpers.require(asArray ? "hlslcc_textureGather4ArrayEmulated" : "hlslcc_textureGather4Emulated");
+  const baseCoord = this._vecArg(state, coordOperand, dimension === 8 ? "xyz" : "xy");
+  const coord = detailLayer === null ? baseCoord : `vec3(${baseCoord}, ${detailLayer}.0)`;
   const texName = state.formatter.registerReference(texOperand);
   const channelLetter = this._gather4Channel(samplerOperand);
   const channelIndex = "xyzw".indexOf(channelLetter);