littlejsengine 1.24.0 → 1.24.2

package/plugins/medalSystem.js

@@ -47,7 +47,6 @@ const medals = {};
 
 // Engine internal variables not exposed to documentation
 let medalsDisplayQueue = [], medalsSaveName, medalsDisplayTimeLast, medalsRenderAdded;
-let medalsLoadWaiting = false; // medalsInit came before any medal, each one made reads its own unlock
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -72,9 +71,7 @@ function medalsInit(saveName)
 // check which local medals are unlocked in the save, and write the catalog back
 function medalsLoad()
 {
-    // with no medals made yet, the save is left as it is for them, a game that calls medalsInit first keeps its unlocks;
-    // it keeps waiting from then on, so loading again (a dropped Newgrounds session) does not drop medals still to come
-    medalsLoadWaiting ||= !Object.keys(medals).length;
+    // the saved unlocks of medals not made yet stay for them, a medal made late or behind a flag keeps its unlock
     if (debugMedals || !medalsSaveName) return;
     const saved = readSaveData(medalsSaveName);
     ASSERT(Object.keys(saved).every(key=> isNumber(+key)),
@@ -131,7 +128,7 @@ function medalsForEach(callback)
 function medalsReset()
 {
     medalsForEach(medal=> medal.isLocal() && (medal.unlocked = false));
-    if (medalsLoadWaiting && medalsSaveName && !debugMedals)
+    if (medalsSaveName && !debugMedals)
     {
         // the saved unlocks of medals not made yet are cleared too, they are read when those medals are made
         const saved = readSaveData(medalsSaveName);
@@ -147,11 +144,10 @@ function medalsReset()
 function medalsSave()
 {
     if (debugMedals || !medalsSaveName) return;
-    // while medalsInit waits for medals made later, their saved entries are kept for them
+    // every saved entry stays: a medal not made this time keeps its unlock for when it is, since a player given a
+    // medal back is better than one who lost it, and what is not a medal is the game's own, under the same name
     const saved = readSaveData(medalsSaveName);
-    const data = medalsLoadWaiting ? {...saved} : {};
-    for (const key in saved) // what is not a medal is the game's own, saved under the same name, and stays
-        isNumber(+key) || (data[key] = saved[key]);
+    const data = {...saved};
     medalsForEach(medal=> {
         if (!medal.isLocal())
         {
@@ -220,9 +216,9 @@ class Medal
         if (src)
             (this.image = new Image).src = src;
 
-        // add this to list of medals, unlocked if the save says so when medalsInit came before any medal
+        // add this to list of medals, unlocked if the save says so when medalsInit came first
         medals[id] = this;
-        if (medalsLoadWaiting && !debugMedals && this.isLocal())
+        if (medalsSaveName && !debugMedals && this.isLocal())
             this.unlocked = !!readSaveData(medalsSaveName)[id]?.unlocked;
     }
 

package/plugins/particleEffects.js

@@ -160,7 +160,7 @@ function particleEffectSanitize(raw)
 {
     // one line of text, line breaks and control characters made spaces
     const text = typeof raw?.name === 'string' ? raw.name.replace(/[\x00-\x1f\x7f]+/g, ' ').trim() : '';
-    const name = text ? text.slice(0, 60) : 'Effect';
+    const name = text ? text.slice(0, 60).trim() : 'Effect'; // no space left where it was cut
     const input = raw?.settings && typeof raw.settings === 'object' ? {...raw.settings} : {};
     input.collideLevel ??= input.collideTiles; // its name before 1.20
     // a library saved before shapes names its tile and no shape, it keeps its tile
@@ -301,7 +301,7 @@ function particleEffectShapeTile(name)
 {
     if (!particleEffectShapeTiles)
     {
-        if (headlessMode || !glContext || typeof OffscreenCanvas == 'undefined') return;
+        if (headlessMode || !glContext || !canvasAvailable()) return;
         // drawn at 4 times 32 pixel cells, so a big soft shape stays smooth when textures are pixelated
         const cell = 32, r = 15, count = particleEffectShapes.length, res = 4;
         const context = createCanvasContext(cell * count * res, cell * res);

package/plugins/pathFinder.js

@@ -83,8 +83,8 @@ class PathFinderNode
  *  const path = pf.findPath(player.pos, mousePos);
  *
  *  // Bare grid with custom walkability:
- *  const pf = new PathFinder(vec2(50, 50));
- *  pf.isWalkable = (x, y) => myGrid[y*50 + x] === 0;
+ *  const gridFinder = new PathFinder(vec2(50, 50));
+ *  gridFinder.isWalkable = (x, y) => myGrid[y*50 + x] === 0;
  */
 class PathFinder
 {

package/plugins/pluginExport.js

@@ -215,6 +215,7 @@ export
     textureSheets,
     TextureSheet,
     loadSprite,
+    loadTiles,
     loadAtlas,
     parseAtlas,
     spritesReady,

package/plugins/render3d.js

@@ -637,6 +637,7 @@ class Render3DPlugin
         this.viewProjection = new Matrix4;
         /** @property {Matrix4} - This frame's light view projection for the shadow map */
         this.shadowMatrix = new Matrix4;
+        this.gelAxes = [1, 0, 0, 1]; // the shadow light's right and up in its map's, for its gel
         /** @property {Vector3} - Camera right axis this frame */
         this.cameraRight = vec3(1, 0, 0);
         /** @property {Vector3} - Camera up axis this frame */
@@ -1240,8 +1241,14 @@ class Render3DPlugin
             // the near plane stays in front of the far one however small the light
             const far = caster.radius, near = min(max(far / 500, .02), far / 2);
             const fov = min(caster.coneAngle, RENDER3D_SHADOW_CONE_MAX) * 2 + .1;
-            this.shadowMatrix = Matrix4.perspective(fov, 1, near, far).multiply(
-                Matrix4.lookAt(pos, pos.add(forward), up).invert());
+            const view = Matrix4.lookAt(pos, pos.add(forward), up);
+            this.shadowMatrix = Matrix4.perspective(fov, 1, near, far).multiply(view.copy().invert());
+            // the map's own right and up are not the light's, which a gel is upright by: the four numbers that
+            // turn the one into the other
+            const v = view.m, l = render3DObjectMatrix(caster).m;
+            const right = vec3(l[0], l[1], l[2]).normalize(), lightUp = vec3(l[4], l[5], l[6]).normalize();
+            const mapRight = vec3(v[0], v[1], v[2]), mapUp = vec3(v[4], v[5], v[6]);
+            this.gelAxes = [right.dot(mapRight), right.dot(mapUp), lightUp.dot(mapRight), lightUp.dot(mapUp)];
             this.shadowPlanes = render3DFrustumPlanes(this.shadowMatrix);
             // depth is not even with perspective: the lookup divides this by the distance squared, which makes
             // the bias the same distance in the world near the light and far from it
@@ -1702,8 +1709,8 @@ function render3DFragmentSource(fragmentCode)
         'uniform vec4 extraLightCones[' + RENDER3D_MAX_LIGHTS + '];' +
         'uniform int extraLightCount;' +
         'uniform vec3 cameraPos;' +
-        'uniform vec4 materialParams,emissiveTint,skyTop,skyHorizon,skyBottom;' +
-        'uniform sampler2D tex,normalTex,emissiveTex;' +
+        'uniform vec4 materialParams,emissiveTint,skyTop,skyHorizon,skyBottom,gelAxes;' +
+        'uniform sampler2D tex,normalTex,emissiveTex,gelTex;' +
         'uniform bool premultipliedTexture;' + // is the texture a render target, which holds premultiplied color
         'uniform highp sampler2DShadow shadowMap;' +
         'in vec3 P,N;in vec2 T,L;in vec4 C,S;' +
@@ -1720,6 +1727,12 @@ function render3DFragmentSource(fragmentCode)
         'for(int x=-1;x<=1;++x)for(int y=-1;y<=1;++y)' +
         's+=texture(shadowMap,vec3(q.xy+vec2(x,y)*shadowParams.z,q.z));' +
         'return s/9.;}' +
+        // the gel the shadow light shines through, at this fragment's place in its view, upright as it looks out;
+        // white with no gel, so a light without one is exactly as before
+        'vec3 gel(){' +
+        'if(S.w<=0.)return vec3(1);' +
+        'vec2 g=S.xy/S.w,u=vec2(dot(gelAxes.xy,g),dot(gelAxes.zw,g))*.5+.5;' +
+        'return texture(gelTex,vec2(u.x,1.-u.y)).rgb;}' +
         // the normal map's normal here, in the frame that the position and texture coordinate change along across the
         // screen, so a mesh needs no tangents; green points up the image and v runs down it, so up is -v;
         // a mesh with no texture coordinates has no frame and keeps its own normal
@@ -1765,7 +1778,7 @@ function render3DFragmentSource(fragmentCode)
         'vec4 K=extraLightCones[i];' +
         'float k=clamp(dot(K.xyz,-v)-K.w,0.,1.);' +
         'lc*=k*k*(3.-2.*k);' +
-        'if(i==si)lc*=sh;' +
+        'if(i==si)lc*=sh*gel();' +
         'l+=lc*max(0.,ln);' +
         'if(lightColor.a>0.)sp+=lc*pow(max(dot(reflect(-v,n),eye),0.),materialParams.y)*step(0.,ln);' +
         '}' +
@@ -1813,6 +1826,8 @@ function render3DUseProgram(program)
     gl.uniform1i(render3DUniform('shadowMap'), 1);
     gl.uniform1i(render3DUniform('normalTex'), 2);
     gl.uniform1i(render3DUniform('emissiveTex'), 3);
+    gl.uniform1i(render3DUniform('gelTex'), 4);
+    gl.uniform4fv(render3DUniform('gelAxes'), r.gelAxes);
     const c = r.camera.pos;
     gl.uniform3f(render3DUniform('cameraPos'), c.x, c.y, c.z);
     gl.uniform1i(render3DUniform('extraLightCount'), r.lightCount);
@@ -2273,8 +2288,16 @@ function render3DRenderPass(after2D)
     // may have left its own texture, which fails every draw; the shadow map goes back there even with shadows off
     gl.activeTexture(gl.TEXTURE1);
     gl.bindTexture(gl.TEXTURE_2D, r.shadowTexture || null);
-    // the material maps' units start white, a 2D plugin may have left its own textures there
+    // the material maps' units start white, a 2D plugin may have left its own textures there, and the shadow
+    // light's gel goes on its unit for the pass, white when it has none
     render3DSetMapUnits(r.whiteTexture);
+    const gel = render3DTextureOf(render3DShadowCaster()?.gel)?.glTexture;
+    if (gel)
+    {
+        gl.activeTexture(gl.TEXTURE4);
+        gl.bindTexture(gl.TEXTURE_2D, gel);
+        gl.activeTexture(gl.TEXTURE0);
+    }
     gl.depthMask(true);
     gl.clear(gl.DEPTH_BUFFER_BIT);
 
@@ -2313,12 +2336,12 @@ function render3DRenderPass(after2D)
     }
 }
 
-// put a texture on both material map units with no sampler, white at the start of the pass and none at its end, and
-// forget what the map cache thought was bound; unit 0 is active after
+// put a texture on the material map units and the gel's with no sampler, white at the start of the pass and none at
+// its end, and forget what the map cache thought was bound; unit 0 is active after
 function render3DSetMapUnits(texture)
 {
     const gl = glContext;
-    for (const unit of [2, 3])
+    for (const unit of [2, 3, 4])
     {
         gl.activeTexture(gl.TEXTURE0 + unit);
         gl.bindTexture(gl.TEXTURE_2D, texture);
@@ -2682,17 +2705,63 @@ const render3DMeshBuffers = typeof FinalizationRegistry == 'undefined' ? undefin
         glContext.deleteBuffer(indexBuffer);
     });
 
-// the place a point is at, to a hundred thousandth, which smooth normals are summed by
-function render3DPlaceKey(p) { return `${round(p.x * 1e5)},${round(p.y * 1e5)},${round(p.z * 1e5)}`; }
+// the points at one place, to a hundred thousandth, which smooth normals are summed by: each point's group, numbered
+// from 0, found by a number made from its place and checked against the place, so no text is made for a point
+function render3DPlaceGroups(points)
+{
+    const groups = new Int32Array(points.length), first = new Map, next = [], places = [];
+    for (let i = 0; i < points.length; ++i)
+    {
+        const p = points[i], x = round(p.x * 1e5), y = round(p.y * 1e5), z = round(p.z * 1e5);
+        const hash = Math.imul(x, 73856093) ^ Math.imul(y, 19349663) ^ Math.imul(z, 83492791);
+        let group = first.get(hash);
+        while (group !== undefined && !(places[group*3] === x && places[group*3+1] === y && places[group*3+2] === z))
+            group = next[group];
+        if (group === undefined)
+        {
+            group = next.length;
+            next.push(first.get(hash));
+            first.set(hash, group);
+            places.push(x, y, z);
+        }
+        groups[i] = group;
+    }
+    return {groups, count: next.length};
+}
 
-// add a face normal to the sum at a triangle's corner a, weighted by the angle there, so a cube corner averages its
-// three faces evenly however it is cut into triangles
-function render3DAddCornerNormal(sums, a, b, c, normal)
+// the face normals meeting at each place added up, each weighted by its corner angle so a cube corner averages its
+// three faces evenly however they are cut into triangles; of a strip, every other triangle turned back, with no
+// indices, or of the index list; in numbers, with no vector made for a triangle or a corner
+function render3DSmoothNormalSums(points, indices)
 {
-    const u = b.subtract(a), v = c.subtract(a);
-    const angle = Math.acos(clamp(u.dot(v) / (u.length() * v.length() || 1), -1, 1));
-    const k = render3DPlaceKey(a);
-    sums.set(k, (sums.get(k) || vec3()).add(normal.scale(angle)));
+    const strip = !indices, triangles = strip ? max(points.length - 2, 0) : indices.length / 3 | 0;
+    const {groups, count} = render3DPlaceGroups(points);
+    const sums = new Float64Array(count * 3), touched = new Uint8Array(count);
+    let nx = 0, ny = 0, nz = 0;
+    const addCorner = (a, b, c, group)=>
+    {
+        // the angle at corner a, then the face normal scaled by it added to the sum at a's place
+        const ux = b.x - a.x, uy = b.y - a.y, uz = b.z - a.z, vx = c.x - a.x, vy = c.y - a.y, vz = c.z - a.z;
+        const dot = ux*vx + uy*vy + uz*vz, lengths = (ux**2 + uy**2 + uz**2)**.5 * (vx**2 + vy**2 + vz**2)**.5;
+        const angle = Math.acos(clamp(dot / (lengths || 1), -1, 1)), s = group * 3;
+        sums[s] += nx * angle, sums[s+1] += ny * angle, sums[s+2] += nz * angle;
+        touched[group] = 1;
+    };
+    for (let t = 0; t < triangles; ++t)
+    {
+        const i0 = strip ? t : indices[t*3], i1 = strip ? t + 1 : indices[t*3+1], i2 = strip ? t + 2 : indices[t*3+2];
+        const a = points[i0], b = points[i1], c = points[i2];
+        const ux = b.x - a.x, uy = b.y - a.y, uz = b.z - a.z, vx = c.x - a.x, vy = c.y - a.y, vz = c.z - a.z;
+        const cx = uy*vz - uz*vy, cy = uz*vx - ux*vz, cz = ux*vy - uy*vx;
+        const lengthSquared = cx**2 + cy**2 + cz**2;
+        if (!lengthSquared) continue; // no area, like a triangle joining two strips
+        const k = (strip && !(t & 1) ? -1 : 1) / lengthSquared**.5;
+        nx = cx * k, ny = cy * k, nz = cz * k;
+        addCorner(a, b, c, groups[i0]);
+        addCorner(b, c, a, groups[i1]);
+        addCorner(c, a, b, groups[i2]);
+    }
+    return {groups, sums, touched};
 }
 
 /**
@@ -3077,42 +3146,52 @@ class Mesh
             // the triangles are listed: smooth normals add up around each position, weighted by the corner angle
             // like the strip's, so vertices split apart at one place smooth back together and a mesh can go flat and
             // smooth again; flat ones need a vertex per corner, so the vertices are split up first
-            if (!smooth)
+            if (smooth)
             {
-                const split = (a)=> this.indices.map(i=> a[i]);
-                this.points = split(this.points), this.normals = split(this.normals);
-                this.uvs = split(this.uvs), this.colors = split(this.colors);
-                this.indices = this.indices.map((_, i)=> i);
+                const {groups, sums, touched} = render3DSmoothNormalSums(this.points, this.indices);
+                this.normals = this.points.map((p, i)=>
+                {
+                    const s = groups[i] * 3, x = sums[s], y = sums[s+1], z = sums[s+2];
+                    const lengthSquared = x**2 + y**2 + z**2, k = 1 / lengthSquared**.5;
+                    return touched[groups[i]] && lengthSquared ? vec3(x * k, y * k, z * k) : RENDER3D_DEFAULT_NORMAL;
+                });
+                this.dirty = true;
+                return this;
             }
-            const points = this.points, indices = this.indices, sums = new Map;
+            const split = (a)=> this.indices.map(i=> a[i]);
+            this.points = split(this.points), this.normals = split(this.normals);
+            this.uvs = split(this.uvs), this.colors = split(this.colors);
+            this.indices = this.indices.map((_, i)=> i);
+            const points = this.points, indices = this.indices;
             const normals = points.map(()=> RENDER3D_DEFAULT_NORMAL);
             for (let t = 0; t < indices.length; t += 3)
             {
                 const a = points[indices[t]], b = points[indices[t+1]], c = points[indices[t+2]];
                 const cross = b.subtract(a).cross(c.subtract(a));
-                if (!cross.lengthSquared()) continue;
-                const normal = cross.normalize();
-                if (!smooth)
-                {
-                    // its own three corners
-                    normals[indices[t]] = normals[indices[t+1]] = normals[indices[t+2]] = normal;
-                    continue;
-                }
-                for (let j = 0; j < 3; ++j)
-                    render3DAddCornerNormal(sums, points[indices[t+j]], points[indices[t+(j+1)%3]],
-                        points[indices[t+(j+2)%3]], normal);
+                if (cross.lengthSquared()) // its own three corners
+                    normals[indices[t]] = normals[indices[t+1]] = normals[indices[t+2]] = cross.normalize();
             }
-            this.normals = !smooth ? normals : points.map(p=>
+            this.normals = normals;
+            this.dirty = true;
+            return this;
+        }
+
+        // smooth normals are the sums at each place made unit length, or straight up for a place with none
+        const points = this.points, n = points.length;
+        if (smooth)
+        {
+            const {groups, sums, touched} = render3DSmoothNormalSums(points);
+            this.normals = points.map((p, i)=>
             {
-                const s = sums.get(render3DPlaceKey(p));
-                return s && s.lengthSquared() ? s.normalize() : RENDER3D_DEFAULT_NORMAL;
+                const s = groups[i] * 3, x = sums[s], y = sums[s+1], z = sums[s+2], l = (x**2 + y**2 + z**2)**.5;
+                return !touched[groups[i]] ? vec3(0, 1, 0) : l ? vec3(x * (1/l), y * (1/l), z * (1/l)) : vec3();
             });
+            this.vertexKeys = undefined;
             this.dirty = true;
             return this;
         }
 
         // the outward normal of each triangle in the strip
-        const points = this.points, n = points.length;
         const faceNormals = [];
         for (let i = 0; i + 2 < n; ++i)
         {
@@ -3123,22 +3202,10 @@ class Mesh
             faceNormals.push(normal.lengthSquared() ? normal.normalize(i & 1 ? 1 : -1) : undefined);
         }
 
-        // then hand those to the vertices, shared around a position or kept per face
+        // then hand those to the vertices: every triangle writes its own three corners, so the only vertices left
+        // with the default are the repeats at the ends of a strip, which no triangle with any area uses
         const normals = points.map(()=> RENDER3D_DEFAULT_NORMAL);
-        if (smooth)
-        {
-            // add up the face normals meeting at each position, each weighted by its corner angle so a cube
-            // corner averages its three faces evenly however the strips cut them, then normalize
-            const sums = new Map;
-            faceNormals.forEach((f, i)=> f && [0, 1, 2].forEach(j=>
-                render3DAddCornerNormal(sums, points[i+j], points[i+(j+1)%3], points[i+(j+2)%3], f)));
-            for (let i = 0; i < n; ++i)
-                normals[i] = (sums.get(render3DPlaceKey(points[i])) || RENDER3D_DEFAULT_NORMAL).normalize();
-        }
-        else
-            // every triangle writes its own three corners, so the only vertices left with the default
-            // are the repeats at the ends of a strip, which no triangle with any area uses
-            faceNormals.forEach((f, i)=> f && (normals[i] = normals[i+1] = normals[i+2] = f));
+        faceNormals.forEach((f, i)=> f && (normals[i] = normals[i+1] = normals[i+2] = f));
 
         this.normals = normals;
         this.vertexKeys = undefined; // flat normals tell entries at one place apart
@@ -4285,6 +4352,7 @@ function engineObjectsCollect3D(pos, size, objects=engineObjects, testCenters=fa
 
 // how far along a ray an object is hit, or undefined for a miss; a mesh is hit on its triangles, in its own space,
 // and a sprite as the quad it draws
+const render3DRaycastCenter = vec3();
 function render3DRaycastObject(ray, o)
 {
     if (o.destroyed || !(o instanceof EngineObject3D)) return;
@@ -4297,7 +4365,8 @@ function render3DRaycastObject(ray, o)
     // a mesh that changed since it was measured is measured again, an upload may not have come yet
     const radius = (mesh.dirty || !mesh.radius ? mesh.computeRadius() : mesh.radius) * render3DMaxStretch(matrix.m);
     if (!(radius > 0)) return; // nothing to hit
-    const center = matrix.getTranslation();
+    // its place read from the matrix into a vector kept for this, a pick tests every object and most miss
+    const m = matrix.m, center = render3DRaycastCenter.set(m[12], m[13], m[14]);
     const distance = raycastSphere(ray, center, radius);
     if (distance === undefined) return;
 
@@ -4766,6 +4835,13 @@ class Light3D extends EngineObject3D
         /** @property {number} - How fast the glow fades from its middle: 1 by default, .5 a wide haze, 2 a tight
          *  bright core */
         this.glowFalloff = 1;
+        /** @property {TextureInfo|TileInfo|undefined} - A gel: a picture the light shines through, like a stained glass
+         *  window or the leaves of a tree, cast along its cone in its colors, upright as the light looks out, the whole
+         *  texture of a TileInfo; only the spotlight that casts the shadows has one, with render3D.shadows on and it
+         *  as render3D.shadowLight, and only on what takes its shadows: an object with receiveShadow off is lit
+         *  without the gel; its alpha is not read, see through panes are dark
+         *  @type {TextureInfo|TileInfo|undefined} */
+        this.gel = undefined;
         this.additive = true; // the glow is added on, in the transparent stage; a light with none draws nothing
         /** @type {LensFlare3D|undefined} */
         this.flareObject = undefined;
@@ -4776,10 +4852,11 @@ class Light3D extends EngineObject3D
      *  @param {number} [count] - How many ghosts there are, besides the glow at the light
      *  @param {number} [intensity] - How bright it is
      *  @param {number} [saturation] - How colorful the ghosts are
+     *  @param {Color} [color] - Tints the flare, with the light's own color
      *  @return {LensFlare3D} - The flare, to change: light.addFlare().shapes = ['hex'] */
-    addFlare(size, count, intensity, saturation)
+    addFlare(size, count, intensity, saturation, color)
     {
-        const flare = new LensFlare3D(size, count, intensity, saturation);
+        const flare = new LensFlare3D(size, count, intensity, saturation, color);
         this.flare = flare;
         return flare;
     }

package/plugins/render3dEditor.js

@@ -549,9 +549,11 @@ function editor3DLevelLoaded(level)
         level.objects = editor3DCopy(saved.objects);
         for (const name of editor3DLevelPartNames)
             parts[name] ? level[name] = editor3DCopy(parts[name]) : delete level[name];
+        saved.stale && console.warn(`LittleJS editor: the edits brought back to ${record.fileName} are older than ` +
+            'the last ones, which storage had no room for');
     }
-    else if (saved)
-        record.pending = saved;
+    else if (saved && isArray(saved.objects))
+        record.pending = saved; // one that is broken is passed by, and the next autosave writes over it
 }
 
 // called by level3DLoad for each object, with what its type made
@@ -662,17 +664,27 @@ function editor3DSetPart(name, part)
 function editor3DPrefabsShow()
 {
     if (editor3DPrefabLevels.has(editor3DLevel)) return; // inside a prefab, the prefabs are the level's
-    const prefabs = editor3DLevelPart('prefabs') ?? {};
+    const prefabs = editor3DLevelPart('prefabs') ?? {}, removed = new Set;
     for (const [name, prefab] of level3DPrefabs)
     {
         if (!prefab.fromLevel || prefabs[name]) continue;
         level3DPrefabs.delete(name);
         level3DTypes.delete(name);
+        removed.add(name);
     }
     level3DPrefabsAdd(prefabs);
-    // every object of a prefab's type, one whose type was not there when the objects were set too
+    // every object of a prefab's type, one whose type was not there when the objects were set too; an instance of a
+    // prefab taken out leaves the game, its object waiting in the level for the prefab to come back
     for (const object of editor3DObjects())
-        level3DPrefabs.has(object.type) && editor3DMakeInstance(object);
+    {
+        if (level3DPrefabs.has(object.type))
+            editor3DMakeInstance(object);
+        else if (removed.has(object.type))
+        {
+            editor3DInstances.get(object.id)?.destroy?.();
+            editor3DInstances.delete(object.id);
+        }
+    }
     editor3DShadowLight();
 }
 
@@ -913,7 +925,9 @@ function editor3DTerrainStore()
 {
     const map = editor3DTerrainMap(), terrain = editor3DLevelPart('terrain');
     if (!map || !terrain) return;
-    terrain.heights = map.heights.map((row)=> row.map((v)=> round(v * 1e3) / 1e3));
+    // the heights changed to a thousandth, the rest as the level has them, so a stroke of paint rounds none
+    const before = terrain.heights;
+    terrain.heights = map.heights.map((row, z)=> row.map((v, x)=> v === before?.[z]?.[x] ? v : round(v * 1e3) / 1e3));
     const paint = editor3DTerrainPaints.get(map);
     if (!paint) return; // nothing painted since the level's was read
     const used = paint.colors.map((hex, i)=> paint.cells.includes(i + 1));
@@ -1789,10 +1803,12 @@ function editor3DJSON(value)
 // a level as the file has it: its version, what else it holds, and its objects, one to a line
 function editor3DLevelJSON(level=editor3DLevel)
 {
+    // the level's parts after the rest, in one order, so the same level is the same file however its parts were made
     const {littlejs3D, objects, ...rest} = level;
     const lines = [`"littlejs3D": ${LEVEL3D_VERSION}`];
-    for (const [key, value] of Object.entries(rest))
-        lines.push(JSON.stringify(key) + ': ' + editor3DJSON(value));
+    const keys = Object.keys(rest).filter((key)=> !editor3DLevelPartNames.includes(key));
+    for (const key of [...keys, ...editor3DLevelPartNames.filter((name)=> name in rest)])
+        lines.push(JSON.stringify(key) + ': ' + editor3DJSON(rest[key]));
     const list = (isArray(objects) ? objects : []).map((o)=> '    ' + editor3DJSON(o));
     lines.push('"objects": [' + (list.length ? '\n' + list.join(',\n') + '\n  ]' : ']'));
     return '{\n  ' + lines.join(',\n  ') + '\n}\n';
@@ -2610,7 +2626,7 @@ function editor3DSetSelectedProperty(name, value)
 {
     const selected = editor3DSelected(), id = selected[0]?.id;
     const defaults = selected[0] && level3DTypes.get(selected[0].type)?.defaults;
-    const d = defaults && Object.hasOwn(defaults, name) ? defaults[name] : undefined;
+    const d = defaults && Object.prototype.hasOwnProperty.call(defaults, name) ? defaults[name] : undefined;
     const sameType = isColor(d) ? isColor(value) : isVector3(d) ? isVector3(value) :
         isVector2(d) ? isVector2(value) : typeof value === typeof d;
     if (selected.length !== 1 || !editor3DPropertyEditable(d) || !sameType) return false;
@@ -3333,7 +3349,7 @@ function editor3DSceneUpdate(box)
         input.onchange = ()=>
         {
             const n = parseFloat(input.value);
-            isNumber(n) && n >= 0 ? set(v = n) : input.value = v + ''; // one not taken shows what it has again
+            isFinite(n) && n >= 0 ? set(v = n) : input.value = v + ''; // one not taken shows what it has again
             editor3DStrokeEnd();
             input.blur();
         };
@@ -3422,7 +3438,7 @@ function editor3DPropertiesUpdate(box)
             input.onchange = ()=>
             {
                 const v = inputs.map((i)=> parseFloat(i.value));
-                if (v.every((n)=> isNumber(n)))
+                if (v.every((n)=> isFinite(n)))
                     set(axes.length > 2 ? vec3(v[0], v[1], v[2]) : vec2(v[0], v[1]));
                 else
                     inputs.forEach((i, k)=> i.value = editor3DRound(value[axes[k]]) + '');
@@ -3464,7 +3480,7 @@ function editor3DPropertiesUpdate(box)
             input.type = 'number';
             input.step = 'any';
             input.value = value + '';
-            input.onchange = ()=> { const v = parseFloat(input.value); isNumber(v) && set(v); };
+            input.onchange = ()=> { const v = parseFloat(input.value); isFinite(v) && set(v); };
         }
         else if (typeof defaultValue === 'string')
         {

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);
@@ -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 off the screen, 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,8 @@ 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, and a spotlight's shows from inside its beam only; a DirectionalLight3D's is far
+         *  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
          *  @type {Light3D|undefined} */
@@ -1695,7 +1697,7 @@ class LensFlare3D extends EngineObject3D
         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;
@@ -1761,19 +1763,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
-        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;
-            const matrix = render3DObjectMatrix(o);
-            if (!matrix.determinant()) return false;
-            const p = matrix.copy().invert().transformPoint(source.pos), b = o.mesh.bounds || o.mesh.getBounds();
+            if (!o.mesh || o instanceof HeightMap) return false;
+            const matrix = render3DObjectMatrix(o), b = o.mesh.bounds || o.mesh.getBounds();
+            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
@@ -1834,9 +1847,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;
@@ -1848,6 +1862,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]);