@forgeax/engine-image 0.1.28 → 0.1.30

package/dist/image-importer.mjs

@@ -16,6 +16,15 @@ var __export = (target, all) => {
 function imageError(detail) {
   return new ImageErrorImpl(detail);
 }
+function cubeParserError(code, sourceKey, field, actual, line) {
+  const lineDetail = line === void 0 ? "" : ` at line ${line}`;
+  return {
+    code,
+    expected: `valid .cube source with LUT_3D_SIZE, DOMAIN_MIN/MAX, and exactly N^3 RGB rows${lineDetail}`,
+    hint: `repair field ${field} in sourceKey ${sourceKey} and re-run the Node image producer`,
+    detail: { sourceKey, field, actual, ...line === void 0 ? {} : { line } }
+  };
+}
 var IMAGE_ERROR_EXPECTED, ImageErrorImpl;
 var init_errors = __esm({
   "src/errors.ts"() {
@@ -331,6 +340,278 @@ async function encodeTextureToKtx2(pixels, width, height, mode, source) {
   return { ok: true, value: { ktx2: result.value, mode: resolved } };
 }
 
+// src/lut/cube-parser.ts
+init_errors();
+var ALLOWED_SIZES = /* @__PURE__ */ new Set([16, 32, 64]);
+function finite(value) {
+  return Number.isFinite(value);
+}
+function parseTriple(tokens) {
+  if (tokens.length !== 3) return void 0;
+  const values = tokens.map(Number);
+  if (!values.every(finite)) return void 0;
+  const [red, green, blue] = values;
+  if (red === void 0 || green === void 0 || blue === void 0) return void 0;
+  return [red, green, blue];
+}
+function float32ToFloat16(value) {
+  const input = new Float32Array([value]);
+  const bits = new Uint32Array(input.buffer).at(0) ?? 0;
+  const sign = bits >>> 16 & 32768;
+  const exponent = bits >>> 23 & 255;
+  const fraction = bits & 8388607;
+  if (exponent === 255) return sign | (fraction === 0 ? 31744 : 32256);
+  const halfExponent = exponent - 127 + 15;
+  if (halfExponent >= 31) return sign | 31744;
+  if (halfExponent <= 0) {
+    if (halfExponent < -10) return sign;
+    const mantissa = (fraction | 8388608) >>> 1 - halfExponent;
+    return sign | mantissa + 4096 >>> 13;
+  }
+  return sign | halfExponent << 10 | fraction + 4096 >>> 13;
+}
+function parseCubeLut(source, sourceKey = "<inline .cube>") {
+  let size;
+  let domainMin;
+  let domainMax;
+  const values = [];
+  const lines = source.split(/\r?\n/);
+  for (const [index, rawLine] of lines.entries()) {
+    const line = rawLine.replace(/#.*/, "").trim();
+    const lineNumber = index + 1;
+    if (line.length === 0) continue;
+    const tokens = line.split(/\s+/);
+    const directive = tokens.shift();
+    if (directive === void 0) continue;
+    if (directive === "TITLE") continue;
+    if (directive === "LUT_3D_SIZE") {
+      const sizeToken = tokens[0];
+      if (size !== void 0 || tokens.length !== 1 || sizeToken === void 0 || !/^\d+$/.test(sizeToken)) {
+        return {
+          ok: false,
+          error: cubeParserError("cube-size-invalid", sourceKey, "LUT_3D_SIZE", line, lineNumber)
+        };
+      }
+      size = Number(sizeToken);
+      if (!ALLOWED_SIZES.has(size)) {
+        return {
+          ok: false,
+          error: cubeParserError("cube-size-invalid", sourceKey, "LUT_3D_SIZE", size, lineNumber)
+        };
+      }
+      continue;
+    }
+    if (directive === "DOMAIN_MIN" || directive === "DOMAIN_MAX") {
+      const triple = parseTriple(tokens);
+      if (triple === void 0) {
+        return {
+          ok: false,
+          error: cubeParserError("cube-domain-invalid", sourceKey, directive, line, lineNumber)
+        };
+      }
+      if (directive === "DOMAIN_MIN") {
+        if (domainMin !== void 0)
+          return {
+            ok: false,
+            error: cubeParserError("cube-domain-invalid", sourceKey, directive, line, lineNumber)
+          };
+        domainMin = triple;
+      } else {
+        if (domainMax !== void 0)
+          return {
+            ok: false,
+            error: cubeParserError("cube-domain-invalid", sourceKey, directive, line, lineNumber)
+          };
+        domainMax = triple;
+      }
+      continue;
+    }
+    if (directive === "LUT_1D_SIZE") {
+      return {
+        ok: false,
+        error: cubeParserError("cube-header-invalid", sourceKey, directive, line, lineNumber)
+      };
+    }
+    const row = parseTriple([directive, ...tokens]);
+    if (row === void 0 || row.some((value) => value < 0 || value > 1)) {
+      return {
+        ok: false,
+        error: cubeParserError("cube-row-invalid", sourceKey, "RGB row", line, lineNumber)
+      };
+    }
+    values.push(...row);
+  }
+  if (size === void 0)
+    return {
+      ok: false,
+      error: cubeParserError("cube-header-invalid", sourceKey, "LUT_3D_SIZE", "missing")
+    };
+  if (domainMin === void 0 || domainMax === void 0) {
+    return {
+      ok: false,
+      error: cubeParserError("cube-domain-invalid", sourceKey, "DOMAIN_MIN/MAX", "missing")
+    };
+  }
+  if (domainMin.some((value, index) => {
+    const maxValue = domainMax[index];
+    return maxValue !== void 0 && value >= maxValue;
+  })) {
+    return {
+      ok: false,
+      error: cubeParserError("cube-domain-invalid", sourceKey, "DOMAIN_MIN/MAX", {
+        domainMin,
+        domainMax
+      })
+    };
+  }
+  const expectedValues = size ** 3 * 3;
+  if (values.length !== expectedValues) {
+    return {
+      ok: false,
+      error: cubeParserError("cube-data-count-invalid", sourceKey, "RGB rows", {
+        expected: expectedValues / 3,
+        actual: values.length / 3
+      })
+    };
+  }
+  return {
+    ok: true,
+    value: {
+      size,
+      domainMin,
+      domainMax,
+      values: new Float32Array(values),
+      sourceKey
+    }
+  };
+}
+function cubeLutBytes(lut) {
+  const bytes = new Uint8Array(lut.size ** 3 * 4 * 2);
+  const view = new DataView(bytes.buffer);
+  for (let index = 0; index < lut.size ** 3; index += 1) {
+    const valueOffset = index * 3;
+    const byteOffset = index * 8;
+    view.setUint16(byteOffset, float32ToFloat16(lut.values[valueOffset] ?? 0), true);
+    view.setUint16(byteOffset + 2, float32ToFloat16(lut.values[valueOffset + 1] ?? 0), true);
+    view.setUint16(byteOffset + 4, float32ToFloat16(lut.values[valueOffset + 2] ?? 0), true);
+    view.setUint16(byteOffset + 6, 15360, true);
+  }
+  return bytes;
+}
+
+// src/lut/cube-producer.ts
+function produceCubeTexture(input, source) {
+  const parsed = parseCubeLut(source, input.sourceKey);
+  if (!parsed.ok) return parsed;
+  const bytes = cubeLutBytes(parsed.value);
+  return {
+    ok: true,
+    value: {
+      guid: input.guid,
+      kind: "texture",
+      payload: {
+        kind: "texture",
+        shape: {
+          viewDimension: "3d",
+          extent: { width: parsed.value.size, height: parsed.value.size, depth: parsed.value.size }
+        },
+        format: "rgba16float",
+        data: bytes,
+        colorSpace: "linear",
+        mips: { kind: "none" }
+      },
+      refs: [],
+      artifacts: {
+        body: {
+          mediaType: "application/x-forgeax-rgba16float",
+          assetCodec: { name: "rgba16float", version: "1" },
+          bytes
+        }
+      }
+    }
+  };
+}
+async function importCubeSource(ctx) {
+  const subAsset = ctx.subAssets.length === 1 ? ctx.subAssets[0] : void 0;
+  if (subAsset === void 0 || subAsset.kind !== "texture" || subAsset.sourceIndex !== 0) {
+    return {
+      ok: false,
+      error: new ImportError({
+        code: "source-validation-failed",
+        expected: "one texture subAsset at sourceIndex 0",
+        actual: JSON.stringify(ctx.subAssets),
+        hint: IMPORT_ERROR_HINTS["source-validation-failed"],
+        detail: {
+          diagnostics: [
+            {
+              code: "cube-subasset-topology",
+              severity: "error",
+              sourcePath: `${ctx.source}#subAssets`,
+              sourceRange: { start: 0, end: 0, line: 1, column: 1 },
+              rule: "cube-required-single-texture",
+              expected: "one texture subAsset at sourceIndex 0",
+              actual: JSON.stringify(ctx.subAssets),
+              hint: "declare one ordinary texture subAsset and retry the same sourceKey"
+            }
+          ]
+        }
+      })
+    };
+  }
+  const source = await ctx.readSource();
+  if (!source.ok) {
+    return {
+      ok: false,
+      error: new ImportError({
+        code: "source-read-failed",
+        expected: `readable .cube source at "${ctx.source}"`,
+        actual: String(source.error),
+        hint: IMPORT_ERROR_HINTS["source-read-failed"],
+        detail: { source: ctx.source, reason: String(source.error) }
+      })
+    };
+  }
+  const produced = produceCubeTexture(
+    {
+      source: ctx.source,
+      sourceKey: subAsset.sourceKey ?? `${ctx.source}:texture`,
+      guid: subAsset.guid
+    },
+    new TextDecoder().decode(source.value)
+  );
+  if (!produced.ok) {
+    return {
+      ok: false,
+      error: new ImportError({
+        code: "source-validation-failed",
+        expected: produced.error.expected,
+        actual: JSON.stringify(produced.error.detail),
+        hint: produced.error.hint,
+        detail: {
+          diagnostics: [
+            {
+              code: produced.error.code,
+              severity: "error",
+              sourcePath: `${ctx.source}#${produced.error.detail.field}`,
+              sourceRange: {
+                start: 0,
+                end: 0,
+                line: produced.error.detail.line ?? 1,
+                column: 1
+              },
+              rule: "cube-source-parser",
+              expected: produced.error.expected,
+              actual: JSON.stringify(produced.error.detail.actual),
+              hint: produced.error.hint
+            }
+          ]
+        }
+      })
+    };
+  }
+  return { ok: true, value: { assets: [produced.value], sourceDependencies: [ctx.source] } };
+}
+
 // src/parse-image.ts
 init_errors();
 
@@ -655,7 +936,7 @@ function mimeFromSource(source) {
 function requiredImageOutputKind(source) {
   const lower = source.toLowerCase();
   if (lower.endsWith(".hdr")) return "equirect";
-  if (mimeFromSource(source) !== void 0 || lower.endsWith(".basis") || lower.endsWith(".ktx2")) {
+  if (mimeFromSource(source) !== void 0 || lower.endsWith(".basis") || lower.endsWith(".ktx2") || lower.endsWith(".cube")) {
     return "texture";
   }
   return void 0;
@@ -1075,6 +1356,9 @@ async function importImage(ctx) {
   if (ctx.source.toLowerCase().endsWith(".texture.json")) {
     return importTextureSource(ctx);
   }
+  if (ctx.source.toLowerCase().endsWith(".cube")) {
+    return importCubeSource(ctx);
+  }
   const requiredKind = requiredImageOutputKind(ctx.source);
   if (requiredKind !== void 0) {
     const topologyError = validateImageOutputTopology(ctx, requiredKind);
@@ -1284,6 +1568,6 @@ var imageImporter = {
   capabilities: { decodeImage: decodeImageForImport }
 };
 
-export { decodeImageForImport, imageImporter };
+export { cubeLutBytes, decodeImageForImport, imageImporter, importCubeSource, parseCubeLut, produceCubeTexture };
 //# sourceMappingURL=image-importer.mjs.map
 //# sourceMappingURL=image-importer.mjs.map