@forgeax/engine-fbx 0.1.4 → 0.1.7

package/src/to-asset-pack.ts

@@ -12,13 +12,10 @@ import { box3 } from '@forgeax/engine-math';
 import { AssetGuid } from '@forgeax/engine-pack/guid';
 import type {
   AnimationClipPod,
-  AssetCodec,
   AssetRef,
   ImportedAsset,
   MaterialAsset,
   MaterialPod,
-  MaterialTextureBindingPod,
-  MaterialTextureValue,
   MeshAsset,
   MeshMaterialSlot,
   MeshMaterialSlotTopologyEntry,
@@ -28,7 +25,6 @@ import type {
   SkeletonPod,
   SkinPod,
   SourceOverrideMap,
-  TextureAsset,
   TexturePod,
 } from '@forgeax/engine-types';
 import {
@@ -346,61 +342,11 @@ export function buildMeshAsset(
   };
 }
 
-export interface FbxDecodedTexture {
-  readonly texture: TextureAsset;
-  readonly bytes: Uint8Array;
-  readonly mediaType?: string;
-  readonly assetCodec?: AssetCodec;
-}
-
-function materialBindings(pod: MaterialPod): readonly MaterialTextureBindingPod[] {
-  if (pod.textureBindings !== undefined) return pod.textureBindings;
-  const bindings: MaterialTextureBindingPod[] = [];
-  const legacy: readonly [MaterialTextureBindingPod['slot'], number | undefined][] = [
-    ['baseColorTexture', pod.baseColorTextureIndex],
-    ['metallicRoughnessTexture', pod.metallicRoughnessTextureIndex],
-    ['normalTexture', pod.normalTextureIndex],
-    ['specularTintTexture', pod.specularTintTextureIndex],
-    ['emissiveTexture', pod.emissiveTextureIndex],
-    ['occlusionTexture', pod.occlusionTextureIndex],
-  ];
-  for (const [slot, textureIndex] of legacy) {
-    if (textureIndex !== undefined) bindings.push({ slot, textureIndex });
-  }
-  return bindings;
-}
-
-function buildMaterialAsset(
-  pod: MaterialPod,
-  guid: string,
-  skinned = false,
-  textureGuidByIndex: ReadonlyMap<number, string> = new Map(),
-): ImportedAsset {
+function buildMaterialAsset(pod: MaterialPod, guid: string, skinned = false): ImportedAsset {
   // A material consumed by a skinned mesh must select the pbr-skin shader so the
   // runtime PSO chain (LayoutKind 'pbr-skin' + 18-float vertex layout + joint
   // palette) is exercised; the render-system fail-fasts otherwise (mirror of
   // gltfImporter's `skinned` routing).
-  const values: Record<string, NonNullable<MaterialAsset['values']>[string]> = {
-    baseColor: pod.baseColorFactor as readonly [number, number, number, number],
-    metallic: pod.metallicFactor,
-    roughness: pod.roughnessFactor,
-  };
-  const refs: AssetRef[] = [];
-  for (const binding of materialBindings(pod)) {
-    const textureGuid = textureGuidByIndex.get(binding.textureIndex);
-    if (textureGuid === undefined) continue;
-    const textureValue: MaterialTextureValue = {
-      // Runtime material loading interprets texture handles as indexes into
-      // this asset's refs[]; the GUID is carried by the corresponding edge.
-      texture: refs.length as unknown as MaterialTextureValue['texture'],
-      ...(binding.texCoord === undefined ? {} : { coordinates: { set: binding.texCoord } }),
-    };
-    values[binding.slot] = textureValue;
-    refs.push({
-      guid: textureGuid,
-      sourceField: { componentName: '<material>', fieldName: binding.slot },
-    });
-  }
   const mat: MaterialAsset = {
     kind: 'material',
     colorSpace: 'linear',
@@ -411,14 +357,18 @@ function buildMaterialAsset(
         renderState: { tags: { LightMode: 'Forward' }, queue: 2000 },
       },
     ],
-    values,
+    values: {
+      baseColor: pod.baseColorFactor as readonly [number, number, number, number],
+      metallic: pod.metallicFactor,
+      roughness: pod.roughnessFactor,
+    },
   };
   return {
     guid,
     kind: 'material',
     ...(pod.name !== undefined ? { name: pod.name } : {}),
     payload: mat,
-    refs,
+    refs: [],
     artifacts: {},
   };
 }
@@ -434,7 +384,7 @@ interface SceneBuildContext {
   readonly refs: readonly string[];
   /**
    * Skin GUIDs (inline strings) injected into the SceneAsset payload and the
-   * scene envelope's refs[] so the typed scene load pulls each
+   * scene envelope's refs[] so the runtime recursive loadByGuid walk pulls each
    * SkinAsset on the browser-async pack-fetch path. Mirrors gltf-importer:
    * stored as GUID strings (the on-disk round-trip + parseScenePayload's
    * resolveSkinGuids accept both shapes).
@@ -528,26 +478,18 @@ function buildSceneAsset(pod: ScenePod, guid: string, ctx: SceneBuildContext): I
   };
 }
 
-function buildTextureAsset(
-  pod: TexturePod,
-  guid: string,
-  decoded: FbxDecodedTexture,
-): ImportedAsset {
+// M3: TextureAsset requires decoded pixel data — deferred to M4.
+// TexturePod.filePath is preserved for diagnostics during M3.
+function buildTextureNote(_pod: TexturePod, _guid: string): ImportedAsset {
+  // Produce a minimal placeholder; real texture import (decode + upload)
+  // lands with M4 material parsing.
   return {
-    guid,
+    guid: _guid,
     kind: 'texture',
-    ...(pod.name !== undefined ? { name: pod.name } : {}),
-    payload: decoded.texture,
+    ...(_pod.name !== undefined ? { name: _pod.name } : {}),
+    payload: {} as never,
     refs: [],
-    artifacts: {
-      body: {
-        mediaType: decoded.mediaType?.startsWith('image/ktx2')
-          ? decoded.mediaType
-          : 'application/x-forgeax-rgba8',
-        ...(decoded.assetCodec === undefined ? {} : { assetCodec: decoded.assetCodec }),
-        bytes: decoded.bytes,
-      },
-    },
+    artifacts: {},
   };
 }
 
@@ -561,14 +503,9 @@ export function toAssetPack(params: {
   readonly animationClips: readonly AnimationClipPod[];
   readonly subAssets: readonly SubAsset[];
   readonly sourceOverrides?: SourceOverrideMap;
-  readonly decodedTextures?: ReadonlyMap<number, FbxDecodedTexture>;
 }): readonly ImportedAsset[] {
   const assets: ImportedAsset[] = [];
   const guidOf = makeGuidResolver(params.subAssets);
-  const textureGuidByIndex = new Map<number, string>();
-  for (const texture of params.subAssets) {
-    if (texture.kind === 'texture') textureGuidByIndex.set(texture.sourceIndex, texture.guid);
-  }
   const materialGuidByIndex = new Map<number, string>();
   const materialNameByIndex = new Map<number, string>();
   const materialSourceKeyByIndex = new Map<number, string>();
@@ -642,20 +579,12 @@ export function toAssetPack(params: {
     if (!mat) continue;
     const guid = guidOf('material', i);
     // Single-mesh fixtures: any material is consumed by the skinned mesh.
-    if (guid !== undefined) {
-      assets.push(buildMaterialAsset(mat, guid, hasSkin, textureGuidByIndex));
-    }
+    if (guid !== undefined) assets.push(buildMaterialAsset(mat, guid, hasSkin));
   }
 
   for (const tex of params.textures) {
     const guid = guidOf('texture', tex.sourceIndex);
-    if (guid !== undefined) {
-      const decoded = params.decodedTextures?.get(tex.sourceIndex);
-      if (decoded === undefined) {
-        throw new Error(`fbx texture ${tex.sourceIndex} was declared but not decoded`);
-      }
-      assets.push(buildTextureAsset(tex, guid, decoded));
-    }
+    if (guid !== undefined) assets.push(buildTextureNote(tex, guid));
   }
 
   // Scene refs[] ordering (mirror of gltfImporter): only direct scene

package/dist/__tests__/asset-runtime-fixture.d.ts

@@ -1,9 +0,0 @@
-import { type AssetRegistry } from '@forgeax/engine-assets-runtime';
-import { type DdcPack } from '@forgeax/engine-import';
-import type { AssetDecoder, MeshAsset } from '@forgeax/engine-types';
-type FixtureAsset = DdcPack['assets'][number];
-export declare const normalizedMeshAssetDecoder: AssetDecoder<MeshAsset>;
-export declare function installMeshDecoder(assets: AssetRegistry): import("@forgeax/engine-types").AssetDecoderLease;
-export declare function createAssetRuntimeFixture(sourceAssets: readonly FixtureAsset[]): AssetRegistry;
-export {};
-//# sourceMappingURL=asset-runtime-fixture.d.ts.map

package/dist/__tests__/asset-runtime-fixture.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asset-runtime-fixture.d.ts","sourceRoot":"","sources":["../../src/__tests__/asset-runtime-fixture.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,aAAa,EAGnB,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,KAAK,OAAO,EAAoB,MAAM,wBAAwB,CAAC;AACxE,OAAO,KAAK,EACV,YAAY,EAEZ,SAAS,EAIV,MAAM,uBAAuB,CAAC;AAwB/B,KAAK,YAAY,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC;AA4F9C,eAAO,MAAM,0BAA0B,EAAE,YAAY,CAAC,SAAS,CAqB9D,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,qDAEvD;AAwCD,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,SAAS,YAAY,EAAE,GAAG,aAAa,CAsD9F"}

package/src/__tests__/asset-runtime-fixture.ts

@@ -1,251 +0,0 @@
-import { createHash } from 'node:crypto';
-import {
-  type AssetRegistry,
-  createAssetRegistry,
-  createCatalogSource,
-} from '@forgeax/engine-assets-runtime';
-import { meshAssetDecoder, meshAssetKind } from '@forgeax/engine-geometry';
-import { type DdcPack, normaliseForPack } from '@forgeax/engine-import';
-import type {
-  AssetDecoder,
-  AssetLoadError,
-  MeshAsset,
-  MorphTarget,
-  Result,
-  VertexAttributeMap,
-} from '@forgeax/engine-types';
-import { err } from '@forgeax/engine-types';
-
-const SCOPE_ID = 'fbx-test-scope';
-const GENERATION = 1;
-const PACK_DIGEST = `sha256:${'4'.repeat(64)}`;
-const OUTPUT_SET_DIGEST = `sha256:${'5'.repeat(64)}`;
-const OUTPUT_DIGEST = `sha256:${'6'.repeat(64)}`;
-const ATTRIBUTE_KEYS = [
-  'position',
-  'normal',
-  'uv',
-  'tangent',
-  'skinIndex',
-  'skinWeight',
-  'uv1',
-  'uv2',
-  'uv3',
-  'uv4',
-  'uv5',
-  'uv6',
-  'uv7',
-] as const;
-
-type FixtureAsset = DdcPack['assets'][number];
-
-function sha256(bytes: Uint8Array): string {
-  return `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
-}
-
-function floatArray(value: unknown): Float32Array | undefined {
-  if (value instanceof Float32Array) return value;
-  if (value instanceof ArrayBuffer) return new Float32Array(value);
-  if (ArrayBuffer.isView(value))
-    return new Float32Array(Array.from(value as unknown as ArrayLike<number>));
-  if (Array.isArray(value)) return new Float32Array(value as number[]);
-  return undefined;
-}
-
-function indexArray(value: unknown): Uint16Array | Uint32Array | undefined {
-  if (value instanceof Uint16Array || value instanceof Uint32Array) return value;
-  if (ArrayBuffer.isView(value) || Array.isArray(value)) {
-    const values = Array.from(value as unknown as ArrayLike<number>);
-    return values.some((entry) => entry > 0xffff)
-      ? new Uint32Array(values)
-      : new Uint16Array(values);
-  }
-  return undefined;
-}
-
-function integerAttribute(value: unknown): Uint16Array | undefined {
-  if (value instanceof Uint16Array) return value;
-  if (Array.isArray(value) || ArrayBuffer.isView(value)) {
-    return new Uint16Array(Array.from(value as unknown as ArrayLike<number>));
-  }
-  return undefined;
-}
-
-function morphTarget(value: unknown): MorphTarget | undefined {
-  if (value === null || typeof value !== 'object') return undefined;
-  const source = value as Record<string, unknown>;
-  const position = floatArray(source.position);
-  const normal = floatArray(source.normal);
-  const tangent = floatArray(source.tangent);
-  return {
-    ...(position === undefined ? {} : { position }),
-    ...(normal === undefined ? {} : { normal }),
-    ...(tangent === undefined ? {} : { tangent }),
-  };
-}
-
-function meshPayload(value: unknown): MeshAsset | undefined {
-  if (value === null || typeof value !== 'object') return undefined;
-  const source = value as Record<string, unknown>;
-  const rawAttributes = source.attributes;
-  if (
-    source.kind !== 'mesh' ||
-    floatArray(source.vertices) === undefined ||
-    rawAttributes === null ||
-    typeof rawAttributes !== 'object' ||
-    !Array.isArray(source.submeshes) ||
-    !Array.isArray(source.materialSlots)
-  ) {
-    return undefined;
-  }
-  const attributes: VertexAttributeMap = {};
-  const sourceAttributes = rawAttributes as Record<string, unknown>;
-  for (const key of ATTRIBUTE_KEYS) {
-    const raw = sourceAttributes[key];
-    if (raw === undefined) continue;
-    const converted = key === 'skinIndex' ? integerAttribute(raw) : floatArray(raw);
-    if (converted !== undefined) attributes[key] = converted;
-  }
-  const morphWeights = floatArray(source.morphWeights);
-  const morphTargets = Array.isArray(source.morphTargets)
-    ? source.morphTargets.flatMap((target) => {
-        const converted = morphTarget(target);
-        return converted === undefined ? [] : [converted];
-      })
-    : undefined;
-  const vertices = floatArray(source.vertices) as Float32Array;
-  const indices = indexArray(source.indices);
-  const aabb = floatArray(source.aabb);
-  return {
-    kind: 'mesh',
-    vertices,
-    ...(indices === undefined ? {} : { indices }),
-    attributes,
-    ...(aabb === undefined ? {} : { aabb }),
-    submeshes: source.submeshes as MeshAsset['submeshes'],
-    materialSlots: source.materialSlots as MeshAsset['materialSlots'],
-    ...(morphTargets === undefined ? {} : { morphTargets }),
-    ...(morphWeights === undefined ? {} : { morphWeights }),
-  };
-}
-
-export const normalizedMeshAssetDecoder: AssetDecoder<MeshAsset> = {
-  async decode(input): Promise<Result<MeshAsset, AssetLoadError>> {
-    const body = input.envelope.artifacts.body;
-    if (body !== undefined) {
-      const bytes = await input.artifacts.read(body);
-      if (!bytes.ok) return bytes;
-    }
-    const payload = meshPayload(input.envelope.payload);
-    if (payload === undefined) {
-      return err({
-        code: 'asset-package-invalid',
-        expected: 'a JSON-safe mesh payload that can be owned by Geometry',
-        hint: 'recook the mesh payload with typed vertex and attribute fields',
-        detail: { guid: input.envelope.guid, reason: 'mesh payload normalization failed' },
-      });
-    }
-    return meshAssetDecoder.decode({
-      ...input,
-      envelope: { ...input.envelope, payload },
-    });
-  },
-};
-
-export function installMeshDecoder(assets: AssetRegistry) {
-  return assets.installDecoder(meshAssetKind, normalizedMeshAssetDecoder);
-}
-
-function row(asset: FixtureAsset, packageUrl: string) {
-  const sourcePath = `fixtures/${asset.guid}`;
-  return {
-    guid: asset.guid,
-    packageUrl,
-    kind: asset.kind,
-    sourcePath,
-    revision: { rootId: 'fbx-fixture', digest: 'sha256:catalog', observedAt: 1 },
-    publication: {
-      schemaVersion: 'asset-publication/1' as const,
-      sourcePath,
-      sourceRevision: 'fbx-fixture-source',
-      generation: GENERATION,
-      digest: PACK_DIGEST,
-      outputSetDigest: OUTPUT_SET_DIGEST,
-      outputs: [
-        {
-          guid: asset.guid,
-          sourceKey: asset.sourceKey ?? asset.guid,
-          kind: asset.kind,
-          digest: OUTPUT_DIGEST,
-          refs: asset.refs,
-        },
-      ],
-      receipt: {
-        schemaVersion: 'asset-publication-receipt/1' as const,
-        sourcePath,
-        sourceRevision: 'fbx-fixture-source',
-        inputFingerprint: 'fbx-fixture-input',
-        outputDigest: OUTPUT_DIGEST,
-        outputSetDigest: OUTPUT_SET_DIGEST,
-        externalEvidence: [],
-      },
-      externalEvidence: [],
-    },
-  };
-}
-
-export function createAssetRuntimeFixture(sourceAssets: readonly FixtureAsset[]): AssetRegistry {
-  const packageUrl = 'https://assets.test/fbx-fixture.pack.json';
-  const artifactBytes = new Map<string, Uint8Array>();
-  const runtimeAssets = sourceAssets.map((asset) => {
-    const artifacts = Object.fromEntries(
-      Object.entries(asset.artifacts).map(([key, body]) => {
-        const path = `${asset.guid}/${key}.bin`;
-        const url = new URL(path, packageUrl).toString();
-        artifactBytes.set(url, body.bytes);
-        return [
-          key,
-          {
-            path,
-            mediaType: body.mediaType,
-            contentEncoding: 'identity' as const,
-            byteLength: body.bytes.byteLength,
-            integrity: { algorithm: 'sha256' as const, digest: sha256(body.bytes) },
-            ...(body.assetCodec === undefined ? {} : { assetCodec: body.assetCodec }),
-          },
-        ];
-      }),
-    );
-    return {
-      guid: asset.guid,
-      kind: asset.kind,
-      ...(asset.name === undefined ? {} : { name: asset.name }),
-      payload: normaliseForPack(asset.payload) as Record<string, unknown>,
-      refs: asset.refs,
-      artifacts,
-    };
-  });
-  const pack = {
-    schemaVersion: '2.0.0' as const,
-    kind: 'internal-text-package' as const,
-    scopeId: SCOPE_ID,
-    generation: GENERATION,
-    digest: PACK_DIGEST,
-    outputSetDigest: OUTPUT_SET_DIGEST,
-    assets: runtimeAssets,
-  };
-  const fetcher: typeof globalThis.fetch = async (input) => {
-    const url = String(input);
-    if (url === packageUrl) return new Response(JSON.stringify(pack));
-    const bytes = artifactBytes.get(url);
-    return bytes === undefined
-      ? new Response('not found', { status: 404 })
-      : new Response(bytes as unknown as BodyInit);
-  };
-  return createAssetRegistry({
-    catalog: createCatalogSource({ entries: sourceAssets.map((asset) => row(asset, packageUrl)) }),
-    fetcher,
-    scopeId: SCOPE_ID,
-    generation: GENERATION,
-  });
-}