@woosh/meep-engine 3.30.0 → 3.32.0

package/src/shade/renderer/loader/gltf/gltf_base_url.js

@@ -0,0 +1,27 @@
+/**
+ * The directory a container's sibling files are resolved against.
+ *
+ * Three cases, and the test used to be against the wrong sentinel — `lastIndexOf('/') !== 0` where
+ * `!== -1` was meant — so it got two of the three wrong:
+ *
+ *  - a bare file name has no slash at all, `lastIndexOf` is -1, and the old test took the "has a
+ *    directory" branch to produce `url.substring(0, 0)` — the empty string, which `loadFromJson`
+ *    rejects outright with "baseUrl must be specified". That is what a drag-and-drop `fileMap`
+ *    produces, which is the case the option exists for.
+ *  - a root-relative `/model.glb` has its only slash at 0, and the old test sent it to `'./'`, so
+ *    a sibling `scene.bin` resolved against the current directory rather than the root.
+ *  - everything with an interior slash was, and is, the prefix up to and including it. That is
+ *    every call site in this repo, which is why neither of the other two has been seen.
+ *
+ * @param {string} url
+ * @returns {string} with a trailing separator, or `'./'` when there is no directory part
+ */
+export function gltf_base_url(url) {
+    const i = url.lastIndexOf('/');
+
+    if (i === -1) {
+        return './';
+    }
+
+    return url.substring(0, i + 1);
+}

package/src/shade/renderer/loader/gltf/gltf_create_material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf_create_material.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/gltf_create_material.js"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH,oDAJW;IAAC,oBAAoB,CAAC,CAAC;IAAA,aAAa,CAAC,EAAC,MAAM,CAAC;IAAA,WAAW,CAAC,EAAC,OAAO,CAAA;CAAC,YAClE,cAAc,GACZ,qBAAqB,CAoQjC;sCAnRqC,yCAAyC"}
+{"version":3,"file":"gltf_create_material.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/gltf_create_material.js"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH,oDAJW;IAAC,oBAAoB,CAAC,CAAC;IAAA,aAAa,CAAC,EAAC,MAAM,CAAC;IAAA,WAAW,CAAC,EAAC,OAAO,CAAA;CAAC,YAClE,cAAc,GACZ,qBAAqB,CA4SjC;sCA3TqC,yCAAyC"}

package/src/shade/renderer/loader/gltf/gltf_create_material.js

@@ -41,7 +41,17 @@ export function gltf_create_material(
     if (normalTexture !== undefined) {
         const texture = textures[normalTexture.index];
 
-        // texture.source.color_space = ColorSpace.None;
+        /*
+         Every slot states its colour space, including the linear ones.
+
+         These used to be written onto the shared ShadeImage — one per glTF image index, held by
+         every ShadeTexture over it — and only ever to sRGB, with no slot writing linear back. So a
+         one-way latch on shared state: if any material in the document named image N as a base
+         colour or an emissive, every other texture over image N decoded sRGB too, whatever slot it
+         filled. An authored roughness of 0.5 read back as 0.216 and the surface rendered far
+         glossier than it was written, for a reason living in a different material.
+        */
+        texture.color_space = ColorSpace.LinearSRGB;
         texture.mipmapGenerationFilter = TextureFilterType.LinearNormal;
 
         material.texture_normal = texture;
@@ -51,7 +61,7 @@ export function gltf_create_material(
 
     if (emissiveTexture !== undefined) {
         const texture = textures[emissiveTexture.index];
-        texture.image.color_space = ColorSpace.SRGB;
+        texture.color_space = ColorSpace.SRGB;
 
         texture.mipmapGenerationFilter = MIPMAP_FILTER_COLOR;
 
@@ -83,7 +93,7 @@ export function gltf_create_material(
         const texture_base = pbr_mr.baseColorTexture;
         if (texture_base !== undefined) {
             const texture = textures[texture_base.index];
-            texture.image.color_space = ColorSpace.SRGB;
+            texture.color_space = ColorSpace.SRGB;
 
             texture.mipmapGenerationFilter = MIPMAP_FILTER_COLOR;
 
@@ -92,14 +102,27 @@ export function gltf_create_material(
 
         const texture_mr = pbr_mr.metallicRoughnessTexture;
         if (texture_mr !== undefined) {
-            material.texture_orm = textures[texture_mr.index];
-        }
+            const texture = textures[texture_mr.index];
+
+            // data, not colour — see the note on the normal slot
+            texture.color_space = ColorSpace.LinearSRGB;
 
-        material.roughness_factor = clamp01(pbr_mr.roughnessFactor ?? 1);
-        material.metallic_factor = clamp01(pbr_mr.metallicFactor ?? 1);
+            material.texture_orm = texture;
+        }
 
     }
 
+    /*
+     glTF 2.0 5.19: every pbrMetallicRoughness property has a default that applies whether or not
+     the object is authored — baseColorFactor [1,1,1,1], metallicFactor 1, roughnessFactor 1. These
+     used to be read inside the branch above, so a material that omits the object kept
+     StandardShadeMaterial own defaults instead, and that class defaults metallic_factor to 0.
+     `{"materials":[{"name":"m"}]}` is a legal glTF material meaning white, fully metallic, fully
+     rough; the loader produced white diffuse plastic — a different BRDF lobe for the whole surface.
+    */
+    material.roughness_factor = clamp01(pbr_mr?.roughnessFactor ?? 1);
+    material.metallic_factor = clamp01(pbr_mr?.metallicFactor ?? 1);
+
     material.transparency_mode = gltf_parse_alphaMode(gltf_material.alphaMode);
 
     // TODO ensure that texture has proper alpha channel if transparency is enabled
@@ -114,6 +137,9 @@ export function gltf_create_material(
 
         const ao_texture = textures[ao_index];
 
+        // data, not colour — see the note on the normal slot
+        ao_texture.color_space = ColorSpace.LinearSRGB;
+
         if (material.texture_orm !== undefined && ao_texture !== material.texture_orm) {
             console.warn(`Material.occlusionTexture uses a different texture from metallicRoughness, this is unsupported. Material name='${material.name}'`);
         }
@@ -145,9 +171,18 @@ export function gltf_create_material(
         if (pbr_sg !== undefined) {
             // see https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Archived/KHR_materials_pbrSpecularGlossiness/README.md
 
-            const diffuse_color = new Color();
-            const specular_color = new Color();
-            let glossiness = 0;
+            /*
+             The extension defaults: diffuseFactor [1,1,1,1], specularFactor [1,1,1],
+             glossinessFactor 1. These were seeded from `new Color()` — which is (0,0,0,1) — and
+             the literal 0, and only overwritten when the file authored the factor. So a material
+             whose colour comes entirely from a map, which is the common shape and perfectly legal,
+             converted from black diffuse and black specular at zero glossiness and landed on a
+             black diffuse_color: every pixel of the surface became the map multiplied by zero.
+             That is the absent-factor-defaults-to-white rule inverted, for all three.
+            */
+            const diffuse_color = new Color(1, 1, 1, 1);
+            const specular_color = new Color(1, 1, 1, 1);
+            let glossiness = 1;
 
             const color_base = pbr_sg.diffuseFactor;
             if (color_base !== undefined) {
@@ -168,6 +203,11 @@ export function gltf_create_material(
 
             material.diffuse_color.copy(mr.base_color);
 
+            // the conversion derives these too, and they used to be dropped on the floor — so an
+            // SG material had no metalness or roughness derived for it at all
+            material.metallic_factor = clamp01(mr.metallic);
+            material.roughness_factor = clamp01(mr.roughness);
+
         }
 
 

package/src/shade/renderer/loader/gltf/load_gltf.d.ts

@@ -31,6 +31,10 @@
  *
  * Exported for spec coverage; not part of the loader's public API.
  *
+ * The walk itself is {@link quat3_canonicalize_sign_run}, which
+ * `hemisphere_align_quaternion_values` in `engine/animation/clip` also runs — that one used to be a
+ * second, weaker implementation, handling only the 4-float stride and anchoring nothing.
+ *
  * @param {Float32Array} values flat values: STEP/LINEAR uses 4
  *     floats/keyframe (x, y, z, w); CUBICSPLINE uses 12 (inX, inY,
  *     inZ, inW, valX, valY, valZ, valW, outX, outY, outZ, outW).

package/src/shade/renderer/loader/gltf/load_gltf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load_gltf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/load_gltf.js"],"names":[],"mappings":"AAmIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,sDATW,YAAY,aAGZ,MAAM,iBACN,MAAM,kBACN;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,QAgDlD;AAuBD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,+BAdW,MAAM;IAEgB,YAAY;IAGN,KAAK;IACY,OAAO,GAApD,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC;IAGF,eAAe,GAA/C,qBAAqB;IAGpB,QAAQ,WAAW,CAAC,CAu0B/B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wCARW,MAAM;IAEgB,YAAY;IACN,KAAK;IACY,OAAO,GAApD,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC;IACF,eAAe,GAA/C,qBAAqB;IACnB,QAAQ,QAAQ,CAAC,CAU7B;4BA7kC2B,mBAAmB;yBAStB,gBAAgB"}
+{"version":3,"file":"load_gltf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/load_gltf.js"],"names":[],"mappings":"AAsIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,sDATW,YAAY,aAGZ,MAAM,iBACN,MAAM,kBACN;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,QAUlD;AAuBD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,+BAdW,MAAM;IAEgB,YAAY;IAGN,KAAK;IACY,OAAO,GAApD,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC;IAGF,eAAe,GAA/C,qBAAqB;IAGpB,QAAQ,WAAW,CAAC,CA00B/B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wCARW,MAAM;IAEgB,YAAY;IACN,KAAK;IACY,OAAO,GAApD,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC;IACF,eAAe,GAA/C,qBAAqB;IACnB,QAAQ,QAAQ,CAAC,CAU7B;4BAjjC2B,mBAAmB;yBAWtB,gBAAgB"}

package/src/shade/renderer/loader/gltf/load_gltf.js

@@ -34,13 +34,16 @@ import { ShadeImage } from "../../texture/source/ShadeImage.js";
 import { SceneBundle } from "../SceneBundle.js";
 import { SceneNode } from "../SceneNode.js";
 import { coalesce_array_duplicates } from "../../../../format/scene/gltf/coalesce_array_duplicates.js";
-import { GLTF_COMPONENT_TYPE } from "../../../../format/scene/gltf/gltf_component_type.js";
 import { gltf_create_material } from "./gltf_create_material.js";
 import { gltf_create_texture } from "./gltf_create_texture.js";
 import { GLTF_PRIMITIVE_MODE, GLTF_PRIMITIVE_MODE_DEFAULT } from "../../../../format/scene/gltf/GLTF_PRIMITIVE_MODE.js";
-import { gltf_read_accessor } from "../../../../format/scene/gltf/gltf_read_accessor.js";
+import {
+    gltf_read_accessor,
+    gltf_read_accessor_as_float32_array
+} from "../../../../format/scene/gltf/gltf_read_accessor.js";
 import { gltf_texture_image_index, gltf_used_image_indices } from "../../../../format/scene/gltf/gltf_used_image_indices.js";
 import { TinyGltf } from "./tiny-gltf.js";
+import { quat3_canonicalize_sign_run } from "../../../../core/geom/3d/quaternion/quat3_canonicalize_sign_run.js";
 
 
 /**
@@ -162,6 +165,10 @@ function node3d_property_component_count(property) {
  *
  * Exported for spec coverage; not part of the loader's public API.
  *
+ * The walk itself is {@link quat3_canonicalize_sign_run}, which
+ * `hemisphere_align_quaternion_values` in `engine/animation/clip` also runs — that one used to be a
+ * second, weaker implementation, handling only the 4-float stride and anchoring nothing.
+ *
  * @param {Float32Array} values flat values: STEP/LINEAR uses 4
  *     floats/keyframe (x, y, z, w); CUBICSPLINE uses 12 (inX, inY,
  *     inZ, inW, valX, valY, valZ, valW, outX, outY, outZ, outW).
@@ -173,48 +180,10 @@ function node3d_property_component_count(property) {
  */
 export function canonicalize_quaternion_signs(values, key_count, interpolation, rest_rotation) {
     const is_cubic = interpolation === AnimationInterpolationKind.CubicTangents;
-    const stride = is_cubic ? 12 : 4;
-    // Offset into a keyframe block at which the val-quat sits.
-    // CUBICSPLINE has [in, val, out]; the val starts at offset 4 (i.e.
-    // after the 4-float in-tangent). STEP/LINEAR has just val at 0.
-    const val_offset = is_cubic ? 4 : 0;
-
-    if (key_count >= 1 && rest_rotation !== undefined) {
-        const rest_dot =
-            values[val_offset + 0] * rest_rotation.x +
-            values[val_offset + 1] * rest_rotation.y +
-            values[val_offset + 2] * rest_rotation.z +
-            values[val_offset + 3] * rest_rotation.w;
-
-        if (rest_dot < 0) {
-            // Negate the whole first keyframe block (value +
-            // tangents); the loop below carries the flip through
-            // the remaining keyframes.
-            for (let i = 0; i < stride; i++) {
-                values[i] = -values[i];
-            }
-        }
-    }
 
-    for (let k = 1; k < key_count; k++) {
-        const prev_base = (k - 1) * stride + val_offset;
-        const cur_base = k * stride + val_offset;
-
-        const dot =
-            values[prev_base + 0] * values[cur_base + 0] +
-            values[prev_base + 1] * values[cur_base + 1] +
-            values[prev_base + 2] * values[cur_base + 2] +
-            values[prev_base + 3] * values[cur_base + 3];
-
-        if (dot < 0) {
-            // Flip the whole keyframe block (value + tangents).
-            const start = k * stride;
-            const end = start + stride;
-            for (let i = start; i < end; i++) {
-                values[i] = -values[i];
-            }
-        }
-    }
+    // CUBICSPLINE has [in, val, out]; the val starts at offset 4, after the 4-float in-tangent.
+    // STEP/LINEAR has just val at 0.
+    quat3_canonicalize_sign_run(values, key_count, is_cubic ? 12 : 4, is_cubic ? 4 : 0, rest_rotation);
 }
 
 /**
@@ -452,22 +421,20 @@ export function load_gltf(url, { assetManager, scope, fileMap, texture_support }
         }
 
         /**
-         * A FLOAT-componentType accessor's values as a flat `Float32Array`. Used for animation
-         * sampler inputs/outputs (times, values) and the skin inverse-bind matrices, where
-         * downstream code wants a stride-free flat buffer.
+         * An accessor's values as a flat `Float32Array`. Used for animation sampler inputs/outputs
+         * (times, values) and the skin inverse-bind matrices, where downstream code wants a
+         * stride-free flat buffer.
+         *
+         * This used to assert FLOAT and return the accessor's storage array verbatim, which refused
+         * a quantised animation outright in a development build and read it as raw integers in a
+         * shipped one — see {@link gltf_read_accessor_as_float32_array}, which is the rule glTF
+         * states for it and was already in the file next door.
          *
          * @param {number} accessor_index
          * @returns {Float32Array}
          */
         function read_accessor_as_float32_array(accessor_index) {
-            const accessor = accessors[accessor_index];
-
-            assert.equal(
-                accessor.componentType, GLTF_COMPONENT_TYPE.FLOAT,
-                `accessor[${accessor_index}].componentType must be FLOAT for read_accessor_as_float32_array`
-            );
-
-            return gltf_read_accessor(gltf, accessor_index).values;
+            return gltf_read_accessor_as_float32_array(gltf, accessor_index);
         }
 
         /**
@@ -677,7 +644,10 @@ export function load_gltf(url, { assetManager, scope, fileMap, texture_support }
                     break;
                 case "point":
                     light = new PointLight();
-                    light.distance = gltf_light.range ?? 1e20; // default light radius
+                    // glTF: no `range` means the light is unbounded, which is what the cull
+                    // shaders read `distance <= 0` as. 1e20 was a stand-in that they took as a
+                    // real extent instead.
+                    light.distance = gltf_light.range ?? 0;
                     break;
                 case "spot":
                     light = new SpotLight();
@@ -697,7 +667,9 @@ export function load_gltf(url, { assetManager, scope, fileMap, texture_support }
                         inverseLerp(light.angle, 0, innerCone)
                     );
 
-                    light.distance = gltf_light.range ?? 1e20;
+                    // as above: the sentinel, not a very large number the cone bounds will
+                    // overflow on
+                    light.distance = gltf_light.range ?? 0;
                     // TODO rotation is messed up?
                     break;
                 default:

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#247@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#251@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tiny-gltf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/tiny-gltf.js"],"names":[],"mappings":"AA4UA;IAoEI;;;;;;;;;;;;;OAaG;IACH,+CAFU,aAAa,CAEgC;IA3BvD;;;;OAIG;IACH,qFAFW,qBAAqB,EAQ/B;IAjED,oBAA2B;IAE3B;;;;;;;;OAQG;IACH,iDAAmD;IAEnD;;;;;;;;;OASG;IACH,SAFU,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC,GAAC,SAAS,CAElC;IAqKpB;;;OAGG;IACH,iBAHW,MAAM,GACJ,QAAQ,QAAQ,CAAC,CAgB7B;IAED;;;;;;OAMG;IACH,4BAJW,WAAW,WACX,MAAM,GACL,QAAQ;QAAC,KAAK,CAAA;KAAC,MAAE,CAAC,CAM7B;IAED;;;;;;OAMG;IACH,mBALW;QAAC,WAAW,CAAC;QAAA,KAAK,CAAC;QAAA,SAAS,EAAC,EAAE,CAAC;QAAA,KAAK,EAAC,EAAE,CAAC;QAAA,QAAQ,CAAC,EAAC,EAAE,CAAC;QAAA,OAAO,EAAC,EAAE,CAAC;QAAA,SAAS,EAAC,EAAE,CAAC;QAAC,QAAQ,EAAC,EAAE,CAAC;QAAC,MAAM,EAAC,EAAE,CAAC;QAAA,MAAM,EAAC,EAAE,CAAA;KAAC,WAChH,MAAM,gBACN,UAAU,GACT,QAAQ;QAAC,KAAK,CAAA;KAAC,MAAE,CAAC,CAuR7B;;CAGJ;8BA5yB6B,qDAAqD"}
+{"version":3,"file":"tiny-gltf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/tiny-gltf.js"],"names":[],"mappings":"AA6UA;IAoEI;;;;;;;;;;;;;OAaG;IACH,+CAFU,aAAa,CAEgC;IA3BvD;;;;OAIG;IACH,qFAFW,qBAAqB,EAQ/B;IAjED,oBAA2B;IAE3B;;;;;;;;OAQG;IACH,iDAAmD;IAEnD;;;;;;;;;OASG;IACH,SAFU,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC,GAAC,SAAS,CAElC;IAqKpB;;;OAGG;IACH,iBAHW,MAAM,GACJ,QAAQ,QAAQ,CAAC,CAe7B;IAED;;;;;;OAMG;IACH,4BAJW,WAAW,WACX,MAAM,GACL,QAAQ;QAAC,KAAK,CAAA;KAAC,MAAE,CAAC,CAM7B;IAED;;;;;;OAMG;IACH,mBALW;QAAC,WAAW,CAAC;QAAA,KAAK,CAAC;QAAA,SAAS,EAAC,EAAE,CAAC;QAAA,KAAK,EAAC,EAAE,CAAC;QAAA,QAAQ,CAAC,EAAC,EAAE,CAAC;QAAA,OAAO,EAAC,EAAE,CAAC;QAAA,SAAS,EAAC,EAAE,CAAC;QAAC,QAAQ,EAAC,EAAE,CAAC;QAAC,MAAM,EAAC,EAAE,CAAC;QAAA,MAAM,EAAC,EAAE,CAAA;KAAC,WAChH,MAAM,gBACN,UAAU,GACT,QAAQ;QAAC,KAAK,CAAA;KAAC,MAAE,CAAC,CAuR7B;;CAGJ;8BA3yB6B,qDAAqD"}