@babylonjs/viewer/dist/chunks/gltf-feature-sparse-usmYxXwF.esm.js

The Babylon Viewer aims to simplify a specific but common Babylon.js use case: loading, viewing, and interacting with a 3D model.

import { ag as TYPE_SIZES, j as U8, T as ThrowLiteError, ak as DV } from './index-By0tcgYN.esm.js';

const BYTE = 5120;
const UNSIGNED_BYTE = 5121;
const SHORT = 5122;
const UNSIGNED_SHORT = 5123;
const UNSIGNED_INT = 5125;
const FLOAT = 5126;
const COMPONENT_BYTES = { 5120: 1, 5121: 1, 5122: 2, 5123: 2, 5125: 4, 5126: 4 };
function align4(n) {
  return n + 3 & -4;
}
function componentBytes(componentType) {
  const b = COMPONENT_BYTES[componentType];
  if (!b) {
    ThrowLiteError(88, componentType);
  }
  return b;
}
function readIndex(view, offset, componentType) {
  switch (componentType) {
    case UNSIGNED_BYTE:
      return view.getUint8(offset);
    case UNSIGNED_SHORT:
      return view.getUint16(offset, true);
    case UNSIGNED_INT:
      return view.getUint32(offset, true);
    default:
      ThrowLiteError(89, componentType);
  }
}
function readComponent(view, offset, componentType) {
  switch (componentType) {
    case BYTE:
      return view.getInt8(offset);
    case UNSIGNED_BYTE:
      return view.getUint8(offset);
    case SHORT:
      return view.getInt16(offset, true);
    case UNSIGNED_SHORT:
      return view.getUint16(offset, true);
    case UNSIGNED_INT:
      return view.getUint32(offset, true);
    case FLOAT:
      return view.getFloat32(offset, true);
    default:
      ThrowLiteError(90, componentType);
  }
}
function writeComponent(view, offset, componentType, value) {
  switch (componentType) {
    case BYTE:
      view.setInt8(offset, value);
      break;
    case UNSIGNED_BYTE:
      view.setUint8(offset, value);
      break;
    case SHORT:
      view.setInt16(offset, value, true);
      break;
    case UNSIGNED_SHORT:
      view.setUint16(offset, value, true);
      break;
    case UNSIGNED_INT:
      view.setUint32(offset, value, true);
      break;
    case FLOAT:
      view.setFloat32(offset, value, true);
      break;
  }
}
const feature = {
  id: "_sparse",
  async preParse(json, binChunk) {
    const accessors = json.accessors ?? [];
    const bufferViews = json.bufferViews ?? [];
    const sparseIdx = [];
    let appended = 0;
    for (let i = 0; i < accessors.length; i++) {
      const a = accessors[i];
      if (a.sparse) {
        sparseIdx.push(i);
        const cc = TYPE_SIZES[a.type] ?? 1;
        appended = align4(appended + a.count * cc * componentBytes(a.componentType));
      }
    }
    if (sparseIdx.length === 0) {
      return;
    }
    const baseLen = align4(binChunk.byteLength);
    const out = new ArrayBuffer(baseLen + appended);
    new U8(out).set(new U8(binChunk.buffer, binChunk.byteOffset, binChunk.byteLength));
    const outView = new DV(out);
    let cursor = baseLen;
    for (const i of sparseIdx) {
      const a = accessors[i];
      const sparse = a.sparse;
      const cc = TYPE_SIZES[a.type] ?? 1;
      const compBytes = componentBytes(a.componentType);
      const elemBytes = cc * compBytes;
      const dstOffset = cursor;
      if (a.bufferView !== void 0) {
        const bv = bufferViews[a.bufferView];
        const stride = bv.byteStride ?? elemBytes;
        const srcBase = (bv.byteOffset ?? 0) + (a.byteOffset ?? 0);
        for (let v = 0; v < a.count; v++) {
          for (let c = 0; c < cc; c++) {
            const value = readComponent(binChunk, srcBase + v * stride + c * compBytes, a.componentType);
            writeComponent(outView, dstOffset + (v * cc + c) * compBytes, a.componentType, value);
          }
        }
      }
      const idxComponentType = sparse.indices.componentType;
      if (idxComponentType === void 0) {
        ThrowLiteError(91);
      }
      const idxBv = bufferViews[sparse.indices.bufferView];
      const idxBase = (idxBv.byteOffset ?? 0) + (sparse.indices.byteOffset ?? 0);
      const idxBytes = componentBytes(idxComponentType);
      const valBv = bufferViews[sparse.values.bufferView];
      const valBase = (valBv.byteOffset ?? 0) + (sparse.values.byteOffset ?? 0);
      for (let e = 0; e < sparse.count; e++) {
        const target = readIndex(binChunk, idxBase + e * idxBytes, idxComponentType);
        if (target < 0 || target >= a.count) {
          ThrowLiteError(92, target, a.count);
        }
        for (let c = 0; c < cc; c++) {
          const value = readComponent(binChunk, valBase + (e * cc + c) * compBytes, a.componentType);
          writeComponent(outView, dstOffset + (target * cc + c) * compBytes, a.componentType, value);
        }
      }
      const byteLength = elemBytes * a.count;
      a.bufferView = bufferViews.length;
      a.byteOffset = 0;
      bufferViews.push({ buffer: 0, byteOffset: dstOffset, byteLength });
      delete a.sparse;
      cursor = align4(cursor + byteLength);
    }
    return outView;
  }
};

export { feature as default };
//# sourceMappingURL=gltf-feature-sparse-usmYxXwF.esm.js.map