x_ite-sog-parser 1.2.1 → 1.2.3

package/README.md

@@ -2,7 +2,7 @@
 
 [![npm Version](https://img.shields.io/npm/v/x_ite-sog-parser)](https://www.npmjs.com/package/x_ite-sog-parser)
 [![Build Size](https://img.shields.io/bundlephobia/minzip/x_ite-sog-parser)](https://bundlephobia.com/package/x_ite-sog-parser)
-[![jsDelivr Hits](https://data.jsdelivr.com/v1/package/npm/x_ite-sog-parser/badge?style=rounded)](https://create3000.github.io/jsdelivr-download-stats/?username=create3000&repository=x_ite)
+[![jsDelivr Hits](https://data.jsdelivr.com/v1/package/npm/x_ite-sog-parser/badge?style=rounded)](https://create3000.github.io/jsdelivr-download-stats/?username=create3000&repository=x_ite-sog-parser)
 [![npm Downloads](https://img.shields.io/npm/dm/x_ite-sog-parser)](https://npmtrends.com/x_ite-sog-parser)
 
 SOG File Format Parser for [X_ITE](https://create3000.github.io/x_ite/) for 3D Gaussian Splatting
@@ -12,10 +12,10 @@ SOG File Format Parser for [X_ITE](https://create3000.github.io/x_ite/) for 3D G
 Include the script before X_ITE:
 
 ```html
-<script defer src="https://cdn.jsdelivr.net/npm/x_ite-sog-parser@1.2.1/dist/x_ite-sog-parser-2.min.js"></script>
+<script defer src="https://cdn.jsdelivr.net/npm/x_ite-sog-parser@1.2.3/dist/x_ite-sog-parser-2.min.js"></script>
 <script defer src="https://cdn.jsdelivr.net/npm/x_ite@VERSION/dist/x_ite.min.js"></script>
 <!-- or as ES module -->
-<script type="module" src="https://cdn.jsdelivr.net/npm/x_ite-sog-parser@1.2.1/dist/x_ite-sog-parser-2.min.js"></script>
+<script type="module" src="https://cdn.jsdelivr.net/npm/x_ite-sog-parser@1.2.3/dist/x_ite-sog-parser-2.min.js"></script>
 <script type="module" src="https://cdn.jsdelivr.net/npm/x_ite@VERSION/dist/x_ite.min.mjs"></script>
 ```
 

package/dist/x_ite-sog-parser-2.js

@@ -2719,7 +2719,7 @@ function unzipSync(data, opts) {
 /************************************************************************/
 var __nested_webpack_exports__ = {};
 /* harmony export */ __nested_webpack_require_43__.d(__nested_webpack_exports__, {
-/* harmony export */   A: () => (/* binding */ register)
+/* harmony export */   A: () => (x_ite_extension)
 /* harmony export */ });
 function register (callback)
 {
@@ -2728,9 +2728,23 @@ function register (callback)
    if (X3D)
       callback (X3D);
    else
-      (window [Symbol .for ("X_ITE.extensions")] ??= [ ]) .push (callback);
+      getExtensions () .push (callback);
 };
 
+function getExtensions ()
+{
+   const
+      _extensions = Symbol .for ("X_ITE.extensions"),
+      extensions  = window [_extensions];
+
+   if (Array .isArray (extensions))
+      return extensions;
+
+   return window [_extensions] = [ ];
+}
+
+/* harmony default export */ const x_ite_extension = (register);
+
 const __webpack_exports__default = __nested_webpack_exports__.A;
 
 
@@ -2738,458 +2752,457 @@ const __webpack_exports__default = __nested_webpack_exports__.A;
 
 
 
-__webpack_exports__default (X3D =>
+/*
+* Parser
+* Reference: https://github.com/playcanvas/splat-transform/blob/main/src/lib/readers/read-sog.ts
+*/
+__webpack_exports__default (X3D => class SOGParser extends X3D .X3DParser
 {
-   /*
-   * Parser
-   * Reference: https://github.com/playcanvas/splat-transform/blob/main/src/lib/readers/read-sog.ts
-   */
+   static
+   {
+      X3D .GoldenGate .addParsers (this);
+   }
 
-   class SOGParser extends X3D .X3DParser
+   constructor (scene)
    {
-      constructor (scene)
-      {
-         super (scene);
-      }
+      super (scene);
+   }
 
-      getEncoding ()
-      {
-         return "ARRAY_BUFFER";
-      }
+   getEncoding ()
+   {
+      return "ARRAY_BUFFER";
+   }
 
-      setInput (buffer)
-      {
-         this .buffer = buffer;
-      }
+   setInput (buffer)
+   {
+      this .buffer = buffer;
+   }
 
-      isValid ()
-      {
-         if (this .buffer .byteLength < 4)
-            return false;
+   isValid ()
+   {
+      if (this .buffer .byteLength < 4)
+         return false;
 
-         // Check magic.
+      // Check magic.
 
-         const dataView = new DataView (this .buffer);
+      const dataView = new DataView (this .buffer);
 
-         if (dataView .getUint32 (0, false) !== 0x504B0304)
-            return false;
+      if (dataView .getUint32 (0, false) !== 0x504B0304)
+         return false;
 
-         // Check minimum requirement for Gaussian Splats.
+      // Check minimum requirement for Gaussian Splats.
 
-         const keys = [
-            "means_l.webp",
-            "means_u.webp",
-            "scales.webp",
-            "sh0.webp",
-            "quats.webp",
-            "meta.json",
-         ];
+      const keys = [
+         "means_l.webp",
+         "means_u.webp",
+         "scales.webp",
+         "sh0.webp",
+         "quats.webp",
+         "meta.json",
+      ];
 
-         this .files = unzipSync (new Uint8Array (this .buffer));
+      this .files = unzipSync (new Uint8Array (this .buffer));
 
-         if (!keys .every (key => this .files [key]))
-            return false;
+      if (!keys .every (key => this .files [key]))
+         return false;
 
-         // Check version.
+      // Check version.
 
-         const meta = this .parseMeta ();
+      const meta = this .parseMeta ();
 
-         if (meta .version < 2 || meta .version > 2)
-            return false;
+      if (meta .version < 2 || meta .version > 2)
+         return false;
 
-         return true;
-      }
+      return true;
+   }
 
-      parseIntoScene (resolve, reject)
-      {
-         this .sog ()
-            .then (resolve)
-            .catch (reject);
-      }
+   parseIntoScene (resolve, reject)
+   {
+      this .sog ()
+         .then (resolve)
+         .catch (reject);
+   }
 
-      async sog ()
-      {
-         const
-            browser = this .getBrowser (),
-            scene   = this .getScene ();
+   async sog ()
+   {
+      const
+         browser = this .getBrowser (),
+         scene   = this .getScene ();
 
-         scene .setEncoding ("SOG");
-         scene .setProfile (browser .getProfile ("Interchange"));
-         scene .addComponent (browser .getComponent ("X_ITE"));
+      scene .setEncoding ("SOG");
+      scene .setProfile (browser .getProfile ("Interchange"));
+      scene .addComponent (browser .getComponent ("X_ITE"));
 
-         await this .getBrowser () .loadComponents (scene);
+      await this .getBrowser () .loadComponents (scene);
 
-         const
-            transform      = scene .createNode ("Transform"),
-            gaussianSplats = scene .createNode ("GaussianSplats"),
-            gaussianCloud  = await this .unpackFiles ();
+      const
+         transform      = scene .createNode ("Transform"),
+         gaussianSplats = scene .createNode ("GaussianSplats"),
+         gaussianCloud  = await this .unpackFiles ();
 
-         gaussianSplats .positions    = gaussianCloud .positions;
-         gaussianSplats .orientations = gaussianCloud .rotations;
-         gaussianSplats .scales       = gaussianCloud .scales;
-         gaussianSplats .opacities    = gaussianCloud .alphas;
+      gaussianSplats .positions    = gaussianCloud .positions;
+      gaussianSplats .orientations = gaussianCloud .rotations;
+      gaussianSplats .scales       = gaussianCloud .scales;
+      gaussianSplats .opacities    = gaussianCloud .alphas;
 
-         gaussianSplats .sphericalHarmonicsDegree0Coef0 = gaussianCloud .colors;
+      gaussianSplats .sphericalHarmonicsDegree0Coef0 = gaussianCloud .colors;
 
-         // Set spherical harmonics.
+      // Set spherical harmonics.
 
-         if (gaussianCloud .shs .length)
-         {
-            const {
-               meta: { count, shN: { bands } },
-            } = this .files;
+      if (gaussianCloud .shs .length)
+      {
+         const {
+            meta: { count, shN: { bands } },
+         } = this .files;
 
-            const
-               shs      = gaussianCloud .shs,
-               shDegree = bands;
+         const
+            shs      = gaussianCloud .shs,
+            shDegree = bands;
 
-            this .setSphericalHarmonics (count, shs, shDegree, gaussianSplats)
-         }
+         this .setSphericalHarmonics (count, shs, shDegree, gaussianSplats)
+      }
 
-         // Add nodes to scene.
+      // Add nodes to scene.
 
-         transform .rotation = new X3D .Rotation4 (1, 0, 0, Math .PI);
+      transform .rotation = new X3D .Rotation4 (1, 0, 0, Math .PI);
 
-         transform .children .push (gaussianSplats);
-         scene .rootNodes .push (transform);
+      transform .children .push (gaussianSplats);
+      scene .rootNodes .push (transform);
 
-         return scene;
-      }
+      return scene;
+   }
+
+   setSphericalHarmonics (numSplats, shs, shDegree, gaussianSplats)
+   {
+      const
+         shCoeffs  = this .dimForDegree (shDegree),
+         shCoeffs3 = this .dimForDegree (shDegree) * 3,
+         splatShs  = Array .from ({ length: shCoeffs }, () => [ ]);
 
-      setSphericalHarmonics (numSplats, shs, shDegree, gaussianSplats)
+      for (let c = 0; c < shCoeffs; ++ c)
       {
          const
-            shCoeffs  = this .dimForDegree (shDegree),
-            shCoeffs3 = this .dimForDegree (shDegree) * 3,
-            splatShs  = Array .from ({ length: shCoeffs }, () => [ ]);
+            c3      = c * 3,
+            splatSh = splatShs [c];
 
-         for (let c = 0; c < shCoeffs; ++ c)
+         for (let i = 0; i < numSplats; ++ i)
          {
-            const
-               c3      = c * 3,
-               splatSh = splatShs [c];
+            const offset = shCoeffs3 * i + c3;
 
-            for (let i = 0; i < numSplats; ++ i)
-            {
-               const offset = shCoeffs3 * i + c3;
-
-               for (let j = 0; j < 3; ++ j)
-                  splatSh .push (shs [offset + j]);
-            }
+            for (let j = 0; j < 3; ++ j)
+               splatSh .push (shs [offset + j]);
          }
+      }
 
-         // GaussianSplats node only supports up to degree 3.
-         const shDegreeMax = Math .min (shDegree, 3);
+      // GaussianSplats node only supports up to degree 3.
+      const shDegreeMax = Math .min (shDegree, 3);
 
-         for (let d = 0, i = 0; d < shDegreeMax; ++ d)
-         {
-            const coefs = this .coefsForDegree (d);
+      for (let d = 0, i = 0; d < shDegreeMax; ++ d)
+      {
+         const coefs = this .coefsForDegree (d);
 
-            for (let c = 0; c < coefs; ++ c, ++ i)
-               gaussianSplats [`sphericalHarmonicsDegree${d + 1}Coef${c}`] = splatShs [i];
-         }
+         for (let c = 0; c < coefs; ++ c, ++ i)
+            gaussianSplats [`sphericalHarmonicsDegree${d + 1}Coef${c}`] = splatShs [i];
       }
+   }
 
-      parseMeta ()
-      {
-         return this .files .meta = JSON .parse (new TextDecoder () .decode (this .files ["meta.json"]));
+   parseMeta ()
+   {
+      return this .files .meta = JSON .parse (new TextDecoder () .decode (this .files ["meta.json"]));
+   }
+
+   async unpackFiles ()
+   {
+      await this .unpackImages ();
+
+      const
+         positions        = this .unpackPositions (),
+         rotations        = this .unpackRotations (),
+         scales           = this .unpackScales (),
+         [alphas, colors] = this .unpackAlphasAndAColors (),
+         shs              = this .unpackSphericalHarmonics ();
+
+      return {
+         positions,
+         rotations,
+         scales,
+         alphas,
+         colors,
+         shs,
       }
+   }
 
-      async unpackFiles ()
-      {
-         await this .unpackImages ();
+   async unpackImages ()
+   {
+      return Promise .all (Object .keys (this .files)
+         .filter (key => key .endsWith (".webp"))
+         .map (key => this .unpackImage (key)));
+   }
 
-         const
-            positions        = this .unpackPositions (),
-            rotations        = this .unpackRotations (),
-            scales           = this .unpackScales (),
-            [alphas, colors] = this .unpackAlphasAndAColors (),
-            shs              = this .unpackSphericalHarmonics ();
-
-         return {
-            positions,
-            rotations,
-            scales,
-            alphas,
-            colors,
-            shs,
-         }
-      }
+   async unpackImage (key)
+   {
+      const
+         bytes = this .files [key],
+         blob  = new Blob ([bytes], { type: "image/webp" }),
+         url   = URL .createObjectURL (blob),
+         image = await this .loadImage (url),
+         data  = this .readPixels (image);
 
-      async unpackImages ()
-      {
-         return Promise .all (Object .keys (this .files)
-            .filter (key => key .endsWith (".webp"))
-            .map (key => this .unpackImage (key)));
-      }
+      this .files [key] = image;
+      this .files [key .replace (".webp", "")] = data;
 
-      async unpackImage (key)
+      URL .revokeObjectURL (url);
+   }
+
+   loadImage (url)
+   {
+      return new Promise ((resolve, reject) =>
       {
-         const
-            bytes = this .files [key],
-            blob  = new Blob ([bytes], { type: "image/webp" }),
-            url   = URL .createObjectURL (blob),
-            image = await this .loadImage (url),
-            data  = this .readPixels (image);
+         const image = new Image ();
 
-         this .files [key] = image;
-         this .files [key .replace (".webp", "")] = data;
+         image .onload = () => resolve (image);
 
-         URL .revokeObjectURL (url);
-      }
+         image .onerror =
+         image .onabort = event => reject (new Error (`Couldn't load WebP image: ${event .type}.`));
 
-      loadImage (url)
-      {
-         return new Promise ((resolve, reject) =>
-         {
-            const image = new Image ();
+         image .src = url;
+      });
+   }
 
-            image .onload = () => resolve (image);
+   readPixels (image)
+   {
+      const
+         gl          = this .getBrowser () .getContext (),
+         texture     = gl .createTexture (),
+         framebuffer = gl .createFramebuffer (),
+         width       = image .width,
+         height      = image .height,
+         data        = new Uint8Array (width * height * 4);
 
-            image .onerror =
-            image .onabort = event => reject (new Error (`Couldn't load WebP image: ${event .type}.`));
+      // Create texture.
 
-            image .src = url;
-         });
-      }
+      gl .bindTexture (gl .TEXTURE_2D, texture);
+      gl .pixelStorei (gl .UNPACK_COLORSPACE_CONVERSION_WEBGL, gl .NONE);
+      gl .texImage2D  (gl .TEXTURE_2D, 0, gl .RGBA, width, height, 0, gl .RGBA, gl .UNSIGNED_BYTE, image);
+      gl .pixelStorei (gl .UNPACK_COLORSPACE_CONVERSION_WEBGL, gl .BROWSER_DEFAULT_WEBGL);
 
-      readPixels (image)
-      {
-         const
-            gl          = this .getBrowser () .getContext (),
-            texture     = gl .createTexture (),
-            framebuffer = gl .createFramebuffer (),
-            width       = image .width,
-            height      = image .height,
-            data        = new Uint8Array (width * height * 4);
+      // Read pixels from framebuffer.
 
-         // Create texture.
+      gl .bindFramebuffer (gl .FRAMEBUFFER, framebuffer);
+      gl .framebufferTexture2D (gl .FRAMEBUFFER, gl .COLOR_ATTACHMENT0, gl .TEXTURE_2D, texture, 0);
+      gl .readPixels (0, 0, width, height, gl .RGBA, gl .UNSIGNED_BYTE, data);
 
-         gl .bindTexture (gl .TEXTURE_2D, texture);
-         gl .pixelStorei (gl .UNPACK_COLORSPACE_CONVERSION_WEBGL, gl .NONE);
-         gl .texImage2D  (gl .TEXTURE_2D, 0, gl .RGBA, width, height, 0, gl .RGBA, gl .UNSIGNED_BYTE, image);
-         gl .pixelStorei (gl .UNPACK_COLORSPACE_CONVERSION_WEBGL, gl .BROWSER_DEFAULT_WEBGL);
+      // Clean up.
 
-         // Read pixels from framebuffer.
+      gl .deleteFramebuffer (framebuffer);
+      gl .deleteTexture (texture);
 
-         gl .bindFramebuffer (gl .FRAMEBUFFER, framebuffer);
-         gl .framebufferTexture2D (gl .FRAMEBUFFER, gl .COLOR_ATTACHMENT0, gl .TEXTURE_2D, texture, 0);
-         gl .readPixels (0, 0, width, height, gl .RGBA, gl .UNSIGNED_BYTE, data);
+      return data;
+   }
 
-         // Clean up.
+   unpackPositions ()
+   {
+      const lerp = (a, b, t) => a + t * (b - a);
 
-         gl .deleteFramebuffer (framebuffer);
-         gl .deleteTexture (texture);
+      const unlog = n => Math .sign (n) * (Math .exp (Math .abs (n)) - 1);
 
-         return data;
-      }
+      const {
+         meta: { count, means: { mins, maxs }},
+         means_l,
+         means_u,
+      } = this .files;
 
-      unpackPositions ()
+      const
+         N     = count * 4,
+         array = [ ];
+
+      for (let i = 0; i < N; i += 4)
       {
-         const lerp = (a, b, t) => a + t * (b - a);
+         // 16-bit normalized value per axis (0..65535)
 
-         const unlog = n => Math .sign (n) * (Math .exp (Math .abs (n)) - 1);
+         const
+            qx = (means_u [i]     << 8) | means_l [i],
+            qy = (means_u [i + 1] << 8) | means_l [i + 1],
+            qz = (means_u [i + 2] << 8) | means_l [i + 2];
 
-         const {
-            meta: { count, means: { mins, maxs }},
-            means_l,
-            means_u,
-         } = this .files;
+         // Dequantize into *log-domain* nx,ny,nz using per-axis ranges from meta:
 
          const
-            N     = count * 4,
-            array = [ ];
+            nx = lerp (mins [0], maxs [0], qx / 65535),
+            ny = lerp (mins [1], maxs [1], qy / 65535),
+            nz = lerp (mins [2], maxs [2], qz / 65535);
 
-         for (let i = 0; i < N; i += 4)
-         {
-            // 16-bit normalized value per axis (0..65535)
-
-            const
-               qx = (means_u [i]     << 8) | means_l [i],
-               qy = (means_u [i + 1] << 8) | means_l [i + 1],
-               qz = (means_u [i + 2] << 8) | means_l [i + 2];
+         // Undo the symmetric log transform used at encode time:
 
-            // Dequantize into *log-domain* nx,ny,nz using per-axis ranges from meta:
+         array .push (
+            unlog (nx),
+            unlog (ny),
+            unlog (nz),
+         );
+      }
 
-            const
-               nx = lerp (mins [0], maxs [0], qx / 65535),
-               ny = lerp (mins [1], maxs [1], qy / 65535),
-               nz = lerp (mins [2], maxs [2], qz / 65535);
+      return array;
+   }
 
-            // Undo the symmetric log transform used at encode time:
+   unpackRotations ()
+   {
+      const toComp = c => (c / 255 - 0.5) * 2 / Math .SQRT2;
 
-            array .push (
-               unlog (nx),
-               unlog (ny),
-               unlog (nz),
-            );
-         }
+      const {
+         meta: { count },
+         quats,
+      } = this .files;
 
-         return array;
-      }
+      const
+         N     = count * 4,
+         array = [ ];
 
-      unpackRotations ()
+      for (let i = 0; i < N; i += 4)
       {
-         const toComp = c => (c / 255 - 0.5) * 2 / Math .SQRT2;
-
-         const {
-            meta: { count },
-            quats,
-         } = this .files;
-
          const
-            N     = count * 4,
-            array = [ ];
+            a = toComp (quats [i]),
+            b = toComp (quats [i + 1]),
+            c = toComp (quats [i + 2]);
 
-         for (let i = 0; i < N; i += 4)
-         {
-            const
-               a = toComp (quats [i]),
-               b = toComp (quats [i + 1]),
-               c = toComp (quats [i + 2]);
+         const mode = quats [i + 3] - 252; // 0..3 → omitted component is w, x, y or z respectively
+
+         // Reconstruct the omitted component so that ||q|| = 1 and w.l.o.g. the omitted one is non-negative.
 
-            const mode = quats [i + 3] - 252; // 0..3 → omitted component is w, x, y or z respectively
+         const
+            t = Math .hypot (a, b, c),
+            d = Math .sqrt (Math .max (0, 1 - t));
 
-            // Reconstruct the omitted component so that ||q|| = 1 and w.l.o.g. the omitted one is non-negative.
+         // Place components according to mode; q is ordered [x, y, z, w].
 
-            const
-               t = Math .hypot (a, b, c),
-               d = Math .sqrt (Math .max (0, 1 - t));
-
-            // Place components according to mode; q is ordered [x, y, z, w].
-
-            switch (mode)
-            {
-               case 0: array .push (a, b, c, d); break; // omitted = w
-               case 1: array .push (d, b, c, a); break; // omitted = x
-               case 2: array .push (b, d, c, a); break; // omitted = y
-               case 3: array .push (b, c, d, a); break; // omitted = z
-               default: throw new Error ("Invalid quaternion mode");
-            }
+         switch (mode)
+         {
+            case 0: array .push (a, b, c, d); break; // omitted = w
+            case 1: array .push (d, b, c, a); break; // omitted = x
+            case 2: array .push (b, d, c, a); break; // omitted = y
+            case 3: array .push (b, c, d, a); break; // omitted = z
+            default: throw new Error ("Invalid quaternion mode");
          }
-
-         return array;
       }
 
-      unpackScales ()
-      {
-         const {
-            meta: { count, scales: { codebook } },
-            scales,
-         } = this .files;
+      return array;
+   }
 
-         const
-            N     = count * 4,
-            array = [ ];
+   unpackScales ()
+   {
+      const {
+         meta: { count, scales: { codebook } },
+         scales,
+      } = this .files;
 
-         for (let i = 0; i < N; i += 4)
-         {
-            array .push (
-               Math .exp (codebook [scales [i]]), // r,g,b are 0..255
-               Math .exp (codebook [scales [i + 1]]),
-               Math .exp (codebook [scales [i + 2]]),
-            );
-         }
+      const
+         N     = count * 4,
+         array = [ ];
 
-         return array;
+      for (let i = 0; i < N; i += 4)
+      {
+         array .push (
+            Math .exp (codebook [scales [i]]), // r,g,b are 0..255
+            Math .exp (codebook [scales [i + 1]]),
+            Math .exp (codebook [scales [i + 2]]),
+         );
       }
 
-      unpackAlphasAndAColors ()
-      {
-         const {
-            meta: { count, sh0: { codebook } },
-            sh0,
-         } = this .files;
+      return array;
+   }
 
-         const
-            N      = count * 4,
-            array  = [ ],
-            alphas = [ ];
+   unpackAlphasAndAColors ()
+   {
+      const {
+         meta: { count, sh0: { codebook } },
+         sh0,
+      } = this .files;
 
-         for (let i = 0; i < N; i += 4)
-         {
-            array .push (
-               codebook [sh0 [i]],
-               codebook [sh0 [i + 1]],
-               codebook [sh0 [i + 2]],
-            );
+      const
+         N      = count * 4,
+         array  = [ ],
+         alphas = [ ];
 
-            alphas .push (sh0 [i + 3] / 255);
-         }
+      for (let i = 0; i < N; i += 4)
+      {
+         array .push (
+            codebook [sh0 [i]],
+            codebook [sh0 [i + 1]],
+            codebook [sh0 [i + 2]],
+         );
 
-         return [alphas, array];
+         alphas .push (sh0 [i + 3] / 255);
       }
 
-      unpackSphericalHarmonics ()
-      {
-         if (!this .files .meta .shN)
-            return [ ];
+      return [alphas, array];
+   }
 
-         const {
-            meta: { count, shN: { bands, codebook } },
-            shN_labels,
-            shN_centroids,
-            "shN_centroids.webp": { width },
-         } = this .files;
+   unpackSphericalHarmonics ()
+   {
+      if (!this .files .meta .shN)
+         return [ ];
 
-         const getIndex = (u, v) => u + v * width;
+      const {
+         meta: { count, shN: { bands, codebook } },
+         shN_labels,
+         shN_centroids,
+         "shN_centroids.webp": { width },
+      } = this .files;
 
-         const
-            coeffs   = [0, 3, 8, 15],
-            shCoeffs = coeffs [bands]; // coefficients per color channel
+      const getIndex = (u, v) => u + v * width;
 
-         if (!shCoeffs)
-            return [ ];
+      const
+         coeffs   = [0, 3, 8, 15],
+         shCoeffs = coeffs [bands]; // coefficients per color channel
 
-         const
-            N     = count * 4,
-            array = [ ];
+      if (!shCoeffs)
+         return [ ];
 
-         for (let i = 0; i < N; i += 4)
-         {
-            // 1. Look up this gaussian's palette entry.
+      const
+         N     = count * 4,
+         array = [ ];
 
-            const label = shN_labels [i] + (shN_labels [i + 1] << 8);
+      for (let i = 0; i < N; i += 4)
+      {
+         // 1. Look up this gaussian's palette entry.
 
-            // 2. For each coefficient, read RGB from the centroids pixel and map through the codebook.
+         const label = shN_labels [i] + (shN_labels [i + 1] << 8);
 
-            for (let c = 0; c < shCoeffs; ++ c)
-            {
-               const
-                  u = (label % 64) * shCoeffs + c,
-                  v = Math .floor (label / 64);
+         // 2. For each coefficient, read RGB from the centroids pixel and map through the codebook.
 
-               // pixel (u, v) in shN_centroids.webp
-               const index = getIndex (u, v) * 4;
+         for (let c = 0; c < shCoeffs; ++ c)
+         {
+            const
+               u = (label % 64) * shCoeffs + c,
+               v = Math .floor (label / 64);
 
-               const
-                  r = shN_centroids [index],
-                  g = shN_centroids [index + 1],
-                  b = shN_centroids [index + 2];
+            // pixel (u, v) in shN_centroids.webp
+            const index = getIndex (u, v) * 4;
 
-               array .push (
-                  codebook [r], // SH AC coefficient for color channel 0
-                  codebook [g], // SH AC coefficient for color channel 1
-                  codebook [b], // SH AC coefficient for color channel 2
-               );
-            }
-         }
+            const
+               r = shN_centroids [index],
+               g = shN_centroids [index + 1],
+               b = shN_centroids [index + 2];
 
-         return array;
+            array .push (
+               codebook [r], // SH AC coefficient for color channel 0
+               codebook [g], // SH AC coefficient for color channel 1
+               codebook [b], // SH AC coefficient for color channel 2
+            );
+         }
       }
 
-      dimForDegree (degree)
-      {
-         return (degree + 1) ** 2 - 1;
-      }
+      return array;
+   }
 
-      coefsForDegree (degree)
-      {
-         return degree * 2 + 3;
-      }
+   dimForDegree (degree)
+   {
+      return (degree + 1) ** 2 - 1;
    }
 
-   X3D .GoldenGate .addParsers (SOGParser);
+   coefsForDegree (degree)
+   {
+      return degree * 2 + 3;
+   }
 });
 
 /******/ })()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "x_ite-sog-parser",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "3DGS SOG File Format Parser for X_ITE",
   "main": "dist/x_ite-sog-parser-2.js",
   "module": "dist/x_ite-sog-parser-2.js",
@@ -39,12 +39,12 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "eslint": "^10.4.1",
+    "eslint": "^10.5.0",
     "fflate": "^0.8.3",
     "globals": "^17.6.0",
     "shell-tools": "^1.1.9",
     "webpack": "^5.107.2",
     "webpack-cli": "^7.0.3",
-    "x_ite-extension": "^1.0.0"
+    "x_ite-extension": "^1.0.1"
   }
 }