case "decodePcSogs": {
        const { fileBytes, extraFiles } = args as {
          fileBytes: Uint8Array;
          extraFiles: Record<string, ArrayBuffer>;
        };
        const json = JSON.parse(
          new TextDecoder().decode(fileBytes),
        ) as PcSogsJson;
        const decoded = await unpackPcSogs(json, extraFiles);
        result = {
          id,
          numSplats: decoded.numSplats,
          packedArray: decoded.packedArray,
          extra: decoded.extra,
        };
        break;
      }
      case "decodePcSogsZip": {
        const { fileBytes } = args as { fileBytes: Uint8Array };
        const decoded = await unpackPcSogsZip(fileBytes);
        result = {
          id,
          numSplats: decoded.numSplats,
          packedArray: decoded.packedArray,
          extra: decoded.extra,
        };
        break;
      }

export type PcSogsJson = {
  means: {
    shape: number[];
    dtype: string;
    mins: number[];
    maxs: number[];
    files: string[];
  };
  scales: {
    shape: number[];
    dtype: string;
    mins: number[];
    maxs: number[];
    files: string[];
  };
  quats: { shape: number[]; dtype: string; encoding?: string; files: string[] };
  sh0: {
    shape: number[];
    dtype: string;
    mins: number[];
    maxs: number[];
    files: string[];
  };
  shN?: {
    shape: number[];
    dtype: string;
    mins: number;
    maxs: number;
    quantization: number;
    files: string[];
  };
};

async function decodeImage(fileBytes: ArrayBuffer) {
  if (!offscreenGlContext) {
    const canvas = new OffscreenCanvas(1, 1);
    offscreenGlContext = canvas.getContext("webgl2");
    if (!offscreenGlContext) {
      throw new Error("Failed to create WebGL2 context");
    }
  }

  const imageBlob = new Blob([fileBytes]);
  const bitmap = await createImageBitmap(imageBlob, {
    premultiplyAlpha: "none",
  });

  const gl = offscreenGlContext;
  const texture = gl.createTexture();
  gl.bindTexture(gl.TEXTURE_2D, texture);
  gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, bitmap);
  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);

  const framebuffer = gl.createFramebuffer();
  gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
  gl.framebufferTexture2D(
    gl.FRAMEBUFFER,
    gl.COLOR_ATTACHMENT0,
    gl.TEXTURE_2D,
    texture,
    0,
  );

  const data = new Uint8Array(bitmap.width * bitmap.height * 4);
  gl.readPixels(
    0,
    0,
    bitmap.width,
    bitmap.height,
    gl.RGBA,
    gl.UNSIGNED_BYTE,
    data,
  );

  gl.deleteTexture(texture);
  gl.deleteFramebuffer(framebuffer);

  return { rgba: data, width: bitmap.width, height: bitmap.height };
}

if (json.shN) {
  const useSH3 = json.shN.shape[1] >= 48 - 3;
  const useSH2 = json.shN.shape[1] >= 27 - 3;
  const useSH1 = json.shN.shape[1] >= 12 - 3;

  if (useSH1) extra.sh1 = new Uint32Array(numSplats * 2);
  if (useSH2) extra.sh2 = new Uint32Array(numSplats * 4);
  if (useSH3) extra.sh3 = new Uint32Array(numSplats * 4);

  const sh1 = new Float32Array(9);
  const sh2 = new Float32Array(15);
  const sh3 = new Float32Array(21);

  const shN = json.shN;
  const shNPromise = Promise.all([
    decodeImage(extraFiles[json.shN.files[0]]),
    decodeImage(extraFiles[json.shN.files[1]]),
  ]).then(([centroids, labels]) => {
    for (let i = 0; i < numSplats; ++i) {
      const i4 = i * 4;
      const label = labels.rgba[i4 + 0] + (labels.rgba[i4 + 1] << 8);
      const col = (label & 63) * 15;
      const row = label >>> 6;
      const offset = row * centroids.width + col;

      for (let d = 0; d < 3; ++d) {
        if (useSH1) {
          for (let k = 0; k < 3; ++k) {
            sh1[k * 3 + d] =
              shN.mins +
              ((shN.maxs - shN.mins) * centroids.rgba[(offset + k) * 4 + d]) /
                255;
          }
        }

        if (useSH2) {
          for (let k = 0; k < 5; ++k) {
            sh2[k * 3 + d] =
              shN.mins +
              ((shN.maxs - shN.mins) *
                centroids.rgba[(offset + 3 + k) * 4 + d]) /
                255;
          }
        }

        if (useSH3) {
          for (let k = 0; k < 7; ++k) {
            sh3[k * 3 + d] =
              shN.mins +
              ((shN.maxs - shN.mins) *
                centroids.rgba[(offset + 8 + k) * 4 + d]) /
                255;
          }
        }
      }

      if (useSH1)
        encodeSh1Rgb(extra.sh1 as Uint32Array, i, sh1, splatEncoding);
      if (useSH2)
        encodeSh2Rgb(extra.sh2 as Uint32Array, i, sh2, splatEncoding);
      if (useSH3)
        encodeSh3Rgb(extra.sh3 as Uint32Array, i, sh3, splatEncoding);
    }
  });
  promises.push(shNPromise);
}

shN?: {
    shape: number[];
    dtype: string;
    mins: number;
    maxs: number;
    quantization: number;
    files: string[];
} | undefined

  if (useSH1) extra.sh1 = new Uint32Array(numSplats * 2);
  if (useSH2) extra.sh2 = new Uint32Array(numSplats * 4);
  if (useSH3) extra.sh3 = new Uint32Array(numSplats * 4);

      const label = labels.rgba[i4 + 0] + (labels.rgba[i4 + 1] << 8);

const label = labels.rgba[i4 + 0] + (labels.rgba[i4 + 1] << 8);
const col = (label & 63) * 15;
const row = label >>> 6;
const offset = row * centroids.width + col;