littlejsengine 1.24.1 → 1.24.3

package/plugins/render3dExtras.js

@@ -28,7 +28,7 @@ function render3DDetach(o)
 let render3DSoftDotTexture;
 function render3DSoftDot()
 {
-    if (render3DSoftDotTexture || !glContext || typeof OffscreenCanvas == 'undefined') return render3DSoftDotTexture;
+    if (render3DSoftDotTexture || !glContext || !canvasAvailable()) return render3DSoftDotTexture;
     const size = 32, context = createCanvasContext(size);
     const gradient = context.createRadialGradient(size / 2, size / 2, 0, size / 2, size / 2, size / 2);
     for (const [stop, alpha] of [[0, 1], [.33, .9], [.67, .7], [1, 0]]) // the same falloff as a soft disc
@@ -50,7 +50,7 @@ function normalMapFromHeight(size, heightFunction, strength=1)
 {
     ASSERT(isVector2(size) && size.x >= 1 && size.y >= 1, 'normalMapFromHeight size must be a Vector2 of pixels');
     const width = size.x | 0, height = size.y | 0;
-    if (typeof OffscreenCanvas == 'undefined')
+    if (!canvasAvailable())
     {
         // headless, nothing to draw into; the right size so what reads it still works
         const textureInfo = new TextureInfo(undefined, false, true);
@@ -631,9 +631,9 @@ class HeightMap extends EngineObject3D
     levelSegment3D(from, to)
     {
         const m = this.pos3D, size = this.mapSize;
-        if (abs(to.x - m.x) > size.x / 2 || abs(to.z - m.z) > size.y / 2) return; // off the map
+        if (abs(to.x - m.x) > size.x / 2 || abs(to.z - m.z) > size.y / 2) return undefined; // off the map
         const a = from.y - this.getHeight(from.x, from.z), b = to.y - this.getHeight(to.x, to.z);
-        if (a < 0 || b >= 0) return; // above all the way, or under from the start
+        if (a < 0 || b >= 0) return undefined; // above all the way, or under from the start
         const distance = a / (a - b);
         return {distance, normal: this.getNormal(from.x + (to.x - from.x) * distance, from.z + (to.z - from.z) * distance)};
     }
@@ -1484,7 +1484,7 @@ function render3DFlareTile(shape)
 {
     if (!render3DFlareTiles)
     {
-        if (headlessMode || !glContext || typeof OffscreenCanvas == 'undefined') return;
+        if (headlessMode || !glContext || !canvasAvailable()) return;
         const cell = 128, shapes = render3DFlareShapes, context = createCanvasContext(cell * shapes.length, cell);
         // each shape is how see-through it is from its middle out
         const alpha =
@@ -1575,7 +1575,8 @@ function render3DFlareTile(shape)
  *   with the sun's own color; shapes says what its ghosts are, glowSize and ghostSize how big its parts are; or
  *   give it elements of your own, which may be tiles of the game's
  * - visible is how much of the sun shows, 0 to 1, eased over fadeTime, there for a game to read; it is 0 while the
- *   sun is too far off the screen for the flare to show, a third of the screen past its edge, where nothing is tested
+ *   sun is too far off the screen for the flare to show, about a seventh of the screen past its edge, where nothing
+ *   is tested
  * - What hides the sun is found with a ray from the camera, against the level and every object that is not see
  *   through, each on the triangles of its mesh, see render3D.pick; turn it off with occlusion
  * - It needs WebGL, and it draws nothing in the shadow of renderAfter2D
@@ -1622,7 +1623,7 @@ class LensFlare3D extends EngineObject3D
         this.elements = undefined;
         /** @property {Light3D|undefined} - A light the flare is of in place of the sun, a lamp or a spotlight: the
          *  flare is at the light and in its color, smaller from farther than the light reaches, hidden by what is
-         *  in front of the light but its lamp, a mesh around it no wider than half its radius, and a spotlight's
+         *  in front of the light but its lamp, a mesh around it whose surface is near it, and a spotlight's
          *  shows from inside its beam only; a DirectionalLight3D's is far
          *  away where it shines from, like the sun's; the flare is destroyed when its light is; light.addFlare
          *  sets this
@@ -1670,9 +1671,11 @@ class LensFlare3D extends EngineObject3D
         return this.made;
     }
 
-    // what the flare is of, seen from the camera: the way to it, how far it is, Infinity for the sun and for a
-    // directional light, which shines from its place toward the origin, and a point to find it on the screen by;
-    // undefined with no direction, or a light that is gone or at the camera
+    /** What the flare is of, seen from the camera: the way to it, how far it is, Infinity for the sun and for a
+     *  directional light, which shines from its place toward the origin, and a point to find it on the screen by;
+     *  undefined with no direction, or a light that is gone or at the camera
+     *  @return {{direction: Vector3, distance: number, pos: Vector3}|undefined}
+     *  @ignore */
     flareSource()
     {
         const camera = render3D.camera.pos, light = this.light;
@@ -1688,15 +1691,17 @@ class LensFlare3D extends EngineObject3D
         return distance ? {direction: offset.scale(1 / distance), distance, pos} : undefined;
     }
 
-    // how the flare would show with nothing in the way: where its source is on the screen, how strong it is there,
-    // fading as it leaves the screen, its tint and the height its sizes are parts of; undefined when it would not
-    // show at all, behind the camera, off the screen, or of a light that is off or seen from outside its cone
+    /** How the flare would show with nothing in the way: where its source is on the screen, how strong it is there,
+     *  fading as it leaves the screen, its tint and the height its sizes are parts of; undefined when it would not
+     *  show at all, behind the camera, off the screen, or of a light that is off or seen from outside its cone
+     *  @return {{sun: Vector2, center: Vector2, strength: number, tint: Color, height: number}|undefined}
+     *  @ignore */
     flareLook()
     {
         const source = this.flareSource(), center = mainCanvasSize.scale(.5);
         const sun = source && render3D.worldToScreen(source.pos);
         if (!sun || !center.x || !center.y) return;
-        // it fades as the sun leaves the screen, gone when it is a third of the screen past the edge
+        // it fades as the sun leaves the screen, gone .3 of half the screen past the edge
         const off = max(abs(sun.x - center.x) / center.x, abs(sun.y - center.y) / center.y);
         const strength = clamp((1.3 - off) / .5) * this.intensity;
         if (!(strength > 0)) return;
@@ -1762,21 +1767,30 @@ class LensFlare3D extends EngineObject3D
         for (const map of maps)
             if (map.raycast(ray, reach, (type)=> !map.blockType(type).seeThrough))
                 return true;
-        // a light's lamp, the mesh the light is inside, does not hide it: one whose box, in its own space, the light
-        // is in, and no wider than half the light's reach, since a room or a whole level has a box around its lights
-        // too, and its walls do hide them from outside
-        const lamp = (o)=>
+        // a light's lamp, a mesh around the light, does not hide it: one whose box, in its own space, the light is in,
+        // hit close to the light, as a shade or a globe is, and small, its thinnest side no more than twice that; a
+        // room or a whole level holds its lights too, and its walls do hide them from outside, even one close behind
+        const inside = (o)=>
         {
-            if (!this.light || reach === Infinity || !o.mesh || o instanceof HeightMap) return false;
+            if (!o.mesh || o instanceof HeightMap) return false;
             const matrix = render3DObjectMatrix(o), b = o.mesh.bounds || o.mesh.getBounds();
-            const side = max(b.max.x - b.min.x, b.max.y - b.min.y, b.max.z - b.min.z) * render3DMaxStretch(matrix.m);
-            if (!matrix.determinant() || side > this.light.radius / 2) return false;
+            const m = matrix.m, scale = (k)=> hypot(m[k], m[k + 1], m[k + 2]); // each axis's own stretch
+            const thinnest = min((b.max.x - b.min.x) * scale(0), (b.max.y - b.min.y) * scale(4), (b.max.z - b.min.z) * scale(8));
+            if (!matrix.determinant() || thinnest > near * 2) return false;
             const p = matrix.copy().invert().transformPoint(source.pos);
             return p.x >= b.min.x && p.x <= b.max.x && p.y >= b.min.y && p.y <= b.max.y &&
                 p.z >= b.min.z && p.z <= b.max.z;
         };
-        const hit = render3D.pick(ray, blockers.filter((o)=> !maps.some((map)=> map === o) && !lamp(o)));
-        return !!hit && hit.distance < reach;
+        const near = this.light && reach < Infinity ? min(2, this.light.radius * .4) : 0;
+        let candidates = blockers.filter((o)=> !maps.some((map)=> map === o));
+        for (let tries = 5; tries--;)
+        {
+            const hit = render3D.pick(ray, candidates);
+            if (!hit || hit.distance >= reach) return false;
+            if (!(reach - hit.distance <= near && inside(hit.object))) return true;
+            candidates = candidates.filter((o)=> o !== hit.object); // its lamp, look past it
+        }
+        return true; // lamps on lamps, take it as hidden
     }
 
     /** Ease visible toward whether the sun shows, called automatically each frame; a flare that would not show
@@ -1837,9 +1851,10 @@ function parseOBJ(text, smooth=render3D?.smoothShading)
     // OBJ indices count from 1, and a negative one counts back from the end of the list so far
     const index = (s, list)=> { const i = parseInt(s); return i < 0 ? list.length + i : i - 1; };
     const lookup = (s, list)=> list[index(s, list)];
-    for (const line of text.split('\n'))
+    // any line end, a line carried on by a backslash at its end, and a comment after what a line holds
+    for (const line of text.replace(/\\\r?\n/g, ' ').split(/\r\n?|\n/))
     {
-        const parts = line.trim().split(/\s+/);
+        const parts = line.replace(/#.*/, '').trim().split(/\s+/);
         switch (parts[0])
         {
             case 'v':  positions.push(vec3(+parts[1], +parts[2], +parts[3])); break;
@@ -1851,6 +1866,7 @@ function parseOBJ(text, smooth=render3D?.smoothShading)
                 if (corners.length < 3) break;
                 const facePoints = corners.map(c=> lookup(c[0], positions));
                 ASSERT(facePoints.every(isVector3), 'OBJ face uses a vertex index the file does not have', line);
+                if (!facePoints.every(isVector3)) break; // a release build leaves the face out
                 const hasNormals = corners.every(c=> c[2]);
                 missingNormals ||= !hasNormals;
                 const faceNormal = hasNormals ? undefined : render3DFaceNormal(facePoints[0], facePoints[1], facePoints[2], facePoints[3]);

package/plugins/render3dLevel.js

@@ -198,18 +198,21 @@ function level3DTerrainShape(terrain)
 {
     if (!terrain || typeof terrain !== 'object') return;
     const size = terrain.size, rows = terrain.heights, n = LEVEL3D_TERRAIN_SAMPLES;
-    if (!isArray(size) || size.length !== 2 || !size.every((v)=> isNumber(v) && v > 0)) return;
+    if (!isArray(size) || size.length !== 2 || !size.every((v)=> level3DFinite(v) && v > 0)) return;
     if (!isArray(rows) || rows.length < 2 || rows.length > n || !isArray(rows[0])) return;
     const columns = rows[0].length;
     if (columns < 2 || columns > n || !rows.every((row)=> isArray(row) && row.length === columns)) return;
-    const heights = rows.map((row)=> row.map((v)=> isNumber(v) ? clamp(v) : 0));
+    const heights = rows.map((row)=> row.map((v)=> level3DFinite(v) ? clamp(v) : 0));
     return {pos: level3DVector(terrain.pos, vec3()), size: vec2(size[0], size[1]),
-        height: isNumber(terrain.height) && terrain.height > 0 ? terrain.height : 1, heights};
+        height: level3DFinite(terrain.height) && terrain.height > 0 ? terrain.height : 1, heights};
 }
 
 // a hex color of a level as a Color, undefined when it is not one
 function level3DHexColor(hex)
-{ return /^#([0-9a-f]{6}|[0-9a-f]{8})$/i.test(hex) ? new Color().setHex(hex) : undefined; }
+{ return typeof hex === 'string' && /^#([0-9a-f]{6}|[0-9a-f]{8})$/i.test(hex) ? new Color().setHex(hex) : undefined; }
+
+// a number of a level that is a real one, not NaN or Infinity, which JSON writes as 1e999
+const level3DFinite = (v)=> typeof v === 'number' && isFinite(v);
 
 // the paint of a level's terrain block, for a terrain of so many samples: its colors as they are written and a
 // color for each sample, row after row, 0 for none and 1 the first of the colors; undefined when it has none or
@@ -248,7 +251,7 @@ function level3DTerrainSetColors(map, terrain, paint=level3DTerrainPaint(terrain
 let level3DVoxelPlain;
 function level3DVoxelPlainTiles()
 {
-    if (textureInfos[0]?.size.x || headlessMode || typeof OffscreenCanvas == 'undefined')
+    if (textureInfos[0]?.size.x || headlessMode || !canvasAvailable())
         return tile();
     if (!level3DVoxelPlain)
     {
@@ -289,12 +292,12 @@ function level3DSceneApply(scene)
 {
     const r = render3D;
     if (!r || !scene || typeof scene !== 'object') return;
-    const color = (value)=> /^#([0-9a-f]{6}|[0-9a-f]{8})$/i.test(value) ? new Color().setHex(value) : undefined;
+    const color = level3DHexColor;
     const sky = isArray(scene.sky) && scene.sky.length === 3 ? scene.sky.map(color) : [];
     if (sky.length && sky.every((c)=> c))
     {
         // as setSky does, without disposing a dome that is the game's own
-        const [top, horizon, bottom] = sky, ambient = isNumber(scene.ambient) ? scene.ambient : .5;
+        const [top, horizon, bottom] = sky, ambient = level3DFinite(scene.ambient) ? scene.ambient : .5;
         level3DSkies.has(r.sky) && r.sky.dispose();
         level3DSkies.add(r.sky = buildSky(top, horizon, bottom));
         r.fogColor = horizon.copy();
@@ -306,7 +309,7 @@ function level3DSceneApply(scene)
         r.sunDirection = sun;
     r.sunColor = color(scene.sunColor) || r.sunColor;
     const fog = scene.fog;
-    if (isArray(fog) && fog.length === 2 && fog.every((v)=> isNumber(v)))
+    if (isArray(fog) && fog.length === 2 && fog.every(level3DFinite))
         r.fogStart = fog[0], r.fogEnd = fog[1];
     r.fogColor = color(scene.fogColor) || r.fogColor;
     if (typeof scene.shadows === 'boolean')
@@ -333,7 +336,7 @@ const level3DSunHasFlare = ()=> engineObjects.some((o)=> o instanceof LensFlare3
 // a vec3 of an array of three numbers, as the file has them, or the fallback
 function level3DVector(value, fallback)
 {
-    return isArray(value) && value.length === 3 && value.every((v)=> isNumber(v)) ?
+    return isArray(value) && value.length === 3 && value.every(level3DFinite) ?
         vec3(value[0], value[1], value[2]) : fallback;
 }
 
@@ -349,12 +352,14 @@ function level3DProperties(type, object)
     {
         const d = type.defaults[key];
         if (isColor(d))
-            /^#([0-9a-f]{6}|[0-9a-f]{8})$/i.test(value) && (properties[key] = new Color().setHex(value));
+            level3DHexColor(value) && (properties[key] = level3DHexColor(value));
         else if (isVector3(d))
             properties[key] = level3DVector(value, properties[key]);
         else if (isVector2(d))
-            isArray(value) && value.length === 2 && value.every((v)=> isNumber(v)) &&
+            isArray(value) && value.length === 2 && value.every(level3DFinite) &&
                 (properties[key] = vec2(value[0], value[1]));
+        else if (typeof d === 'number')
+            level3DFinite(value) && (properties[key] = value);
         else if (d === undefined || typeof value === typeof d)
             properties[key] = value;
     }
@@ -439,6 +444,8 @@ const level3DPrefabs = new Map;
 // how many prefabs deep an instance being made is, a prefab that holds itself is stopped; and how many of those
 // are attached: a prefab inside an attached one is attached too, or its parts would be left behind in the world
 let level3DPrefabDepth = 0, level3DPrefabAttached = 0;
+// the prefabs being made, one inside the next, so one that holds itself is caught where it does, however many times
+const level3DPrefabMaking = [];
 
 /** Add a prefab: a small level, its objects placed about its own origin, to place many times under one name
  *  - It is a type from then on: a level's object of that type, the level editor's Place list and level3DSpawn make
@@ -580,11 +587,12 @@ class Prefab3D extends EngineObject3D
     {
         const prefab = level3DPrefabs.get(this.prefabName);
         if (!prefab) return;
-        if (level3DPrefabDepth >= 8)
+        if (level3DPrefabMaking.includes(this.prefabName) || level3DPrefabDepth >= 8)
         {
             debug && console.error(`level3DLoad: the prefab ${this.prefabName} holds itself, left out there`);
             return;
         }
+        level3DPrefabMaking.push(this.prefabName);
         ++level3DPrefabDepth;
         this.attached && ++level3DPrefabAttached;
         try
@@ -628,6 +636,7 @@ class Prefab3D extends EngineObject3D
         finally
         {
             --level3DPrefabDepth;
+            level3DPrefabMaking.pop();
             this.attached && --level3DPrefabAttached;
         }
     }

package/plugins/render3dVoxels.js

@@ -256,8 +256,8 @@ class VoxelMap extends EngineObject3D
 
                 // a double sided block shows the face from inside too, its corners the other way round
                 if (block.doubleSided)
-                    mesh.addStrip([points[1], points[0], points[3], points[2]], normal.scale(-1),
-                        [uvs[1], uvs[0], uvs[3], uvs[2]], [colors[1], colors[0], colors[3], colors[2]]);
+                    mesh.addStrip([points[0], points[2], points[1], points[3]], normal.scale(-1),
+                        [uvs[0], uvs[2], uvs[1], uvs[3]], [colors[0], colors[2], colors[1], colors[3]]);
             }
         }
         this.chunkMeshes[index]?.dispose();

package/plugins/textureSheet.js

@@ -7,6 +7,7 @@
  * - Animation frames keep layout and wrap across rows as needed
  * - WebGL textures upload once per batch of loads
  * - loadAtlas imports pre-packed atlases (TexturePacker and Aseprite json)
+ * - loadTiles packs separate tile images, or several tile sheets, into one tile set for tile layers and maps
  * @namespace TextureSheets
  */
 
@@ -32,6 +33,12 @@ let textureSheets = [];
 // pending loads pack through a queue so sheets fill in call order
 let textureSheetQueue = Promise.resolve();
 let textureSheetPendingCount = 0;
+// what each load handed back by what it was given, so the same image loaded again is packed once
+const textureSheetLoaded = new Map;
+// a load's key: what it was given, a vector by its numbers
+const textureSheetLoadKey = (...parts)=> parts.map((p)=> isVector2(p) ? p.x + ',' + p.y : String(p)).join('|');
+// a load whose file failed is forgotten, so loading it again tries again, as when the server comes back
+const textureSheetLoadFailed = (key, loaded)=> textureSheetLoaded.get(key) === loaded && textureSheetLoaded.delete(key);
 
 /**
  * Texture Sheet - A texture that images are packed into as they load
@@ -188,6 +195,8 @@ class TextureSheet
  *  - Pass frameSize for animations, then step through them with TileInfo.frame
  *  - Grid images keep their layout and frames wrap down to the next row
  *  - Pass sourcePadding if the source image has padding baked in around frames
+ *  - The same image loaded again with the same settings gives back what the first load did, packed once, unless
+ *    that load failed
  *  @param {string} src - Image source path
  *  @param {Vector2|number} [frameSize] - Size of each animation frame in pixels, or the whole image less its
  *  source padding if not passed
@@ -208,10 +217,14 @@ function loadSprite(src, frameSize, padding=textureSheetPadding, sourcePadding=0
 
     if (isNumber(frameSize))
         frameSize = vec2(/** @type {number} */ (frameSize));
+    const key = textureSheetLoadKey('sprite', src, frameSize, padding, sourcePadding);
+    if (!headlessMode && textureSheetLoaded.has(key))
+        return textureSheetLoaded.get(key);
 
     // start with an empty tile that gets filled in when the image loads
     const tileInfo = new TileInfo(vec2(), vec2(), undefined, padding, 0);
     if (headlessMode) return tileInfo;
+    textureSheetLoaded.set(key, tileInfo);
 
     // point at a sheet right away so drawing before it loads picks up empty pixels
     tileInfo.textureInfo = (textureSheets[0] || textureSheetCreate()).textureInfo;
@@ -238,7 +251,7 @@ function loadSprite(src, frameSize, padding=textureSheetPadding, sourcePadding=0
             if (!added)
             {
                 // leave the tile empty, no sheet can hold it
-                LOG('loadSprite image is too large to fit on a texture sheet:', src);
+                console.warn('loadSprite image is too large to fit on a texture sheet:', src);
                 return;
             }
             Object.assign(tileInfo, added.tile);
@@ -247,13 +260,80 @@ function loadSprite(src, frameSize, padding=textureSheetPadding, sourcePadding=0
         else
         {
             // leave the tile empty if the image failed to load
-            LOG('loadSprite failed to load image:', src);
+            console.warn('loadSprite failed to load image:', src);
+            textureSheetLoadFailed(key, tileInfo);
         }
     });
 
     return tileInfo;
 }
 
+/** Load tile images and pack them into texture sheets as one tile set, for tile layers and maps
+ *  - Each image is cut into tiles of tileSize, left to right then down, so an image of one tile is one tile and a
+ *    sheet is all of its tiles; the tiles are numbered from 0 in the order the images are given
+ *  - Returns a tile set at once, a TileInfo whose tiles fill in as the images load; wait for them with spritesReady
+ *  - Give it to tileLayersLoad, a TileLayer or a TileCollisionLayer as its tile info: tile n draws tiles[n],
+ *    wherever it was packed, and the level editor's palette offers each of them; frame and index do not read the
+ *    list, use set.tiles[n] for one tile; make the layers after spritesReady, a layer made before draws nothing
+ *  - An image that is not a whole number of tiles gives the whole tiles in it; a sheet with gaps between its tiles
+ *    is not read, cut it into its tiles first
+ *  - An image that fails to load, or that no sheet can hold, adds no tiles and says so in the console, so the tiles
+ *    of the images after it move up
+ *  - The same images loaded again with the same settings give back what the first load did, packed once, unless
+ *    an image of it failed
+ *  @param {Array<string>} sources - Image source paths
+ *  @param {Vector2|number} [tileSize] - Size of a tile in pixels
+ *  @param {number} [padding] - How many pixels padding around each tile on the sheet
+ *  @return {TileInfo}
+ *  @example
+ *  const tiles = loadTiles(['grass.png', 'dirt.png', 'water.png', 'props.png'], 16);
+ *  await spritesReady();
+ *  tileLayersLoad(map, tiles); // tile 0 is grass, 1 dirt, 2 water, then the tiles of props.png
+ *  @memberof TextureSheets */
+function loadTiles(sources, tileSize=tileDefaultSize, padding=textureSheetPadding)
+{
+    ASSERT(isArray(sources) && sources.every((src)=> isStringLike(src)), 'sources must be a list of image paths');
+    ASSERT(isVector2(tileSize) || isNumber(tileSize), 'tileSize must be a vec2 or number');
+    ASSERT(isNumber(padding), 'padding must be a number');
+    ASSERT(engineInitialized || headlessMode, 'call loadTiles after engineInit, e.g. in gameInit');
+    const size = isNumber(tileSize) ? vec2(/** @type {number} */ (tileSize)) : /** @type {Vector2} */ (tileSize).copy();
+    const key = textureSheetLoadKey('tiles', sources.join('\n'), size, padding);
+    if (!headlessMode && textureSheetLoaded.has(key))
+        return textureSheetLoaded.get(key);
+    const set = new TileInfo(vec2(), size, undefined, 0, 0);
+    set.tiles = [];
+    if (headlessMode) return set;
+    textureSheetLoaded.set(key, set);
+    set.textureInfo = (textureSheets[0] || textureSheetCreate()).textureInfo;
+
+    // every image decodes at once, and packs through the queue in the order given, so the tiles keep that order
+    for (const src of sources)
+    {
+        const image = new Image;
+        const imagePromise = new Promise((resolve)=>
+        {
+            image.onerror = image.onload = resolve;
+            image.crossOrigin = 'anonymous';
+            image.src = src;
+        });
+        textureSheetQueueJob('loadTiles ' + src, async ()=>
+        {
+            await imagePromise;
+            // the whole tiles of it, an edge past the last one left out
+            const columns = image.width / size.x | 0, rows = image.height / size.y | 0, count = columns * rows;
+            const added = count && textureSheetAdd(vec2(columns * size.x, rows * size.y), size, padding, 0);
+            image.width || textureSheetLoadFailed(key, set);
+            if (!added)
+                return console.warn('loadTiles: ' + src + (count ? ' does not fit on a texture sheet' :
+                    ' failed to load, or is smaller than a tile') + ', its tiles are left out');
+            added.sheet.drawImage(image, added.tile, false); // upload once per batch
+            for (let k = 0; k < count; ++k)
+                set.tiles.push(added.tile.frame(k));
+        });
+    }
+    return set;
+}
+
 /** Load a pre-packed texture atlas and repack it onto texture sheets
  *  - Supports TexturePacker json (hash and array) and Aseprite json
  *  - Returns an empty object which is filled with TileInfos when loaded
@@ -261,6 +341,8 @@ function loadSprite(src, frameSize, padding=textureSheetPadding, sourcePadding=0
  *  - Aseprite frame tags become animations, so do names like run_0, run_1
  *  - Trimmed frames are restored to their full source size when packed
  *  - Rotated frames are rotated back upright when packed
+ *  - The same atlas loaded again by its paths, with the same padding, gives back what the first load did, packed
+ *    once, unless that load failed
  *  @param {string} imageSrc - Atlas image path
  *  @param {string|Object} jsonSrc - Atlas json path, or already parsed json data
  *  @param {number} [padding] - How many pixels padding around each frame
@@ -278,9 +360,15 @@ function loadAtlas(imageSrc, jsonSrc, padding=textureSheetPadding)
     ASSERT(isNumber(padding), 'padding must be a number');
     ASSERT(engineInitialized || headlessMode, 'call loadAtlas after engineInit, e.g. in gameInit');
 
+    // json passed in as data may be another atlas each time, only one loaded by its path is kept
+    const key = typeof jsonSrc === 'object' ? undefined : textureSheetLoadKey('atlas', imageSrc, jsonSrc, padding);
+    if (!headlessMode && textureSheetLoaded.has(key))
+        return textureSheetLoaded.get(key);
+
     /** @type {Object<string, TileInfo>} */
     const atlas = {};
     if (headlessMode) return atlas;
+    key && textureSheetLoaded.set(key, atlas);
 
     // start fetching the json and decoding the image right away, in parallel
     const jsonPromise = typeof jsonSrc === 'object' ? Promise.resolve(jsonSrc) :
@@ -309,7 +397,7 @@ function loadAtlas(imageSrc, jsonSrc, padding=textureSheetPadding)
                 const added = textureSheetAdd(blockSize, sourceSize, padding);
                 if (!added)
                 {
-                    LOG('loadAtlas frames are too large to fit on a texture sheet:', group.name);
+                    console.warn('loadAtlas frames are too large to fit on a texture sheet:', group.name);
                     continue;
                 }
                 const {sheet, tile} = added;
@@ -343,7 +431,8 @@ function loadAtlas(imageSrc, jsonSrc, padding=textureSheetPadding)
         else
         {
             // leave the atlas empty if either file failed to load
-            LOG('loadAtlas failed to load:', imageSrc, jsonSrc);
+            console.warn('loadAtlas failed to load:', imageSrc, jsonSrc);
+            textureSheetLoadFailed(key, atlas);
         }
     });
 
@@ -401,12 +490,14 @@ function parseAtlas(data)
         const tagged = new Set;
         for (const tag of tags)
         {
-            groups.push({name: tag.name, frames: frames.slice(tag.from, tag.to + 1)});
-            for (let i = tag.from; i <= tag.to; ++i)
+            // a tag reaches only frames there are, whatever its numbers say
+            const from = max(0, floor(tag.from) || 0), to = min(frames.length - 1, floor(tag.to) || 0);
+            groups.push({name: tag.name, frames: frames.slice(from, to + 1)});
+            for (let i = from; i <= to; ++i)
                 tagged.add(i);
         }
         frames.forEach((f, i)=> tagged.has(i) || groups.push({name: f.name, frames: [f]}));
-        return groups;
+        return parseAtlasNamesCheck(groups);
     }
 
     // group frames that share a name stem with contiguous trailing numbers
@@ -435,6 +526,17 @@ function parseAtlas(data)
         else
             list.forEach(f=> groups.push({name: f.name, frames: [f]}));
     }
+    return parseAtlasNamesCheck(groups);
+}
+
+// an atlas's groups, with a warning for each name two of them have, as a sprite is looked up by name and the second
+// takes the first's place
+function parseAtlasNamesCheck(groups)
+{
+    const names = new Set;
+    for (const {name} of groups)
+        names.has(name) ? console.warn(`parseAtlas: two sprites are named ${name}, the second takes the first's place`) :
+            names.add(name);
     return groups;
 }
 

package/plugins/tweakables.js

@@ -379,7 +379,7 @@ function tweakNumber(parent, axis, get, set, options, save)
     const change = (input)=>
     {
         const v = parseFloat(input.value);
-        if (!isNumber(v)) return; // a box part way through typing
+        if (!isFinite(v)) return; // a box part way through typing, or 1e999
         set(v);
         save();
     };

package/plugins/tweenSystem.js

@@ -510,14 +510,14 @@ function tweenProperty(target, propertyPath, start, end, duration = 1, options =
 function tweenCarryOvershoot(tween)
 {
     const duration = tween.duration;
-    tween.life = duration ? min(tween.life, 0) % duration + duration : 1e-9;
+    tween.life = duration > 0 ? min(tween.life, 0) % duration + duration : 1e-9;
 }
 
 // How many iterations the update that finished one ran through: that one and every whole one after it
 function tweenPassed(tween)
 {
     const duration = tween.duration;
-    return duration ? 1 + floor(-min(tween.life, 0) / duration) : 1;
+    return duration > 0 ? 1 + floor(-min(tween.life, 0) / duration) : 1; // no time, or less, is one each update
 }
 
 // start the next iteration of a loop or pingPong, the time the last one ran over already spent, true

package/plugins/uiSystem.js

@@ -747,6 +747,8 @@ class UISystemPlugin
     showConfirmDialog(text='Are you sure?', yesCallback, noCallback, size=vec2(500,250), exitKey='Escape')
     {
         ASSERT(!uiSystem.confirmDialog, 'a confirm dialog is already open, check uiSystem.confirmDialog');
+        if (uiSystem.confirmDialog)
+            return uiSystem.confirmDialog; // in a release build, the one open, as a second would break navigation
 
         const savedNavigationDirection = uiSystem.navigationDirection;
         const savedNavigationObject = uiSystem.navigationObject;
@@ -1412,7 +1414,7 @@ class UITextInput extends UIObject
     onKeyDown(e)
     {
         // named keys by key, so numpad Enter works as Enter
-        const code = e.code, key = e.key;
+        const code = e.code, key = e.key || ''; // autofill sends a keydown with no key
         if (e.repeat && (key === 'Enter' || code === 'Space'))
             return; // a key held when editing began repeats, it should not type or stop editing
         this.text += ''; // a game may have set a number
@@ -1646,12 +1648,14 @@ class UISlider extends UIObject
     }
     update()
     {
+        // held when the frame began, so a release in the same frame as the last move still reads it
+        const wasActive = this.isActiveObject();
         super.update();
         if (!this.interactive)
             return;
 
         const oldValue = this.value;
-        if (this.isActiveObject())
+        if (wasActive || this.isActiveObject())
         {
             // handle horizontal or vertical slider
             const isHorizontal = this.size.x > this.size.y;