Skip to content

3D engine that AI agents drive

5.8 KB
Raw Blame
import assert from 'node:assert/strict';
import { test } from 'node:test';
import sharp from 'sharp';
import { declareWebpTextures, parseArguments, readGlb, recodeGlbTextures, writeGlb } from '../scripts/recode-glb-textures.mjs';

async function noisyJpeg(size) {
  const raw = Buffer.alloc(size * size * 3);
  for (let index = 0; index < raw.length; index++) raw[index] = (index * 31 + (index >> 7) * 17) & 255;
  return sharp(raw, { raw: { width: size, height: size, channels: 3 } }).jpeg({ quality: 95 }).toBuffer();
}

// One JPEG image and one stand-in for a meshopt buffer view, whose data lives in the extension and not in the view.
async function buildGlb(size) {
  const jpeg = await noisyJpeg(size);
  const geometry = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
  const padded = bytes => Buffer.concat([bytes, Buffer.alloc((4 - (bytes.length % 4)) % 4)]);
  const binary = Buffer.concat([padded(geometry), padded(jpeg)]);
  const json = {
    asset: { version: '2.0' },
    buffers: [{ byteLength: binary.length }, { byteLength: 8, extensions: { EXT_meshopt_compression: { fallback: true } } }],
    bufferViews: [
      { buffer: 1, byteOffset: 0, byteLength: 8, extensions: { EXT_meshopt_compression: { buffer: 0, byteOffset: 0, byteLength: 8, byteStride: 4, count: 2, mode: 'ATTRIBUTES' } } },
      { buffer: 0, byteOffset: padded(geometry).length, byteLength: jpeg.length },
    ],
    images: [{ bufferView: 1, mimeType: 'image/jpeg' }],
    textures: [{ source: 0, sampler: 0 }],
    extensionsUsed: ['EXT_meshopt_compression'],
    extensionsRequired: ['EXT_meshopt_compression'],
  };
  return { glb: writeGlb(json, binary), geometry, jpegBytes: jpeg.length };
}

test('parseArguments reads both options and rejects unknown ones', () => {
  const parsed = parseArguments(['in.glb', 'out.glb', '--webp-quality', '70', '--max-texture', '2048']);
  assert.deepEqual(parsed.options, { webpQuality: 70, maxTexture: 2048 });
  assert.throws(() => parseArguments(['in.glb', 'out.glb', '--bogus', '1']), /Unknown or invalid option/);
  assert.throws(() => parseArguments(['only-one.glb']), /Pass <input.glb> and <output.glb>/);
});

test('textures become WebP and the meshopt data stays byte for byte', async () => {
  const { glb, geometry } = await buildGlb(256);
  const result = await recodeGlbTextures(glb, { webpQuality: 60, maxTexture: 4096 });
  const { json, binary } = readGlb(result.glb);
  assert.equal(json.images[0].mimeType, 'image/webp');
  assert.ok(json.extensionsRequired.includes('EXT_texture_webp'));
  assert.deepEqual(json.textures[0], { sampler: 0, extensions: { EXT_texture_webp: { source: 0 } } });
  const meshopt = json.bufferViews[0].extensions.EXT_meshopt_compression;
  assert.deepEqual([...binary.subarray(meshopt.byteOffset, meshopt.byteOffset + meshopt.byteLength)], [...geometry]);
  const view = json.bufferViews[1];
  const metadata = await sharp(binary.subarray(view.byteOffset, view.byteOffset + view.byteLength)).metadata();
  assert.equal(metadata.format, 'webp');
  assert.ok(json.buffers[0].byteLength <= binary.length);
  assert.equal(json.buffers[0].byteLength % 4, 0);
});

test('a texture above the cap is scaled down, keeping its aspect ratio', async () => {
  const { glb } = await buildGlb(512);
  const { json, binary } = readGlb((await recodeGlbTextures(glb, { webpQuality: 60, maxTexture: 128 })).glb);
  const view = json.bufferViews[1];
  const metadata = await sharp(binary.subarray(view.byteOffset, view.byteOffset + view.byteLength)).metadata();
  assert.deepEqual([metadata.width, metadata.height], [128, 128]);
});

test('an image whose WebP would be larger is left as it was', async () => {
  const { glb } = await buildGlb(64);
  const unchanged = await recodeGlbTextures(glb, { webpQuality: 100, maxTexture: 4096 });
  const { json } = readGlb(unchanged.glb);
  if (json.images[0].mimeType === 'image/jpeg') assert.equal(unchanged.imageBytesAfter, unchanged.imageBytesBefore);
  else assert.ok(unchanged.imageBytesAfter < unchanged.imageBytesBefore);
});

test('declareWebpTextures moves only the WebP images into the extension and does nothing without any', () => {
  const json = {
    images: [{ mimeType: 'image/webp' }, { mimeType: 'image/png' }],
    textures: [{ source: 0 }, { source: 1, sampler: 2 }],
    extensionsUsed: ['KHR_mesh_quantization'],
  };
  declareWebpTextures(json);
  assert.deepEqual(json.textures[0], { extensions: { EXT_texture_webp: { source: 0 } } });
  assert.deepEqual(json.textures[1], { source: 1, sampler: 2 });
  assert.deepEqual(json.extensionsUsed, ['KHR_mesh_quantization', 'EXT_texture_webp']);
  assert.deepEqual(json.extensionsRequired, ['EXT_texture_webp']);

  const untouched = { images: [{ mimeType: 'image/png' }], textures: [{ source: 0 }] };
  declareWebpTextures(untouched);
  assert.deepEqual(untouched, { images: [{ mimeType: 'image/png' }], textures: [{ source: 0 }] });
});

test('parseArguments refuses a quality above 100 and a texture cap that is not a whole number', () => {
  assert.throws(() => parseArguments(['in.glb', 'out.glb', '--webp-quality', '150']), /webpQuality was 150; pass a whole number from 1 to 100/);
  assert.throws(() => parseArguments(['in.glb', 'out.glb', '--max-texture', '0.5']), /maxTexture was 0.5/);
});

test('an image that lives at a URI is left alone and the other images still convert', async () => {
  const { glb } = await buildGlb(256);
  const { json, binary } = readGlb(glb);
  json.images.unshift({ uri: 'external.png' });
  json.textures = [{ source: 1, sampler: 0 }, { source: 0 }];
  const result = await recodeGlbTextures(writeGlb(json, binary), { webpQuality: 60, maxTexture: 4096 });
  const recoded = readGlb(result.glb).json;
  assert.deepEqual(recoded.images[0], { uri: 'external.png' });
  assert.equal(recoded.images[1].mimeType, 'image/webp');
  assert.deepEqual(recoded.textures, [{ sampler: 0, extensions: { EXT_texture_webp: { source: 1 } } }, { source: 0 }]);
});