@loaders.gl/scene 5.0.0-alpha.8 → 5.0.0-beta.1

package/src/gltf/lib/api/validate-gltf-v1-buffers.ts

@@ -0,0 +1,139 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {GLTFWithBuffers} from '../types/gltf-types';
+import {
+  hasOpaqueGLTFV1Consumers,
+  validateGLTFV1AccessorSource,
+  type GLTFV1AccessorSource
+} from './repack-gltf-v1-accessors';
+
+/** Validate buffer spans and plan only loaded, bounded buffer and dense accessor-view lengths. */
+export function validateGLTFV1Buffers(
+  gltf: GLTFWithBuffers,
+  uriBufferIndices: ReadonlySet<number>,
+  reportUnsupported: (feature: string) => void,
+  reportNote: (message: string) => void
+): void {
+  const lengths = new Map<number, number>();
+  const inferredLengths = new Map<number, number>();
+  const inferredViewLengths = new Map<number, number>();
+  for (const [bufferIndex, definition] of (gltf.json.buffers || []).entries()) {
+    const label = `buffer ${bufferIndex}`;
+    const loaded = gltf.buffers[bufferIndex];
+    const validPayload = Boolean(
+      loaded &&
+        loaded.arrayBuffer instanceof ArrayBuffer &&
+        Number.isSafeInteger(loaded.byteOffset) &&
+        loaded.byteOffset >= 0 &&
+        Number.isSafeInteger(loaded.byteLength) &&
+        loaded.byteLength >= 0 &&
+        Number.isSafeInteger(loaded.byteOffset + loaded.byteLength) &&
+        loaded.byteOffset + loaded.byteLength <= loaded.arrayBuffer.byteLength
+    );
+    if (loaded && !validPayload) reportUnsupported(`${label} invalid borrowed payload span`);
+    let byteLength = definition.byteLength;
+    if (
+      byteLength === undefined &&
+      uriBufferIndices.has(bufferIndex) &&
+      !definition.extensions &&
+      validPayload &&
+      loaded.byteLength > 0
+    ) {
+      byteLength = loaded.byteLength;
+      inferredLengths.set(bufferIndex, byteLength);
+    }
+    if (!Number.isSafeInteger(byteLength) || byteLength < 1) {
+      reportUnsupported(
+        `${label} requires a positive byteLength; missing lengths require unambiguous loaded URI data`
+      );
+      continue;
+    }
+    lengths.set(bufferIndex, byteLength);
+    // Resources may exceed their declared logical length, including GLB padding.
+    if (validPayload && loaded.byteLength < byteLength)
+      reportUnsupported(`${label} declared byteLength exceeds its loaded payload`);
+  }
+  const hasOpaqueConsumers = hasOpaqueGLTFV1Consumers(gltf.json);
+  for (const [viewIndex, view] of (gltf.json.bufferViews || []).entries()) {
+    const byteOffset = view.byteOffset === undefined ? 0 : view.byteOffset;
+    const bufferLength = lengths.get(view.buffer);
+    const byteLength =
+      view.byteLength === undefined && !hasOpaqueConsumers && bufferLength !== undefined
+        ? inferAccessorViewLength(gltf, viewIndex, lengths)
+        : view.byteLength;
+    if (view.byteLength === undefined && byteLength !== undefined)
+      inferredViewLengths.set(viewIndex, byteLength);
+    if (
+      !Number.isSafeInteger(view.buffer) ||
+      view.buffer < 0 ||
+      bufferLength === undefined ||
+      !Number.isSafeInteger(byteOffset) ||
+      byteOffset < 0 ||
+      !Number.isSafeInteger(byteLength) ||
+      (byteLength ?? 0) < 1 ||
+      !Number.isSafeInteger(byteOffset + (byteLength ?? 0)) ||
+      byteOffset + (byteLength ?? 0) > bufferLength
+    )
+      reportUnsupported(
+        `bufferView ${viewIndex} requires a valid buffer reference and contained positive byte span`
+      );
+  }
+  for (const [viewIndex, byteLength] of inferredViewLengths) {
+    gltf.json.bufferViews![viewIndex].byteLength = byteLength;
+    reportNote(`Inferred bufferView ${viewIndex} byteLength from its dense accessor spans.`);
+  }
+  for (const [bufferIndex, byteLength] of inferredLengths) {
+    gltf.json.buffers![bufferIndex].byteLength = byteLength;
+    reportNote(`Inferred buffer ${bufferIndex} byteLength from its loaded URI payload.`);
+  }
+}
+
+/** Infer the smallest known accessor envelope without trimming or changing the source buffer. */
+function inferAccessorViewLength(
+  gltf: GLTFWithBuffers,
+  viewIndex: number,
+  lengths: ReadonlyMap<number, number>
+): number | undefined {
+  const view = gltf.json.bufferViews![viewIndex];
+  if (
+    (view.byteOffset !== undefined &&
+      (!Number.isSafeInteger(view.byteOffset) || view.byteOffset < 0)) ||
+    (view.byteStride !== undefined &&
+      (!Number.isSafeInteger(view.byteStride) || view.byteStride < 0)) ||
+    gltf.json.images?.some(image => image.bufferView === viewIndex) ||
+    gltf.json.accessors?.some(accessor => Boolean(accessor.sparse))
+  )
+    return undefined;
+  const remainingLength = lengths.get(view.buffer)! - (view.byteOffset ?? 0);
+  const candidate = {
+    ...gltf,
+    json: {
+      ...gltf.json,
+      buffers: gltf.json.buffers!.map((buffer, index) => ({
+        ...buffer,
+        byteLength: lengths.get(index)!
+      })),
+      bufferViews: gltf.json.bufferViews!.map((bufferView, index) =>
+        index === viewIndex ? {...bufferView, byteLength: remainingLength} : bufferView
+      )
+    }
+  };
+  let byteLength = 0;
+  for (const [accessorIndex, accessor] of (gltf.json.accessors || []).entries()) {
+    if (accessor.bufferView !== viewIndex) continue;
+    const legacyAccessor = accessor as GLTFV1AccessorSource['accessor'];
+    for (const value of [legacyAccessor.byteOffset, legacyAccessor.byteStride]) {
+      if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) return undefined;
+    }
+    const source = validateGLTFV1AccessorSource(candidate, accessorIndex);
+    if (typeof source === 'string') return undefined;
+    const accessorLength =
+      (accessor.byteOffset ?? 0) +
+      (accessor.count - 1) * source.byteStride +
+      source.rows * source.columns * source.componentSize;
+    byteLength = Math.max(byteLength, accessorLength);
+  }
+  return byteLength > 0 ? byteLength : undefined;
+}

package/src/gltf/lib/api/validate-gltf-v1-cameras.ts

@@ -0,0 +1,40 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {GLTF} from '../types/gltf-types';
+
+/** Check projection constraints without inventing replacement clipping planes or magnification. */
+export function validateGLTFV1Cameras(
+  json: GLTF,
+  reportUnsupported: (feature: string) => void
+): void {
+  for (const [cameraIndex, camera] of (json.cameras || []).entries()) {
+    const perspective = camera.perspective;
+    const orthographic = camera.orthographic;
+    const valid =
+      camera.type === 'perspective'
+        ? perspective &&
+          isPositive(perspective.yfov) &&
+          isPositive(perspective.znear) &&
+          (perspective.aspectRatio === undefined || isPositive(perspective.aspectRatio)) &&
+          (perspective.zfar === undefined ||
+            (isPositive(perspective.zfar) && perspective.zfar > perspective.znear))
+        : camera.type === 'orthographic' &&
+          orthographic &&
+          Number.isFinite(orthographic.xmag) &&
+          orthographic.xmag !== 0 &&
+          Number.isFinite(orthographic.ymag) &&
+          orthographic.ymag !== 0 &&
+          Number.isFinite(orthographic.znear) &&
+          orthographic.znear >= 0 &&
+          isPositive(orthographic.zfar) &&
+          orthographic.zfar > orthographic.znear;
+    if (!valid) reportUnsupported(`camera ${cameraIndex} invalid projection parameters`);
+  }
+}
+
+/** Projection distances and perspective angles require finite positive numbers. */
+function isPositive(value: number): boolean {
+  return Number.isFinite(value) && value > 0;
+}

package/src/gltf/lib/api/validate-gltf-v1-geometry.ts

@@ -0,0 +1,156 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {GLTFWithBuffers} from '../types/gltf-types';
+import {
+  readGLTFV1AccessorComponent,
+  type GLTFV1AccessorReader,
+  type GLTFV1AccessorSource
+} from './repack-gltf-v1-accessors';
+
+/** Validate core attribute values, topology, vertex counts, and indices without repairing geometry. */
+export function validateGLTFV1Geometry(
+  gltf: GLTFWithBuffers,
+  readAccessor: GLTFV1AccessorReader,
+  reportUnsupported: (feature: string) => void
+): void {
+  const maximumIndices = new Map<number, number>();
+  const checkedAttributes = new Set<string>();
+  for (const [meshIndex, mesh] of (gltf.json.meshes || []).entries())
+    for (const [primitiveIndex, primitive] of mesh.primitives.entries()) {
+      const label = `mesh ${meshIndex} primitive ${primitiveIndex}`;
+      for (const category of ['TEXCOORD', 'COLOR', 'JOINTS', 'WEIGHTS']) {
+        const sets = Object.keys(primitive.attributes)
+          .filter(semantic => semantic.startsWith(`${category}_`))
+          .map(semantic => Number(semantic.slice(category.length + 1)))
+          .sort((first, second) => first - second);
+        if (sets.some((setIndex, index) => setIndex !== index))
+          reportUnsupported(`${label} ${category} sets must be contiguous starting at zero`);
+      }
+      for (const [semantic, accessorIndex] of Object.entries(primitive.attributes)) {
+        const category = semantic.split('_')[0];
+        if (!['NORMAL', 'TANGENT', 'COLOR', 'TEXCOORD', 'JOINTS', 'WEIGHTS'].includes(category))
+          continue;
+        const key = `${category}:${accessorIndex}`;
+        if (checkedAttributes.has(key)) continue;
+        checkedAttributes.add(key);
+        const source = readAccessor(accessorIndex, `${semantic} accessor ${accessorIndex}`);
+        if (source)
+          validateAttribute(
+            source,
+            category,
+            `${semantic} accessor ${accessorIndex}`,
+            reportUnsupported
+          );
+      }
+      const counts = Object.values(primitive.attributes).map(accessorIndex => {
+        const accessor = Number.isSafeInteger(accessorIndex)
+          ? gltf.json.accessors?.[accessorIndex]
+          : undefined;
+        return accessor?.count;
+      });
+      if (
+        !counts.length ||
+        counts.some(count => !Number.isSafeInteger(count) || (count as number) < 1)
+      ) {
+        reportUnsupported(`${label} requires valid vertex attribute accessors`);
+        continue;
+      }
+      if (counts.some(count => count !== counts[0]))
+        reportUnsupported(`${label} vertex attribute counts do not match`);
+      const drawCount =
+        primitive.indices === undefined
+          ? counts[0]
+          : gltf.json.accessors?.[primitive.indices]?.count;
+      const mode = primitive.mode === undefined ? 4 : primitive.mode;
+      if (!Number.isInteger(mode) || mode < 0 || mode > 6)
+        reportUnsupported(`${label} requires a primitive mode in [0, 6]`);
+      else if (!primitive.extensions || !Object.keys(primitive.extensions).length) {
+        if (
+          !Number.isSafeInteger(drawCount) ||
+          (drawCount as number) < 1 ||
+          (mode === 1 && (drawCount as number) % 2 !== 0) ||
+          ([2, 3].includes(mode) && (drawCount as number) < 2) ||
+          (mode === 4 && (drawCount as number) % 3 !== 0) ||
+          ([5, 6].includes(mode) && (drawCount as number) < 3)
+        )
+          reportUnsupported(
+            `${label} draw count ${drawCount} is incompatible with primitive mode ${mode}`
+          );
+      }
+      if (primitive.indices === undefined) continue;
+      const source = readAccessor(primitive.indices, `${label} indices`);
+      if (!source) continue;
+      if (
+        source.accessor.type !== 'SCALAR' ||
+        ![5121, 5123, 5125].includes(source.accessor.componentType) ||
+        source.accessor.normalized
+      ) {
+        reportUnsupported(`${label} indices require unnormalized unsigned SCALAR data`);
+        continue;
+      }
+      let maximum = maximumIndices.get(primitive.indices);
+      if (maximum === undefined) {
+        maximum = 0;
+        for (let elementIndex = 0; elementIndex < source.accessor.count; elementIndex++)
+          maximum = Math.max(maximum, readGLTFV1AccessorComponent(source, elementIndex, 0));
+        maximumIndices.set(primitive.indices, maximum);
+      }
+      if (counts.some(count => maximum! >= (count as number)))
+        reportUnsupported(`${label} index ${maximum} is outside its vertex attribute counts`);
+    }
+}
+
+/** Check standard dense attribute metadata and finite values, retaining invalid data for diagnostics. */
+function validateAttribute(
+  source: GLTFV1AccessorSource,
+  category: string,
+  label: string,
+  reportUnsupported: (feature: string) => void
+): void {
+  const accessor = source.accessor;
+  const isFloat = accessor.componentType === 5126 && !accessor.normalized;
+  const isUnitInteger =
+    [5121, 5123].includes(accessor.componentType) && accessor.normalized === true;
+  const validNormalization =
+    accessor.normalized === undefined || typeof accessor.normalized === 'boolean';
+  const validType =
+    category === 'NORMAL'
+      ? accessor.type === 'VEC3' && isFloat
+      : category === 'TANGENT'
+        ? accessor.type === 'VEC4' && isFloat
+        : category === 'JOINTS'
+          ? accessor.type === 'VEC4' &&
+            [5121, 5123].includes(accessor.componentType) &&
+            !accessor.normalized
+          : category === 'COLOR'
+            ? ['VEC3', 'VEC4'].includes(accessor.type) && (isFloat || isUnitInteger)
+            : accessor.type === (category === 'TEXCOORD' ? 'VEC2' : 'VEC4') &&
+              (isFloat || isUnitInteger);
+  if (!validNormalization || !validType) {
+    reportUnsupported(
+      `${label} has incompatible core attribute shape, component type, or normalization`
+    );
+    return;
+  }
+  for (let elementIndex = 0; elementIndex < accessor.count; elementIndex++) {
+    const values = Array.from({length: source.rows}, (_, componentIndex) =>
+      readGLTFV1AccessorComponent(source, elementIndex, componentIndex)
+    );
+    if (
+      values.some(value => !Number.isFinite(value)) ||
+      (['NORMAL', 'TANGENT'].includes(category) &&
+        Math.abs(Math.hypot(...values.slice(0, 3)) - 1) > 1e-5) ||
+      (category === 'TANGENT' && values[3] !== 1 && values[3] !== -1) ||
+      (['COLOR', 'WEIGHTS'].includes(category) &&
+        isFloat &&
+        values.some(value => value < 0 || value > 1))
+    ) {
+      reportUnsupported(
+        `${label} requires finite core values, unit directions, tangent handedness ±1, and colors/weights in [0, 1]`
+      );
+      return;
+    }
+  }
+}

package/src/gltf/lib/api/validate-gltf-v1-payloads.ts

@@ -0,0 +1,315 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {GLTFWithBuffers} from '../types/gltf-types';
+import {
+  validateGLTFV1AccessorSource,
+  readGLTFV1AccessorComponent,
+  type GLTFV1AccessorSource,
+  type GLTFV1AccessorReader
+} from './repack-gltf-v1-accessors';
+import {validateGLTFV1Geometry} from './validate-gltf-v1-geometry';
+
+/** Validate supported core payload semantics and repair required bounds without changing source bytes. */
+export function validateGLTFV1Payloads(
+  gltf: GLTFWithBuffers,
+  reportUnsupported: (feature: string) => void,
+  reportNote: (message: string) => void
+): void {
+  const cache = new Map<number, GLTFV1AccessorSource | string>();
+  const failed = new Set<number>();
+  const plans: Array<() => void> = [];
+  /** Validate spans once, reporting unavailable or opaque bytes before any semantic read. */
+  const readAccessor: GLTFV1AccessorReader = (accessorIndex, label) => {
+    let source = cache.get(accessorIndex);
+    if (source === undefined) {
+      source = validateGLTFV1AccessorSource(gltf, accessorIndex);
+      cache.set(accessorIndex, source);
+    }
+    if (typeof source === 'string') {
+      if (!failed.has(accessorIndex)) {
+        failed.add(accessorIndex);
+        reportUnsupported(`${label}: ${source}`);
+      }
+      return null;
+    }
+    return source;
+  };
+  const positions = new Set<number>();
+  for (const mesh of gltf.json.meshes || [])
+    for (const primitive of mesh.primitives)
+      if (primitive.attributes.POSITION !== undefined) positions.add(primitive.attributes.POSITION);
+  for (const accessorIndex of positions) {
+    const source = readAccessor(accessorIndex, `POSITION accessor ${accessorIndex}`);
+    if (!source) continue;
+    if (!isFloatAccessor(source, 'VEC3')) {
+      reportUnsupported(`POSITION accessor ${accessorIndex} requires unnormalized FLOAT VEC3 data`);
+      continue;
+    }
+    planBounds(source, accessorIndex);
+  }
+  validateAnimations();
+  validateInverseBindMatrices();
+  validateSkinInfluences(gltf, readAccessor, reportUnsupported);
+  validateGLTFV1Geometry(gltf, readAccessor, reportUnsupported);
+  for (const apply of plans) apply();
+
+  /** Check all supplied inverse-bind data, including identity bind shapes and unused skins. */
+  function validateInverseBindMatrices(): void {
+    for (const [skinIndex, skin] of (gltf.json.skins || []).entries()) {
+      if (skin.inverseBindMatrices === undefined) continue;
+      const label = `skin ${skinIndex} inverse-bind matrices`;
+      const source = readAccessor(skin.inverseBindMatrices, label);
+      if (!source) continue;
+      if (!isFloatAccessor(source, 'MAT4') || source.accessor.count < (skin.joints?.length || 0)) {
+        reportUnsupported(`${label} require FLOAT MAT4 data with at least one matrix per joint`);
+        continue;
+      }
+      for (let matrixIndex = 0; matrixIndex < source.accessor.count; matrixIndex++) {
+        const matrix = Array.from({length: 16}, (_, componentIndex) =>
+          readGLTFV1AccessorComponent(source, matrixIndex, componentIndex)
+        );
+        if (
+          matrix.some(value => !Number.isFinite(value)) ||
+          matrix[3] !== 0 ||
+          matrix[7] !== 0 ||
+          matrix[11] !== 0 ||
+          matrix[15] !== 1
+        ) {
+          reportUnsupported(`${label} require finite affine matrices`);
+          break;
+        }
+      }
+    }
+  }
+
+  /** Calculate finite raw extrema, committing only after all strict checks pass. */
+  function planBounds(source: GLTFV1AccessorSource, accessorIndex: number): boolean {
+    const minimum = new Array<number>(source.rows).fill(Infinity);
+    const maximum = new Array<number>(source.rows).fill(-Infinity);
+    for (let elementIndex = 0; elementIndex < source.accessor.count; elementIndex++)
+      for (let componentIndex = 0; componentIndex < source.rows; componentIndex++) {
+        const value = readGLTFV1AccessorComponent(source, elementIndex, componentIndex);
+        if (!Number.isFinite(value)) {
+          reportUnsupported(
+            `accessor ${accessorIndex} non-finite values cannot supply required bounds`
+          );
+          return false;
+        }
+        minimum[componentIndex] = Math.min(minimum[componentIndex], value);
+        maximum[componentIndex] = Math.max(maximum[componentIndex], value);
+      }
+    if (
+      JSON.stringify(source.accessor.min) !== JSON.stringify(minimum) ||
+      JSON.stringify(source.accessor.max) !== JSON.stringify(maximum)
+    )
+      plans.push(() => {
+        source.accessor.min = minimum;
+        source.accessor.max = maximum;
+        reportNote(`Calculated required bounds for accessor ${accessorIndex}.`);
+      });
+    return true;
+  }
+
+  /** Check compatible TRS keyframes without sorting, resampling, or fabricating interpolation tangents. */
+  function validateAnimations(): void {
+    const checkedTimes = new Set<number>();
+    const checkedOutputs = new Set<string>();
+    for (const [animationIndex, animation] of (gltf.json.animations || []).entries()) {
+      const targets = new Set<string>();
+      if (!animation.samplers.length || !animation.channels?.length)
+        reportUnsupported(`animation ${animationIndex} requires samplers and channels`);
+      for (const [samplerIndex, sampler] of animation.samplers.entries()) {
+        const label = `animation ${animationIndex} sampler ${samplerIndex}`;
+        if (!['LINEAR', 'STEP'].includes(sampler.interpolation ?? 'LINEAR'))
+          reportUnsupported(`${label} unsupported interpolation ${sampler.interpolation}`);
+        if (!checkedTimes.has(sampler.input)) {
+          checkedTimes.add(sampler.input);
+          const source = readAccessor(sampler.input, `${label} input`);
+          if (source) {
+            if (!isFloatAccessor(source, 'SCALAR'))
+              reportUnsupported(`${label} time input requires unnormalized FLOAT SCALAR data`);
+            else {
+              let previous = -Infinity;
+              let valid = true;
+              for (let elementIndex = 0; elementIndex < source.accessor.count; elementIndex++) {
+                const time = readGLTFV1AccessorComponent(source, elementIndex, 0);
+                if (!Number.isFinite(time) || time < 0 || time <= previous) valid = false;
+                previous = time;
+              }
+              if (!valid)
+                reportUnsupported(
+                  `${label} times must be finite, nonnegative, and strictly increasing`
+                );
+              else planBounds(source, sampler.input);
+            }
+          }
+        }
+      }
+      for (const [channelIndex, channel] of (animation.channels || []).entries()) {
+        const label = `animation ${animationIndex} channel ${channelIndex}`;
+        const sampler = Number.isSafeInteger(channel.sampler)
+          ? animation.samplers[channel.sampler]
+          : undefined;
+        const target = channel.target;
+        const node = Number.isSafeInteger(target?.node)
+          ? gltf.json.nodes?.[target.node as number]
+          : undefined;
+        if (!sampler || !node || !['translation', 'rotation', 'scale'].includes(target?.path)) {
+          reportUnsupported(`${label} invalid sampler, node, or TRS target`);
+          continue;
+        }
+        if (node.matrix !== undefined)
+          reportUnsupported(`${label} matrix node requires TRS decomposition`);
+        const targetKey = `${target.node}:${target.path}`;
+        if (targets.has(targetKey)) reportUnsupported(`${label} duplicate node/path target`);
+        targets.add(targetKey);
+        if (!['LINEAR', 'STEP'].includes(sampler.interpolation ?? 'LINEAR')) continue;
+        const input = gltf.json.accessors?.[sampler.input];
+        const output = readAccessor(sampler.output, `${label} output`);
+        if (!output) continue;
+        if (
+          !isFloatAccessor(output, target.path === 'rotation' ? 'VEC4' : 'VEC3') ||
+          output.accessor.count !== input?.count
+        ) {
+          reportUnsupported(
+            `${label} output shape, type, or count does not match its target and keys`
+          );
+          continue;
+        }
+        const outputKey = `${sampler.output}:${target.path}`;
+        if (checkedOutputs.has(outputKey)) continue;
+        checkedOutputs.add(outputKey);
+        for (let elementIndex = 0; elementIndex < output.accessor.count; elementIndex++) {
+          const values = Array.from({length: output.rows}, (_, componentIndex) =>
+            readGLTFV1AccessorComponent(output, elementIndex, componentIndex)
+          );
+          if (
+            values.some(value => !Number.isFinite(value)) ||
+            (target.path === 'rotation' && Math.abs(Math.hypot(...values) - 1) > 1e-5)
+          ) {
+            reportUnsupported(
+              `${label} output requires finite values and unit rotation quaternions`
+            );
+            break;
+          }
+        }
+      }
+    }
+  }
+}
+
+/** Core positions, timeline values, and TRS samples use unnormalized FLOAT accessors. */
+function isFloatAccessor(source: GLTFV1AccessorSource, type: string): boolean {
+  return (
+    source.accessor.componentType === 5126 &&
+    !source.accessor.normalized &&
+    source.accessor.type === type
+  );
+}
+
+/** Validate supplied influence sets against every resolved skin that instantiates their mesh. */
+function validateSkinInfluences(
+  gltf: GLTFWithBuffers,
+  readAccessor: GLTFV1AccessorReader,
+  reportUnsupported: (feature: string) => void
+): void {
+  const checkedBindings = new Set<string>();
+  for (const node of gltf.json.nodes || []) {
+    const skin = gltf.json.skins?.[node.skin as number];
+    const mesh = gltf.json.meshes?.[node.mesh as number];
+    if (!Array.isArray(skin?.joints) || !skin.joints.length || !mesh) continue;
+    const binding = `${node.mesh}:${node.skin}`;
+    if (checkedBindings.has(binding)) continue;
+    checkedBindings.add(binding);
+    for (const [primitiveIndex, primitive] of mesh.primitives.entries()) {
+      const label = `mesh ${node.mesh} primitive ${primitiveIndex} skin ${node.skin}`;
+      const jointSets = Object.keys(primitive.attributes)
+        .filter(name => /^JOINTS_\d+$/.test(name))
+        .map(name => Number(name.slice(7)))
+        .sort((first, second) => first - second);
+      const weightSets = Object.keys(primitive.attributes)
+        .filter(name => /^WEIGHTS_\d+$/.test(name))
+        .map(name => Number(name.slice(8)))
+        .sort((first, second) => first - second);
+      if (!jointSets.length && !weightSets.length) {
+        reportUnsupported(`${label} requires JOINTS_0 and WEIGHTS_0 skin influences`);
+        continue;
+      }
+      if (
+        JSON.stringify(jointSets) !== JSON.stringify(weightSets) ||
+        jointSets.some((setIndex, index) => setIndex !== index)
+      ) {
+        reportUnsupported(
+          `${label} requires matching contiguous joint/weight sets starting at zero`
+        );
+        continue;
+      }
+      const count = gltf.json.accessors?.[primitive.attributes.POSITION]?.count;
+      const sets = jointSets.map(setIndex => ({
+        joints: readAccessor(
+          primitive.attributes[`JOINTS_${setIndex}`],
+          `${label} joint set ${setIndex}`
+        ),
+        weights: readAccessor(
+          primitive.attributes[`WEIGHTS_${setIndex}`],
+          `${label} weight set ${setIndex}`
+        )
+      }));
+      if (sets.some(({joints, weights}) => !joints || !weights)) continue;
+      if (
+        sets.some(
+          ({joints, weights}) =>
+            joints!.accessor.type !== 'VEC4' ||
+            weights!.accessor.type !== 'VEC4' ||
+            ![5121, 5123].includes(joints!.accessor.componentType) ||
+            joints!.accessor.normalized ||
+            !(
+              (weights!.accessor.componentType === 5126 && !weights!.accessor.normalized) ||
+              ([5121, 5123].includes(weights!.accessor.componentType) &&
+                weights!.accessor.normalized)
+            ) ||
+            joints!.accessor.count !== weights!.accessor.count ||
+            (count !== undefined && joints!.accessor.count !== count) ||
+            joints!.accessor.count !== sets[0].joints!.accessor.count
+        )
+      ) {
+        reportUnsupported(`${label} incompatible influence accessor types or vertex counts`);
+        continue;
+      }
+      for (let vertexIndex = 0; vertexIndex < sets[0].joints!.accessor.count; vertexIndex++) {
+        let sum = 0;
+        let nonzeroWeights = 0;
+        let valid = true;
+        const weightedJoints = new Set<number>();
+        for (const {joints, weights} of sets) {
+          const divisor = weights!.accessor.normalized
+            ? weights!.accessor.componentType === 5121
+              ? 255
+              : 65535
+            : 1;
+          for (let componentIndex = 0; componentIndex < 4; componentIndex++) {
+            const joint = readGLTFV1AccessorComponent(joints!, vertexIndex, componentIndex);
+            const weight =
+              readGLTFV1AccessorComponent(weights!, vertexIndex, componentIndex) / divisor;
+            if (joint >= skin.joints.length || !Number.isFinite(weight) || weight < 0 || weight > 1)
+              valid = false;
+            if (weight > 0) {
+              if (weightedJoints.has(joint)) valid = false;
+              weightedJoints.add(joint);
+              nonzeroWeights++;
+            }
+            sum += weight;
+          }
+        }
+        if (!valid || Math.abs(sum - 1) > 2e-7 * Math.max(nonzeroWeights, 1)) {
+          reportUnsupported(
+            `${label} invalid palette index, repeated weighted joint, or weights not summing to one at vertex ${vertexIndex}`
+          );
+          break;
+        }
+      }
+    }
+  }
+}