littlejsengine 1.18.18 → 1.18.21

package/dist/littlejs.js

@@ -35,7 +35,7 @@ const engineName = 'LittleJS';
  *  @type {string}
  *  @default
  *  @memberof Engine */
-const engineVersion = '1.18.18';
+const engineVersion = '1.18.21';
 
 /** Frames per second to update
  *  @type {number}
@@ -474,6 +474,11 @@ function engineObjectsUpdate()
     // get list of solid objects for physics optimization
     engineObjectsCollide = engineObjects.filter(o=>o.collideSolidObjects);
 
+    // update physics before object update
+    for (const o of engineObjects)
+        if (!o.parent && !o.destroyed)
+            o.updatePhysics();
+
     // recursive object update
     function updateChildObject(o)
     {
@@ -489,7 +494,6 @@ function engineObjectsUpdate()
 
         // update top level objects
         o.update();
-        o.updatePhysics();
         for (const child of o.children)
             updateChildObject(child);
         o.updateTransforms();
@@ -1237,6 +1241,7 @@ function debugVideoCaptureStart()
     {
         LOG('Video capture not supported in this browser!');
         silentAudioSource?.stop();
+        audioStreamDestination && audioMasterGain.disconnect(audioStreamDestination);
         return;
     }
 
@@ -1265,6 +1270,8 @@ function debugVideoCaptureStop()
     debugVideoCapture.silentAudioSource?.stop();
     debugVideoCapture.mediaRecorder?.stop();
     debugVideoCapture.videoTrack?.stop();
+    if (debugVideoCapture.audioStreamDestination)
+        audioMasterGain.disconnect(debugVideoCapture.audioStreamDestination);
     debugVideoCapture = undefined;
 }
 
@@ -1503,7 +1510,7 @@ function smoothStep(percent) { return percent * percent * (3 - 2 * percent); }
  *  @param {number} value
  *  @return {boolean}
  *  @memberof Math */
-function isPowerOfTwo(value) { return !(value & (value - 1)); }
+function isPowerOfTwo(value) { return value > 0 && !(value & (value - 1)); }
 
 /** Returns the nearest power of two not less than the value
  *  @param {number} value
@@ -1580,7 +1587,7 @@ function isIntersecting(start, end, pos, size)
  *  @memberof Math */
 function oscillate(frequency=1, amplitude=1, t=time, offset=0, type=0)
 {
-    const phase = (offset + t*frequency) % 1;
+    const phase = mod(offset + t*frequency, 1);
     let value;
     
     if (type === 1) // triangle
@@ -2516,7 +2523,7 @@ const MAGENTA = debugProtectConstant(rgb(1,0,1));
 class Timer
 {
     /** Create a timer object set time passed in
-     *  @param {number} [timeLeft] - How much time left before the timer 
+     *  @param {number} [timeLeft] - How much time left before the timer is elapsed in seconds (undefined = unset)
      *  @param {boolean} [useRealTime] - Should the timer keep running even when the game is paused? (useful for UI) */
     constructor(timeLeft, useRealTime=false)
     {
@@ -3115,6 +3122,7 @@ let vibrateEnable = true;
 let soundEnable = true;
 
 /** Volume scale to apply to all sound, music and speech
+ *  Use setSoundVolume to also update the audio master gain immediately
  *  @type {number}
  *  @default
  *  @memberof Settings */
@@ -3669,8 +3677,6 @@ class EngineObject
 
                 // notify objects of collision and check if should be resolved
                 const collide1 = this.collideWithObject(o);
-                // callback may have destroyed us; stop resolving against more objects
-                if (this.destroyed) return;
                 const collide2 = o.collideWithObject(this);
                 if (!collide1 || !collide2) continue;
 
@@ -4196,6 +4202,14 @@ class TileInfo
         return this.offset(new Vector2(x));
     }
 
+    /**
+     * Returns a tile info for an index using this tile as reference
+     * @param {Vector2|number} [index=0]
+     * @return {TileInfo}
+     */
+    index(index)
+    { return tile(index, this.size, this.textureInfo, this.padding, this.bleed); }
+
     /**
      * Set this tile to use a full image in a texture info
      * @param {TextureInfo} [textureInfo]
@@ -4209,14 +4223,6 @@ class TileInfo
         this.bleed = this.padding = 0;
         return this;
     }
-
-    /**
-     * Returns a tile info for an index using this tile as reference
-     * @param {Vector2|number} [index=0]
-     * @return {TileInfo}
-     */
-    tile(index)
-    { return tile(index, this.size, this.textureInfo, this.padding, this.bleed); }
 }
 
 /**
@@ -5914,7 +5920,10 @@ function inputInit()
     {
         inputData[0][e.code] = (inputData[0][e.code]&2) | 4;
         if (inputWASDEmulateDirection)
-            inputData[0][remapKey(e.code)] = 4;
+        {
+            const remap = remapKey(e.code);
+            inputData[0][remap] = (inputData[0][remap]&2) | 4;
+        }
     }
     function remapKey(k)
     {
@@ -5989,7 +5998,7 @@ function inputInit()
         document.addEventListener('touchend',   (e)=> handleTouch(e), { passive: false });
 
         // handle all touch events the same way
-        let wasTouching;
+        let wasTouching, touchIdentifier;
         function handleTouch(e)
         {
             if (!touchInputEnable) return;
@@ -6020,10 +6029,11 @@ function inputInit()
                     const pos = vec2(gameTouches[0].clientX, gameTouches[0].clientY);
                     const mousePosScreenLast = mousePosScreen;
                     mousePosScreen = mouseEventToScreen(pos);
-                    if (wasTouching)
+                    if (wasTouching && gameTouches[0].identifier === touchIdentifier)
                         mouseDeltaScreen = mouseDeltaScreen.add(mousePosScreen.subtract(mousePosScreenLast));
-                    else
+                    else if (!wasTouching)
                         inputData[0][button] = 3;
+                    touchIdentifier = gameTouches[0].identifier;
                 }
                 else if (wasTouching)
                     inputData[0][button] = inputData[0][button] & 2 | 4;
@@ -7181,7 +7191,7 @@ class SoundInstance
  *  @param {number} [rate] - How quickly to speak
  *  @param {number} [pitch] - How much to change the pitch by
  *  @param {string} [language] - The language/accent to use (examples: en, it, ru, ja, zh)
- *  @return {SpeechSynthesisUtterance} - The utterance that was spoken
+ *  @return {SpeechSynthesisUtterance|undefined} - The utterance that was spoken, or undefined if speech is unavailable
  *  @memberof Audio */
 function speak(text, volume=1, rate=1, pitch=1, language='')
 {
@@ -7234,7 +7244,7 @@ function getNoteFrequency(semitoneOffset, rootFrequency=220)
  *  @param {number}   [pan] - How much to apply stereo panning
  *  @param {boolean}  [loop] - True if the sound should loop when it reaches the end
  *  @param {number}   [sampleRate=44100] - Sample rate for the sound
- *  @param {GainNode} [gainNode] - Optional gain node for volume control while playing
+ *  @param {GainNode} [gainNode] - Optional gain node for volume control while playing (disconnected when the sound ends)
  *  @param {number}   [offset] - Offset in seconds to start playback from
  *  @param {AudioEndedCallback} [onended] - Callback for when the sound ends
  *  @return {AudioBufferSourceNode} - The source node of the sound played, may be undefined if play fails
@@ -7476,10 +7486,14 @@ function tileCollisionGetData(pos, solidOnly=true)
     // check all tile collision layers
     for (const layer of tileCollisionLayers)
         if (!solidOnly || layer.isSolid)
-        if (pos.arrayCheck(layer.size))
         {
-            const data = layer.getCollisionData(pos);
-            if (data) return data;
+            // convert world pos to layer local space
+            const layerPos = pos.subtract(layer.pos);
+            if (layerPos.arrayCheck(layer.size))
+            {
+                const data = layer.getCollisionData(layerPos);
+                if (data) return data;
+            }
         }
     return 0;
 }
@@ -7754,7 +7768,7 @@ class TileLayer extends CanvasLayer
         
         /** @property {TileInfo} - Default tile info for layer */
         this.tileInfo = undefined;
-        /** @property {Array<TileLayerData>} - Default tile info for layer */
+        /** @property {Array<TileLayerData>} - Array of tile data for the layer */
         this.data = [];
         /** @property {boolean} - Is this layer using a webgl texture? */
         this.isUsingWebGL = false;
@@ -7839,7 +7853,7 @@ class TileLayer extends CanvasLayer
 
         const size = this.drawSize || this.size;
         const pos = this.pos.add(size.scale(.5));
-        this.draw(pos, this.size, this.color, this.angle, this.mirror, this.additiveColor);
+        this.draw(pos, size, this.color, this.angle, this.mirror, this.additiveColor);
     }
 
     /** Called after this layer is redrawn, does nothing by default */
@@ -7928,7 +7942,7 @@ class TileLayer extends CanvasLayer
         const d = this.getData(layerPos);
         if (!d || !d.tile) return;
 
-        const tileInfo = this.tileInfo && this.tileInfo.tile(d.tile);
+        const tileInfo = this.tileInfo && this.tileInfo.index(d.tile);
         this.drawLayerTile(drawPos, drawSize, tileInfo, d.color, d.direction*PI/2, d.mirror);
     }
 
@@ -8222,8 +8236,8 @@ class TileCollisionLayer extends TileLayer
  *     rgb(1,1,1,1), rgb(0,0,0,1), // colorStartA, colorStartB
  *     rgb(1,1,1,0), rgb(0,0,0,0), // colorEndA, colorEndB
  *     1, .2, .2, .1, .05,  // particleTime, sizeStart, sizeEnd, particleSpeed, particleAngleSpeed
- *     .99, 1, 1, PI, .05,  // damping, angleDamping, gravityScale, particleCone, fadeRate,
- *     .5, 1                // randomness, collide, additive, randomColorLinear, renderOrder
+ *     .99, 1, 1, PI, .05,  // damping, angleDamping, gravityScale, particleCone, fadeRate
+ *     .5, 1                // randomness, collide
  * );
  */
 class ParticleEmitter extends EngineObject
@@ -8615,13 +8629,12 @@ class Particle
             const hitLayer = tileCollisionTest(this.pos);
             if (!testCollision(oldPos))
             {
-                // testCollision already invoked collideCallback with the
-                // correct (this, data, pos) args; no need to re-check here.
                 // test which side we bounced off (or both if a corner)
                 const isBlockedX = testCollision(vec2(this.pos.x, oldPos.y));
                 const isBlockedY = testCollision(vec2(oldPos.x, this.pos.y));
-                const hitRestitution = max(restitution, hitLayer.restitution);
-                const hitFriction = max(friction, hitLayer.friction);
+                // collide callback may hit where the layer test does not, so hitLayer can be undefined
+                const hitRestitution = hitLayer ? max(restitution, hitLayer.restitution) : restitution;
+                const hitFriction = hitLayer ? max(friction, hitLayer.friction) : friction;
                 if (isBlockedX)
                 {
                     // move to previous X position and bounce
@@ -10270,7 +10283,8 @@ class NewgroundsPlugin
             return;
         }
         debugMedals && LOG(xmlHttp.responseText);
-        return xmlHttp.responseText && JSON.parse(xmlHttp.responseText);
+        try { return xmlHttp.responseText && JSON.parse(xmlHttp.responseText); }
+        catch(e) { debugMedals && LOG('newgrounds response is not valid JSON', e); }
     }
 }
 /**
@@ -10289,8 +10303,8 @@ class NewgroundsPlugin
 let postProcess;
 
 /////////////////////////////////////////////////////////////////////////
-/** 
- * UI System Global Object
+/**
+ * Post Process Plugin - Applies a full screen shader to the rendered output
  * @memberof PostProcess
  */
 class PostProcessPlugin
@@ -10404,8 +10418,9 @@ class PostProcessPlugin
                 workCanvas.height = mainCanvasSize.y;
                 glCopyToContext(workContext);
                 workContext.drawImage(mainCanvas, 0, 0);
-                mainCanvas.width |= 0
-                
+                mainCanvas.width |= 0; // setting size clears the main canvas
+
+
                 // copy work canvas to texture
                 glContext.texImage2D(glContext.TEXTURE_2D, 0, glContext.RGBA, glContext.RGBA, glContext.UNSIGNED_BYTE, workCanvas);
             }
@@ -11510,7 +11525,7 @@ class UISystemPlugin
     }
 
     /** Get other axis navigation direction from gamepad or keyboard
-     *  @return {Vector2} */
+     *  @return {number} */
     getNavigationOtherDirection()
     {
         if (uiSystem.navigationDirection === 2)
@@ -11599,6 +11614,7 @@ class UISystemPlugin
             uiSystem.navigationDirection = savedNavigationDirection;
             inputClear();
         }
+        return confirmMenu;
     }
 }
 
@@ -12032,7 +12048,7 @@ class UITextInput extends UIObject
         this.onClick();
     }
 
-    /** Stop editing the text edited */
+    /** Stop editing the text */
     stopEditing()
     {
         if (!this.isKeyInputObject())
@@ -12195,7 +12211,7 @@ class UICheckbox extends UIObject
         ASSERT(isStringLike(text), 'ui checkbox must be a string');
         ASSERT(isColor(color), 'ui checkbox color must be a color');
 
-        /** @property {boolean} - Current percentage value of this slider 0-1 */
+        /** @property {boolean} - Is the checkbox currently checked? */
         this.checked = checked;
         // set properties
         this.text = text;
@@ -12960,7 +12976,7 @@ class Box2dObject extends EngineObject
             shape.set_m_vertex3(box2d.vec2dTo(getPoint(i+2)));
             const f = this.addShape(shape, density, friction, restitution, isSensor);
             fixtures.push(f);
-            i < points.length && edgePoints.push(points[i].copy());
+            edgePoints.push(points[i].copy());
         }
         this.edgeLoops.push(edgePoints);
         return fixtures;
@@ -13026,7 +13042,7 @@ class Box2dObject extends EngineObject
     /** Sets the position
      *  @param {Vector2} pos */
     setPosition(pos)
-    { this.setTransform(pos, this.body.GetAngle()); }
+    { this.setTransform(pos, -this.body.GetAngle()); }
 
     /** Sets the angle
      *  @param {number} angle */
@@ -13123,6 +13139,7 @@ class Box2dObject extends EngineObject
             filter.set_categoryBits(categoryBits);
             filter.set_maskBits(0xffff & ~ignoreCategoryBits);
             filter.set_groupIndex(groupIndex);
+            fixture.SetFilterData(filter); // applies and refilters contacts
         });
     }
 
@@ -13658,7 +13675,7 @@ class Box2dRevoluteJoint extends Box2dJoint
         jointDef.set_bodyB(objectB.body);
         jointDef.set_localAnchorA(box2d.vec2dTo(localAnchorA));
         jointDef.set_localAnchorB(box2d.vec2dTo(localAnchorB));
-        jointDef.set_referenceAngle(objectA.body.GetAngle() - objectB.body.GetAngle());
+        jointDef.set_referenceAngle(objectB.body.GetAngle() - objectA.body.GetAngle());
         jointDef.set_collideConnected(collide);
         super(jointDef);
     }
@@ -13805,14 +13822,14 @@ class Box2dPrismaticJoint extends Box2dJoint
         anchor ||= box2d.vec2From(objectB.body.GetPosition());
         const localAnchorA = objectA.worldToLocal(anchor);
         const localAnchorB = objectB.worldToLocal(anchor);
-        const localAxisA = objectB.worldToLocalVector(worldAxis);
+        const localAxisA = objectA.worldToLocalVector(worldAxis);
         const jointDef = new box2d.instance.b2PrismaticJointDef();
         jointDef.set_bodyA(objectA.body);
         jointDef.set_bodyB(objectB.body);
         jointDef.set_localAnchorA(box2d.vec2dTo(localAnchorA));
         jointDef.set_localAnchorB(box2d.vec2dTo(localAnchorB));
         jointDef.set_localAxisA(box2d.vec2dTo(localAxisA));
-        jointDef.set_referenceAngle(objectA.body.GetAngle() - objectB.body.GetAngle());
+        jointDef.set_referenceAngle(objectB.body.GetAngle() - objectA.body.GetAngle());
         jointDef.set_collideConnected(collide);
         super(jointDef);
     }
@@ -13915,7 +13932,7 @@ class Box2dWheelJoint extends Box2dJoint
         anchor ||= box2d.vec2From(objectB.body.GetPosition());
         const localAnchorA = objectA.worldToLocal(anchor);
         const localAnchorB = objectB.worldToLocal(anchor);
-        const localAxisA = objectB.worldToLocalVector(worldAxis);
+        const localAxisA = objectA.worldToLocalVector(worldAxis);
         const jointDef = new box2d.instance.b2WheelJointDef();
         jointDef.set_bodyA(objectA.body);
         jointDef.set_bodyB(objectB.body);
@@ -14015,7 +14032,7 @@ class Box2dWeldJoint extends Box2dJoint
         jointDef.set_bodyB(objectB.body);
         jointDef.set_localAnchorA(box2d.vec2dTo(localAnchorA));
         jointDef.set_localAnchorB(box2d.vec2dTo(localAnchorB));
-        jointDef.set_referenceAngle(objectA.body.GetAngle() - objectB.body.GetAngle());
+        jointDef.set_referenceAngle(objectB.body.GetAngle() - objectA.body.GetAngle());
         jointDef.set_collideConnected(collide);
         super(jointDef);
     }
@@ -14462,7 +14479,7 @@ class Box2dPlugin
      *  @param {number} [lineWidth]
      *  @param {boolean} [useWebGL=glEnable]
      *  @param {CanvasRenderingContext2D} [context] */
-    drawFixture(fixture, pos, angle, color=WHITE, lineColor=BLACK, lineWidth=.1, useWebgl, context)
+    drawFixture(fixture, pos, angle, color=WHITE, lineColor=BLACK, lineWidth=.1, useWebGL, context)
     {
         const shape = box2d.castShapeObject(fixture.GetShape());
         switch (shape.GetType())
@@ -14472,20 +14489,20 @@ class Box2dPlugin
                 let points = [];
                 for (let i=shape.GetVertexCount(); i--;)
                     points.push(box2d.vec2From(shape.GetVertex(i)));
-                drawPoly(points, color, lineWidth, lineColor, pos, angle, useWebgl, false, context);
+                drawPoly(points, color, lineWidth, lineColor, pos, angle, useWebGL, false, context);
                 break;
             }
             case box2d.instance.b2Shape.e_circle:
             {
                 const radius = shape.get_m_radius();
-                drawCircle(pos, radius*2, color, lineWidth, lineColor, useWebgl, false, context);
+                drawCircle(pos, radius*2, color, lineWidth, lineColor, useWebGL, false, context);
                 break;
             }
             case box2d.instance.b2Shape.e_edge:
             {
                 const v1 = box2d.vec2From(shape.get_m_vertex1());
                 const v2 = box2d.vec2From(shape.get_m_vertex2());
-                drawLine(v1, v2, lineWidth, lineColor, pos, angle, useWebgl, false, context);
+                drawLine(v1, v2, lineWidth, lineColor, pos, angle, useWebGL, false, context);
                 break;
             }
         }
@@ -15316,7 +15333,11 @@ function tweenProperty(target, propertyPath, start, end, duration = 1, options =
     const callback = (value) =>
     {
         let obj = target;
-        for (const k of parts) obj = obj[k];
+        for (const k of parts)
+        {
+            obj = obj[k];
+            ASSERT(obj != null, 'tweenProperty path does not resolve: ' + propertyPath);
+        }
         obj[lastKey] = value;
     };
     return new Tween(callback, start, end, duration, options);
@@ -16199,3 +16220,157 @@ class PathFinder
     }
 }
 
+/**
+ * LittleJS Three.js Plugin
+ * - Renders a three.js scene on a canvas behind the LittleJS canvases
+ * - The three.js module is passed in by the user, nothing is bundled
+ * - Keep canvasClearColor transparent so the 3D scene shows through
+ * - Aligned camera mode locks the 3D camera to the LittleJS 2D camera
+ * - ThreeJSObject lets LittleJS physics drive a three.js mesh
+ * - Call new ThreeJSPlugin(THREE) in gameInit to set up
+ * @namespace ThreeJS
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+
+/** Global ThreeJS plugin object
+ *  @type {ThreeJSPlugin}
+ *  @memberof ThreeJS */
+let threeJS;
+
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * ThreeJS Plugin - Renders a three.js scene behind the LittleJS canvas
+ * @example
+ * // in gameInit, with three.js loaded by the user
+ * new ThreeJSPlugin(THREE);
+ * threeJS.scene.add(new THREE.AmbientLight);
+ * @memberof ThreeJS
+ */
+class ThreeJSPlugin
+{
+    /** Set up the three.js rendering layer, call in gameInit
+     *  @param {Object} THREE - The three.js module, supplied by the user
+     *  @param {number} [cameraFOV] - Vertical field of view in degrees */
+    constructor(THREE, cameraFOV=60)
+    {
+        ASSERT(!threeJS, 'ThreeJS plugin already initialized');
+        threeJS = this;
+        if (headlessMode) return;
+        ASSERT(mainCanvas, 'ThreeJS plugin must be created after engineInit, call in gameInit');
+        ASSERT(THREE && THREE.WebGLRenderer, 'three.js module must be passed in');
+
+        /** @property {Object} - The three.js module passed into the constructor */
+        this.THREE = THREE;
+        /** @property {Object} - The three.js renderer */
+        this.renderer = new THREE.WebGLRenderer({antialias: true});
+        /** @property {Object} - The three.js scene, add lights and meshes here */
+        this.scene = new THREE.Scene();
+        /** @property {Object} - The three.js perspective camera */
+        this.camera = new THREE.PerspectiveCamera(cameraFOV, 1, .1, 1e3);
+        /** @property {boolean} - Lock the camera to the LittleJS 2D camera so the z=0 plane matches world space */
+        this.cameraAlign2D = true;
+
+        // insert the canvas below the engine canvases and match the layout
+        const threeCanvas = this.renderer.domElement;
+        const rootElement = mainCanvas.parentElement;
+        rootElement.insertBefore(threeCanvas, rootElement.firstChild);
+        threeCanvas.style.cssText = mainCanvas.style.cssText;
+
+        // render automatically each frame after the engine renders
+        engineAddPlugin(undefined, ()=> this.render());
+    }
+
+    /** Position the camera so the z=0 plane exactly matches LittleJS world space,
+     *  called automatically when cameraAlign2D is set */
+    alignCamera2D()
+    {
+        const halfHeight = mainCanvasSize.y / 2 / cameraScale; // half visible height in world units
+        const distance = halfHeight / tan(this.camera.fov/2 * PI/180);
+        this.camera.position.set(cameraPos.x, cameraPos.y, distance);
+        // reset all axes in case a free camera was used, littlejs angles are clockwise
+        this.camera.rotation.set(0, 0, -cameraAngle);
+    }
+
+    /** Sync the canvas layout and render the scene, called automatically each frame */
+    render()
+    {
+        if (!this.renderer) return; // headless mode
+
+        // keep renderer size and css in sync with the LittleJS canvas
+        const threeCanvas = this.renderer.domElement;
+        if (threeCanvas.width != mainCanvasSize.x || threeCanvas.height != mainCanvasSize.y)
+        {
+            this.renderer.setSize(mainCanvasSize.x, mainCanvasSize.y, false);
+            this.camera.aspect = mainCanvasSize.x / mainCanvasSize.y;
+            this.camera.updateProjectionMatrix();
+        }
+        if (threeCanvas.style.cssText != mainCanvas.style.cssText)
+            threeCanvas.style.cssText = mainCanvas.style.cssText;
+
+        if (this.cameraAlign2D)
+            this.alignCamera2D();
+        this.renderer.render(this.scene, this.camera);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * ThreeJS Object - EngineObject that drives a three.js mesh
+ * - LittleJS physics moves the object and the mesh follows automatically
+ * - Destroying the object removes the mesh from the scene
+ * @extends EngineObject
+ * @memberof ThreeJS
+ */
+class ThreeJSObject extends EngineObject
+{
+    /** Create an engine object that drives a three.js mesh
+     *  @param {Vector2} [pos] - World space position
+     *  @param {Vector2} [size] - World space size
+     *  @param {Object} [mesh] - The three.js object3d to drive
+     *  @param {number} [z] - Mesh height above the 2D plane */
+    constructor(pos, size, mesh, z=0)
+    {
+        super(pos, size);
+        ASSERT(threeJS, 'ThreeJS plugin must be initialized first');
+
+        /** @property {Object} - The three.js object3d this object drives */
+        this.mesh = mesh;
+        /** @property {number} - Mesh height above the 2D plane */
+        this.z = z;
+        if (mesh)
+        {
+            threeJS.scene.add(mesh);
+            this.syncMesh();
+        }
+    }
+
+    /** Update the object and sync the mesh to its transform */
+    update()
+    {
+        super.update();
+        this.syncMesh();
+    }
+
+    /** Copy this object's transform to the mesh */
+    syncMesh()
+    {
+        if (!this.mesh) return;
+        this.mesh.position.set(this.pos.x, this.pos.y, this.z);
+        this.mesh.rotation.z = -this.angle; // littlejs angles are clockwise
+    }
+
+    /** The mesh is this object's visual, the default 2D rendering is skipped */
+    render() {}
+
+    /** Destroy this object and remove its mesh from the scene
+     *  @param {boolean} [immediate] */
+    destroy(immediate)
+    {
+        if (this.destroyed) return;
+        // note: frequently destroyed objects should also dispose geometry and material
+        this.mesh && threeJS.scene.remove(this.mesh);
+        super.destroy(immediate);
+    }
+}
+