x_ite-sog-parser 1.1.1 → 1.2.0

package/README.md

@@ -13,18 +13,16 @@ Include the script after X_ITE:
 
 ```html
 <script defer src="https://cdn.jsdelivr.net/npm/x_ite@VERSION/dist/x_ite.min.js"></script>
-<script defer src="https://cdn.jsdelivr.net/npm/x_ite-sog-parser@1.1.1/dist/x_ite-sog-parser-2.min.js"></script>
+<script defer src="https://cdn.jsdelivr.net/npm/x_ite-sog-parser@1.2.0/dist/x_ite-sog-parser-2.min.js"></script>
 <!-- or as ES module -->
 <script type="module" src="https://cdn.jsdelivr.net/npm/x_ite@VERSION/dist/x_ite.min.mjs"></script>
-<script type="module" src="https://cdn.jsdelivr.net/npm/x_ite-sog-parser@1.1.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.0/dist/x_ite-sog-parser-2.min.js"></script>
 ```
 
-Now you can directly load `.sog` files with the `src` attribute, but you also have to add the `extensions` attribute with a number, how many X_ITE extension you have included. Each extension will decrease this count and when it becomes `0`, the canvas knows that all extensions are loaded and now starts loading the file in the `src` attribute.
-
-You can also use `.sog` files as source of an Inline node.
+You can now load `.sog` files directly using the `src` attribute, but you can also use `.sog` files as source of an Inline node.
 
 ```html
-<x3d-canvas data-src="room.sog" extensions="1"></x3d-canvas>
+<x3d-canvas src="room.sog"></x3d-canvas>
 ```
 
 ## NPM

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

@@ -2694,472 +2694,503 @@ function unzipSync(data, opts) {
     return files;
 }
 
-;// ./src/x_ite-sog-parser-2.js
+;// ./node_modules/x_ite-extension/dist/x_ite-extension.js
+/******/ // The require scope
+/******/ var __nested_webpack_require_43__ = {};
+/******/ 
+/************************************************************************/
+/******/ /* webpack/runtime/define property getters */
+/******/ (() => {
+/******/ 	// define getter functions for harmony exports
+/******/ 	__nested_webpack_require_43__.d = (exports, definition) => {
+/******/ 		for(var key in definition) {
+/******/ 			if(__nested_webpack_require_43__.o(definition, key) && !__nested_webpack_require_43__.o(exports, key)) {
+/******/ 				Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 			}
+/******/ 		}
+/******/ 	};
+/******/ })();
+/******/ 
+/******/ /* webpack/runtime/hasOwnProperty shorthand */
+/******/ (() => {
+/******/ 	__nested_webpack_require_43__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ })();
+/******/ 
+/************************************************************************/
+var __nested_webpack_exports__ = {};
+/* harmony export */ __nested_webpack_require_43__.d(__nested_webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ register)
+/* harmony export */ });
+function register (callback)
+{
+   const X3D = window [Symbol .for ("X_ITE.X3D")];
+
+   if (X3D)
+      callback (X3D);
+   else
+      (window [Symbol .for ("X_ITE.extensions")] ??= [ ]) .push (callback);
+};
 
+const __webpack_exports__default = __nested_webpack_exports__.A;
 
-const X3D = window [Symbol .for ("X_ITE.X3D")];
 
-/*
- * Parser
- * Reference: https://github.com/playcanvas/splat-transform/blob/main/src/lib/readers/read-sog.ts
- */
+;// ./src/x_ite-sog-parser-2.js
 
-class SOGParser extends X3D .X3DParser
+
+
+__webpack_exports__default (X3D =>
 {
-   constructor (scene)
-   {
-      super (scene);
-   }
+   /*
+   * Parser
+   * Reference: https://github.com/playcanvas/splat-transform/blob/main/src/lib/readers/read-sog.ts
+   */
 
-   getEncoding ()
+   class SOGParser extends X3D .X3DParser
    {
-      return "ARRAY_BUFFER";
-   }
+      constructor (scene)
+      {
+         super (scene);
+      }
 
-   setInput (buffer)
-   {
-      this .buffer = buffer;
-   }
+      getEncoding ()
+      {
+         return "ARRAY_BUFFER";
+      }
 
-   isValid ()
-   {
-      if (this .buffer .byteLength < 4)
-         return false;
+      setInput (buffer)
+      {
+         this .buffer = buffer;
+      }
 
-      // Check magic.
+      isValid ()
+      {
+         if (this .buffer .byteLength < 4)
+            return false;
 
-      const dataView = new DataView (this .buffer);
+         // Check magic.
 
-      if (dataView .getUint32 (0, false) !== 0x504B0304)
-         return false;
+         const dataView = new DataView (this .buffer);
 
-      // Check minimum requirement for Gaussian Splats.
+         if (dataView .getUint32 (0, false) !== 0x504B0304)
+            return false;
 
-      const keys = [
-         "means_l.webp",
-         "means_u.webp",
-         "scales.webp",
-         "sh0.webp",
-         "quats.webp",
-         "meta.json",
-      ];
+         // Check minimum requirement for Gaussian Splats.
 
-      this .files = unzipSync (new Uint8Array (this .buffer));
+         const keys = [
+            "means_l.webp",
+            "means_u.webp",
+            "scales.webp",
+            "sh0.webp",
+            "quats.webp",
+            "meta.json",
+         ];
 
-      if (!keys .every (key => this .files [key]))
-         return false;
+         this .files = unzipSync (new Uint8Array (this .buffer));
 
-      // Check version.
+         if (!keys .every (key => this .files [key]))
+            return false;
 
-      const meta = this .parseMeta ();
+         // Check version.
 
-      if (meta .version < 2 || meta .version > 2)
-         return false;
+         const meta = this .parseMeta ();
 
-      return true;
-   }
+         if (meta .version < 2 || meta .version > 2)
+            return false;
 
-   parseIntoScene (resolve, reject)
-   {
-      this .sog ()
-         .then (resolve)
-         .catch (reject);
-   }
+         return true;
+      }
 
-   async sog ()
-   {
-      const
-         browser = this .getBrowser (),
-         scene   = this .getScene ();
+      parseIntoScene (resolve, reject)
+      {
+         this .sog ()
+            .then (resolve)
+            .catch (reject);
+      }
 
-      scene .setEncoding ("SOG");
-      scene .setProfile (browser .getProfile ("Interchange"));
-      scene .addComponent (browser .getComponent ("X_ITE"));
+      async sog ()
+      {
+         const
+            browser = this .getBrowser (),
+            scene   = this .getScene ();
 
-      await this .getBrowser () .loadComponents (scene);
+         scene .setEncoding ("SOG");
+         scene .setProfile (browser .getProfile ("Interchange"));
+         scene .addComponent (browser .getComponent ("X_ITE"));
 
-      const
-         transform      = scene .createNode ("Transform"),
-         gaussianSplats = scene .createNode ("GaussianSplats"),
-         gaussianCloud  = await this .unpackFiles ();
+         await this .getBrowser () .loadComponents (scene);
 
-      gaussianSplats .positions    = gaussianCloud .positions;
-      gaussianSplats .orientations = gaussianCloud .rotations;
-      gaussianSplats .scales       = gaussianCloud .scales;
-      gaussianSplats .opacities    = gaussianCloud .alphas;
+         const
+            transform      = scene .createNode ("Transform"),
+            gaussianSplats = scene .createNode ("GaussianSplats"),
+            gaussianCloud  = await this .unpackFiles ();
 
-      gaussianSplats .sphericalHarmonicsDegree0Coef0 = gaussianCloud .colors;
+         gaussianSplats .positions    = gaussianCloud .positions;
+         gaussianSplats .orientations = gaussianCloud .rotations;
+         gaussianSplats .scales       = gaussianCloud .scales;
+         gaussianSplats .opacities    = gaussianCloud .alphas;
 
-      // Set spherical harmonics.
+         gaussianSplats .sphericalHarmonicsDegree0Coef0 = gaussianCloud .colors;
 
-      if (gaussianCloud .shs .length)
-      {
-         const {
-            meta: { count, shN: { bands } },
-         } = this .files;
+         // Set spherical harmonics.
 
-         const
-            shs      = gaussianCloud .shs,
-            shDegree = bands;
+         if (gaussianCloud .shs .length)
+         {
+            const {
+               meta: { count, shN: { bands } },
+            } = this .files;
 
-         this .setSphericalHarmonics (count, shs, shDegree, gaussianSplats)
-      }
+            const
+               shs      = gaussianCloud .shs,
+               shDegree = bands;
 
-      // Add nodes to scene.
+            this .setSphericalHarmonics (count, shs, shDegree, gaussianSplats)
+         }
 
-      transform .rotation = new X3D .Rotation4 (1, 0, 0, Math .PI);
+         // Add nodes to scene.
 
-      transform .children .push (gaussianSplats);
-      scene .rootNodes .push (transform);
+         transform .rotation = new X3D .Rotation4 (1, 0, 0, Math .PI);
 
-      return scene;
-   }
+         transform .children .push (gaussianSplats);
+         scene .rootNodes .push (transform);
 
-   setSphericalHarmonics (numSplats, shs, shDegree, gaussianSplats)
-   {
-      const
-         shCoeffs  = this .dimForDegree (shDegree),
-         shCoeffs3 = this .dimForDegree (shDegree) * 3,
-         splatShs  = Array .from ({ length: shCoeffs }, () => [ ]);
+         return scene;
+      }
 
-      for (let c = 0; c < shCoeffs; ++ c)
+      setSphericalHarmonics (numSplats, shs, shDegree, gaussianSplats)
       {
          const
-            c3      = c * 3,
-            splatSh = splatShs [c];
+            shCoeffs  = this .dimForDegree (shDegree),
+            shCoeffs3 = this .dimForDegree (shDegree) * 3,
+            splatShs  = Array .from ({ length: shCoeffs }, () => [ ]);
 
-         for (let i = 0; i < numSplats; ++ i)
+         for (let c = 0; c < shCoeffs; ++ c)
          {
-            const offset = shCoeffs3 * i + c3;
+            const
+               c3      = c * 3,
+               splatSh = splatShs [c];
+
+            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"]));
-   }
-
-   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,
+      parseMeta ()
+      {
+         return this .files .meta = JSON .parse (new TextDecoder () .decode (this .files ["meta.json"]));
       }
-   }
-
-   async unpackImages ()
-   {
-      return Promise .all (Object .keys (this .files)
-         .filter (key => key .endsWith (".webp"))
-         .map (key => this .unpackImage (key)));
-   }
 
-   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);
-
-      this .files [key] = image;
-      this .files [key .replace (".webp", "")] = data;
+      async unpackFiles ()
+      {
+         await this .unpackImages ();
 
-      URL .revokeObjectURL (url);
-   }
+         const
+            positions        = this .unpackPositions (),
+            rotations        = this .unpackRotations (),
+            scales           = this .unpackScales (),
+            [alphas, colors] = this .unpackAlphasAndAColors (),
+            shs              = this .unpackSphericalHarmonics ();
+
+         return {
+            positions,
+            rotations,
+            scales,
+            alphas,
+            colors,
+            shs,
+         }
+      }
 
-   loadImage (url)
-   {
-      return new Promise ((resolve, reject) =>
+      async unpackImages ()
       {
-         const image = new Image ();
+         return Promise .all (Object .keys (this .files)
+            .filter (key => key .endsWith (".webp"))
+            .map (key => this .unpackImage (key)));
+      }
 
-         image .onload = () => resolve (image);
+      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);
 
-         image .onerror =
-         image .onabort = event => reject (new Error (`Couldn't load WebP image: ${event .type}.`));
+         this .files [key] = image;
+         this .files [key .replace (".webp", "")] = data;
 
-         image .src = url;
-      });
-   }
+         URL .revokeObjectURL (url);
+      }
 
-   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);
+      loadImage (url)
+      {
+         return new Promise ((resolve, reject) =>
+         {
+            const image = new Image ();
 
-      // Create texture.
+            image .onload = () => resolve (image);
 
-      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);
+            image .onerror =
+            image .onabort = event => reject (new Error (`Couldn't load WebP image: ${event .type}.`));
 
-      // Read pixels from framebuffer.
+            image .src = url;
+         });
+      }
 
-      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);
+      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);
 
-      // Clean up.
+         // Create texture.
 
-      gl .deleteFramebuffer (framebuffer);
-      gl .deleteTexture (texture);
+         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);
 
-      return data;
-   }
+         // Read pixels from framebuffer.
 
-   unpackPositions ()
-   {
-      const lerp = (a, b, t) => a + t * (b - a);
+         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);
 
-      const unlog = n => Math .sign (n) * (Math .exp (Math .abs (n)) - 1);
+         // Clean up.
 
-      const {
-         meta: { count, means: { mins, maxs }},
-         means_l,
-         means_u,
-      } = this .files;
+         gl .deleteFramebuffer (framebuffer);
+         gl .deleteTexture (texture);
 
-      const
-         N     = count * 4,
-         array = [ ];
+         return data;
+      }
 
-      for (let i = 0; i < N; i += 4)
+      unpackPositions ()
       {
-         // 16-bit normalized value per axis (0..65535)
+         const lerp = (a, b, t) => a + t * (b - a);
 
-         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 unlog = n => Math .sign (n) * (Math .exp (Math .abs (n)) - 1);
 
-         // Dequantize into *log-domain* nx,ny,nz using per-axis ranges from meta:
+         const {
+            meta: { count, means: { mins, maxs }},
+            means_l,
+            means_u,
+         } = this .files;
 
          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);
+            N     = count * 4,
+            array = [ ];
 
-         // Undo the symmetric log transform used at encode time:
+         for (let i = 0; i < N; i += 4)
+         {
+            // 16-bit normalized value per axis (0..65535)
 
-         array .push (
-            unlog (nx),
-            unlog (ny),
-            unlog (nz),
-         );
-      }
+            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];
 
-      return array;
-   }
+            // Dequantize into *log-domain* nx,ny,nz using per-axis ranges from meta:
 
-   unpackRotations ()
-   {
-      const toComp = c => (c / 255 - 0.5) * 2 / Math .SQRT2;
+            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);
 
-      const {
-         meta: { count },
-         quats,
-      } = this .files;
+            // Undo the symmetric log transform used at encode time:
 
-      const
-         N     = count * 4,
-         array = [ ];
+            array .push (
+               unlog (nx),
+               unlog (ny),
+               unlog (nz),
+            );
+         }
 
-      for (let i = 0; i < N; i += 4)
-      {
-         const
-            a = toComp (quats [i]),
-            b = toComp (quats [i + 1]),
-            c = toComp (quats [i + 2]);
+         return array;
+      }
 
-         const mode = quats [i + 3] - 252; // 0..3 → omitted component is w, x, y or z respectively
+      unpackRotations ()
+      {
+         const toComp = c => (c / 255 - 0.5) * 2 / Math .SQRT2;
 
-         // Reconstruct the omitted component so that ||q|| = 1 and w.l.o.g. the omitted one is non-negative.
+         const {
+            meta: { count },
+            quats,
+         } = this .files;
 
          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].
+            N     = count * 4,
+            array = [ ];
 
-         switch (mode)
+         for (let i = 0; i < N; i += 4)
          {
-            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");
-         }
-      }
+            const
+               a = toComp (quats [i]),
+               b = toComp (quats [i + 1]),
+               c = toComp (quats [i + 2]);
 
-      return array;
-   }
+            const mode = quats [i + 3] - 252; // 0..3 → omitted component is w, x, y or z respectively
 
-   unpackScales ()
-   {
-      const {
-         meta: { count, scales: { codebook } },
-         scales,
-      } = this .files;
+            // Reconstruct the omitted component so that ||q|| = 1 and w.l.o.g. the omitted one is non-negative.
 
-      const
-         N     = count * 4,
-         array = [ ];
+            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");
+            }
+         }
 
-      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]]),
-         );
+         return array;
       }
 
-      return array;
-   }
-
-   unpackAlphasAndAColors ()
-   {
-      const {
-         meta: { count, sh0: { codebook } },
-         sh0,
-      } = this .files;
+      unpackScales ()
+      {
+         const {
+            meta: { count, scales: { codebook } },
+            scales,
+         } = this .files;
 
-      const
-         N      = count * 4,
-         array  = [ ],
-         alphas = [ ];
+         const
+            N     = count * 4,
+            array = [ ];
 
-      for (let i = 0; i < N; i += 4)
-      {
-         array .push (
-            codebook [sh0 [i]],
-            codebook [sh0 [i + 1]],
-            codebook [sh0 [i + 2]],
-         );
+         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]]),
+            );
+         }
 
-         alphas .push (sh0 [i + 3] / 255);
+         return array;
       }
 
-      return [alphas, array];
-   }
+      unpackAlphasAndAColors ()
+      {
+         const {
+            meta: { count, sh0: { codebook } },
+            sh0,
+         } = this .files;
 
-   unpackSphericalHarmonics ()
-   {
-      if (!this .files .meta .shN)
-         return [ ];
+         const
+            N      = count * 4,
+            array  = [ ],
+            alphas = [ ];
 
-      const {
-         meta: { count, shN: { bands, codebook } },
-         shN_labels,
-         shN_centroids,
-         "shN_centroids.webp": { width },
-      } = this .files;
+         for (let i = 0; i < N; i += 4)
+         {
+            array .push (
+               codebook [sh0 [i]],
+               codebook [sh0 [i + 1]],
+               codebook [sh0 [i + 2]],
+            );
 
-      const getIndex = (u, v) => u + v * width;
+            alphas .push (sh0 [i + 3] / 255);
+         }
 
-      const
-         coeffs   = [0, 3, 8, 15],
-         shCoeffs = coeffs [bands]; // coefficients per color channel
+         return [alphas, array];
+      }
 
-      if (!shCoeffs)
-         return [ ];
+      unpackSphericalHarmonics ()
+      {
+         if (!this .files .meta .shN)
+            return [ ];
 
-      const
-         N     = count * 4,
-         array = [ ];
+         const {
+            meta: { count, shN: { bands, codebook } },
+            shN_labels,
+            shN_centroids,
+            "shN_centroids.webp": { width },
+         } = this .files;
 
-      for (let i = 0; i < N; i += 4)
-      {
-         // 1. Look up this gaussian's palette entry.
+         const getIndex = (u, v) => u + v * width;
 
-         const label = shN_labels [i] + (shN_labels [i + 1] << 8);
+         const
+            coeffs   = [0, 3, 8, 15],
+            shCoeffs = coeffs [bands]; // coefficients per color channel
 
-         // 2. For each coefficient, read RGB from the centroids pixel and map through the codebook.
+         if (!shCoeffs)
+            return [ ];
 
-         for (let c = 0; c < shCoeffs; ++ c)
+         const
+            N     = count * 4,
+            array = [ ];
+
+         for (let i = 0; i < N; i += 4)
          {
-            const
-               u = (label % 64) * shCoeffs + c,
-               v = Math .floor (label / 64);
+            // 1. Look up this gaussian's palette entry.
 
-            // pixel (u, v) in shN_centroids.webp
-            const index = getIndex (u, v) * 4;
+            const label = shN_labels [i] + (shN_labels [i + 1] << 8);
 
-            const
-               r = shN_centroids [index],
-               g = shN_centroids [index + 1],
-               b = shN_centroids [index + 2];
+            // 2. For each coefficient, read RGB from the centroids pixel and map through the codebook.
 
-            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
-            );
-         }
-      }
+            for (let c = 0; c < shCoeffs; ++ c)
+            {
+               const
+                  u = (label % 64) * shCoeffs + c,
+                  v = Math .floor (label / 64);
 
-      return array;
-   }
-
-   dimForDegree (degree)
-   {
-      return (degree + 1) ** 2 - 1;
-   }
+               // pixel (u, v) in shN_centroids.webp
+               const index = getIndex (u, v) * 4;
 
-   coefsForDegree (degree)
-   {
-      return degree * 2 + 3;
-   }
-}
+               const
+                  r = shN_centroids [index],
+                  g = shN_centroids [index + 1],
+                  b = shN_centroids [index + 2];
 
-X3D .GoldenGate .addParsers (SOGParser);
+               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
+               );
+            }
+         }
 
-// Decrement extensions attribute to show that the parser is loaded.
+         return array;
+      }
 
-const canvases = document .querySelectorAll ("x3d-canvas");
+      dimForDegree (degree)
+      {
+         return (degree + 1) ** 2 - 1;
+      }
 
-for (const canvas of canvases)
-{
-   const { element } = X3D .getBrowser (canvas);
+      coefsForDegree (degree)
+      {
+         return degree * 2 + 3;
+      }
+   }
 
-   element .setAttribute ("extensions", Math .max ((element .getAttribute ("extensions")|0) - 1, 0));
-}
+   X3D .GoldenGate .addParsers (SOGParser);
+});
 
 /******/ })()
 ;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "x_ite-sog-parser",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "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",
@@ -44,6 +44,7 @@
     "globals": "^17.6.0",
     "shell-tools": "^1.1.9",
     "webpack": "^5.107.2",
-    "webpack-cli": "^7.0.3"
+    "webpack-cli": "^7.0.3",
+    "x_ite-extension": "^1.0.0"
   }
 }