@forgeax/engine-gltf 0.1.20 → 0.1.23

package/dist/index.d.ts

@@ -10,6 +10,8 @@ export { checkExtensions, EXTENSION_ALLOWLIST } from './check-extensions.js';
 export type { GltfAccessorTypeMismatchDetail, GltfAnimationCubicsplineUnsupportedDetail, GltfBufferOutOfBoundsDetail, GltfColorAccessorMalformedDetail, GltfColorAccessorUnsupportedDetail, GltfError, GltfErrorCode, GltfErrorDetail, GltfExtensionUnsupportedDetail, GltfImageExtractFailedDetail, GltfImageMimeUnsupportedDetail, GltfInstancingCountMismatchDetail, GltfMalformedHeaderDetail, GltfMaterialTransmissionInvalidDetail, GltfMetaMissingDetail, GltfMorphInvalidDetail, GltfMorphUnsupportedDetail, GltfSkinAttrAsymmetricDetail, GltfSkinJointCountExceededDetail, GltfSkinJointNameMissingDetail, GltfTextureLoadFailedDetail, GltfVersionUnsupportedDetail, Result, } from './errors.js';
 export { err, GLTF_ERROR_HINTS, gltfErr, ok } from './errors.js';
 export { gltfImporter } from './gltf-importer.js';
+export { type GltfLodRelation, parseGltfLodExtension } from './lod/parse-lod.js';
+export { projectGltfLodMeta } from './lod/project-meta.js';
 export type { GlbChunks } from './parse-glb-chunks.js';
 export { parseGlbChunks, parseGltfHeader } from './parse-glb-chunks.js';
 export type { ExternalLoader, GltfAssetPack, GltfAssetPackResult, GltfDiagnosticsIr, GltfDoc, GltfImageIr, GltfMaterialIr, GltfMeshIr, GltfNodeIr, GltfNormalTextureInfoIr, GltfOcclusionTextureInfoIr, GltfSamplerIr, GltfSceneIr, GltfTextureInfoIr, GltfTextureIr, GltfTextureTransformIr, MeshJson, MeshPrimitiveJson, NodeInstancingIr, } from './parse-gltf.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.mjs

@@ -3,6 +3,7 @@ export { err, ok } from '@forgeax/engine-types';
 import { packInterleavedVertexAttributes } from '@forgeax/engine-geometry';
 import { box3, mat4, vec3, quat } from '@forgeax/engine-math';
 import { AssetGuid } from '@forgeax/engine-pack/guid';
+import { deriveDefaultLodScreenCoverages, reconcileMeshLodMeta } from '@forgeax/engine-import';
 import { packMeshBinV4 } from '@forgeax/engine-import/mesh-bin';
 import { deriveAnimationTargetId } from '@forgeax/engine-animation/target-id';
 
@@ -26,6 +27,10 @@ var gltfErrorPolicy = {
     expected: "extension listed in v1 allowlist (see EXTENSION_ALLOWLIST in @forgeax/engine-gltf)",
     hint: "see feat-future-gltf-extensions-allowlist; remove this extension or wait for the allowlist to expand"
   },
+  "gltf-lod-invalid": {
+    expected: "MSFT_lod ids to reference unique existing node indices with valid coverage",
+    hint: "repair the MSFT_lod node relation or remove it from extensionsRequired before re-importing"
+  },
   "gltf-material-transmission-invalid": {
     expected: "KHR transmission, IOR, and volume values are finite and within their glTF ranges",
     hint: "repair the named glTF material extension value and re-import the source"
@@ -966,7 +971,9 @@ function toMaterialAsset(mat, ctx) {
 // src/check-extensions.ts
 var EXTENSION_ALLOWLIST = [
   "EXT_mesh_gpu_instancing",
-  "EXT_meshopt_compression"
+  "EXT_meshopt_compression",
+  "MSFT_lod",
+  "MSFT_screencoverage"
 ];
 var SUPPORTED_EXTENSIONS = [
   ...EXTENSION_ALLOWLIST,
@@ -1169,8 +1176,8 @@ function parseGlbChunks(buffer, filePath) {
 
 // src/extract-image-bytes.ts
 var DATA_URI_MIME_RE = /^data:([^;,]+)(?:;[^,;]+)*;base64,/;
-function describeImportError(err2) {
-  return err2.message;
+function describeImportError(err3) {
+  return err3.message;
 }
 function classifyMime(declaredMime, bytes) {
   if (declaredMime === "image/png" || declaredMime === "image/jpeg") return declaredMime;
@@ -1424,6 +1431,103 @@ function deriveTextureColorSpace(input) {
   return result;
 }
 
+// src/lod/parse-lod.ts
+function parseGltfLodExtension(json) {
+  const doc = json;
+  const nodes = doc.nodes ?? [];
+  const rawCoverage = doc.extensions?.MSFT_screencoverage?.scales;
+  const groups = [];
+  for (let rootNode = 0; rootNode < nodes.length; rootNode += 1) {
+    if (nodes[rootNode]?.extensions?.MSFT_lod === void 0) continue;
+    const idsRaw = nodes[rootNode]?.extensions?.MSFT_lod?.ids;
+    if (!Array.isArray(idsRaw)) {
+      return err(gltfErr("gltf-lod-invalid", { rootNode, ids: [], reason: "not-integer" }));
+    }
+    const ids = idsRaw.filter((value) => typeof value === "number");
+    if (ids.length !== idsRaw.length || ids.some((id) => !Number.isInteger(id) || id < 0 || id >= nodes.length)) {
+      return err(gltfErr("gltf-lod-invalid", { rootNode, ids, reason: "missing-node" }));
+    }
+    if (new Set(ids).size !== ids.length || ids.includes(rootNode)) {
+      return err(gltfErr("gltf-lod-invalid", { rootNode, ids, reason: "duplicate-node" }));
+    }
+    const hasMesh = (node) => {
+      if (typeof node?.mesh !== "number" || !Number.isInteger(node.mesh) || node.mesh < 0) {
+        return false;
+      }
+      const mesh = doc.meshes?.[node.mesh];
+      return mesh !== void 0 && Array.isArray(mesh.primitives) && mesh.primitives.length > 0;
+    };
+    if (!hasMesh(nodes[rootNode]) || ids.some((id) => !hasMesh(nodes[id]))) {
+      return err(gltfErr("gltf-lod-invalid", { rootNode, ids, reason: "missing-node" }));
+    }
+    const nodeCoverage = nodes[rootNode]?.extras?.MSFT_screencoverage;
+    const coverage = normalizeScreenCoverages(
+      nodeCoverage === void 0 ? rawCoverage : nodeCoverage,
+      ids.length,
+      nodeCoverage !== void 0
+    );
+    if (coverage === "invalid") {
+      return err(gltfErr("gltf-lod-invalid", { rootNode, ids, reason: "coverage" }));
+    }
+    groups.push({
+      rootNode,
+      lodNodeIds: ids,
+      screenCoverages: coverage ?? []
+    });
+  }
+  const first = groups[0];
+  if (first === void 0) {
+    if (doc.extensionsRequired?.some((extension) => extension === "MSFT_lod")) {
+      return err(gltfErr("gltf-lod-invalid", { rootNode: 0, ids: [], reason: "missing-node" }));
+    }
+    return ok({ rootNode: 0, lodNodeIds: [], screenCoverages: [], groups: [] });
+  }
+  return ok({
+    rootNode: first.rootNode,
+    lodNodeIds: first.lodNodeIds,
+    screenCoverages: first.screenCoverages,
+    groups
+  });
+}
+function normalizeScreenCoverages(raw, lodCount, officialNodeForm) {
+  if (raw === void 0) return void 0;
+  if (!Array.isArray(raw)) return "invalid";
+  if (raw.some(
+    (value) => typeof value !== "number" || !Number.isFinite(value) || value <= 0 || value > 1
+  )) {
+    return "invalid";
+  }
+  const expectedLengths = officialNodeForm ? [lodCount + 1] : [lodCount, lodCount + 1];
+  if (!expectedLengths.includes(raw.length)) return "invalid";
+  const values = raw.slice(0, lodCount);
+  for (let index = 1; index < values.length; index += 1) {
+    if (values[index] >= values[index - 1]) return "invalid";
+  }
+  return values;
+}
+function projectGltfLodMeta(input) {
+  const defaults = deriveDefaultLodScreenCoverages(input.levels.length + 1);
+  const previous = (input.previous ?? []).map((level) => ({
+    sourceKey: level.sourceKey,
+    meshGuid: level.guid,
+    ...level.screenCoverage === void 0 ? {} : { screenCoverage: level.screenCoverage }
+  }));
+  const next = input.levels.map((level, index) => ({
+    sourceKey: level.sourceKey,
+    meshGuid: level.guid,
+    screenCoverage: level.screenCoverage ?? defaults[index] ?? 0
+  }));
+  const reconciled = reconcileMeshLodMeta(previous, next);
+  if (!reconciled.ok) return err({ code: reconciled.error.code, reason: reconciled.error.reason });
+  return ok({
+    lods: reconciled.value.lods.map((level) => ({
+      sourceKey: level.sourceKey,
+      meshGuid: level.meshGuid,
+      screenCoverage: level.screenCoverage
+    }))
+  });
+}
+
 // src/material/parse-material.ts
 function tuple2(values) {
   if (values === void 0 || values.length < 2) return void 0;
@@ -2336,6 +2440,8 @@ async function parseGltfWithBin(json, ctx) {
   const extResult = checkExtensions(json);
   if (!extResult.ok) return err(extResult.error);
   const unsupportedExtensions = extResult.value.unsupportedUsed;
+  const lodResult = parseGltfLodExtension(json);
+  if (!lodResult.ok) return err(lodResult.error);
   const lightsResult = parsePunctualLights(json, ctx.filePath);
   if (!lightsResult.ok) return err(lightsResult.error);
   const meshesJson = json.meshes ?? [];
@@ -2876,7 +2982,8 @@ async function parseGltfWithBin(json, ctx) {
       matrixTrsCoexistNodes: diagnostics.matrixTrsCoexistNodes
     },
     meshPrimitiveCount,
-    lights: lightsResult.value
+    lights: lightsResult.value,
+    ...lodResult.value.lodNodeIds.length === 0 ? {} : { lod: lodResult.value }
   });
 }
 async function parseGltfForImporter(json, externalLoader, filePath, options = {}) {
@@ -3015,6 +3122,74 @@ function toAssetPack(doc, existingMeta, source) {
   const sourceOverrides = {
     ...existingMeta?.sourceOverrides ?? {}
   };
+  const lodGroups = doc.lod === void 0 ? [] : doc.lod.groups.length > 0 ? doc.lod.groups : [doc.lod];
+  for (const lodGroup of lodGroups) {
+    if (lodGroup.lodNodeIds.length === 0) continue;
+    const rootMeshIndex = doc.nodes[lodGroup.rootNode]?.meshIndex;
+    const referencedMeshIndices = [
+      rootMeshIndex,
+      ...lodGroup.lodNodeIds.map((nodeIndex) => doc.nodes[nodeIndex]?.meshIndex)
+    ];
+    if (referencedMeshIndices.some(
+      (meshIndex) => !Number.isInteger(meshIndex) || meshIndex === null || meshIndex === void 0 || !seenMeshIndices.has(meshIndex)
+    )) {
+      return err(
+        gltfErr("gltf-lod-invalid", {
+          rootNode: lodGroup.rootNode,
+          ids: lodGroup.lodNodeIds,
+          reason: "missing-node"
+        })
+      );
+    }
+    const rootOutput = rootMeshIndex === void 0 || rootMeshIndex === null ? void 0 : subAssetByKindIndex.get(`mesh:${rootMeshIndex}`);
+    const levels = lodGroup.lodNodeIds.map((nodeIndex, index) => {
+      const meshIndex = doc.nodes[nodeIndex]?.meshIndex;
+      const output = meshIndex === void 0 || meshIndex === null ? void 0 : subAssetByKindIndex.get(`mesh:${meshIndex}`);
+      return {
+        sourceKey: output?.sourceKey ?? `mesh:${meshIndex ?? nodeIndex}`,
+        meshGuid: output?.guid ?? "",
+        ...lodGroup.screenCoverages[index] === void 0 ? {} : { screenCoverage: lodGroup.screenCoverages[index] }
+      };
+    });
+    if (rootOutput?.sourceKey !== void 0 && levels.every((level) => level.meshGuid !== "")) {
+      const previousLodMeta = (() => {
+        const raw = existingMeta?.sourceOverrides?.[rootOutput.sourceKey]?.lods;
+        if (!Array.isArray(raw)) return void 0;
+        return raw.flatMap((entry) => {
+          if (entry === null || typeof entry !== "object") return [];
+          const value = entry;
+          return typeof value.sourceKey === "string" && typeof value.meshGuid === "string" ? [
+            {
+              sourceKey: value.sourceKey,
+              guid: value.meshGuid,
+              ...typeof value.screenCoverage === "number" ? { screenCoverage: value.screenCoverage } : {}
+            }
+          ] : [];
+        });
+      })();
+      const projected = projectGltfLodMeta({
+        rootSourceKey: rootOutput.sourceKey,
+        levels: levels.map((level) => ({
+          sourceKey: level.sourceKey,
+          guid: level.meshGuid,
+          ...level.screenCoverage === void 0 ? {} : { screenCoverage: level.screenCoverage }
+        })),
+        ...previousLodMeta === void 0 ? {} : { previous: previousLodMeta }
+      });
+      if (!projected.ok)
+        return err(
+          gltfErr("gltf-lod-invalid", {
+            rootNode: lodGroup.rootNode,
+            ids: lodGroup.lodNodeIds,
+            reason: "coverage"
+          })
+        );
+      sourceOverrides[rootOutput.sourceKey] = {
+        ...sourceOverrides[rootOutput.sourceKey] ?? {},
+        lods: projected.value.lods
+      };
+    }
+  }
   for (const meshIndex of seenMeshIndices) {
     const meshOutput = subAssetByKindIndex.get(`mesh:${meshIndex}`);
     if (meshOutput?.sourceKey === void 0) continue;
@@ -3456,7 +3631,55 @@ async function importGltf(ctx, meshopt) {
           })
         };
       }
-      const meshPayload = stabilizeMeshMaterialSlots(bridged.value, ctx, sub.guid, sub.sourceKey);
+      const stabilizedMesh = stabilizeMeshMaterialSlots(
+        bridged.value,
+        ctx,
+        sub.guid,
+        sub.sourceKey
+      );
+      const lodGroup = doc.lod?.groups?.find(
+        (group) => doc.nodes[group.rootNode]?.meshIndex === sub.sourceIndex
+      ) ?? (doc.lod?.rootNode !== void 0 && doc.nodes[doc.lod.rootNode]?.meshIndex === sub.sourceIndex ? doc.lod : void 0);
+      const rootMeshIndex = lodGroup === void 0 ? void 0 : sub.sourceIndex;
+      if (lodGroup !== void 0) {
+        const referencedMeshIndices = [
+          sub.sourceIndex,
+          ...lodGroup.lodNodeIds.map((nodeIndex) => doc.nodes[nodeIndex]?.meshIndex)
+        ];
+        const missingMeshIndex = referencedMeshIndices.find(
+          (meshIndex) => !Number.isInteger(meshIndex) || meshIndex === null || meshIndex === void 0 || maps.meshGuidByIndex.get(meshIndex) === void 0
+        );
+        if (missingMeshIndex !== void 0) {
+          return {
+            ok: false,
+            error: new ImportError({
+              code: "import-internal-error",
+              expected: "every MSFT_lod node to resolve a cooked mesh sub-asset",
+              actual: String(missingMeshIndex),
+              hint: "repair the referenced glTF mesh primitives and re-run the importer",
+              detail: {
+                reason: `MSFT_lod group for mesh ${sub.sourceIndex} references an unprojected mesh`
+              }
+            })
+          };
+        }
+      }
+      const authoredLods = sub.sourceKey === void 0 ? void 0 : ctx.sourceOverrides?.[sub.sourceKey]?.lods;
+      const lodEntries = Array.isArray(authoredLods) ? authoredLods : [];
+      const lodLevels = rootMeshIndex === sub.sourceIndex && lodGroup !== void 0 ? lodGroup.lodNodeIds.flatMap((nodeIndex, index) => {
+        const meshIndex = doc.nodes[nodeIndex]?.meshIndex;
+        const guid = meshIndex === void 0 || meshIndex === null ? void 0 : maps.meshGuidByIndex.get(meshIndex);
+        if (guid === void 0) return [];
+        const authored = lodEntries[index];
+        const authoredCoverage = authored !== null && typeof authored === "object" ? authored.screenCoverage : void 0;
+        const coverage = typeof authoredCoverage === "number" ? authoredCoverage : lodGroup.screenCoverages[index] ?? deriveDefaultLodScreenCoverages(lodGroup.lodNodeIds.length + 1)[index];
+        const parsed2 = AssetGuid.parse(guid);
+        return parsed2.ok && coverage !== void 0 ? [{ mesh: parsed2.value, screenCoverage: coverage, guid }] : [];
+      }) : [];
+      const meshPayload = lodLevels.length === 0 ? stabilizedMesh : {
+        ...stabilizedMesh,
+        lods: lodLevels.map(({ mesh, screenCoverage }) => ({ mesh, screenCoverage }))
+      };
       const materialRefs = [];
       const seenMaterialGuids = /* @__PURE__ */ new Set();
       for (let slotIndex = 0; slotIndex < meshPayload.materialSlots.length; slotIndex++) {
@@ -3470,6 +3693,15 @@ async function importGltf(ctx, meshopt) {
           });
         }
       }
+      for (const [lodIndex, level] of lodLevels.entries()) {
+        if (!seenMaterialGuids.has(level.guid.toLowerCase())) {
+          seenMaterialGuids.add(level.guid.toLowerCase());
+          materialRefs.push({
+            guid: level.guid,
+            sourceField: { fieldName: "lods", arrayIndex: lodIndex }
+          });
+        }
+      }
       out.push({
         guid: sub.guid,
         kind: "mesh",
@@ -3773,6 +4005,6 @@ function serializeMetaJson(meta) {
 `;
 }
 
-export { COMPONENT_TYPE, EXTENSION_ALLOWLIST, GLTF_ERROR_HINTS, checkExtensions, decodeAccessor, decodeColorAccessor, decomposeNodeTransform, deriveGltfSourceKeys, gltfDocToSceneAsset, gltfErr, gltfImporter, meshIrToMeshAsset, parseGlb, parseGlbChunks, parseGltf, parseGltfHeader, reimportReuseMeta, serializeMetaJson, sourceKeyForGltfOutput, subAssetKey, toAssetPack, toMaterialAsset };
+export { COMPONENT_TYPE, EXTENSION_ALLOWLIST, GLTF_ERROR_HINTS, checkExtensions, decodeAccessor, decodeColorAccessor, decomposeNodeTransform, deriveGltfSourceKeys, gltfDocToSceneAsset, gltfErr, gltfImporter, meshIrToMeshAsset, parseGlb, parseGlbChunks, parseGltf, parseGltfHeader, parseGltfLodExtension, projectGltfLodMeta, reimportReuseMeta, serializeMetaJson, sourceKeyForGltfOutput, subAssetKey, toAssetPack, toMaterialAsset };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map