@forgeax/engine-fbx 0.1.4 → 0.1.6

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,
-  });
-}