@carbonenginejs/runtime-resource 0.12.1 → 0.13.0

package/dist/formats/webgl/core/inspectGlslEffectContainer.js

@@ -0,0 +1,122 @@
+import { CjsCarbonEffectReader } from '../../../format/carbonEffect/CjsCarbonEffectReader.js';
+import { hlslShaderStageName } from '../../hlsl/core/tr2/HlslRenderContextEnum.js';
+
+/**
+ * Cheap inspection of a WebGL effect container.
+ *
+ * The chunk package's inspection reported tags, offsets and sizes, because a
+ * chunk file's structure *was* a list of tagged byte ranges. A Carbon v15
+ * container has no such list, so none of that vocabulary is carried across. A
+ * `chunks` array describing a container would be a lie, and a believed one.
+ *
+ * What a container's structure actually is: an arena of strings, a set of
+ * permutation axes, and an offset table whose rows point at description bodies —
+ * with rows deliberately aliased onto one body when permutations share a
+ * translation. So that is what this reports: how many rows, how many distinct
+ * bodies they resolve to, how much of the file is arena, and what the axes are.
+ *
+ * `uniqueBodyCount` and `aliasedRowCount` come from the reader's own structural
+ * diagnostics rather than being recomputed here — the reader already validates
+ * every row's byte range while building them, so a second walk could only
+ * disagree with the thing that already refused to construct.
+ *
+ * Body decoding is done once per *distinct* body offset, not once per row.
+ * Effects here reach 4,096 permutations over a few dozen bodies, so decoding per
+ * row would make an inspection call cost more than the packaging that produced
+ * the file.
+ */
+
+/**
+ * Counts programs and backend blocks across the container's distinct bodies.
+ *
+ * A stage slot with zero-length `shaderData` is a declared stage that carries no
+ * stored program — the shape `buildCarbonEffectContainer` emits for a body the
+ * translator could not lower. Counting those separately is the whole point: a
+ * container with every stage present and every program empty would otherwise
+ * inspect identically to a complete one.
+ *
+ * @param {CjsCarbonEffectReader} reader Container reader.
+ * @returns {{programCount:number, emptyProgramCount:number, backendBlockCount:number,
+ *   techniqueCount:number, passCount:number, stageNames:string[]}} Body tallies.
+ */
+function inspectBodies(reader) {
+  const seenOffsets = new Set();
+  const stageNames = new Set();
+  let programCount = 0;
+  let emptyProgramCount = 0;
+  let backendBlockCount = 0;
+  let techniqueCount = 0;
+  let passCount = 0;
+  for (let index = 0; index < reader.records.length; index += 1) {
+    const {
+      offset
+    } = reader.records[index];
+    if (seenOffsets.has(offset)) continue;
+    seenOffsets.add(offset);
+    const description = reader.readDescription(index, {
+      backend: true
+    });
+    for (const technique of description.techniques) {
+      techniqueCount += 1;
+      for (const pass of technique.passes) {
+        passCount += 1;
+        if (pass.backendBlock?.size) backendBlockCount += 1;
+        for (const stage of pass.stages) {
+          stageNames.add(hlslShaderStageName(stage.type));
+          if (stage.shaderData?.size) programCount += 1;else emptyProgramCount += 1;
+        }
+      }
+    }
+  }
+  return {
+    programCount,
+    emptyProgramCount,
+    backendBlockCount,
+    techniqueCount,
+    passCount,
+    stageNames: [...stageNames].sort()
+  };
+}
+
+/**
+ * Inspects WebGL effect container bytes.
+ *
+ * @param {Uint8Array|ArrayBuffer|Buffer|DataView} input Container payload.
+ * @param {object} [values] Normalized format values.
+ * @param {string} [values.source] Source name, for diagnostics.
+ * @returns {object} Plain summary data.
+ */
+function inspectGlslEffectContainer(input, values = {}) {
+  const source = values.source ?? "memory";
+  const reader = new CjsCarbonEffectReader(input, {
+    source
+  });
+  const bodies = inspectBodies(reader);
+  return {
+    source,
+    isContainer: true,
+    version: reader.version,
+    compilerVersion: [...reader.compilerVersion],
+    byteLength: reader.bytes.length,
+    arenaByteLength: reader.stringTableSize,
+    // The offset table, and what it resolves to. `recordCount` counts rows;
+    // `uniqueBodyCount` counts the bodies those rows point at. The gap
+    // between them is the sharing, which is the container's whole reason for
+    // being cheaper than one file per permutation.
+    recordCount: reader.diagnostics.recordCount,
+    permutationProduct: reader.diagnostics.permutationProduct,
+    dense: reader.diagnostics.dense,
+    uniqueBodyCount: reader.diagnostics.uniqueBodyCount,
+    aliasedRowCount: reader.diagnostics.aliasedRowCount,
+    permutationAxes: reader.permutations.map(axis => ({
+      name: axis.name.value,
+      type: axis.type,
+      defaultOption: axis.defaultOption,
+      options: axis.options.map(option => option.value)
+    })),
+    ...bodies
+  };
+}
+
+export { inspectGlslEffectContainer };
+//# sourceMappingURL=inspectGlslEffectContainer.js.map

package/dist/formats/webgl/core/inspectGlslEffectContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectGlslEffectContainer.js","sources":["../../../../../src/formats/webgl/core/inspectGlslEffectContainer.js"],"sourcesContent":["import { CjsCarbonEffectReader } from \"../../../format/carbonEffect/CjsCarbonEffectReader.js\";\nimport { hlslShaderStageName } from \"../../hlsl/core/tr2/HlslRenderContextEnum.js\";\n\n/**\n * Cheap inspection of a WebGL effect container.\n *\n * The chunk package's inspection reported tags, offsets and sizes, because a\n * chunk file's structure *was* a list of tagged byte ranges. A Carbon v15\n * container has no such list, so none of that vocabulary is carried across. A\n * `chunks` array describing a container would be a lie, and a believed one.\n *\n * What a container's structure actually is: an arena of strings, a set of\n * permutation axes, and an offset table whose rows point at description bodies —\n * with rows deliberately aliased onto one body when permutations share a\n * translation. So that is what this reports: how many rows, how many distinct\n * bodies they resolve to, how much of the file is arena, and what the axes are.\n *\n * `uniqueBodyCount` and `aliasedRowCount` come from the reader's own structural\n * diagnostics rather than being recomputed here — the reader already validates\n * every row's byte range while building them, so a second walk could only\n * disagree with the thing that already refused to construct.\n *\n * Body decoding is done once per *distinct* body offset, not once per row.\n * Effects here reach 4,096 permutations over a few dozen bodies, so decoding per\n * row would make an inspection call cost more than the packaging that produced\n * the file.\n */\n\n/**\n * Counts programs and backend blocks across the container's distinct bodies.\n *\n * A stage slot with zero-length `shaderData` is a declared stage that carries no\n * stored program — the shape `buildCarbonEffectContainer` emits for a body the\n * translator could not lower. Counting those separately is the whole point: a\n * container with every stage present and every program empty would otherwise\n * inspect identically to a complete one.\n *\n * @param {CjsCarbonEffectReader} reader Container reader.\n * @returns {{programCount:number, emptyProgramCount:number, backendBlockCount:number,\n *   techniqueCount:number, passCount:number, stageNames:string[]}} Body tallies.\n */\nfunction inspectBodies(reader)\n{\n    const seenOffsets = new Set();\n    const stageNames = new Set();\n    let programCount = 0;\n    let emptyProgramCount = 0;\n    let backendBlockCount = 0;\n    let techniqueCount = 0;\n    let passCount = 0;\n\n    for (let index = 0; index < reader.records.length; index += 1)\n    {\n        const { offset } = reader.records[index];\n        if (seenOffsets.has(offset)) continue;\n        seenOffsets.add(offset);\n\n        const description = reader.readDescription(index, { backend: true });\n        for (const technique of description.techniques)\n        {\n            techniqueCount += 1;\n            for (const pass of technique.passes)\n            {\n                passCount += 1;\n                if (pass.backendBlock?.size) backendBlockCount += 1;\n                for (const stage of pass.stages)\n                {\n                    stageNames.add(hlslShaderStageName(stage.type));\n                    if (stage.shaderData?.size) programCount += 1;\n                    else emptyProgramCount += 1;\n                }\n            }\n        }\n    }\n\n    return {\n        programCount,\n        emptyProgramCount,\n        backendBlockCount,\n        techniqueCount,\n        passCount,\n        stageNames: [ ...stageNames ].sort()\n    };\n}\n\n/**\n * Inspects WebGL effect container bytes.\n *\n * @param {Uint8Array|ArrayBuffer|Buffer|DataView} input Container payload.\n * @param {object} [values] Normalized format values.\n * @param {string} [values.source] Source name, for diagnostics.\n * @returns {object} Plain summary data.\n */\nexport function inspectGlslEffectContainer(input, values = {})\n{\n    const source = values.source ?? \"memory\";\n    const reader = new CjsCarbonEffectReader(input, { source });\n    const bodies = inspectBodies(reader);\n\n    return {\n        source,\n        isContainer: true,\n        version: reader.version,\n        compilerVersion: [ ...reader.compilerVersion ],\n        byteLength: reader.bytes.length,\n        arenaByteLength: reader.stringTableSize,\n\n        // The offset table, and what it resolves to. `recordCount` counts rows;\n        // `uniqueBodyCount` counts the bodies those rows point at. The gap\n        // between them is the sharing, which is the container's whole reason for\n        // being cheaper than one file per permutation.\n        recordCount: reader.diagnostics.recordCount,\n        permutationProduct: reader.diagnostics.permutationProduct,\n        dense: reader.diagnostics.dense,\n        uniqueBodyCount: reader.diagnostics.uniqueBodyCount,\n        aliasedRowCount: reader.diagnostics.aliasedRowCount,\n\n        permutationAxes: reader.permutations.map((axis) => ({\n            name: axis.name.value,\n            type: axis.type,\n            defaultOption: axis.defaultOption,\n            options: axis.options.map((option) => option.value)\n        })),\n\n        ...bodies\n    };\n}\n\nexport default inspectGlslEffectContainer;\n"],"names":["inspectBodies","reader","seenOffsets","Set","stageNames","programCount","emptyProgramCount","backendBlockCount","techniqueCount","passCount","index","records","length","offset","has","add","description","readDescription","backend","technique","techniques","pass","passes","backendBlock","size","stage","stages","hlslShaderStageName","type","shaderData","sort","inspectGlslEffectContainer","input","values","source","CjsCarbonEffectReader","bodies","isContainer","version","compilerVersion","byteLength","bytes","arenaByteLength","stringTableSize","recordCount","diagnostics","permutationProduct","dense","uniqueBodyCount","aliasedRowCount","permutationAxes","permutations","map","axis","name","value","defaultOption","options","option"],"mappings":"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"}

package/dist/formats/webgl/core/readGlslEffectContainer.js

@@ -0,0 +1,303 @@
+import { CjsCarbonEffectReader } from '../../../format/carbonEffect/CjsCarbonEffectReader.js';
+import { readGlslBackendBlock } from './glslBackendBlock.js';
+import { hlslShaderStageName, HlslUsageCodeNames } from '../../hlsl/core/tr2/HlslRenderContextEnum.js';
+
+/**
+ * Decodes a WebGL effect container into the stage/shader records the
+ * completeness rules consume.
+ *
+ * This exists so the rules run from container bytes alone. The alternative was
+ * to hand them the in-memory translation, which works inside `buildEffectPackage`
+ * and nowhere else — the validator reads a finished file and has no translation
+ * in scope. That would have cost the validator its completeness check while
+ * still requiring a decoder to produce the programs it compiles in a browser, so
+ * it was strictly more work for strictly less checking.
+ *
+ * The vocabulary is deliberately the one the rules already speak — `stages` with
+ * pass coordinates, `shaders` with source and a translation verdict. The rules
+ * are about the translation, not about how it was stored, so retargeting them
+ * meant changing where the records come from and nothing about what they mean.
+ *
+ * **What the wire cannot tell you.** `buildCarbonEffectContainer` stores a body
+ * the translator could not lower as its full pass tree with zero-length
+ * programs; the *reason* it failed stays in the in-memory build result and is
+ * never written. So a shader decoded from bytes reports `ok: false` with
+ * "no program was stored" and nothing more specific. That is the honest answer:
+ * a file on disk does not know why a translation failed months ago. Callers that
+ * do know — `buildEffectPackage`, at build time — keep their specific
+ * diagnostics by feeding the rules their own records instead.
+ */
+
+/** The verdict a stage carrying no stored program gets. */
+const NO_PROGRAM_REASON = "no program was stored";
+
+/**
+ * Reshapes one Carbon stage's own reflection into the manifest vocabulary the
+ * runtime-ABI rules read.
+ *
+ * The chunk package carried this as a separate META manifest, which is why the
+ * old rules cross-checked two chunks against each other. The container needs no
+ * such cross-check: `pipelineInputs`, `textures` and `samplers` are Carbon's own
+ * per-stage reflection, read straight out of the description. There is only one
+ * copy, so there is nothing for a second copy to disagree with — the class of
+ * bug those cross-chunk rules existed to catch cannot occur here.
+ *
+ * `usageName` is derived from the `usage` byte rather than carried, the same way
+ * `carbonDescriptionToRuntime.js:261` derives it.
+ *
+ * @param {object} stage Decoded Carbon stage record.
+ * @returns {{pipelineInputs:object[], bindings:object[]}} Manifest-shaped reflection.
+ */
+function stageManifest(stage) {
+  return {
+    pipelineInputs: (stage.pipelineInputs ?? []).map(input => ({
+      registerIndex: input.registerIndex,
+      usageName: HlslUsageCodeNames[input.usage] || `USAGE_${input.usage}`,
+      usageIndex: input.usageIndex,
+      usedMask: input.usedMask
+    })),
+    bindings: [
+    // The stage-local constant buffer, carrying the named constants an
+    // engine binds its material parameters to. Register 0 is this
+    // stage's own buffer in per-stage numbering; a consumer maps it to
+    // the slot its backend uses (vertex b0, pixel b7 by the GL
+    // convention).
+    //
+    // This is not optional detail. Without it an engine has no names to
+    // bind parameters to, uploads nothing, and every material value the
+    // shader reads is zero — which draws, links and binds correctly and
+    // renders pure black. It was missing because the completeness rules
+    // this reader was written for only needed inputs, resources and
+    // samplers, so nothing noticed the constants were dropped.
+    {
+      kind: "constantBuffer",
+      registerIndex: 0,
+      carbon: {
+        // Authored defaults live in the stage's blob; its declared
+        // size is what a consumer allocates against.
+        constantValueSize: stage.defaultValues?.size ?? 0,
+        constants: (stage.constants ?? []).map(constant => ({
+          // String refs decode as `{offset, value}` records.
+          name: constant.name?.value ?? constant.name,
+          offset: constant.offset,
+          size: constant.size,
+          type: constant.type,
+          dimension: constant.dimension,
+          elements: constant.elements,
+          isSRGB: constant.isSRGB,
+          isAutoregister: constant.isAutoregister
+        }))
+      }
+    }, ...(stage.textures ?? []).map(texture => ({
+      kind: "resource",
+      registerIndex: texture.registerIndex,
+      // Named so a rule can ask whether a described resource belongs
+      // to a family the packager is known to lower away.
+      name: texture.name.value,
+      // Carbon's own flags, nested like the sampler's, because that
+      // is where the consumer already looks for them.
+      //
+      // `isAutoregister` is not cosmetic: such a resource is bound
+      // automatically from the engine's global variable store rather
+      // than set by a material. Dropping it makes every resource look
+      // user-settable, so a consumer builds an ordinary texture
+      // parameter that nothing ever assigns and the global never
+      // reaches the shader.
+      carbon: {
+        isSRGB: texture.isSRGB === 1,
+        isAutoregister: texture.isAutoregister === 1
+      }
+    })), ...(stage.samplers ?? []).map(sampler => ({
+      kind: "sampler",
+      registerIndex: sampler.registerIndex,
+      // Carbon stores the flag as a byte; the rule compares against
+      // `=== true`, so the conversion has to happen here rather than
+      // letting a truthy 1 pass a strict check by accident.
+      carbon: {
+        sampler: {
+          comparison: sampler.comparison !== 0
+        }
+      }
+    }))]
+  };
+}
+
+/**
+ * Decodes one pass's backend block, tolerating a pass that has none.
+ *
+ * @param {object} pass Decoded pass record.
+ * @param {string} passKey Enclosing pass key.
+ * @param {string} source Source name for error details.
+ * @returns {object} Per-stage backend data, keyed by stage name.
+ */
+function backendStages(pass, passKey, source) {
+  if (!pass.backendBlock?.size) return {
+    stages: {},
+    transforms: []
+  };
+  const block = readGlslBackendBlock(pass.backendBlock.bytes, {
+    layoutKey: passKey,
+    source
+  });
+  return {
+    stages: block.stages ?? {},
+    transforms: block.transforms ?? []
+  };
+}
+
+/**
+ * Decodes container bytes into stage and shader records.
+ *
+ * Bodies are decoded once each rather than once per permutation row: rows alias
+ * onto shared bodies, and a rule that saw the same body 4,096 times would report
+ * 4,096 identical incomplete passes.
+ *
+ * @param {Uint8Array|ArrayBuffer|Buffer|DataView} input Container payload.
+ * @param {object} [values] Read values.
+ * @param {string} [values.source] Source name, for diagnostics.
+ * @returns {{stages:object[], shaders:object[], recordCount:number, bodyCount:number}}
+ *   Stage graph in the completeness rules' vocabulary.
+ */
+function readGlslEffectContainer(input, values = {}) {
+  const source = values.source ?? "memory";
+  const reader = new CjsCarbonEffectReader(input, {
+    source
+  });
+  const stages = [];
+  const shaders = [];
+  const bodyKeyByOffset = new Map();
+
+  // Every permutation index that resolves to each body.
+  //
+  // This is the bridge a caller actually needs, and the only one that is
+  // sound. `bodyKey` here is this reader's own ordinal spelling; the
+  // permutation graph mints `body${N}` for the same body, and the two are not
+  // merely spelled differently — the graph dedupes by content (SHA-256 plus
+  // byte equality) while this reader dedupes by source-record offset. Those
+  // partitions coincide only because the container writer aliases
+  // byte-identical bodies onto one offset, which is a property of the writer
+  // rather than a contract.
+  //
+  // So a consumer must never map between the two by string surgery on either
+  // spelling, and must not assume the two ordinal sequences agree. It holds a
+  // permutation index; this gives it the body directly.
+  const permutationIndicesByOffset = new Map();
+  for (let index = 0; index < reader.records.length; index += 1) {
+    const {
+      offset
+    } = reader.records[index];
+    const seen = permutationIndicesByOffset.get(offset);
+    if (seen) seen.push(index);else permutationIndicesByOffset.set(offset, [index]);
+  }
+
+  // Distinct program texts share one shader record, so `shaders` counts unique
+  // translations the way the chunk package's shader table did. Empty stages are
+  // deliberately *not* pooled: each keeps its own record so a report can name
+  // every pass that is missing a program rather than one shared "absent".
+  //
+  // The pool key is the program text *and* the backend reflection that came
+  // with it, not the text alone. A pooled record carries the bindings and
+  // stage inputs of whichever stage was seen first, and
+  // `validateShaderRuntimeContract` judges the emitted GLSL against them — so
+  // pooling on text alone would let two stages with identical source but
+  // different reflection be checked against the wrong metadata, silently. It
+  // is unlikely that identical GLSL ever carries different reflection, which
+  // is exactly why it would not be noticed.
+  const shaderKeyByIdentity = new Map();
+  for (let index = 0; index < reader.records.length; index += 1) {
+    const {
+      offset
+    } = reader.records[index];
+    if (bodyKeyByOffset.has(offset)) continue;
+    const bodyKey = `body_${bodyKeyByOffset.size}`;
+    bodyKeyByOffset.set(offset, bodyKey);
+    const description = reader.readDescription(index, {
+      backend: true
+    });
+    for (const technique of description.techniques) {
+      const techniqueName = technique.name.value;
+      for (const [passIndex, pass] of technique.passes.entries()) {
+        const passKey = `${techniqueName}.pass${passIndex}`;
+        const {
+          stages: backend,
+          transforms
+        } = backendStages(pass, passKey, source);
+        for (const stage of pass.stages) {
+          const name = hlslShaderStageName(stage.type);
+          const stageKey = `${bodyKey}.${passKey}.${name}`;
+          const stageBackend = backend[name] ?? {};
+          let shaderKey;
+          if (stage.shaderData?.size) {
+            const code = new TextDecoder().decode(stage.shaderData.bytes);
+            const identity = `${JSON.stringify([stageBackend.bindings ?? [], stageBackend.stageInputs ?? [], stageBackend.computeFragment ?? null])} ${code}`;
+            const pooled = shaderKeyByIdentity.get(identity);
+            if (pooled) {
+              shaderKey = pooled;
+            } else {
+              shaderKey = `shader_${shaderKeyByIdentity.size}`;
+              shaderKeyByIdentity.set(identity, shaderKey);
+              shaders.push({
+                key: shaderKey,
+                stageName: name,
+                source: code,
+                hlsl2webgl: {
+                  ok: true
+                },
+                bindings: stageBackend.bindings ?? [],
+                stageInputs: stageBackend.stageInputs ?? [],
+                ...(stageBackend.computeFragment ? {
+                  computeFragment: stageBackend.computeFragment
+                } : {})
+              });
+            }
+          } else {
+            shaderKey = `${stageKey}.absent`;
+            shaders.push({
+              key: shaderKey,
+              stageName: name,
+              source: "",
+              hlsl2webgl: {
+                ok: false,
+                reason: NO_PROGRAM_REASON
+              },
+              bindings: stageBackend.bindings ?? [],
+              stageInputs: stageBackend.stageInputs ?? []
+            });
+          }
+          stages.push({
+            key: stageKey,
+            bodyKey,
+            techniqueName,
+            passIndex,
+            stageName: name,
+            stageType: stage.type,
+            shaderKey,
+            manifest: stageManifest(stage),
+            // The pass's transforms, so a rule can ask whether a
+            // description resource was merged away rather than lost.
+            transforms
+          });
+        }
+      }
+    }
+  }
+
+  // Ordered by first appearance, matching `bodyKey`'s ordinal.
+  const bodies = [];
+  for (const [offset, key] of bodyKeyByOffset) {
+    bodies.push({
+      key,
+      permutationIndices: Object.freeze(permutationIndicesByOffset.get(offset) ?? [])
+    });
+  }
+  return {
+    stages,
+    shaders,
+    bodies,
+    recordCount: reader.records.length,
+    bodyCount: bodyKeyByOffset.size
+  };
+}
+
+export { readGlslEffectContainer };
+//# sourceMappingURL=readGlslEffectContainer.js.map

package/dist/formats/webgl/core/readGlslEffectContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readGlslEffectContainer.js","sources":["../../../../../src/formats/webgl/core/readGlslEffectContainer.js"],"sourcesContent":["import { CjsCarbonEffectReader } from \"../../../format/carbonEffect/CjsCarbonEffectReader.js\";\r\nimport { readGlslBackendBlock } from \"./glslBackendBlock.js\";\r\nimport {\r\n    hlslShaderStageName,\r\n    HlslUsageCodeNames\r\n} from \"../../hlsl/core/tr2/HlslRenderContextEnum.js\";\r\n\r\n/**\r\n * Decodes a WebGL effect container into the stage/shader records the\r\n * completeness rules consume.\r\n *\r\n * This exists so the rules run from container bytes alone. The alternative was\r\n * to hand them the in-memory translation, which works inside `buildEffectPackage`\r\n * and nowhere else — the validator reads a finished file and has no translation\r\n * in scope. That would have cost the validator its completeness check while\r\n * still requiring a decoder to produce the programs it compiles in a browser, so\r\n * it was strictly more work for strictly less checking.\r\n *\r\n * The vocabulary is deliberately the one the rules already speak — `stages` with\r\n * pass coordinates, `shaders` with source and a translation verdict. The rules\r\n * are about the translation, not about how it was stored, so retargeting them\r\n * meant changing where the records come from and nothing about what they mean.\r\n *\r\n * **What the wire cannot tell you.** `buildCarbonEffectContainer` stores a body\r\n * the translator could not lower as its full pass tree with zero-length\r\n * programs; the *reason* it failed stays in the in-memory build result and is\r\n * never written. So a shader decoded from bytes reports `ok: false` with\r\n * \"no program was stored\" and nothing more specific. That is the honest answer:\r\n * a file on disk does not know why a translation failed months ago. Callers that\r\n * do know — `buildEffectPackage`, at build time — keep their specific\r\n * diagnostics by feeding the rules their own records instead.\r\n */\r\n\r\n/** The verdict a stage carrying no stored program gets. */\r\nconst NO_PROGRAM_REASON = \"no program was stored\";\r\n\r\n/**\r\n * Reshapes one Carbon stage's own reflection into the manifest vocabulary the\r\n * runtime-ABI rules read.\r\n *\r\n * The chunk package carried this as a separate META manifest, which is why the\r\n * old rules cross-checked two chunks against each other. The container needs no\r\n * such cross-check: `pipelineInputs`, `textures` and `samplers` are Carbon's own\r\n * per-stage reflection, read straight out of the description. There is only one\r\n * copy, so there is nothing for a second copy to disagree with — the class of\r\n * bug those cross-chunk rules existed to catch cannot occur here.\r\n *\r\n * `usageName` is derived from the `usage` byte rather than carried, the same way\r\n * `carbonDescriptionToRuntime.js:261` derives it.\r\n *\r\n * @param {object} stage Decoded Carbon stage record.\r\n * @returns {{pipelineInputs:object[], bindings:object[]}} Manifest-shaped reflection.\r\n */\r\nfunction stageManifest(stage)\r\n{\r\n    return {\r\n        pipelineInputs: (stage.pipelineInputs ?? []).map((input) => ({\r\n            registerIndex: input.registerIndex,\r\n            usageName: HlslUsageCodeNames[input.usage] || `USAGE_${input.usage}`,\r\n            usageIndex: input.usageIndex,\r\n            usedMask: input.usedMask\r\n        })),\r\n        bindings: [\r\n            // The stage-local constant buffer, carrying the named constants an\r\n            // engine binds its material parameters to. Register 0 is this\r\n            // stage's own buffer in per-stage numbering; a consumer maps it to\r\n            // the slot its backend uses (vertex b0, pixel b7 by the GL\r\n            // convention).\r\n            //\r\n            // This is not optional detail. Without it an engine has no names to\r\n            // bind parameters to, uploads nothing, and every material value the\r\n            // shader reads is zero — which draws, links and binds correctly and\r\n            // renders pure black. It was missing because the completeness rules\r\n            // this reader was written for only needed inputs, resources and\r\n            // samplers, so nothing noticed the constants were dropped.\r\n            {\r\n                kind: \"constantBuffer\",\r\n                registerIndex: 0,\r\n                carbon: {\r\n                    // Authored defaults live in the stage's blob; its declared\r\n                    // size is what a consumer allocates against.\r\n                    constantValueSize: stage.defaultValues?.size ?? 0,\r\n                    constants: (stage.constants ?? []).map((constant) => ({\r\n                        // String refs decode as `{offset, value}` records.\r\n                        name: constant.name?.value ?? constant.name,\r\n                        offset: constant.offset,\r\n                        size: constant.size,\r\n                        type: constant.type,\r\n                        dimension: constant.dimension,\r\n                        elements: constant.elements,\r\n                        isSRGB: constant.isSRGB,\r\n                        isAutoregister: constant.isAutoregister\r\n                    }))\r\n                }\r\n            },\r\n            ...(stage.textures ?? []).map((texture) => ({\r\n                kind: \"resource\",\r\n                registerIndex: texture.registerIndex,\r\n                // Named so a rule can ask whether a described resource belongs\r\n                // to a family the packager is known to lower away.\r\n                name: texture.name.value,\r\n                // Carbon's own flags, nested like the sampler's, because that\r\n                // is where the consumer already looks for them.\r\n                //\r\n                // `isAutoregister` is not cosmetic: such a resource is bound\r\n                // automatically from the engine's global variable store rather\r\n                // than set by a material. Dropping it makes every resource look\r\n                // user-settable, so a consumer builds an ordinary texture\r\n                // parameter that nothing ever assigns and the global never\r\n                // reaches the shader.\r\n                carbon: {\r\n                    isSRGB: texture.isSRGB === 1,\r\n                    isAutoregister: texture.isAutoregister === 1\r\n                }\r\n            })),\r\n            ...(stage.samplers ?? []).map((sampler) => ({\r\n                kind: \"sampler\",\r\n                registerIndex: sampler.registerIndex,\r\n                // Carbon stores the flag as a byte; the rule compares against\r\n                // `=== true`, so the conversion has to happen here rather than\r\n                // letting a truthy 1 pass a strict check by accident.\r\n                carbon: { sampler: { comparison: sampler.comparison !== 0 } }\r\n            }))\r\n        ]\r\n    };\r\n}\r\n\r\n/**\r\n * Decodes one pass's backend block, tolerating a pass that has none.\r\n *\r\n * @param {object} pass Decoded pass record.\r\n * @param {string} passKey Enclosing pass key.\r\n * @param {string} source Source name for error details.\r\n * @returns {object} Per-stage backend data, keyed by stage name.\r\n */\r\nfunction backendStages(pass, passKey, source)\r\n{\r\n    if (!pass.backendBlock?.size) return { stages: {}, transforms: [] };\r\n    const block = readGlslBackendBlock(pass.backendBlock.bytes, { layoutKey: passKey, source });\r\n    return { stages: block.stages ?? {}, transforms: block.transforms ?? [] };\r\n}\r\n\r\n/**\r\n * Decodes container bytes into stage and shader records.\r\n *\r\n * Bodies are decoded once each rather than once per permutation row: rows alias\r\n * onto shared bodies, and a rule that saw the same body 4,096 times would report\r\n * 4,096 identical incomplete passes.\r\n *\r\n * @param {Uint8Array|ArrayBuffer|Buffer|DataView} input Container payload.\r\n * @param {object} [values] Read values.\r\n * @param {string} [values.source] Source name, for diagnostics.\r\n * @returns {{stages:object[], shaders:object[], recordCount:number, bodyCount:number}}\r\n *   Stage graph in the completeness rules' vocabulary.\r\n */\r\nexport function readGlslEffectContainer(input, values = {})\r\n{\r\n    const source = values.source ?? \"memory\";\r\n    const reader = new CjsCarbonEffectReader(input, { source });\r\n\r\n    const stages = [];\r\n    const shaders = [];\r\n    const bodyKeyByOffset = new Map();\r\n\r\n    // Every permutation index that resolves to each body.\r\n    //\r\n    // This is the bridge a caller actually needs, and the only one that is\r\n    // sound. `bodyKey` here is this reader's own ordinal spelling; the\r\n    // permutation graph mints `body${N}` for the same body, and the two are not\r\n    // merely spelled differently — the graph dedupes by content (SHA-256 plus\r\n    // byte equality) while this reader dedupes by source-record offset. Those\r\n    // partitions coincide only because the container writer aliases\r\n    // byte-identical bodies onto one offset, which is a property of the writer\r\n    // rather than a contract.\r\n    //\r\n    // So a consumer must never map between the two by string surgery on either\r\n    // spelling, and must not assume the two ordinal sequences agree. It holds a\r\n    // permutation index; this gives it the body directly.\r\n    const permutationIndicesByOffset = new Map();\r\n\r\n    for (let index = 0; index < reader.records.length; index += 1)\r\n    {\r\n        const { offset } = reader.records[index];\r\n        const seen = permutationIndicesByOffset.get(offset);\r\n        if (seen) seen.push(index);\r\n        else permutationIndicesByOffset.set(offset, [ index ]);\r\n    }\r\n\r\n    // Distinct program texts share one shader record, so `shaders` counts unique\r\n    // translations the way the chunk package's shader table did. Empty stages are\r\n    // deliberately *not* pooled: each keeps its own record so a report can name\r\n    // every pass that is missing a program rather than one shared \"absent\".\r\n    //\r\n    // The pool key is the program text *and* the backend reflection that came\r\n    // with it, not the text alone. A pooled record carries the bindings and\r\n    // stage inputs of whichever stage was seen first, and\r\n    // `validateShaderRuntimeContract` judges the emitted GLSL against them — so\r\n    // pooling on text alone would let two stages with identical source but\r\n    // different reflection be checked against the wrong metadata, silently. It\r\n    // is unlikely that identical GLSL ever carries different reflection, which\r\n    // is exactly why it would not be noticed.\r\n    const shaderKeyByIdentity = new Map();\r\n\r\n    for (let index = 0; index < reader.records.length; index += 1)\r\n    {\r\n        const { offset } = reader.records[index];\r\n        if (bodyKeyByOffset.has(offset)) continue;\r\n\r\n        const bodyKey = `body_${bodyKeyByOffset.size}`;\r\n        bodyKeyByOffset.set(offset, bodyKey);\r\n\r\n        const description = reader.readDescription(index, { backend: true });\r\n\r\n        for (const technique of description.techniques)\r\n        {\r\n            const techniqueName = technique.name.value;\r\n            for (const [ passIndex, pass ] of technique.passes.entries())\r\n            {\r\n                const passKey = `${techniqueName}.pass${passIndex}`;\r\n                const { stages: backend, transforms } = backendStages(\r\n                    pass,\r\n                    passKey,\r\n                    source\r\n                );\r\n\r\n                for (const stage of pass.stages)\r\n                {\r\n                    const name = hlslShaderStageName(stage.type);\r\n                    const stageKey = `${bodyKey}.${passKey}.${name}`;\r\n                    const stageBackend = backend[name] ?? {};\r\n\r\n                    let shaderKey;\r\n                    if (stage.shaderData?.size)\r\n                    {\r\n                        const code = new TextDecoder().decode(stage.shaderData.bytes);\r\n                        const identity = `${JSON.stringify([\r\n                            stageBackend.bindings ?? [],\r\n                            stageBackend.stageInputs ?? [],\r\n                            stageBackend.computeFragment ?? null\r\n                        ])} ${code}`;\r\n                        const pooled = shaderKeyByIdentity.get(identity);\r\n                        if (pooled)\r\n                        {\r\n                            shaderKey = pooled;\r\n                        }\r\n                        else\r\n                        {\r\n                            shaderKey = `shader_${shaderKeyByIdentity.size}`;\r\n                            shaderKeyByIdentity.set(identity, shaderKey);\r\n                            shaders.push({\r\n                                key: shaderKey,\r\n                                stageName: name,\r\n                                source: code,\r\n                                hlsl2webgl: { ok: true },\r\n                                bindings: stageBackend.bindings ?? [],\r\n                                stageInputs: stageBackend.stageInputs ?? [],\r\n                                ...(stageBackend.computeFragment\r\n                                    ? { computeFragment: stageBackend.computeFragment }\r\n                                    : {})\r\n                            });\r\n                        }\r\n                    }\r\n                    else\r\n                    {\r\n                        shaderKey = `${stageKey}.absent`;\r\n                        shaders.push({\r\n                            key: shaderKey,\r\n                            stageName: name,\r\n                            source: \"\",\r\n                            hlsl2webgl: { ok: false, reason: NO_PROGRAM_REASON },\r\n                            bindings: stageBackend.bindings ?? [],\r\n                            stageInputs: stageBackend.stageInputs ?? []\r\n                        });\r\n                    }\r\n\r\n                    stages.push({\r\n                        key: stageKey,\r\n                        bodyKey,\r\n                        techniqueName,\r\n                        passIndex,\r\n                        stageName: name,\r\n                        stageType: stage.type,\r\n                        shaderKey,\r\n                        manifest: stageManifest(stage),\r\n                        // The pass's transforms, so a rule can ask whether a\r\n                        // description resource was merged away rather than lost.\r\n                        transforms\r\n                    });\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    // Ordered by first appearance, matching `bodyKey`'s ordinal.\r\n    const bodies = [];\r\n    for (const [ offset, key ] of bodyKeyByOffset)\r\n    {\r\n        bodies.push({\r\n            key,\r\n            permutationIndices: Object.freeze(permutationIndicesByOffset.get(offset) ?? [])\r\n        });\r\n    }\r\n\r\n    return {\r\n        stages,\r\n        shaders,\r\n        bodies,\r\n        recordCount: reader.records.length,\r\n        bodyCount: bodyKeyByOffset.size\r\n    };\r\n}\r\n\r\nexport default readGlslEffectContainer;\r\n"],"names":["NO_PROGRAM_REASON","stageManifest","stage","pipelineInputs","map","input","registerIndex","usageName","HlslUsageCodeNames","usage","usageIndex","usedMask","bindings","kind","carbon","constantValueSize","defaultValues","size","constants","constant","name","value","offset","type","dimension","elements","isSRGB","isAutoregister","textures","texture","samplers","sampler","comparison","backendStages","pass","passKey","source","backendBlock","stages","transforms","block","readGlslBackendBlock","bytes","layoutKey","readGlslEffectContainer","values","reader","CjsCarbonEffectReader","shaders","bodyKeyByOffset","Map","permutationIndicesByOffset","index","records","length","seen","get","push","set","shaderKeyByIdentity","has","bodyKey","description","readDescription","backend","technique","techniques","techniqueName","passIndex","passes","entries","hlslShaderStageName","stageKey","stageBackend","shaderKey","shaderData","code","TextDecoder","decode","identity","JSON","stringify","stageInputs","computeFragment","pooled","key","stageName","hlsl2webgl","ok","reason","stageType","manifest","bodies","permutationIndices","Object","freeze","recordCount","bodyCount"],"mappings":"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"}

package/dist/formats/webgl/index.js

@@ -1,2 +1,2 @@
-export { CjsWebglFormat, CjsWebglFormat as default } from './CjsWebglFormat.js';
-//# sourceMappingURL=index.js.map
+export { CjsWebglFormat, CjsWebglFormat as default } from './CjsWebglFormat.js';
+//# sourceMappingURL=index.js.map