littlejsengine 1.25.0 → 1.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "littlejsengine",
-  "version": "1.25.0",
+  "version": "1.26.0",
   "description": "LittleJS - Tiny and Fast HTML5 Game Engine",
   "main": "dist/littlejs.esm.js",
   "types": "dist/littlejs.d.ts",
@@ -11,6 +11,8 @@
       "default": "./dist/littlejs.esm.js"
     },
     "./dist/*": "./dist/*",
+    "./plugins/*": "./plugins/*",
+    "./src/*": "./src/*",
     "./package.json": "./package.json"
   },
   "repository": {
@@ -52,12 +54,10 @@
     "test:browser": "node test/browser/run.mjs"
   },
   "engines": {
-    "node": "^20.19.0 || >=22.12.0"
+    "node": ">=22.12.0"
   },
   "devDependencies": {
     "bestzip": "^2.2.1",
-    "electron": "^38.2.0",
-    "electron-packager": "^17.1.2",
     "google-closure-compiler": "~20230502.0.0",
     "jsdoc": "~4.0.2",
     "roadroller": "~2.1.0",

package/plugins/box2d.js

@@ -35,7 +35,7 @@ let box2dDebug = false;
 let box2dTempVectors;
 function box2dTemp(v, slot=0)
 {
-    ASSERT(isVector2(v));
+    ASSERT(isVector2(v), 'Box2D: expected a vec2', v);
     const temp = (box2dTempVectors ||= [new box2d.instance.b2Vec2(), new box2d.instance.b2Vec2()])[slot];
     temp.Set(v.x, v.y);
     return temp;
@@ -88,6 +88,9 @@ function box2dWakeWithContacts(body)
         edge.get_other().SetAwake(true);
 }
 
+// a number Box2D can take: it stops for good on NaN or Infinity, and a release build has no asserts to catch one first
+const box2dFinite = (value, otherwise)=> isFinite(value) ? value : otherwise;
+
 // wake both bodies of a joint whose length, spring, ratio or strength changed, a sleeping body would stay where it was
 function box2dWakeJoint(joint)
 {
@@ -147,6 +150,64 @@ function box2dDestroyGears(joint)
  *  @memberof Box2D */
 function box2dSetDebug(enable) { box2dDebug = enable; }
 
+// the EngineObject physics fields a Box2D body does not read, each with what moves the body instead; a debug build
+// warns once a field when a game sets one, which did nothing and said nothing
+const box2dUnusedFields = {
+    velocity: 'setLinearVelocity', angleVelocity: 'setAngularVelocity', damping: 'setLinearDamping',
+    angleDamping: 'setAngularDamping', mass: 'setMass or the density of its shapes',
+    friction: 'the friction of its shapes, given to addBox and the rest',
+    restitution: 'the restitution of its shapes, given to addBox and the rest'};
+const box2dUnusedWarned = new Set, box2dUnusedStarts = new WeakMap;
+
+// the values of those fields as numbers, a vector as its two, then gravityScale, kept for the object
+function box2dUnusedFieldValues(o)
+{
+    const values = [];
+    for (const name in box2dUnusedFields)
+    {
+        const value = o[name];
+        value instanceof Vector2 ? values.push(value.x, value.y) : values.push(value);
+    }
+    values.push(o.gravityScale);
+    return values;
+}
+
+// warn once a field
+function box2dUnusedWarn(name, use)
+{
+    if (box2dUnusedWarned.has(name)) return;
+    box2dUnusedWarned.add(name);
+    console.warn('Box2dObject.' + name + ' does nothing on a Box2D body, use ' + use);
+}
+
+// warn once a field of one set on a Box2dObject, and of gravityScale set on the field, not with setGravityScale;
+// compared in place, as it runs for every body every step of a debug build
+function box2dCheckUnusedFields(o)
+{
+    const start = box2dUnusedStarts.get(o);
+    if (!start) return;
+    let i = 0;
+    for (const name in box2dUnusedFields)
+    {
+        const value = o[name];
+        let changed;
+        if (value instanceof Vector2)
+        {
+            changed = value.x !== start[i] || value.y !== start[i + 1];
+            i += 2;
+        }
+        else
+            changed = value !== start[i++];
+        changed && box2dUnusedWarn(name, box2dUnusedFields[name]);
+    }
+
+    // the body's own scale is a call into Box2D, asked only when the field changed since it was last asked,
+    // since setGravityScale sets both
+    if (o.gravityScale === start[i]) return;
+    start[i] = o.gravityScale;
+    Math.fround(o.gravityScale) === o.body.GetGravityScale() || box2dUnusedWarn('gravityScale', 'setGravityScale');
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 /** 
  * Box2D Object - extend with your own custom physics objects
@@ -154,6 +215,10 @@ function box2dSetDebug(enable) { box2dDebug = enable; }
  * - Provides interface for Box2D body and fixture functions
  * - Each object can have multiple fixtures and joints
  * - Angular values are clockwise like angle: angular velocity, torque, joint angles, limits and motor speeds
+ * - Box2D moves the body, so the EngineObject physics fields do nothing on it: velocity, angleVelocity, damping,
+ *   angleDamping, mass, friction, restitution and gravityScale; use setLinearVelocity, setAngularVelocity,
+ *   setLinearDamping, setAngularDamping, setMass, the friction and restitution of its shapes and setGravityScale.
+ *   A debug build warns once when one of them is set
  * @extends EngineObject
  * @memberof Box2D
  */
@@ -196,6 +261,9 @@ class Box2dObject extends EngineObject
 
         this.body.object = this; // link body to this object
         box2d.objects.push(this); // keep track of all box2d objects
+
+        // a debug build notes the engine physics fields Box2D does not read, to warn when one is set
+        debug && box2dUnusedStarts.set(this, box2dUnusedFieldValues(this));
     }
 
     /** Destroy this object and its physics body
@@ -244,7 +312,7 @@ class Box2dObject extends EngineObject
             this.drawFixtures(this.color, this.lineColor, this.lineWidth);
     }
 
-    /** Render debug info */
+    /** Draw its fixtures for the debug view: yellow asleep, blue static, both when both */
     renderDebugInfo()
     {
         const isAsleep = !this.getIsAwake();
@@ -253,7 +321,7 @@ class Box2dObject extends EngineObject
         this.drawFixtures(color);
     }
 
-    /** Draws all this object's fixtures 
+    /** Draw all this object's fixtures 
      *  @param {Color}   [color]
      *  @param {Color}   [lineColor]
      *  @param {number}  [lineWidth]
@@ -343,8 +411,8 @@ class Box2dObject extends EngineObject
         ASSERT(isNumber(angle), 'angle must be a number');
 
         // Box2D stops for good on a box with almost no area, like addPoly no fixture is made from one
-        ASSERT(size.x * size.y > 1e-6, 'box is too small for Box2D');
-        if (!(size.x * size.y > 1e-6)) return;
+        ASSERT(size.x * size.y > 1e-6 && isFinite(size.x * size.y), 'box is too small or too big for Box2D');
+        if (!(size.x * size.y > 1e-6) || !isFinite(size.x * size.y)) return;
 
         const shape = new box2d.instance.b2PolygonShape();
         shape.SetAsBox(size.x/2, size.y/2, box2dTemp(offset), -angle);
@@ -449,12 +517,13 @@ class Box2dObject extends EngineObject
      *  @param {number}  [friction]
      *  @param {number}  [restitution]
      *  @param {boolean} [isSensor]
-     *  @return {Object} - The fixture made, Box2D's own */
+     *  @return {Object|undefined} - The fixture made, Box2D's own, undefined for a circle too big to make */
     addCircle(diameter=1, offset=vec2(), density, friction, restitution, isSensor)
     {
-        ASSERT(isNumber(diameter) && diameter>0, 'diameter must be a positive number');
+        ASSERT(isNumber(diameter) && diameter>0 && isFinite(diameter), 'diameter must be a positive number');
         ASSERT(isVector2(offset), 'offset must be a Vector2');
-        
+        if (!isFinite(diameter)) return; // Box2D stops for good on it, no fixture is made
+
         const shape = new box2d.instance.b2CircleShape();
         shape.set_m_p(box2dTemp(offset));
         shape.set_m_radius(diameter/2);
@@ -685,12 +754,14 @@ class Box2dObject extends EngineObject
     setAngularVelocity(angularVelocity)
     { this.body.SetAngularVelocity(-angularVelocity); }
 
-    /** Sets the linear damping
+    /** Sets the linear damping, Box2D's: a rate, 0 none and larger slows it faster, with no upper limit, where the
+     *  damping of an EngineObject is the fraction it keeps each frame and does nothing on a Box2dObject
      *  @param {number} damping */
     setLinearDamping(damping)
     { this.body.SetLinearDamping(damping); }
 
-    /** Sets the angular damping
+    /** Sets the angular damping, Box2D's: a rate, 0 none and larger slows its turning faster, with no upper limit;
+     *  angleDamping does nothing on a Box2dObject
      *  @param {number} damping */
     setAngularDamping(damping)
     { this.body.SetAngularDamping(damping); }
@@ -767,7 +838,7 @@ class Box2dObject extends EngineObject
             const f = Math.fround;
             const oldInertia = f(data.get_I() - box2dCenterInertia(oldMass, center.get_x(), center.get_y()));
             const inertia = momentOfInertia ?? oldInertia;
-            mass ??= oldMass;
+            mass = box2dFinite(mass ?? oldMass, oldMass);
             const offset = box2dCenterInertia(mass > 0 ? mass : 1, cx, cy); // a mass of 0 or less is 1 to Box2D
             const I = f(inertia + offset);
             data.set_mass(mass);
@@ -1088,13 +1159,15 @@ class Box2dJoint
         const bodyA = jointDef.get_bodyA(), bodyB = jointDef.get_bodyB();
         const bothLive = !box2d.isNull(bodyA) && !box2d.isNull(bodyB);
         ASSERT(bothLive, 'a joint needs two objects that are not destroyed');
-        ASSERT(box2d.instance.getPointer(bodyA) !== box2d.instance.getPointer(bodyB), 'a joint needs two different objects');
+        const twoObjects = !bothLive || box2d.instance.getPointer(bodyA) !== box2d.instance.getPointer(bodyB);
+        ASSERT(twoObjects, 'a joint needs two different objects');
 
         /** @property {Object} - The Box2d joint, 0 once it is destroyed, as it is when either object is */
         this.box2dJoint = 0;
-        if (!bothLive)
+        if (!bothLive || !twoObjects)
         {
-            // one of its objects is gone, so it is made destroyed, as it would be had it gone after
+            // one of its objects is gone, so it is made destroyed, as it would be had it gone after; a joint of an
+            // object to itself, which Box2D stops for good on, is made destroyed too in a release build
             box2d.instance.destroy(jointDef);
             return;
         }
@@ -1206,7 +1279,7 @@ class Box2dTargetJoint extends Box2dJoint
     
     /** Sets the joint frequency in Hertz, above 0, Box2D stops for good on 0
      *  @param {number} hz */
-    setFrequency(hz) { this.box2dJoint.SetFrequency(max(hz, 1e-3)); box2dWakeJoint(this.box2dJoint); }
+    setFrequency(hz) { this.box2dJoint.SetFrequency(max(box2dFinite(hz, 0), 1e-3)); box2dWakeJoint(this.box2dJoint); }
     
     /** Gets the joint frequency in Hertz
      *  @return {number} */
@@ -1269,11 +1342,11 @@ class Box2dDistanceJoint extends Box2dJoint
      *  @return {number} */
     getFrequency() { return this.box2dJoint.GetFrequency(); }
     
-    /** Set the damping ratio
+    /** Set how much the spring is damped, 0 for none and 1 to stop it bouncing
      *  @param {number} ratio */
     setDampingRatio(ratio) { this.box2dJoint.SetDampingRatio(ratio); box2dWakeJoint(this.box2dJoint); }
     
-    /** Get the damping ratio
+    /** Get how much the spring is damped, 0 for none and 1 to stop it bouncing
      *  @return {number} */
     getDampingRatio() { return this.box2dJoint.GetDampingRatio(); }
 }
@@ -1402,6 +1475,7 @@ class Box2dRevoluteJoint extends Box2dJoint
     setLimits(min, max)
     {
         ASSERT(min <= max, 'the lower limit must not be above the upper one');
+        min = box2dFinite(min, 0), max = box2dFinite(max, 0); // or on NaN, which passes the order check
         if (min > max) [min, max] = [max, min]; // Box2D stops on them reversed
         this.box2dJoint.SetLimits(-max, -min);
     }
@@ -1426,7 +1500,7 @@ class Box2dRevoluteJoint extends Box2dJoint
      *  @param {number} torque */
     setMaxMotorTorque(torque) { this.box2dJoint.SetMaxMotorTorque(torque); }
 
-    /** Get the max motor torque
+    /** Get the most torque the motor can apply, a magnitude
      *  @return {number} */
     getMaxMotorTorque() { return this.box2dJoint.GetMaxMotorTorque(); }
 
@@ -1604,6 +1678,7 @@ class Box2dPrismaticJoint extends Box2dJoint
     setLimits(min, max)
     {
         ASSERT(min <= max, 'the lower limit must not be above the upper one');
+        min = box2dFinite(min, 0), max = box2dFinite(max, 0); // or on NaN, which passes the order check
         if (min > max) [min, max] = [max, min]; // Box2D stops on them reversed
         this.box2dJoint.SetLimits(min, max);
     }
@@ -1616,11 +1691,11 @@ class Box2dPrismaticJoint extends Box2dJoint
      *  @param {boolean} [enable] */
     enableMotor(enable=true) { this.box2dJoint.EnableMotor(enable); }
     
-    /** Set the motor speed
+    /** Set the speed the motor drives the bodies apart along the axis, in meters per second
      *  @param {number} speed */
     setMotorSpeed(speed) { this.box2dJoint.SetMotorSpeed(speed); }
     
-    /** Get the motor speed
+    /** Get the speed the motor drives the bodies apart along the axis, in meters per second
      *  @return {number} */
     getMotorSpeed() { return this.box2dJoint.GetMotorSpeed(); }
     
@@ -1712,7 +1787,7 @@ class Box2dWheelJoint extends Box2dJoint
      *  @param {number} torque */
     setMaxMotorTorque(torque) { this.box2dJoint.SetMaxMotorTorque(torque); }
 
-    /** Get the max motor torque
+    /** Get the most torque the wheel's motor can apply, a magnitude
      *  @return {number} */
     getMaxMotorTorque() { return this.box2dJoint.GetMaxMotorTorque(); }
 
@@ -1729,11 +1804,11 @@ class Box2dWheelJoint extends Box2dJoint
      *  @return {number} */
     getSpringFrequencyHz() { return this.box2dJoint.GetSpringFrequencyHz(); }
 
-    /** Set the spring damping ratio
+    /** Set how much the suspension spring is damped, 0 for none and 1 to stop it bouncing
      *  @param {number} ratio */
     setSpringDampingRatio(ratio) { this.box2dJoint.SetSpringDampingRatio(ratio); box2dWakeJoint(this.box2dJoint); }
 
-    /** Get the spring damping ratio
+    /** Get how much the suspension spring is damped, 0 for none and 1 to stop it bouncing
      *  @return {number} */
     getSpringDampingRatio() { return this.box2dJoint.GetSpringDampingRatio(); }
 }
@@ -1791,11 +1866,11 @@ class Box2dWeldJoint extends Box2dJoint
      *  @return {number} */
     getFrequency() { return this.box2dJoint.GetFrequency(); }
 
-    /** Set the damping ratio
+    /** Set how much the weld's spring is damped, 0 for none and 1 to stop it bouncing
      *  @param {number} ratio */
     setDampingRatio(ratio) { this.box2dJoint.SetDampingRatio(ratio); box2dWakeJoint(this.box2dJoint); }
 
-    /** Get the damping ratio
+    /** Get how much the weld's spring is damped, 0 for none and 1 to stop it bouncing
      *  @return {number} */
     getDampingRatio() { return this.box2dJoint.GetDampingRatio(); }
 }
@@ -1839,7 +1914,7 @@ class Box2dFrictionJoint extends Box2dJoint
 
     /** Set the maximum friction force
      *  @param {number} force */
-    setMaxForce(force) { this.box2dJoint.SetMaxForce(max(force, 0)); } // Box2D stops on a negative one
+    setMaxForce(force) { this.box2dJoint.SetMaxForce(max(box2dFinite(force, 0), 0)); } // Box2D stops on a negative one
 
     /** Get the maximum friction force
      *  @return {number} */
@@ -1847,7 +1922,7 @@ class Box2dFrictionJoint extends Box2dJoint
 
     /** Set the maximum friction torque
      *  @param {number} torque */
-    setMaxTorque(torque) { this.box2dJoint.SetMaxTorque(max(torque, 0)); } // Box2D stops on a negative one
+    setMaxTorque(torque) { this.box2dJoint.SetMaxTorque(max(box2dFinite(torque, 0), 0)); } // Box2D stops on a negative one
 
     /** Get the maximum friction torque
      *  @return {number} */
@@ -1888,7 +1963,7 @@ class Box2dPulleyJoint extends Box2dJoint
         jointDef.set_localAnchorA(box2dTemp(localAnchorA));
         jointDef.set_localAnchorB(box2dTemp(localAnchorB));
         ASSERT(ratio, 'a pulley ratio can not be 0');
-        jointDef.set_ratio(ratio);
+        jointDef.set_ratio(box2dFinite(ratio, 1) || 1); // Box2D stops for good on 0
         jointDef.set_lengthA(groundAnchorA.distance(anchorA));
         jointDef.set_lengthB(groundAnchorB.distance(anchorB));
         jointDef.set_collideConnected(collide);
@@ -1949,11 +2024,11 @@ class Box2dMotorJoint extends Box2dJoint
         super(jointDef);
     }
 
-    /** Set the target linear offset, in frame A, in meters.
+    /** Set the target linear offset, in frame A, in meters
      *  @param {Vector2} offset */
     setLinearOffset(offset) { this.box2dJoint.SetLinearOffset(box2dTemp(offset)); }
 
-    /** Get the target linear offset, in frame A, in meters.
+    /** Get the target linear offset, in frame A, in meters
      *  @return {Vector2} */
     getLinearOffset() { return box2d.vec2From(this.box2dJoint.GetLinearOffset()); }
 
@@ -1967,7 +2042,7 @@ class Box2dMotorJoint extends Box2dJoint
 
     /** Set the maximum force
      *  @param {number} force */
-    setMaxForce(force) { this.box2dJoint.SetMaxForce(max(force, 0)); box2dWakeJoint(this.box2dJoint); } // Box2D stops on a negative one
+    setMaxForce(force) { this.box2dJoint.SetMaxForce(max(box2dFinite(force, 0), 0)); box2dWakeJoint(this.box2dJoint); } // Box2D stops on a negative one
 
     /** Get the maximum force
      *  @return {number} */
@@ -1975,7 +2050,7 @@ class Box2dMotorJoint extends Box2dJoint
 
     /** Set the maximum torque
      *  @param {number} torque */
-    setMaxTorque(torque) { this.box2dJoint.SetMaxTorque(max(torque, 0)); box2dWakeJoint(this.box2dJoint); } // Box2D stops on a negative one
+    setMaxTorque(torque) { this.box2dJoint.SetMaxTorque(max(box2dFinite(torque, 0), 0)); box2dWakeJoint(this.box2dJoint); } // Box2D stops on a negative one
 
     /** Get the maximum torque
      *  @return {number} */
@@ -2329,7 +2404,7 @@ class Box2dPlugin
      *  @return {Vector2} */
     vec2From(v)
     {
-        ASSERT(v instanceof box2d.instance.b2Vec2);
+        ASSERT(v instanceof box2d.instance.b2Vec2, 'vec2From: expected a b2Vec2', v);
         return new Vector2(v.get_x(), v.get_y()); 
     }
 
@@ -2348,7 +2423,7 @@ class Box2dPlugin
      *  @return {Object} - A Box2D vector, its b2Vec2 */
     vec2dTo(v)
     {
-        ASSERT(isVector2(v));
+        ASSERT(isVector2(v), 'vec2dTo: expected a vec2', v);
         return new box2d.instance.b2Vec2(v.x, v.y);
     }
 
@@ -2445,6 +2520,7 @@ async function box2dInit()
         {
             if (o.body)
             {
+                debug && box2dCheckUnusedFields(o);
                 // moved in place, as the engine moves an EngineObject's pos, so what holds it follows the body;
                 // box2d uses reverse angle
                 const p = o.body.GetPosition();

package/plugins/gltf.js

@@ -73,6 +73,9 @@ class GLTFPart
         this.emissiveMap = undefined;
         /** @property {Color} - The emissiveFactor, which multiplies the emissive map */
         this.emissiveMapColor = WHITE;
+        /** @property {number} - The material's roughnessFactor, 0 a mirror to 1 matte, 1 when it has none as the
+         *  format says; the object createObject makes takes it as its roughness, which sets its shininess */
+        this.roughness = 1;
         /** @property {GLTFSkin|undefined} - For a skinned mesh, what bends it: mesh is its resting pose, and the
          *  object createObject makes bends a copy of its own to each pose
          *  @type {GLTFSkin|undefined} */
@@ -134,6 +137,8 @@ class GLTFModel
         /** @property {Array<GLTFAnimation>} - The animations, play one through createObject's GLTFObject
          *  @type {Array<GLTFAnimation>} */
         this.animations = animations;
+        /** @type {{nodes: Array<Object>, parents: Array<number|undefined>, restInverse: Array<Matrix4>,
+         *  restPose: Array<Matrix4|undefined>}|undefined} */
         this.nodeTree = nodeTree;             // each node's parent and resting place, for animation
         this.modelMatrix = new Matrix4;       // what center, fit and transform did to the parts, animation works through it
         /** @property {Mesh} - Every part combined, each tinted with its material color; the texture is textureInfo,
@@ -303,6 +308,7 @@ class GLTFObject extends EngineObject3D
             o.emissive = part.unlit ? 1 : 0;
             o.normalMap = part.normalMap, o.normalScale = part.normalScale;
             o.emissiveMap = part.emissiveMap, o.emissiveMapColor = part.emissiveMapColor.copy(); // its own, as color is
+            o.roughness = part.roughness;
             const rest = !part.skin && model.nodeTree?.restPose?.[part.node];
             if (rest)
             {
@@ -313,6 +319,7 @@ class GLTFObject extends EngineObject3D
                 o.rotation3D = m.getRotation();
                 o.scale3D = m.getScale();
             }
+            render3DShareSettings(o, this); // what is set on the model, the part's own material otherwise
             this.addChild(o);
             this.parts.push(o);
         }
@@ -450,9 +457,9 @@ class GLTFObject extends EngineObject3D
  *  @memberof GLTF */
 async function loadGLTF(url)
 {
-    const response = await fetch(url);
+    const response = await loadFetch(url, 'loadGLTF');
     if (!response.ok)
-        throw new Error('loadGLTF failed: ' + url);
+        throw new Error(`loadGLTF: could not load ${url}, ${response.status} ${response.statusText}`);
     // the files beside it are beside where it came from, after any redirect; a blob or data url has nothing
     // beside it, and a model in one is whole, or parsed with parseGLTF and a base of its own
     const from = response.url || url;
@@ -477,7 +484,7 @@ async function loadGLTF(url)
  *    is fetched then
  *  - A file the model needs that is not found is named in the error, and an image that can not be read is named in
  *    a warning and left out
- *  @param {ArrayBuffer|Object|string} data - GLB bytes, or the glTF JSON as bytes, text or an object
+ *  @param {ArrayBuffer|ArrayBufferView|Object<string, any>|string} data - GLB bytes, or the glTF JSON as bytes, text or an object
  *  @param {string} [baseUrl] - Where the .bin and image files are, with its trailing slash; loadGLTF passes the file's folder
  *  @param {Map<string, Blob>} [files] - The files it refers to, by their paths, in place of fetching them
  *  @return {Promise<GLTFModel>}
@@ -489,7 +496,10 @@ async function loadGLTF(url)
  *  @memberof GLTF */
 async function parseGLTF(data, baseUrl='', files)
 {
-    let json = data, glbBuffer;
+    // bytes as a typed array, a Node Buffer or a view into a bigger buffer, read as an ArrayBuffer of just them
+    if (ArrayBuffer.isView(data))
+        data = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+    let json = /** @type {any} */ (data), glbBuffer; // bytes, text or the parsed glTF, an object once parsed
     if (data instanceof ArrayBuffer)
     {
         const view = new DataView(data);
@@ -784,39 +794,67 @@ function gltfSkinMeshCopy(mesh)
 
 // bend a skinned mesh to a pose: each vertex its stored place moved by its four joints, weighted, and its normal by
 // their normal matrices, each joint's matrix modelMatrix * its place now * its inverse bind; written into the
-// mesh's own vectors, so a pose makes nothing for each vertex
+// mesh's own vectors, so a pose makes nothing for each vertex, and once an upload has laid the mesh out for the GPU
+// into that data too, with the radius and box the upload would measure, so it sends the data as it is
 function gltfSkinApply(skin, worldOf, modelMatrix, mesh)
 {
-    const matrices = [], normalMatrices = [];
-    for (let j = 0; j < skin.joints.length; ++j)
+    // each joint's point matrix, 12 numbers, then its normal matrix, 9, in one array the skin keeps
+    const jointCount = skin.joints.length, M = skin.jointMatrices ||= new Float32Array(jointCount * 21);
+    const m = gltfSkinScratch[0], n = gltfSkinScratch[1];
+    for (let j = 0; j < jointCount; ++j)
     {
-        const m = modelMatrix.copy().multiply(worldOf(skin.joints[j])).multiply(skin.inverseBind[j]);
-        matrices.push(m.m), normalMatrices.push(render3DNormalMatrix(m).m);
+        m.m.set(modelMatrix.m);
+        m.multiply(worldOf(skin.joints[j])).multiply(skin.inverseBind[j]);
+        n.m.set(m.m);
+        n.invert().transpose();
+        const a = m.m, b = n.m, o = j * 21;
+        M[o]    = a[0], M[o+1]  = a[1], M[o+2]  = a[2],  M[o+3]  = a[4], M[o+4]  = a[5], M[o+5]  = a[6];
+        M[o+6]  = a[8], M[o+7]  = a[9], M[o+8]  = a[10], M[o+9]  = a[12], M[o+10] = a[13], M[o+11] = a[14];
+        M[o+12] = b[0], M[o+13] = b[1], M[o+14] = b[2],  M[o+15] = b[4], M[o+16] = b[5], M[o+17] = b[6];
+        M[o+18] = b[8], M[o+19] = b[9], M[o+20] = b[10];
     }
     const {vertexJoints, vertexWeights, bindPoints, bindNormals} = skin, points = mesh.points, normals = mesh.normals;
-    for (let v = 0; v < points.length; ++v)
+    // an indexed mesh's GPU vertex j is its point j, as upload lays it out
+    const layout = mesh.vertexLayout, count = points.length;
+    const floats = layout && mesh.indices && layout.pointCount === count ? new Float32Array(layout.data) : undefined;
+    let r = 0, x0 = Infinity, y0 = Infinity, z0 = Infinity, x1 = -Infinity, y1 = -Infinity, z1 = -Infinity;
+    for (let v = 0; v < count; ++v)
     {
-        const px = bindPoints[v*3], py = bindPoints[v*3+1], pz = bindPoints[v*3+2];
-        const qx = bindNormals[v*3], qy = bindNormals[v*3+1], qz = bindNormals[v*3+2];
+        const v3 = v*3, v4 = v*4, px = bindPoints[v3], py = bindPoints[v3+1], pz = bindPoints[v3+2];
+        const qx = bindNormals[v3], qy = bindNormals[v3+1], qz = bindNormals[v3+2];
         let x = 0, y = 0, z = 0, nx = 0, ny = 0, nz = 0;
         for (let k = 0; k < 4; ++k)
         {
-            const w = vertexWeights[v*4+k];
+            const w = vertexWeights[v4+k];
             if (!w) continue;
-            const m = matrices[vertexJoints[v*4+k]], n = normalMatrices[vertexJoints[v*4+k]];
-            x += w * (m[0]*px + m[4]*py + m[8]*pz + m[12]);
-            y += w * (m[1]*px + m[5]*py + m[9]*pz + m[13]);
-            z += w * (m[2]*px + m[6]*py + m[10]*pz + m[14]);
-            nx += w * (n[0]*qx + n[4]*qy + n[8]*qz);
-            ny += w * (n[1]*qx + n[5]*qy + n[9]*qz);
-            nz += w * (n[2]*qx + n[6]*qy + n[10]*qz);
+            const o = vertexJoints[v4+k] * 21;
+            x += w * (M[o]*px + M[o+3]*py + M[o+6]*pz + M[o+9]);
+            y += w * (M[o+1]*px + M[o+4]*py + M[o+7]*pz + M[o+10]);
+            z += w * (M[o+2]*px + M[o+5]*py + M[o+8]*pz + M[o+11]);
+            nx += w * (M[o+12]*qx + M[o+15]*qy + M[o+18]*qz);
+            ny += w * (M[o+13]*qx + M[o+16]*qy + M[o+19]*qz);
+            nz += w * (M[o+14]*qx + M[o+17]*qy + M[o+20]*qz);
         }
         const p = points[v], normal = normals[v], l = (nx*nx + ny*ny + nz*nz) ** .5 || 1;
         p.x = x, p.y = y, p.z = z;
         normal.x = nx / l, normal.y = ny / l, normal.z = nz / l;
+        if (!floats) continue;
+        const at = v * RENDER3D_VERTEX_FLOATS;
+        floats[at]   = x,        floats[at+1] = y,        floats[at+2] = z;
+        floats[at+3] = normal.x, floats[at+4] = normal.y, floats[at+5] = normal.z;
+        r = max(r, x*x + y*y + z*z);
+        x0 = min(x0, x), y0 = min(y0, y), z0 = min(z0, z);
+        x1 = max(x1, x), y1 = max(y1, y), z1 = max(z1, z);
+    }
+    if (floats)
+    {
+        mesh.radius = r ** .5;
+        mesh.bounds = count ? {min: vec3(x0, y0, z0), max: vec3(x1, y1, z1)} : {min: vec3(), max: vec3()};
+        mesh.vertexDataPacked = true;
     }
     mesh.dirty = true;
 }
+const gltfSkinScratch = [new Matrix4, new Matrix4]; // a joint's matrix and its normal matrix, as it is worked out
 
 // a node's translation, rotation and scale as arrays to animate, copies so the file's stay as they rest
 function gltfNodeTRS(node)
@@ -977,7 +1015,7 @@ function gltfFetch(uri, baseUrl, files)
     const page = typeof location !== 'undefined' && location.href;
     const base = page ? new URL(baseUrl, page) : /^[a-z][a-z0-9+.-]*:/i.test(baseUrl) ? baseUrl : undefined;
     const url = base ? new URL(uri, base).href : baseUrl + uri;
-    return fetch(url).then(r=>
+    return loadFetch(url, 'glTF').then(r=>
     {
         if (!r.ok) throw new Error('glTF needs ' + uri + ', not found at ' + url);
         return r;
@@ -1022,6 +1060,9 @@ function gltfAccessor(json, buffers, index)
     if (view)
     {
         const buffer = buffers[view.buffer], offset = (view.byteOffset || 0) + (a.byteOffset || 0);
+        // the format keeps values on their size, a typed array can not read them off it
+        if (offset % size || stride % size)
+            throw new Error('glTF accessor ' + index + ' is not aligned to its ' + size + ' byte values');
         if (stride === components * size)
             out.set(new Type(buffer, offset, a.count * components)); // packed, one view over all of it
         else
@@ -1036,6 +1077,13 @@ function gltfAccessor(json, buffers, index)
         const indexView = json.bufferViews?.[indices.bufferView], valueView = json.bufferViews?.[values.bufferView];
         if (!IndexType || !indexView || !valueView)
             throw new Error('glTF sparse accessor is missing its indices or values');
+        // its indices and values in their buffers and on their sizes, before typed arrays are made over them
+        const indexAt = (indexView.byteOffset || 0) + (indices.byteOffset || 0);
+        const valueAt = (valueView.byteOffset || 0) + (values.byteOffset || 0);
+        if (indexAt % IndexType.BYTES_PER_ELEMENT || valueAt % size ||
+            !(indexAt + sparse.count * IndexType.BYTES_PER_ELEMENT <= (buffers[indexView.buffer]?.byteLength ?? 0)) ||
+            !(valueAt + sparse.count * components * size <= (buffers[valueView.buffer]?.byteLength ?? 0)))
+            throw new Error('glTF sparse accessor ' + index + ' is not aligned or reaches past its buffer');
         const at = new IndexType(buffers[indexView.buffer], (indexView.byteOffset || 0) + (indices.byteOffset || 0), sparse.count);
         const data = new Type(buffers[valueView.buffer], (valueView.byteOffset || 0) + (values.byteOffset || 0), sparse.count * components);
         for (let i = 0; i < sparse.count; ++i)
@@ -1067,7 +1115,10 @@ function gltfPart(json, buffers, textures, primitive, matrix, name)
     };
     const points = read(attributes.POSITION, (d, k)=> vec3(d[k], d[k+1], d[k+2]));
     const normals = attributes.NORMAL !== undefined ? read(attributes.NORMAL, (d, k)=> vec3(d[k], d[k+1], d[k+2])) : undefined;
-    // the uv set the base color texture names, moved by its KHR_texture_transform once here, offset + rotation * scale
+    // the uv set the base color texture names, moved by its KHR_texture_transform once here, offset + rotation * scale,
+    // the rotation turning (u, v) to (cos u + sin v, cos v - sin u), counter-clockwise in glTF's uv space with v down,
+    // as the extension's text says and as Khronos's sample renderer and three.js turn it, which models are made to
+    // look right in; the GLSL sample in the extension's readme, read column major, turns the other way
     const material = json.materials?.[primitive.material] || {}, pbr = material.pbrMetallicRoughness || {};
     const textureRef = pbr.baseColorTexture, uvTransform = textureRef?.extensions?.KHR_texture_transform;
     const uvAccessor = attributes['TEXCOORD_' + (uvTransform?.texCoord ?? textureRef?.texCoord ?? 0)];
@@ -1108,6 +1159,7 @@ function gltfPart(json, buffers, textures, primitive, matrix, name)
     const normalRef = material.normalTexture, emissiveRef = material.emissiveTexture;
     part.normalMap = normalRef && textures[normalRef.index];
     part.normalScale = normalRef?.scale ?? 1;
+    part.roughness = pbr.roughnessFactor ?? 1; // a roughness map is not read
     const [er, eg, eb] = material.emissiveFactor || [0, 0, 0];
     if (er || eg || eb)
     {