@carbonenginejs/runtime-resource 0.16.0 → 0.17.0

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

@@ -5,20 +5,25 @@ import { DxbcGlslHelperRegistry } from './DxbcGlslHelpers.js';
 
 const COMPONENTS = ["x", "y", "z", "w"];
 
-/**
- * Map-style compute lowering caps simultaneous UAV writes to this many
- * fragment color outputs. WebGL2 only guarantees `MAX_DRAW_BUFFERS >= 4`
- * (real implementations commonly expose up to 8); a compute kernel that
- * writes more UAVs than fit in one draw call's attachment set (e.g. a
- * hierarchical mip-chain "Pack" pass writing 16 mip levels per dispatch)
- * cannot become a single map-style fragment pass at all.
+/**
+ * Map-style compute lowering caps simultaneous UAV writes to this many
+ * fragment color outputs. WebGL2 only guarantees `MAX_DRAW_BUFFERS >= 4`
+ * (real implementations commonly expose up to 8); a compute kernel that
+ * writes more UAVs than fit in one draw call's attachment set (e.g. a
+ * hierarchical mip-chain "Pack" pass writing 16 mip levels per dispatch)
+ * cannot become a single map-style fragment pass at all.
  */
 const MAX_MAP_STYLE_UAV_OUTPUTS = 8;
 
-/**
- * GLSL sampler type per DXBC resource-dimension id (float return types; the
- * stripped-RDEF corpus reflects everything as float).
+/**
+ * GLSL sampler type per DXBC resource-dimension id (float return types; the
+ * stripped-RDEF corpus reflects everything as float).
  */
+/**
+ * DXBC resource dimension for a cube map. Emulated addressing refuses it: a
+ * cube coordinate is a direction, so a [0,1] range test is meaningless there.
+ */
+const CUBE_DIMENSION = 6;
 const SAMPLER_TYPE_BY_DIMENSION = {
   2: "sampler2D",
   3: "sampler2D",
@@ -27,11 +32,11 @@ const SAMPLER_TYPE_BY_DIMENSION = {
   8: "sampler2DArray"
 };
 
-/**
- * Shadow-sampler type per WebGL2-supported DXBC resource dimension.
- * Comparison sampling changes both the call signature and the uniform type;
- * keeping this separate from the ordinary sampler table guarantees shaders
- * without comparison opcodes retain their existing declarations verbatim.
+/**
+ * Shadow-sampler type per WebGL2-supported DXBC resource dimension.
+ * Comparison sampling changes both the call signature and the uniform type;
+ * keeping this separate from the ordinary sampler table guarantees shaders
+ * without comparison opcodes retain their existing declarations verbatim.
  */
 const SHADOW_SAMPLER_TYPE_BY_DIMENSION = {
   3: "sampler2DShadow",
@@ -41,9 +46,9 @@ const SHADOW_SAMPLER_TYPE_BY_DIMENSION = {
 const COMPARISON_SAMPLE_OPCODES = new Set(["sample_c", "sample_c_lz"]);
 const NON_COMPARISON_TEXTURE_OPCODES = new Set(["sample", "sample_l", "sample_b", "sample_d", "gather4", "gather4_po", "ld", "ld_ms", "lod"]);
 
-/**
- * Filtered-sample coordinate mask per resource dimension
- * (HLSLcc `TranslateTexCoord`, toGLSLInstruction.cpp:985-1031).
+/**
+ * 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";
@@ -57,32 +62,32 @@ const COORD_MASK_BY_DIMENSION = {
   10: "xyzw"
 };
 
-/**
- * DXBC -> GLSL ES 3.00 emitter for vertex and pixel stages.
- *
- * Implements the lowering rules in `docs/dxbc-lowering/*.md`, which pin every
- * template to HLSLcc's `toGLSLInstruction.cpp`/`toGLSLDeclaration.cpp`.
- * Registers are stored as float vec4s with bitcasts at use sites, comparison
- * results are 0xFFFFFFFF/0 masks (never bools), and register-stable symbols
- * (`cb#.data[]`, `t#`, `in_SEMANTIC#`, `vs_SEMANTIC#`) form the ABI surface.
- *
- * Emitter-wide policy: Adreno-3xx driver hygiene from HLSLcc (per-component
- * bitwise splits, `op_not`, `uint(0)` literals, `uvecN()` ctor wraps) is NOT
- * ported; the target is ANGLE-backed WebGL2 and the plain spec-legal forms
- * are emitted instead.
+/**
+ * DXBC -> GLSL ES 3.00 emitter for vertex and pixel stages.
+ *
+ * Implements the lowering rules in `docs/dxbc-lowering/*.md`, which pin every
+ * template to HLSLcc's `toGLSLInstruction.cpp`/`toGLSLDeclaration.cpp`.
+ * Registers are stored as float vec4s with bitcasts at use sites, comparison
+ * results are 0xFFFFFFFF/0 masks (never bools), and register-stable symbols
+ * (`cb#.data[]`, `t#`, `in_SEMANTIC#`, `vs_SEMANTIC#`) form the ABI surface.
+ *
+ * Emitter-wide policy: Adreno-3xx driver hygiene from HLSLcc (per-component
+ * bitwise splits, `op_not`, `uint(0)` literals, `uvecN()` ctor wraps) is NOT
+ * ported; the target is ANGLE-backed WebGL2 and the plain spec-legal forms
+ * are emitted instead.
  */
 class DxbcGlslEmitter {
-  /**
-  * @param {object} [options] Emitter options.
-  * @param {object} [options.profile] Target-runtime profile overrides.
-  * @param {"array"|"std140"} [options.profile.constantBufferStyle] `uniform vec4 cbN[]`
-  *   arrays for ccpwgl's uniform4fv path, or std140 blocks.
-  * @param {Object.<number,number>} [options.profile.pixelConstantBufferRemap] Pixel-stage
-  *   cb slot renames (ccpwgl keeps PS effect constants at cb7).
-  * @param {function(number,string):string} [options.profile.samplerName] Texture uniform
-  *   naming per register and stage.
-  * @param {number} [options.profile.vertexStructuredCapacity] Element capacity for
-  *   vertex-stage structured-buffer UBOs (bones; Carbon max is 69 joints).
+  /**
+  * @param {object} [options] Emitter options.
+  * @param {object} [options.profile] Target-runtime profile overrides.
+  * @param {"array"|"std140"} [options.profile.constantBufferStyle] `uniform vec4 cbN[]`
+  *   arrays for ccpwgl's uniform4fv path, or std140 blocks.
+  * @param {Object.<number,number>} [options.profile.pixelConstantBufferRemap] Pixel-stage
+  *   cb slot renames (ccpwgl keeps PS effect constants at cb7).
+  * @param {function(number,string):string} [options.profile.samplerName] Texture uniform
+  *   naming per register and stage.
+  * @param {number} [options.profile.vertexStructuredCapacity] Element capacity for
+  *   vertex-stage structured-buffer UBOs (bones; Carbon max is 69 joints).
   */
   constructor(options = {}) {
     this.helpers = new DxbcGlslHelperRegistry();
@@ -124,13 +129,54 @@ class DxbcGlslEmitter {
     };
   }
 
-  /**
-  * Registers the GLSL helper functions this emitter's lowerings can require.
-  * GLSL ES 3.00 has no `bitfieldExtract`/`bitfieldInsert`/`bitCount`/
-  * `textureGather` (all ES 3.10+), so `ibfe`/`ubfe`/`bfi`/`countbits`/
-  * `gather4` lower to these hand-written equivalents instead.
+  /**
+  * Registers the GLSL helper functions this emitter's lowerings can require.
+  * GLSL ES 3.00 has no `bitfieldExtract`/`bitfieldInsert`/`bitCount`/
+  * `textureGather` (all ES 3.10+), so `ibfe`/`ubfe`/`bfi`/`countbits`/
+  * `gather4` lower to these hand-written equivalents instead.
   */
   _defineHelpers() {
+    // Texture address modes WebGL2 cannot express, emulated in the shader.
+    //
+    // WebGL2 does REPEAT, MIRRORED_REPEAT and CLAMP_TO_EDGE natively. It has
+    // no CLAMP_TO_BORDER (that needs EXT_texture_border_clamp, absent on our
+    // desktop contexts) and no MIRROR_ONCE. Only those two are done here.
+    //
+    // The mode is a RUNTIME value, per axis, read from the address buffer.
+    // It cannot be baked: ccpwgl resolves sampler overrides after
+    // translation and caches one translated GLSL per resource path across
+    // every instance, so a compile-time mode is wrong for any object whose
+    // override differs from the container - in both directions.
+    //
+    // Modes are the Trinity enum as stored: 1 wrap, 2 mirror, 3 clamp-edge,
+    // 4 border, 5 mirror-once. **0 means "nothing to emulate"**, which is
+    // what every failure produces - a zeroed buffer, an absent upload, a
+    // texture the consumer did not know about. Carbon's enum starts at 1 and
+    // no shipped sampler carries 0, so 0 cannot swallow a real mode.
+    //
+    // Two arities rather than one vec3 form: a 2D sample has no third
+    // coordinate, and its sampler may still declare a W mode - eight shipped
+    // samplers declare border on W - which must not be tested against a
+    // component that does not exist.
+    this.helpers.define("cjsAddressCoord", {
+      source: ["vec2 cjsAddressCoord(vec2 uv, vec2 modes) {", "    if (int(modes.x) == 5) uv.x = clamp(abs(uv.x), 0.0, 1.0);", "    if (int(modes.y) == 5) uv.y = clamp(abs(uv.y), 0.0, 1.0);", "    return uv;", "}", "", "vec3 cjsAddressCoord(vec3 uv, vec3 modes) {", "    if (int(modes.x) == 5) uv.x = clamp(abs(uv.x), 0.0, 1.0);", "    if (int(modes.y) == 5) uv.y = clamp(abs(uv.y), 0.0, 1.0);", "    if (int(modes.z) == 5) uv.z = clamp(abs(uv.z), 0.0, 1.0);", "    return uv;", "}"].join("\n")
+    });
+
+    // Applied to the already sampled value, so it composes with every sample
+    // form the emitter produces - texture, textureLod, textureGrad and the
+    // bias variant - instead of needing an overload for each.
+    //
+    // The border colour is baked, not read from the buffer: Carbon's
+    // AddSamplerOverride takes only U and V, so no override can change it.
+    // It is NOT always transparent black - specialfx/cloud, cloudsimple and
+    // volumetrichalfsphereglow use opaque white.
+    //
+    // Testing the post-transform coordinate is safe: an axis is either
+    // mirror-once or border, never both, and mirror-once leaves other axes
+    // untouched.
+    this.helpers.define("cjsAddressBorder", {
+      source: ["vec4 cjsAddressBorder(vec4 sampled, vec2 uv, vec2 modes, vec4 borderColor) {", "    if (int(modes.x) == 4 && (uv.x < 0.0 || uv.x > 1.0)) return borderColor;", "    if (int(modes.y) == 4 && (uv.y < 0.0 || uv.y > 1.0)) return borderColor;", "    return sampled;", "}", "", "vec4 cjsAddressBorder(vec4 sampled, vec3 uv, vec3 modes, vec4 borderColor) {", "    if (int(modes.x) == 4 && (uv.x < 0.0 || uv.x > 1.0)) return borderColor;", "    if (int(modes.y) == 4 && (uv.y < 0.0 || uv.y > 1.0)) return borderColor;", "    if (int(modes.z) == 4 && (uv.z < 0.0 || uv.z > 1.0)) return borderColor;", "    return sampled;", "}"].join("\n")
+    });
     // D3D11 IBFE pseudocode: width = src0 & 0x1f, offset = src1 & 0x1f;
     // width == 0 -> 0; width + offset < 32 -> a left/right arithmetic-shift
     // pair that sign-extends from bit (width-1); else an arithmetic shift by
@@ -173,16 +219,16 @@ class DxbcGlslEmitter {
     });
   }
 
-  /**
-  * Translates one DXBC stage into GLSL ES 3.00 source.
-  *
-  * @param {ArrayBuffer|ArrayBufferView|Uint8Array} bytes DXBC container bytes.
-  * @param {object} [options] Emit options.
-  * @param {string} [options.source] Source name used in error details.
-  * @returns {{source:string,stageName:string,inputs:object[],outputs:object[],bindings:object[],warnings:string[],computeFragment:(object|undefined)}}
-  *   GLSL text plus the IO contract the packaging layer records; compute
-  *   stages add a `computeFragment` host contract (thread group,
-  *   dispatch-origin uniform, per-output UAV slice routing).
+  /**
+  * Translates one DXBC stage into GLSL ES 3.00 source.
+  *
+  * @param {ArrayBuffer|ArrayBufferView|Uint8Array} bytes DXBC container bytes.
+  * @param {object} [options] Emit options.
+  * @param {string} [options.source] Source name used in error details.
+  * @returns {{source:string,stageName:string,inputs:object[],outputs:object[],bindings:object[],warnings:string[],computeFragment:(object|undefined)}}
+  *   GLSL text plus the IO contract the packaging layer records; compute
+  *   stages add a `computeFragment` host contract (thread group,
+  *   dispatch-origin uniform, per-output UAV slice routing).
   */
   Emit(bytes, options = {}) {
     const sourceName = options.source || "memory";
@@ -214,12 +260,20 @@ class DxbcGlslEmitter {
       outputNames: new Map(),
       resourceDimensions: new Map(),
       resourceNames: new Map(),
-      comparisonResources: this._analyzeComparisonResources(raw.decoder, sourceName),
+      ...(() => {
+        const analysed = this._analyzeComparisonResources(raw.decoder, sourceName);
+        return {
+          comparisonResources: analysed.comparison,
+          pairedSamplers: analysed.paired
+        };
+      })(),
       constantBufferNames: new Map(),
       structuredBuffers: new Map(),
       lightConstantBuffer: this._normalizeLightConstantBufferProfile(),
       lightConstantBufferDeclared: false,
       lightPackedTexture: this._normalizeLightPackedTextureProfile(),
+      emulatedAddressing: this._normalizeEmulatedAddressingProfile(),
+      addressBufferDeclared: false,
       lightPackedTextureDeclared: false,
       // Resource (t#) registers stubbed to a compile-time zero: their
       // declarations/bindings are dropped and every read of them lowers
@@ -361,10 +415,10 @@ class DxbcGlslEmitter {
     return result;
   }
 
-  /**
-  * Normalizes the optional local-light constant-buffer lowering profile.
-  *
-  * @returns {object|null} Normalized profile, or null when disabled.
+  /**
+  * Normalizes the optional local-light constant-buffer lowering profile.
+  *
+  * @returns {object|null} Normalized profile, or null when disabled.
   */
   _normalizeLightConstantBufferProfile() {
     const profile = this.profile.lightConstantBuffer;
@@ -383,30 +437,52 @@ class DxbcGlslEmitter {
     };
   }
 
-  /**
-  * Finds resources used by comparison-sample instructions before resource
-  * declarations are emitted, so those declarations can use shadow sampler
-  * types. A single GLSL uniform cannot be both a shadow and ordinary sampler;
-  * reject that shape explicitly instead of producing invalid GLSL.
-  *
-  * @param {object} decoder Decoded DXBC instruction stream.
-  * @param {string} sourceName Source name used in error details.
-  * @returns {Map<number,Set<number>>} Resource register -> sampler registers.
+  /**
+  * Finds resources used by comparison-sample instructions before resource
+  * declarations are emitted, so those declarations can use shadow sampler
+  * types. A single GLSL uniform cannot be both a shadow and ordinary sampler;
+  * reject that shape explicitly instead of producing invalid GLSL.
+  *
+  * The same walk records the t#/s# pairing for EVERY sampled resource, not
+  * only the comparison ones. D3D carries sampler state on a shared sampler
+  * object and pairs it with a texture at the sample site; GLSL merges the two
+  * into one uniform, so that pairing is the only place the pairing exists once
+  * the shader is translated. Dropping it forces a consumer to guess, and the
+  * available guess - "the sampler whose register equals the texture's" - is
+  * numeric coincidence: with two pattern samplers declared, `NormalMap` at t3
+  * collides with the clamp sampler at s3 and every hull's normal map is read
+  * clamped instead of wrapped.
+  *
+  * @param {object} decoder Decoded DXBC instruction stream.
+  * @param {string} sourceName Source name used in error details.
+  * @returns {{comparison:Map<number,Set<number>>,paired:Map<number,Set<number>>}}
+  *   Resource register -> sampler registers, for comparison sampling and for
+  *   all sampling respectively.
   */
   _analyzeComparisonResources(decoder, sourceName) {
     const comparisonResources = new Map();
+    const pairedSamplers = new Map();
     const ordinaryResources = new Set();
+    const recordPair = (map, register, samplerRegister) => {
+      const samplers = map.get(register) || new Set();
+      if (Number.isInteger(samplerRegister)) samplers.add(samplerRegister);
+      map.set(register, samplers);
+    };
     for (const instruction of decoder.instructions) {
       const resourceOperand = instruction.operands?.[2];
       if (!resourceOperand || !Number.isInteger(resourceOperand.registerIndex)) continue;
+      const register = resourceOperand.registerIndex;
+      const samplerRegister = instruction.operands?.[3]?.registerIndex;
       if (COMPARISON_SAMPLE_OPCODES.has(instruction.opcodeName)) {
-        const register = resourceOperand.registerIndex;
-        const samplerRegister = instruction.operands?.[3]?.registerIndex;
-        const samplers = comparisonResources.get(register) || new Set();
-        if (Number.isInteger(samplerRegister)) samplers.add(samplerRegister);
-        comparisonResources.set(register, samplers);
+        recordPair(comparisonResources, register, samplerRegister);
+        recordPair(pairedSamplers, register, samplerRegister);
       } else if (NON_COMPARISON_TEXTURE_OPCODES.has(instruction.opcodeName)) {
-        ordinaryResources.add(resourceOperand.registerIndex);
+        ordinaryResources.add(register);
+        // `ld`-family fetches carry no sampler operand and legitimately
+        // pair with nothing; only record a pair when one is present.
+        if (Number.isInteger(samplerRegister)) {
+          recordPair(pairedSamplers, register, samplerRegister);
+        }
       }
     }
     for (const register of comparisonResources.keys()) {
@@ -417,13 +493,258 @@ class DxbcGlslEmitter {
         });
       }
     }
-    return comparisonResources;
+    return {
+      comparison: comparisonResources,
+      paired: pairedSamplers
+    };
+  }
+
+  /**
+  * Normalizes the emulated-addressing profile.
+  *
+  * Keyed by RESOURCE register, not sampler register, because that is what
+  * every layer we touch keys on: GL stores wrap state on the texture object,
+  * ccpwgl keys overrides by texture name, and the emitted GLSL declares one
+  * sampler uniform per resource. Only D3D treats the mode as a property of a
+  * shared sampler - in `decalv5` five textures share one bordered sampler and
+  * each can resolve to a different mode, which a sampler-keyed scheme cannot
+  * represent.
+  *
+  * It arrives as a profile option because it CANNOT be discovered here: DXBC
+  * carries no sampler state, which lives in the Carbon container wrapping it.
+  * The caller also chooses the SUPERSET - listing a texture whose container
+  * mode needs no emulation is deliberate and cheap, because the runtime mode
+  * decides, and it is what lets an override correct a container that is wrong.
+  *
+  * Shape: `{ bufferRegister, textures: [{ registerIndex, borderColor }] }`.
+  *
+  * @returns {{bufferRegister:number, textures:Map<number,{color:number[]}>}|null}
+  *   Null when disabled.
+  */
+  _normalizeEmulatedAddressingProfile() {
+    const value = this.profile.emulatedAddressing;
+
+    // Either input alone is a complete profile: `samplerModes` is the
+    // ordinary case (container modes, mapped onto resources here), and
+    // `textures` is for a caller gating something the container gives it no
+    // reason to gate. Requiring both would reject the ordinary case.
+    if (!value || typeof value !== "object") return null;
+    if (!Array.isArray(value.textures) && !value.samplerModes) return null;
+    const bufferRegister = Number(value.bufferRegister ?? 8);
+    if (!Number.isInteger(bufferRegister) || bufferRegister < 0 || bufferRegister > 254) {
+      throw new WebglReadError("Emulated-addressing buffer register must be an integer in 0..254", {
+        bufferRegister: value.bufferRegister
+      });
+    }
+    const colorOf = raw => {
+      if (raw === undefined || raw === null) return [0, 0, 0, 0];
+      if (!Array.isArray(raw) || raw.length !== 4) {
+        throw new WebglReadError("Border colour must be four components", {
+          color: raw
+        });
+      }
+      const parsed = raw.map(Number);
+
+      // A malformed colour must not become a plausible one: transparent
+      // black is the common case, so silently defaulting to it would hide
+      // the mistake in exactly the effects that differ from it.
+      if (parsed.some(c => !Number.isFinite(c))) {
+        throw new WebglReadError("Border colour components must be finite numbers", {
+          color: raw
+        });
+      }
+      return parsed;
+    };
+
+    // Container sampler modes, keyed by SAMPLER register. Supplied so the
+    // emitter can derive which resources need a gate: only it knows, from
+    // the DXBC, which resource is read through which sampler. The caller
+    // knows the modes but not that mapping; the emitter knows the mapping
+    // but not the modes, because DXBC carries no sampler state.
+    const samplerModes = new Map();
+    for (const [key, modes] of Object.entries(value.samplerModes ?? {})) {
+      const registerIndex = Number(key);
+      if (!Number.isInteger(registerIndex) || registerIndex < 0) continue;
+      const axes = [modes?.u, modes?.v, modes?.w].map(Number);
+
+      // Only the two modes WebGL2 cannot express need a gate. Everything
+      // else is left to GL, so listing it would cost a branch for nothing.
+      if (axes.some(m => m === 4 || m === 5)) {
+        samplerModes.set(registerIndex, true);
+      }
+    }
+    const textures = new Map();
+    for (const entry of value.textures ?? []) {
+      const registerIndex = Number.isInteger(entry) ? entry : Number(entry?.registerIndex);
+      if (!Number.isInteger(registerIndex) || registerIndex < 0) {
+        throw new WebglReadError("Emulated-addressing entries need an integer resource registerIndex", {
+          entry
+        });
+      }
+      textures.set(registerIndex, {
+        color: colorOf(Number.isInteger(entry) ? null : entry?.borderColor)
+      });
+    }
+    if (!textures.size && !samplerModes.size) return null;
+    return {
+      bufferRegister,
+      textures,
+      samplerModes,
+      defaultColor: colorOf(value.borderColor)
+    };
+  }
+
+  /**
+  * Applies emulated address modes to one sample.
+  *
+  * Emits nothing for a texture the caller did not list, so a shader with no
+  * emulated addressing is byte-identical to one emitted without the profile.
+  *
+  * @param {object} state Emit state.
+  * @param {object} instruction Decoded texture instruction.
+  * @param {string} call The GLSL sample expression built so far.
+  * @param {string} coord The coordinate expression passed to that sample.
+  * @param {string} coordMask Component mask of the coordinate.
+  * @returns {string} The sample expression, addressed when the caller listed it.
+  * @private
+  */
+  _applyEmulatedAddressing(state, instruction, call, coord, coordMask) {
+    const profile = state.emulatedAddressing;
+    if (!profile) return call;
+    const resourceRegister = instruction.operands?.[2]?.registerIndex;
+    if (!Number.isInteger(resourceRegister)) return call;
+
+    // An explicit entry wins; otherwise derive from the sampler this
+    // resource is read through. Deriving is the ordinary case - the caller
+    // supplies container modes and the emitter maps them onto resources -
+    // and the explicit list is for a caller that wants a texture gated the
+    // container gives it no reason to gate. That is not redundant: a
+    // sampler override can introduce an emulated mode the container never
+    // declared, and overrides exist precisely to correct a wrong container.
+    let entry = profile.textures.get(resourceRegister);
+    if (!entry) {
+      const samplerRegister = instruction.operands?.[3]?.registerIndex;
+      if (!Number.isInteger(samplerRegister)) return call;
+      if (!profile.samplerModes.has(samplerRegister)) return call;
+      entry = {
+        color: profile.defaultColor
+      };
+    }
+
+    // A cube coordinate is a DIRECTION, not a texture coordinate, so a
+    // [0,1] test has no meaning on it. Refuse rather than emit a test that
+    // is silently nonsense - the caller must not list cube-target
+    // resources. decalholev5's interior cube and cubetextureviewer are the
+    // shipped cases that reach here.
+    const dimension = state.resourceDimensions.get(resourceRegister);
+    if (dimension === CUBE_DIMENSION) {
+      // Reported and skipped, not fatal. `decalholev5` reads its interior
+      // cube through a bordered sampler, so refusing would make a shipped
+      // effect unbuildable over a mode that cannot apply to it anyway -
+      // trading a missing border for no shader at all. Skipping silently
+      // is the other wrong answer, so it goes in warnings.
+      state.warnings.push(`emulated addressing skipped for cube resource t${resourceRegister}: ` + "a cube coordinate is a direction, so a [0,1] range test has no meaning");
+      return call;
+    }
+    if (coordMask.length !== 2 && coordMask.length !== 3) {
+      throw new WebglReadError("Emulated addressing supports two- and three-component sampling only", {
+        source: state.sourceName,
+        registerIndex: resourceRegister,
+        coordMask
+      });
+    }
+    const buffer = this._ensureAddressBuffer(state);
+    const swizzle = coordMask.length === 2 ? "xy" : "xyz";
+    const modes = `${buffer}[${resourceRegister}].${swizzle}`;
+    const glslFloat = n => Number.isInteger(n) ? `${n}.0` : String(n);
+    const color = entry.color.map(glslFloat).join(", ");
+
+    // Mirror-once rewrites the coordinate BEFORE the fetch; border tests
+    // after it. Both are emitted: an axis is only ever one of them, and the
+    // unused one reads mode 0 or a native mode and does nothing.
+    const coordHelper = this.helpers.require("cjsAddressCoord");
+    const borderHelper = this.helpers.require("cjsAddressBorder");
+    const addressedCoord = `${coordHelper}(${coord}, ${modes})`;
+    const rewritten = call.split(coord).join(addressedCoord);
+    return `${borderHelper}(${rewritten}, ${addressedCoord}, ${modes}, vec4(${color}))`;
+  }
+
+  /**
+  * Declares the emulated-addressing constant buffer, once per shader.
+  *
+  * Sized to the highest listed resource register so the array stays compact,
+  * the way Carbon emitters declare compact `cb` arrays. The register is
+  * caller-chosen and defaults to 8: shipped effects declare only cb0-4, 6 and
+  * 7, and ccpwgl already resolves `cb0`..`cb15` by name, so 8 needs no new
+  * binding table.
+  *
+  * @param {object} state Emit state.
+  * @returns {string} The buffer's GLSL name.
+  * @private
+  */
+  _ensureAddressBuffer(state) {
+    const {
+      bufferRegister,
+      textures
+    } = state.emulatedAddressing;
+    const name = `cb${bufferRegister}`;
+    if (state.addressBufferDeclared) return name;
+
+    // Two declarations of one cb name is a GLSL redefinition error that
+    // nothing downstream checks, so catch it here, where the register is
+    // still attributable to a caller's choice.
+    //
+    // Compared by NAME, not by register: `constantBufferNames` is keyed by
+    // DXBC slot while the emitted name uses the remapped register, and on a
+    // pixel stage slot 0 becomes `cb7`. Comparing register to slot would
+    // miss exactly that case and emit two `cb7` declarations.
+    if ([...state.constantBufferNames.values()].includes(name)) {
+      throw new WebglReadError("Emulated-addressing buffer register collides with a declared constant buffer", {
+        source: state.sourceName,
+        bufferRegister
+      });
+    }
+
+    // Sized from every resource the shader DECLARES, not from the addressed
+    // set: with a derived set the addressed registers are not all known yet,
+    // and the array is indexed by resource register, so it must be long
+    // enough for any of them. DXBC puts declarations before instructions, so
+    // resourceDimensions is complete by the first sample.
+    const highest = Math.max(-1, ...state.resourceDimensions.keys(), ...textures.keys());
+    const rows = highest + 1;
+    if (rows < 1) {
+      throw new WebglReadError("Emulated addressing found no declared resource to size its buffer", {
+        source: state.sourceName
+      });
+    }
+    state.constantBufferNames.set(bufferRegister, name);
+    state.addressBufferDeclared = true;
+    state.declarationLines.push(`uniform vec4 ${name}[${rows}];`);
+    // An ordinary constantBuffer binding, deliberately with no extra fields.
+    // `cjsSemantic` is reserved vocabulary for the local-light family and
+    // the block writer throws on any other value, and the wire drops fields
+    // it does not encode - so an invented one would vanish for every effect
+    // loaded from bytes, which is exactly how the packed-light branch came
+    // to be silently dead.
+    //
+    // The consumer identifies it by register instead: Carbon declares only
+    // cb0-4, 6 and 7 across all 537 shipped effects, so a constant buffer at
+    // 8 or above is ours. That is a convention, and it is written down in
+    // the addressing contract rather than left to be inferred.
+    state.bindings.push({
+      kind: "constantBuffer",
+      registerIndex: bufferRegister,
+      name,
+      sizeInVec4: rows,
+      style: "array"
+    });
+    return name;
   }
 
-  /**
-  * Normalizes the optional packed local-light texture lowering profile.
-  *
-  * @returns {object|null} Normalized profile, or null when disabled.
+  /**
+  * Normalizes the optional packed local-light texture lowering profile.
+  *
+  * @returns {object|null} Normalized profile, or null when disabled.
   */
   _normalizeLightPackedTextureProfile() {
     const profile = this.profile.lightPackedTexture;
@@ -441,12 +762,12 @@ class DxbcGlslEmitter {
     };
   }
 
-  /**
-  * Declares the packed local-light texture ABI used to replace the
-  * LightIndexBuffer/LightBuffer/LightProfileArray trio with one RGBA32UI
-  * data texture.
-  *
-  * @param {object} state Emit state.
+  /**
+  * Declares the packed local-light texture ABI used to replace the
+  * LightIndexBuffer/LightBuffer/LightProfileArray trio with one RGBA32UI
+  * data texture.
+  *
+  * @param {object} state Emit state.
   */
   _ensureLightPackedTexture(state) {
     const profile = state.lightPackedTexture;
@@ -468,11 +789,11 @@ class DxbcGlslEmitter {
     });
   }
 
-  /**
-  * Declares the local-light constant-buffer ABI used to replace the two
-  * tiled-light structured buffers without consuming sampler units.
-  *
-  * @param {object} state Emit state.
+  /**
+  * Declares the local-light constant-buffer ABI used to replace the two
+  * tiled-light structured buffers without consuming sampler units.
+  *
+  * @param {object} state Emit state.
   */
   _ensureLightConstantBuffer(state) {
     const profile = state.lightConstantBuffer;
@@ -495,15 +816,15 @@ class DxbcGlslEmitter {
     });
   }
 
-  /**
-  * Rejects compute shaders that need real compute-pipeline features (shared
-  * memory, barriers, atomics, raw/structured/typed UAV reads) instead of the
-  * "map-style" thread-per-fragment shape this emitter lowers. The message
-  * intentionally contains "not supported" so packaging's kill-list
-  * classifier regex (`/not supported|No GLSL lowering|unimplementable/i`)
-  * routes these to the exclusion list rather than the failure list.
-  *
-  * @param {object} state Emit state.
+  /**
+  * Rejects compute shaders that need real compute-pipeline features (shared
+  * memory, barriers, atomics, raw/structured/typed UAV reads) instead of the
+  * "map-style" thread-per-fragment shape this emitter lowers. The message
+  * intentionally contains "not supported" so packaging's kill-list
+  * classifier regex (`/not supported|No GLSL lowering|unimplementable/i`)
+  * routes these to the exclusion list rather than the failure list.
+  *
+  * @param {object} state Emit state.
   */
   _assertMapStyleCompute(state) {
     for (const instruction of state.decoder.instructions) {
@@ -519,26 +840,26 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-  * Pre-scans a map-style compute shader's `store_uav_typed` instructions and
-  * builds a per-UAV slice plan before any declaration is emitted.
-  *
-  * Straight-line constant propagation only: the address registers ASSAO-style
-  * Prepare passes build are `mov rX.<c>, l(k)` immediates, so the tracker
-  * records the last constant written to each temp component and treats every
-  * other write as dynamic. Each stored-to UAV register resolves to either
-  * `{ kind: "single" }` (at most one store; the array-slice coordinate, when
-  * present, is dropped — the host attaches the target layer via
-  * `framebufferTextureLayer`) or `{ kind: "multiSlice", slices, sliceByOffset }`
-  * (several stores at statically distinct texture2darray slices, each routed
-  * to its own fragment output — the host attaches those layers as sequential
-  * color attachments).
-  *
-  * Anything outside those two shapes cannot become one fragment pass, so the
-  * throw messages deliberately contain "not supported" for packaging's
-  * kill-list classifier (see `_assertMapStyleCompute`).
-  *
-  * @param {object} state Emit state.
+  /**
+  * Pre-scans a map-style compute shader's `store_uav_typed` instructions and
+  * builds a per-UAV slice plan before any declaration is emitted.
+  *
+  * Straight-line constant propagation only: the address registers ASSAO-style
+  * Prepare passes build are `mov rX.<c>, l(k)` immediates, so the tracker
+  * records the last constant written to each temp component and treats every
+  * other write as dynamic. Each stored-to UAV register resolves to either
+  * `{ kind: "single" }` (at most one store; the array-slice coordinate, when
+  * present, is dropped — the host attaches the target layer via
+  * `framebufferTextureLayer`) or `{ kind: "multiSlice", slices, sliceByOffset }`
+  * (several stores at statically distinct texture2darray slices, each routed
+  * to its own fragment output — the host attaches those layers as sequential
+  * color attachments).
+  *
+  * Anything outside those two shapes cannot become one fragment pass, so the
+  * throw messages deliberately contain "not supported" for packaging's
+  * kill-list classifier (see `_assertMapStyleCompute`).
+  *
+  * @param {object} state Emit state.
   */
   _analyzeUavStores(state) {
     for (const instruction of state.decoder.instructions) {
@@ -611,16 +932,16 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-  * Updates the per-temp-component constant tracker for one instruction:
-  * `mov rX.<mask>, l(...)` records each written component's immediate dword,
-  * and any other write to a temp component invalidates it. Destination
-  * operands are exactly the mask-selection temp operands (DXBC sources
-  * always read through swizzle/select1), so this also handles multi-
-  * destination opcodes like `sincos` and `udiv` conservatively.
-  *
-  * @param {object} instruction Decoded non-declaration instruction.
-  * @param {Map<string, number>} constantTemps Constant tracker keyed `<register>.<component>`.
+  /**
+  * Updates the per-temp-component constant tracker for one instruction:
+  * `mov rX.<mask>, l(...)` records each written component's immediate dword,
+  * and any other write to a temp component invalidates it. Destination
+  * operands are exactly the mask-selection temp operands (DXBC sources
+  * always read through swizzle/select1), so this also handles multi-
+  * destination opcodes like `sincos` and `udiv` conservatively.
+  *
+  * @param {object} instruction Decoded non-declaration instruction.
+  * @param {Map<string, number>} constantTemps Constant tracker keyed `<register>.<component>`.
   */
   _trackTempConstants(instruction, constantTemps) {
     const source = instruction.operands[1];
@@ -639,13 +960,13 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-  * Resolves the array-slice (z) component of a `store_uav_typed` address
-  * operand to a compile-time constant, or null when it is dynamic.
-  *
-  * @param {object} addressOperand Decoded address operand.
-  * @param {Map<string, number>} constantTemps Constant tracker keyed `<register>.<component>`.
-  * @returns {number|null} Constant slice index, or null.
+  /**
+  * Resolves the array-slice (z) component of a `store_uav_typed` address
+  * operand to a compile-time constant, or null when it is dynamic.
+  *
+  * @param {object} addressOperand Decoded address operand.
+  * @param {Map<string, number>} constantTemps Constant tracker keyed `<register>.<component>`.
+  * @returns {number|null} Constant slice index, or null.
   */
   _resolveSliceConstant(addressOperand, constantTemps) {
     if (addressOperand.type === 4) {
@@ -660,14 +981,14 @@ class DxbcGlslEmitter {
     return constantTemps.has(key) ? constantTemps.get(key) : null;
   }
 
-  /**
-  * Allocates the next map-style UAV fragment-output location, enforcing the
-  * `MAX_MAP_STYLE_UAV_OUTPUTS` attachment budget across single-output UAVs
-  * and per-slice multi-output UAVs alike.
-  *
-  * @param {object} state Emit state.
-  * @param {number} register UAV register index (error detail only).
-  * @returns {number} Allocated output location.
+  /**
+  * Allocates the next map-style UAV fragment-output location, enforcing the
+  * `MAX_MAP_STYLE_UAV_OUTPUTS` attachment budget across single-output UAVs
+  * and per-slice multi-output UAVs alike.
+  *
+  * @param {object} state Emit state.
+  * @param {number} register UAV register index (error detail only).
+  * @returns {number} Allocated output location.
   */
   _allocateUavOutputLocation(state, register) {
     const location = state.uavOutputCount;
@@ -686,12 +1007,12 @@ class DxbcGlslEmitter {
   // Declarations
   // ------------------------------------------------------------------
 
-  /**
-   * Emits one decoded DXBC declaration into the GLSL interface and manifest.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC declaration instruction.
-   * @private
+  /**
+   * Emits one decoded DXBC declaration into the GLSL interface and manifest.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC declaration instruction.
+   * @private
    */
   _emitDeclaration(state, instruction) {
     const declaration = instruction.declaration;
@@ -795,12 +1116,21 @@ class DxbcGlslEmitter {
           state.resourceDimensions.set(register, declaration.resourceDimension);
           state.resourceNames.set(register, name);
           state.declarationLines.push(`uniform mediump ${samplerType} ${name};`);
+          // The sampler this texture is actually paired with at its sample
+          // sites. A texture sampled through more than one sampler cannot
+          // be represented by one GLSL uniform's state, so record them all
+          // and let the packaging layer decide; a texture sampled through
+          // none (pure `ld`) simply has no sampler state to carry.
+          const paired = state.pairedSamplers.get(register);
           state.bindings.push({
             kind: "resource",
             registerIndex: register,
             name,
             samplerType,
             dimensionName: declaration.resourceDimensionName,
+            ...(paired?.size ? {
+              pairedSamplerRegisters: [...paired].sort((a, b) => a - b)
+            } : {}),
             ...(comparisonSamplers ? {
               comparison: true,
               samplerRegisterIndices: [...comparisonSamplers].sort((a, b) => a - b)
@@ -978,24 +1308,24 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-   * Finds the signature element assigned to a register.
-   *
-   * @param {object|null} signature Decoded DXBC signature.
-   * @param {number} registerIndex Register index.
-   * @returns {object|null} Matching signature element.
-   * @private
+  /**
+   * Finds the signature element assigned to a register.
+   *
+   * @param {object|null} signature Decoded DXBC signature.
+   * @param {number} registerIndex Register index.
+   * @returns {object|null} Matching signature element.
+   * @private
    */
   _signatureElement(signature, registerIndex) {
     return signature?.elements.find(element => element.registerIndex === registerIndex) || null;
   }
 
-  /**
-   * Declares one vertex input using its Carbon semantic identity.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded input declaration.
-   * @private
+  /**
+   * Declares one vertex input using its Carbon semantic identity.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded input declaration.
+   * @private
    */
   _declareVertexInput(state, instruction) {
     const register = instruction.declaration.registerIndex;
@@ -1037,12 +1367,12 @@ class DxbcGlslEmitter {
     });
   }
 
-  /**
-   * Declares one pixel-stage varying or system input.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded input declaration.
-   * @private
+  /**
+   * Declares one pixel-stage varying or system input.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded input declaration.
+   * @private
    */
   _declarePixelInput(state, instruction) {
     const register = instruction.declaration.registerIndex;
@@ -1082,12 +1412,12 @@ class DxbcGlslEmitter {
     });
   }
 
-  /**
-   * Maps a supported system-generated input to its GLSL expression.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded system-input declaration.
-   * @private
+  /**
+   * Maps a supported system-generated input to its GLSL expression.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded system-input declaration.
+   * @private
    */
   _declareSystemInput(state, instruction) {
     const declaration = instruction.declaration;
@@ -1110,16 +1440,16 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-  * Records which compute pseudo-input(s) a `dcl_input` declaration exposes.
-  * The actual GLSL (uniform + derived locals) is emitted once, after every
-  * declaration has been seen, by `_emitComputeInputPrelude` — `dcl_input`
-  * for a thread-id kind can appear before or after `dcl_thread_group` in the
-  * bytecode stream, and the flattened/group-id forms need the workgroup
-  * size regardless of declaration order.
-  *
-  * @param {object} state Emit state.
-  * @param {object} instruction `dcl_input` instruction with a thread-id-kind operand.
+  /**
+  * Records which compute pseudo-input(s) a `dcl_input` declaration exposes.
+  * The actual GLSL (uniform + derived locals) is emitted once, after every
+  * declaration has been seen, by `_emitComputeInputPrelude` — `dcl_input`
+  * for a thread-id kind can appear before or after `dcl_thread_group` in the
+  * bytecode stream, and the flattened/group-id forms need the workgroup
+  * size regardless of declaration order.
+  *
+  * @param {object} state Emit state.
+  * @param {object} instruction `dcl_input` instruction with a thread-id-kind operand.
   */
   _declareComputeInput(state, instruction) {
     const kind = instruction.declaration.operandTypeName;
@@ -1144,13 +1474,13 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-  * Emits the shared `gl_FragCoord`-derived thread-id prelude for map-style
-  * 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.
-  *
-  * @param {object} state Emit state.
+  /**
+  * Emits the shared `gl_FragCoord`-derived thread-id prelude for map-style
+  * 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.
+  *
+  * @param {object} state Emit state.
   */
   _emitComputeInputPrelude(state) {
     const used = state.computeInputsUsed;
@@ -1185,12 +1515,12 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-  * Reads the workgroup size recorded by `dcl_thread_group`, required to
-  * split the flat thread id back into group id / id-in-group components.
-  *
-  * @param {object} state Emit state.
-  * @returns {[number,number,number]} Workgroup size.
+  /**
+  * Reads the workgroup size recorded by `dcl_thread_group`, required to
+  * split the flat thread id back into group id / id-in-group components.
+  *
+  * @param {object} state Emit state.
+  * @returns {[number,number,number]} Workgroup size.
   */
   _threadGroupSizeOrThrow(state) {
     if (!Array.isArray(state.threadGroup)) {
@@ -1201,12 +1531,12 @@ class DxbcGlslEmitter {
     return state.threadGroup;
   }
 
-  /**
-   * Declares one stage output and records its backend identity.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded output declaration.
-   * @private
+  /**
+   * Declares one stage output and records its backend identity.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded output declaration.
+   * @private
    */
   _declareOutput(state, instruction) {
     const declaration = instruction.declaration;
@@ -1264,12 +1594,12 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-   * Materializes an immediate constant-buffer declaration.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded custom-data declaration.
-   * @private
+  /**
+   * Materializes an immediate constant-buffer declaration.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded custom-data declaration.
+   * @private
    */
   _declareImmediateConstantBuffer(state, instruction) {
     const rows = instruction.customData?.immediateConstantBuffer;
@@ -1280,11 +1610,11 @@ class DxbcGlslEmitter {
     state.declarationLines.push(`const vec4 ${state.icbName}[${rows.length}] = vec4[${rows.length}](`, ...literals.map((literal, index) => `    ${literal}${index < literals.length - 1 ? "," : ""}`), ");");
   }
 
-  /**
-   * Initializes paired vertex outputs that the source shader does not write.
-   *
-   * @param {object} state Mutable emission state.
-   * @private
+  /**
+   * Initializes paired vertex outputs that the source shader does not write.
+   *
+   * @param {object} state Mutable emission state.
+   * @private
    */
   _zeroFillUnwrittenOutputs(state) {
     const written = new Set();
@@ -1309,12 +1639,12 @@ class DxbcGlslEmitter {
   // Instructions
   // ------------------------------------------------------------------
 
-  /**
-   * Dispatches one decoded instruction to its GLSL lowering rule.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @private
+  /**
+   * Dispatches one decoded instruction to its GLSL lowering rule.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @private
    */
   _emitInstruction(state, instruction) {
     const lower = DxbcGlslEmitter.LOWERINGS[instruction.opcodeName];
@@ -1328,23 +1658,23 @@ class DxbcGlslEmitter {
     lower.call(this, state, instruction);
   }
 
-  /**
-   * Appends one correctly indented line to the emitted function body.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {string} text GLSL source line.
-   * @private
+  /**
+   * Appends one correctly indented line to the emitted function body.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {string} text GLSL source line.
+   * @private
    */
   _line(state, text) {
     state.bodyLines.push(`${"    ".repeat(state.indent)}${text}`);
   }
 
-  /**
-   * Counts the active components in a DXBC mask.
-   *
-   * @param {number} mask DXBC component bit mask.
-   * @returns {number} Active component count.
-   * @private
+  /**
+   * Counts the active components in a DXBC mask.
+   *
+   * @param {number} mask DXBC component bit mask.
+   * @returns {number} Active component count.
+   * @private
    */
   _maskWidth(mask) {
     let width = 0;
@@ -1354,51 +1684,51 @@ class DxbcGlslEmitter {
     return width || 4;
   }
 
-  /**
-   * Converts a DXBC component bit mask to GLSL swizzle characters.
-   *
-   * @param {number} mask DXBC component bit mask.
-   * @returns {string} GLSL component string.
-   * @private
+  /**
+   * Converts a DXBC component bit mask to GLSL swizzle characters.
+   *
+   * @param {number} mask DXBC component bit mask.
+   * @returns {string} GLSL component string.
+   * @private
    */
   _maskChars(mask) {
     return COMPONENTS.filter((_, bit) => mask & 1 << bit).join("") || "xyzw";
   }
 
-  /**
-  * Builds the lvalue text for one register-space destination component,
-  * remapped into the target variable's declared component space.
+  /**
+  * Builds the lvalue text for one register-space destination component,
+  * remapped into the target variable's declared component space.
   */
   _destComponentRef(state, destOperand, target, component) {
     const remapped = state.formatter.remapComponents(destOperand, component);
     return `${target.ref}${remapped ? `.${remapped}` : ""}`;
   }
 
-  /**
-   * Formats a resolved destination reference and optional mask.
-   *
-   * @param {object} target Resolved destination.
-   * @returns {string} GLSL lvalue text.
-   * @private
+  /**
+   * Formats a resolved destination reference and optional mask.
+   *
+   * @param {object} target Resolved destination.
+   * @returns {string} GLSL lvalue text.
+   * @private
    */
   _destText(target) {
     return `${target.ref}${target.mask ? `.${target.mask}` : ""}`;
   }
 
-  /**
-   * Selects the GLSL floating scalar or vector type for a width.
-   *
-   * @param {number} width Component width.
-   * @returns {string} GLSL type name.
-   * @private
+  /**
+   * Selects the GLSL floating scalar or vector type for a width.
+   *
+   * @param {number} width Component width.
+   * @returns {string} GLSL type name.
+   * @private
    */
   _vecType(width) {
     return width === 1 ? "float" : `vec${width}`;
   }
 
-  /**
-  * Reads a source at the destination mask's width, wrapping in a matching
-  * constructor so intrinsic arguments always type-check exactly.
+  /**
+  * Reads a source at the destination mask's width, wrapping in a matching
+  * constructor so intrinsic arguments always type-check exactly.
   */
   _vecArg(state, operand, destMask, as = "float") {
     const expression = state.formatter.sourceExpression(operand, {
@@ -1416,14 +1746,14 @@ class DxbcGlslEmitter {
     return `${ctor}(${expression})`;
   }
 
-  /**
-   * Resolves a destination operand and its register-space component mask.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {number} [operandIndex=0] Destination operand index.
-   * @returns {{target: object|null, mask: string}} Destination and mask.
-   * @private
+  /**
+   * Resolves a destination operand and its register-space component mask.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {number} [operandIndex=0] Destination operand index.
+   * @returns {{target: object|null, mask: string}} Destination and mask.
+   * @private
    */
   _destMask(state, instruction, operandIndex = 0) {
     const target = state.formatter.destination(instruction.operands[operandIndex]);
@@ -1436,25 +1766,25 @@ class DxbcGlslEmitter {
     };
   }
 
-  /**
-   * Tests whether an operand produces one scalar component.
-   *
-   * @param {object} operand Decoded DXBC operand.
-   * @returns {boolean} True when the source is scalar.
-   * @private
+  /**
+   * Tests whether an operand produces one scalar component.
+   *
+   * @param {object} operand Decoded DXBC operand.
+   * @returns {boolean} True when the source is scalar.
+   * @private
    */
   _isScalarSource(operand) {
     return operand.selectionModeName === "select1" || operand.type === 4 && operand.componentCount === 1 || operand.componentCount === 1;
   }
 
-  /**
-   * Emits an assignment and applies instruction saturation when required.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {string} valueExpression GLSL right-hand expression.
-   * @param {object} [options={}] Assignment formatting options.
-   * @private
+  /**
+   * Emits an assignment and applies instruction saturation when required.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {string} valueExpression GLSL right-hand expression.
+   * @param {object} [options={}] Assignment formatting options.
+   * @private
    */
   _assign(state, instruction, valueExpression, options = {}) {
     const statement = state.formatter.assignment(instruction.operands[0], valueExpression, options);
@@ -1470,13 +1800,13 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-   * Emits a width-correct floating binary infix operation.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {string} operator GLSL infix operator.
-   * @private
+  /**
+   * Emits a width-correct floating binary infix operation.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {string} operator GLSL infix operator.
+   * @private
    */
   _infixBinary(state, instruction, operator) {
     const {
@@ -1492,15 +1822,15 @@ class DxbcGlslEmitter {
     this._assignWidened(state, instruction, mask, `${a} ${operator} ${b}`, width === 1);
   }
 
-  /**
-   * Widens a scalar result when assigning it to a vector destination.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {string} mask Destination component mask.
-   * @param {string} expression GLSL expression.
-   * @param {boolean} rhsIsScalar Whether the expression is scalar.
-   * @private
+  /**
+   * Widens a scalar result when assigning it to a vector destination.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {string} mask Destination component mask.
+   * @param {string} expression GLSL expression.
+   * @param {boolean} rhsIsScalar Whether the expression is scalar.
+   * @private
    */
   _assignWidened(state, instruction, mask, expression, rhsIsScalar) {
     const value = rhsIsScalar && mask.length > 1 ? `vec${mask.length}(${expression})` : expression;
@@ -1509,13 +1839,13 @@ class DxbcGlslEmitter {
     });
   }
 
-  /**
-   * Emits a unary GLSL intrinsic with destination-width handling.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {string} glslName GLSL intrinsic name.
-   * @private
+  /**
+   * Emits a unary GLSL intrinsic with destination-width handling.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {string} glslName GLSL intrinsic name.
+   * @private
    */
   _helperUnary(state, instruction, glslName) {
     const {
@@ -1527,13 +1857,13 @@ class DxbcGlslEmitter {
     this._assignWidened(state, instruction, mask, `${glslName}(${src})`, state.formatter.expressionWidth(instruction.operands[1], mask) === 1);
   }
 
-  /**
-   * Emits a binary GLSL intrinsic with width-matched arguments.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {string} glslName GLSL intrinsic name.
-   * @private
+  /**
+   * Emits a binary GLSL intrinsic with width-matched arguments.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {string} glslName GLSL intrinsic name.
+   * @private
    */
   _helperBinary(state, instruction, glslName) {
     const {
@@ -1546,13 +1876,13 @@ class DxbcGlslEmitter {
     });
   }
 
-  /**
-   * Emits a dot product and replicates its scalar result when necessary.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {string} sourceMask Source component mask.
-   * @private
+  /**
+   * Emits a dot product and replicates its scalar result when necessary.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {string} sourceMask Source component mask.
+   * @private
    */
   _dotProduct(state, instruction, sourceMask) {
     const {
@@ -1566,16 +1896,16 @@ class DxbcGlslEmitter {
     });
   }
 
-  /**
-   * Emits scalar or vector comparison bits in the float register model.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {object} options Comparison options.
-   * @param {string} options.intrinsic GLSL vector comparison intrinsic.
-   * @param {string} options.operator GLSL scalar comparison operator.
-   * @param {"float"|"int"|"uint"} options.as Operand interpretation.
-   * @private
+  /**
+   * Emits scalar or vector comparison bits in the float register model.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {object} options Comparison options.
+   * @param {string} options.intrinsic GLSL vector comparison intrinsic.
+   * @param {string} options.operator GLSL scalar comparison operator.
+   * @param {"float"|"int"|"uint"} options.as Operand interpretation.
+   * @private
    */
   _comparison(state, instruction, {
     intrinsic,
@@ -1602,13 +1932,13 @@ class DxbcGlslEmitter {
     this._assign(state, instruction, `uintBitsToFloat(uvec${mask.length}(${intrinsic}(${a}, ${b})) * 0xFFFFFFFFu)`);
   }
 
-  /**
-   * Emits an unsigned bitwise operation through register bitcasts.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {string} operator GLSL bitwise operator.
-   * @private
+  /**
+   * Emits an unsigned bitwise operation through register bitcasts.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {string} operator GLSL bitwise operator.
+   * @private
    */
   _bitwiseBinary(state, instruction, operator) {
     const {
@@ -1619,14 +1949,14 @@ class DxbcGlslEmitter {
     this._assign(state, instruction, `uintBitsToFloat(${a} ${operator} ${b})`);
   }
 
-  /**
-   * Emits a signed or unsigned integer binary operation through bitcasts.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {string} operator GLSL integer operator.
-   * @param {"int"|"uint"} [as="int"] Integer interpretation.
-   * @private
+  /**
+   * Emits a signed or unsigned integer binary operation through bitcasts.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {string} operator GLSL integer operator.
+   * @param {"int"|"uint"} [as="int"] Integer interpretation.
+   * @private
    */
   _intBinary(state, instruction, operator, as = "int") {
     const {
@@ -1638,13 +1968,13 @@ class DxbcGlslEmitter {
     this._assign(state, instruction, `${wrap}(${a} ${operator} ${b})`);
   }
 
-  /**
-   * Formats the DXBC zero or nonzero control-flow condition.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @returns {string} GLSL boolean expression.
-   * @private
+  /**
+   * Formats the DXBC zero or nonzero control-flow condition.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @returns {string} GLSL boolean expression.
+   * @private
    */
   _condition(state, instruction) {
     const scalar = state.formatter.sourceExpression(instruction.operands[0], {
@@ -1654,12 +1984,12 @@ class DxbcGlslEmitter {
     return `floatBitsToUint(${scalar}) ${test} 0u`;
   }
 
-  /**
-   * Emits component-wise conditional moves without aliasing destinations.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @private
+  /**
+   * Emits component-wise conditional moves without aliasing destinations.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @private
    */
   _movc(state, instruction) {
     const destOperand = instruction.operands[0];
@@ -1699,12 +2029,12 @@ class DxbcGlslEmitter {
     }
   }
 
-  /**
-   * Emits the paired sine and cosine destinations in alias-safe order.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @private
+  /**
+   * Emits the paired sine and cosine destinations in alias-safe order.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @private
    */
   _sincos(state, instruction) {
     const [sinDest, cosDest, angle] = instruction.operands;
@@ -1732,20 +2062,20 @@ 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
+  /**
+   * 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
@@ -1761,6 +2091,15 @@ class DxbcGlslEmitter {
     state.resourceNames.set(register, DETAIL_MAP_ARRAY_SYMBOL);
     if (state.detailMapArrayDeclared) return;
     state.detailMapArrayDeclared = true;
+
+    // One GL uniform now stands for every merged layer, so it can carry only
+    // one sampler state. Union the layers' pairings: if they disagree the
+    // merge itself was invalid, and the packaging layer is where that is
+    // detectable, because only it holds the sampler values to compare.
+    const merged = new Set();
+    for (const layerRegister of state.detailMapArrayLayers.keys()) {
+      for (const sampler of state.pairedSamplers.get(layerRegister) ?? []) merged.add(sampler);
+    }
     state.declarationLines.push(`uniform mediump sampler2DArray ${DETAIL_MAP_ARRAY_SYMBOL};`);
     state.bindings.push({
       kind: "resource",
@@ -1769,35 +2108,38 @@ class DxbcGlslEmitter {
       samplerType: "sampler2DArray",
       dimensionName: "texture2darray",
       arrayLayerCount: state.detailMapArrayLayers.size,
-      mergedFrom: [...state.detailMapArrayLayers.keys()]
+      mergedFrom: [...state.detailMapArrayLayers.keys()],
+      ...(merged.size ? {
+        pairedSamplerRegisters: [...merged].sort((a, b) => a - b)
+      } : {})
     });
   }
 
-  /**
-   * 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
+  /**
+   * 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
+  /**
+   * 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;
@@ -1808,14 +2150,14 @@ class DxbcGlslEmitter {
     });
   }
 
-  /**
-   * Resolves and validates the declared dimension of a texture operand.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC instruction.
-   * @param {object} texOperand Texture resource operand.
-   * @returns {number} DXBC resource-dimension code.
-   * @private
+  /**
+   * Resolves and validates the declared dimension of a texture operand.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC instruction.
+   * @param {object} texOperand Texture resource operand.
+   * @returns {number} DXBC resource-dimension code.
+   * @private
    */
   _resourceDimension(state, instruction, texOperand) {
     const dimension = state.resourceDimensions.get(texOperand.registerIndex);
@@ -1829,18 +2171,18 @@ class DxbcGlslEmitter {
     return dimension;
   }
 
-  /**
-   * Emits a regular, LOD, bias, gradient, or comparison texture sample.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC texture instruction.
-   * @param {object} [options={}] Sampling-mode operand indexes.
-   * @param {number|null} [options.lodOperandIndex=null] Explicit LOD operand.
-   * @param {number|null} [options.biasOperandIndex=null] LOD bias operand.
-   * @param {number[]|null} [options.gradOperandIndexes=null] Gradient operands.
-   * @param {number|null} [options.comparisonRefOperandIndex=null] Comparison reference operand.
-   * @param {boolean} [options.forceLodZero=false] Whether to force the LOD-zero adaptation.
-   * @private
+  /**
+   * Emits a regular, LOD, bias, gradient, or comparison texture sample.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC texture instruction.
+   * @param {object} [options={}] Sampling-mode operand indexes.
+   * @param {number|null} [options.lodOperandIndex=null] Explicit LOD operand.
+   * @param {number|null} [options.biasOperandIndex=null] LOD bias operand.
+   * @param {number[]|null} [options.gradOperandIndexes=null] Gradient operands.
+   * @param {number|null} [options.comparisonRefOperandIndex=null] Comparison reference operand.
+   * @param {boolean} [options.forceLodZero=false] Whether to force the LOD-zero adaptation.
+   * @private
    */
   _textureSample(state, instruction, {
     lodOperandIndex = null,
@@ -1948,17 +2290,18 @@ class DxbcGlslEmitter {
     } else {
       call = `texture(${texName}, ${coord})`;
     }
+    call = this._applyEmulatedAddressing(state, instruction, call, coord, coordMask);
     this._assign(state, instruction, `${call}.${returnSwizzle}`, {
       saturate: instruction.saturate
     });
   }
 
-  /**
-   * Emits an integer-coordinate texel fetch for a declared resource.
-   *
-   * @param {object} state Mutable emission state.
-   * @param {object} instruction Decoded DXBC load instruction.
-   * @private
+  /**
+   * Emits an integer-coordinate texel fetch for a declared resource.
+   *
+   * @param {object} state Mutable emission state.
+   * @param {object} instruction Decoded DXBC load instruction.
+   * @private
    */
   _texelFetch(state, instruction) {
     const {
@@ -1994,9 +2337,9 @@ class DxbcGlslEmitter {
   }
 }
 
-/**
- * Per-opcode lowering table. Every rule cites its family spec in
- * `docs/dxbc-lowering/`; templates are HLSLcc-derived, see each doc.
+/**
+ * Per-opcode lowering table. Every rule cites its family spec in
+ * `docs/dxbc-lowering/`; templates are HLSLcc-derived, see each doc.
  */
 DxbcGlslEmitter.LOWERINGS = {
   // --- float-alu ---
@@ -2571,11 +2914,11 @@ DxbcGlslEmitter.LOWERINGS = {
   }
 };
 
-/**
- * `ld_structured` lowering. Vertex UBO path reads `name.data[row]` vec4 rows;
- * pixel data-texture path reads RGBA32UI texels (4 dwords per texel, fixed
- * 2048-texel row width). 16-byte-aligned reads use one static channel per
- * component; unaligned reads fall back to per-dword dynamic addressing.
+/**
+ * `ld_structured` lowering. Vertex UBO path reads `name.data[row]` vec4 rows;
+ * pixel data-texture path reads RGBA32UI texels (4 dwords per texel, fixed
+ * 2048-texel row width). 16-byte-aligned reads use one static channel per
+ * component; unaligned reads fall back to per-dword dynamic addressing.
  */
 DxbcGlslEmitter.prototype._ldStructured = function _ldStructured(state, instruction) {
   const target = state.formatter.destination(instruction.operands[0]);
@@ -2654,10 +2997,10 @@ DxbcGlslEmitter.prototype._ldStructured = function _ldStructured(state, instruct
   }
 };
 
-/**
- * `resinfo` lowering: width/height/depth via textureSize per live destination
- * component; the 4th (mip-count) channel has no WebGL2 equivalent and throws
- * only when a shader actually reads it.
+/**
+ * `resinfo` lowering: width/height/depth via textureSize per live destination
+ * component; the 4th (mip-count) channel has no WebGL2 equivalent and throws
+ * only when a shader actually reads it.
  */
 DxbcGlslEmitter.prototype._resinfo = function _resinfo(state, instruction) {
   const {
@@ -2701,8 +3044,8 @@ DxbcGlslEmitter.prototype._resinfo = function _resinfo(state, instruction) {
   }
 };
 
-/**
- * Shared int/uint min-max lowering used by imax/imin/umax/umin.
+/**
+ * Shared int/uint min-max lowering used by imax/imin/umax/umin.
  */
 DxbcGlslEmitter.prototype._intMinMax = function _intMinMax(state, instruction, fn, as) {
   const {
@@ -2714,16 +3057,16 @@ DxbcGlslEmitter.prototype._intMinMax = function _intMinMax(state, instruction, f
   this._assign(state, instruction, `${wrap}(${fn}(${a}, ${b}))`);
 };
 
-/**
- * `gather4` lowering: fetches one channel from each of the four texels a
- * bilinear sample would blend, via the `hlslcc_textureGather4Emulated` /
- * `hlslcc_textureGather4ArrayEmulated` helpers (GLSL ES 3.00 has no
- * `textureGather`). Only 2D and 2D-array resources are supported — the
- * dimensions the AO/blur/FSR/CAS map-style corpus this lowering targets is
- * known to use (ASSAO gathers from its deinterleaved texture2darray slices).
- *
- * @param {object} state Emit state.
- * @param {object} instruction `gather4` instruction.
+/**
+ * `gather4` lowering: fetches one channel from each of the four texels a
+ * bilinear sample would blend, via the `hlslcc_textureGather4Emulated` /
+ * `hlslcc_textureGather4ArrayEmulated` helpers (GLSL ES 3.00 has no
+ * `textureGather`). Only 2D and 2D-array resources are supported — the
+ * dimensions the AO/blur/FSR/CAS map-style corpus this lowering targets is
+ * known to use (ASSAO gathers from its deinterleaved texture2darray slices).
+ *
+ * @param {object} state Emit state.
+ * @param {object} instruction `gather4` instruction.
  */
 DxbcGlslEmitter.prototype._gather4 = function _gather4(state, instruction) {
   const {
@@ -2757,13 +3100,13 @@ DxbcGlslEmitter.prototype._gather4 = function _gather4(state, instruction) {
   });
 };
 
-/**
- * Reads the gathered-channel selector `gather4`/`gather4_po` carry on their
- * sampler operand (a 1-component swizzle; red/`x` is the default when no
- * selection is encoded).
- *
- * @param {object} operand Decoded sampler operand.
- * @returns {string} Channel letter (`x`/`y`/`z`/`w`).
+/**
+ * Reads the gathered-channel selector `gather4`/`gather4_po` carry on their
+ * sampler operand (a 1-component swizzle; red/`x` is the default when no
+ * selection is encoded).
+ *
+ * @param {object} operand Decoded sampler operand.
+ * @returns {string} Channel letter (`x`/`y`/`z`/`w`).
  */
 DxbcGlslEmitter.prototype._gather4Channel = function _gather4Channel(operand) {
   if (operand.selectionModeName === "select1" && operand.selected) {
@@ -2775,8 +3118,8 @@ DxbcGlslEmitter.prototype._gather4Channel = function _gather4Channel(operand) {
   return "x";
 };
 
-/**
- * Assembles the final GLSL text.
+/**
+ * Assembles the final GLSL text.
  */
 DxbcGlslEmitter.prototype._assemble = function _assemble(state) {
   const lines = ["#version 300 es"];