littlejsengine 1.11.13 → 1.12.4

package/reference.md

@@ -13,7 +13,7 @@ To start LittleJS, you need to create a few functions and pass them to engineIni
 
 ```javascript
 // Start up LittleJS engine with your callback functions
-engineInit(init, update, updatePost, render, renderPost, imageSources=['tiles.png']);
+engineInit(init, update, updatePost, render, renderPost, imageSources=[]);
 ```
 
 ## LittleJS Utilities Classes and Functions
@@ -29,7 +29,7 @@ engineInit(init, update, updatePost, render, renderPost, imageSources=['tiles.pn
 vec2(x=0, y=x)                                // Create a 2D vector with Vector or floats
 rgb(r=1, g=1, b=1, a=1)                       // Create a color object with RGBA values
 hsl(h=0, s=0, l=1, a=1)                       // Create a color object with HSLA values
-tile(pos=(0,0), size, textureIndex=0)         // Create a tile info object
+tile(pos, size=(16,16), texture=0, padding=0) // Create a tile info object
 
 // Helper functions 
 abs(value)                                    // Get absolute value
@@ -131,12 +131,12 @@ Timer.valueOf()        // Get how long since elapsed, 0 if not set
 
 ```javascript
 // Drawing functions
-drawTile(pos, size=(1,1), tileInfo, color, angle=0, mirror, additiveColor)
-drawRect(pos, size=(1,1), color=(1,1,1,1), angle=0)
-drawLine(posA, posB, thickness=.1, color=(1,1,1,1))
+drawTile(pos, size=(1,1), tileInfo, color=WHITE, angle=0, mirror, additiveColor)
+drawRect(pos, size=(1,1), color=WHITE, angle=0)
+drawLine(posA, posB, thickness=.1, color=WHITE)
 drawCanvas2D(pos, size, angle, mirror, drawFunction)
-drawText(text, pos, size=1, color=(1,1,1,1), lineWidth, lineColor)
-drawTextScreen(text, pos, size=1, color=(1,1,1,1), lineWidth, lineColor)
+drawText(text, pos, size=1, color=WHITE, lineWidth, lineColor)
+drawTextScreen(text, pos, size=1, color=WHITE, lineWidth, lineColor)
 setBlendMode(additive)
 toggleFullscreen()
 isFullscreen()
@@ -172,10 +172,15 @@ getCameraSize()          // Get the camera's visible area in world space
 canvasMaxSize = (1920, 1200)  // The max size of the canvas
 canvasFixedSize = (0, 0)      // Fixed size of the canvas
 fontDefault = 'arial'         // Default font used for text rendering
-canvasPixelated = true        // Disable filtering for crisper pixel art?
-showSplashScreen = false      // Show the LittleJS splash screen on startup?
-glEnable = true               // Enable fast WebGL rendering?
-glOverlay = true              // Prevent compositing the WebGL canvas?
+canvasPixelated = true        // Use nearest neighbor canvas scaling for more pixelated look
+tilesPixelated = true         // Disable filtering for crisper pixel art
+showSplashScreen = false      // Show the LittleJS splash screen on startup
+glEnable = true               // Enable fast WebGL rendering
+glOverlay = true              // Prevent compositing the WebGL canvas
+
+// Tile sheet settings
+tileSizeDefault = (16,16)  // Default size of tiles in pixels
+tileFixBleedScale = .3     // How much smaller to draw tiles to prevent bleeding
 ```
 
 ## LittleJS Audio System
@@ -224,7 +229,7 @@ soundDefaultTaper = .7  // Default range percent to taper off sound (0-1)
 keyIsDown(key)                        // Is key down?
 keyWasPressed(key)                    // Was key pressed this frame?
 keyWasReleased(key)                   // Was key released this frame?
-keyDirection()                        // Get input vector from arrow keys or wasd
+keyDirection(up, down, left, right)                        // Get input vector from arrow keys or wasd
 
 // Mouse / Touch
 mousePos                              // World space mouse position
@@ -276,7 +281,7 @@ touchGamepadAlpha = .3                // Transparency of touch gamepad overlay
 
 ```javascript
 // Engine Object
-EngineObject(pos=(0,0), size=(1,1), tileInfo, angle=0, color, renderOrder=0)
+EngineObject(pos, size=(1,1), tileInfo, angle=0, color, renderOrder=0)
 EngineObject.update()                              // Update object, called automatically
 EngineObject.render()                              // Render object, called automatically
 EngineObject.destroy()                             // Destroy this object and children
@@ -317,7 +322,7 @@ objectDefaultAngleDamping = 1 // How much to slow angular velocity each frame (0
 objectDefaultElasticity = 0   // How much to bounce when a collision occurs (0-1)
 objectDefaultFriction = .8    // How much to slow when touching (0-1)
 objectMaxSpeed = 1            // Clamp max speed to avoid fast objects missing collisions
-gravity = 0                   // How much gravity to apply to objects
+gravity = (0,0)               // How much gravity to apply to objects
 
 // Engine Object functions
 engineObjectsCollect(pos, size, objects=engineObjects)k
@@ -336,15 +341,8 @@ engineObjectsDestroy()
 - Drawn directly to the main canvas without using WebGL
 
 ```javascript
-// Tile Collision System
-tileCollisionSize                              // Size of the tile collision layer
-initTileCollision(size)                        // Clear and initialize tile collision
-setTileCollisionData(pos, data=0)              // Set tile collision data at pos
-getTileCollisionData(pos)                      // Get tile collision data at pos
-tileCollisionTest(pos, size=(0,0), object)     // Check if collision should occur
-tileCollisionRaycast(posStart, posEnd, object) // Return the center of tile if hit
-
-// Tile Layer Object
+
+// LittleJS Layer System
 TileLayer(position, size, tileInfo, scale)     // Create a tile layer object
 TileLayer.setData(layerPos, data, redraw)      // Set data at position
 TileLayer.getData(layerPos)                    // Get data at position
@@ -355,12 +353,16 @@ TileLayer.drawTile(pos, size=(1,1), tileInfo, color, angle, mirror) // Draw tile
 TileLayer.drawCanvas2D(pos, size, angle, mirror, drawFunction)      // Draw to 2D canvas
 
 // Tile Layer Data Object
-TileLayerData(tile, direction=0, mirror=false, color=(1,1,1,1)) // Create tile data object
+TileLayerData(tile, direction=0, mirror=false, color=WHITE) // Create tile data object
 TileLayerData.clear()      // Clear this tile data
 
-// Tile sheet settings
-tileSizeDefault = (16,16)  // Default size of tiles in pixels
-tileFixBleedScale = .3     // How much smaller to draw tiles to prevent bleeding
+// Tile Collision Layer
+TileCollisionLayer(position, size, tileInfo=tile()) // Create a tile collision layer object
+TileCollisionLayer.size                             // Size of the tile collision layer
+TileCollisionLayer.setCollisionData(pos, data=1)    // Set tile collision data at pos
+getTileCollisionData(pos)                           // Get tile collision data at pos
+tileCollisionTest(pos, size=(0,0), object)          // Check if collision should occur
+tileCollisionRaycast(posStart, posEnd, object)      // Return the center of tile if hit
 ```
 
 ## LittleJS Particle System

package/src/engine.js

@@ -30,7 +30,7 @@ const engineName = 'LittleJS';
  *  @type {string}
  *  @default
  *  @memberof Engine */
-const engineVersion = '1.11.13';
+const engineVersion = '1.12.4';
 
 /** Frames per second to update
  *  @type {number}
@@ -118,16 +118,11 @@ function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRender
     ASSERT(Array.isArray(imageSources), 'pass in images as array');
 
     // allow passing in empty functions
-    if (!gameInit)
-        gameInit = ()=>{};
-    if (!gameUpdate)
-        gameUpdate = ()=>{};
-    if (!gameUpdatePost)
-        gameUpdatePost = ()=>{};
-    if (!gameRender)
-        gameRender = ()=>{};
-    if (!gameRenderPost)
-        gameRenderPost = ()=>{};
+    gameInit       ||= ()=>{};
+    gameUpdate     ||= ()=>{};
+    gameUpdatePost ||= ()=>{};
+    gameRender     ||= ()=>{};
+    gameRenderPost ||= ()=>{};
 
     // Called automatically by engine to setup render system
     function enginePreRender()
@@ -154,11 +149,13 @@ function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRender
         const debugSpeedUp   = debug && keyIsDown('Equal'); // +
         const debugSpeedDown = debug && keyIsDown('Minus'); // -
         if (debug) // +/- to speed/slow time
-            frameTimeDeltaMS *= debugSpeedUp ? 5 : debugSpeedDown ? .2 : 1;
+            frameTimeDeltaMS *= debugSpeedUp ? 10 : debugSpeedDown ? .1 : 1;
         timeReal += frameTimeDeltaMS / 1e3;
         frameTimeBufferMS += paused ? 0 : frameTimeDeltaMS;
         if (!debugSpeedUp)
-            frameTimeBufferMS = min(frameTimeBufferMS, 50); // clamp in case of slow framerate
+            frameTimeBufferMS = min(frameTimeBufferMS, 50); // clamp min framerate
+        if (debug && debugVideoCaptureIsActive())
+            frameTimeBufferMS = 0; // disable time smoothing when capturing video
 
         updateCanvas();
 
@@ -237,6 +234,7 @@ function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRender
             }
         }
 
+        debugVideoCaptureUpdate();
         requestAnimationFrame(engineUpdate);
     }
 
@@ -284,11 +282,7 @@ function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRender
 
     // setup html
     const styleRoot = 
-        'margin:0;overflow:hidden;' + // fill the window
-        'width:100vw;height:100vh;' + // fill the window
-        'display:flex;' +             // use flexbox
-        'align-items:center;' +       // horizontal center
-        'justify-content:center;' +   // vertical center
+        'margin:0;' +                 // fill the window
         'background:#000;' +          // set background color
         (canvasPixelated ? 'image-rendering:pixelated;' : '') + // pixel art
         'user-select:none;' +         // prevent hold to select
@@ -311,7 +305,8 @@ function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRender
     overlayContext = overlayCanvas.getContext('2d');
 
     // set canvas style
-    const styleCanvas = 'position:absolute'; // allow canvases to overlap
+    const styleCanvas = 'position:absolute;'+ // allow canvases to overlap
+        'top:50%;left:50%;transform:translate(-50%,-50%)'; // center on screen
     mainCanvas.style.cssText = overlayCanvas.style.cssText = styleCanvas;
     if (glCanvas)
         glCanvas.style.cssText = styleCanvas;
@@ -322,12 +317,12 @@ function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRender
         new Promise(resolve => 
         {
             const image = new Image;
-            image.crossOrigin = 'anonymous';
             image.onerror = image.onload = ()=> 
             {
                 textureInfos[textureIndex] = new TextureInfo(image);
                 resolve();
             }
+            image.crossOrigin = 'anonymous';
             image.src = src;
         })
     );

package/src/engineAudio.js

@@ -19,16 +19,15 @@ let audioContext = new AudioContext;
 /** Master gain node for all audio to pass through
  *  @type {GainNode}
  *  @memberof Audio */
-let audioGainNode;
+let audioMasterGain;
 
 function audioInit()
 {
     if (!soundEnable || headlessMode) return;
     
-    // (createGain is more widely supported then GainNode constructor)
-    audioGainNode = audioContext.createGain();
-    audioGainNode.connect(audioContext.destination);
-    audioGainNode.gain.value = soundVolume; // set starting value
+    audioMasterGain = audioContext.createGain();
+    audioMasterGain.connect(audioContext.destination);
+    audioMasterGain.gain.value = soundVolume; // set starting value
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -157,6 +156,8 @@ class Sound
     isLoading() { return !this.sampleChannels; }
 }
 
+///////////////////////////////////////////////////////////////////////////////
+
 /** 
  * Sound Wave Object - Stores a wave sound for later use and can be played positionally
  * - this can be used to play wave, mp3, and ogg files
@@ -208,59 +209,7 @@ function playAudioFile(filename, volume=1, loop=false)
     return new SoundWave(filename,0,0,0, s=>s.play(undefined, volume, 1, 1, loop));
 }
 
-/**
- * Music Object - Stores a zzfx music track for later use
- * 
- * <a href=https://keithclark.github.io/ZzFXM/>Create music with the ZzFXM tracker.</a>
- * @example
- * // create some music
- * const music_example = new Music(
- * [
- *     [                         // instruments
- *       [,0,400]                // simple note
- *     ], 
- *     [                         // patterns
- *         [                     // pattern 1
- *             [                 // channel 0
- *                 0, -1,        // instrument 0, left speaker
- *                 1, 0, 9, 1    // channel notes
- *             ], 
- *             [                 // channel 1
- *                 0, 1,         // instrument 0, right speaker
- *                 0, 12, 17, -1 // channel notes
- *             ]
- *         ],
- *     ],
- *     [0, 0, 0, 0], // sequence, play pattern 0 four times
- *     90            // BPM
- * ]);
- * 
- * // play the music
- * music_example.play();
- */
-class Music extends Sound
-{
-    /** Create a music object and cache the zzfx music samples for later use
-     *  @param {[Array, Array, Array, number]} zzfxMusic - Array of zzfx music parameters
-     */
-    constructor(zzfxMusic)
-    {
-        super(undefined);
-
-        if (!soundEnable || headlessMode) return;
-        this.randomness = 0;
-        this.sampleChannels = zzfxM(...zzfxMusic);
-        this.sampleRate = zzfxR;
-    }
-
-    /** Play the music
-     *  @param {number}  [volume=1] - How much to scale volume by
-     *  @param {boolean} [loop] - True if the music should loop
-     *  @return {AudioBufferSourceNode} - The audio source node
-     */
-    playMusic(volume, loop=false)
-    { return super.play(undefined, volume, 1, 1, loop); }
-}
+///////////////////////////////////////////////////////////////////////////////
 
 /** Speak text with passed in settings
  *  @param {string} text - The text to speak
@@ -332,7 +281,7 @@ function playSamples(sampleChannels, volume=1, rate=1, pan=0, loop=false, sample
     // create and connect gain node
     gainNode = gainNode || audioContext.createGain();
     gainNode.gain.value = volume;
-    gainNode.connect(audioGainNode);
+    gainNode.connect(audioMasterGain);
 
     // connect source to stereo panner and gain
     const pannerNode = new StereoPannerNode(audioContext, {'pan':clamp(pan, -1, 1)});
@@ -352,7 +301,7 @@ function playSamples(sampleChannels, volume=1, rate=1, pan=0, loop=false, sample
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// ZzFXMicro - Zuper Zmall Zound Zynth - v1.3.1 by Frank Force
+// ZzFXMicro - Zuper Zmall Zound Zynth - v1.3.2 by Frank Force
 
 /** Generate and play a ZzFX sound
  *  
@@ -394,21 +343,45 @@ const zzfxR = 44100;
  */
 function zzfxG
 (
-    // parameters
-    volume = 1, randomness = .05, frequency = 220, attack = 0, sustain = 0,
-    release = .1, shape = 0, shapeCurve = 1, slide = 0, deltaSlide = 0,
-    pitchJump = 0, pitchJumpTime = 0, repeatTime = 0, noise = 0, modulation = 0,
-    bitCrush = 0, delay = 0, sustainVolume = 1, decay = 0, tremolo = 0, filter = 0
+    volume = 1, 
+    randomness = .05,
+    frequency = 220,
+    attack = 0,
+    sustain = 0,
+    release = .1,
+    shape = 0,
+    shapeCurve = 1,
+    slide = 0, 
+    deltaSlide = 0, 
+    pitchJump = 0, 
+    pitchJumpTime = 0, 
+    repeatTime = 0, 
+    noise = 0,
+    modulation = 0,
+    bitCrush = 0,
+    delay = 0,
+    sustainVolume = 1,
+    decay = 0,
+    tremolo = 0,
+    filter = 0
 )
 {
-    // LJS Note: ZZFX modded so randomness is handled by Sound class
-
     // init parameters
-    let PI2 = PI*2, sampleRate = zzfxR,
+    let sampleRate = zzfxR,
+        PI2 = PI*2, 
         startSlide = slide *= 500 * PI2 / sampleRate / sampleRate,
         startFrequency = frequency *= 
-            rand(1 + randomness, 1-randomness) * PI2 / sampleRate,
-        b = [], t = 0, tm = 0, i = 0, j = 1, r = 0, c = 0, s = 0, f, length,
+            (1 + rand(randomness,-randomness)) * PI2 / sampleRate,
+        modOffset = 0, // modulation offset  
+        repeat = 0,    // repeat offset
+        crush = 0,     // bit crush offset
+        jump = 1,      // pitch jump timer
+        length,        // sample length
+        b = [],        // sample buffer
+        t = 0,         // sample time
+        i = 0,         // sample index 
+        s = 0,         // sample value
+        f,             // wave frequency
 
         // biquad LP/HP filter
         quality = 2, w = PI2 * abs(filter) * 2 / sampleRate,
@@ -418,35 +391,37 @@ function zzfxG
         b1 = -(sign(filter) + cos) / a0, b2 = b0,
         x2 = 0, x1 = 0, y2 = 0, y1 = 0;
 
-    // scale by sample rate
-    attack = attack * sampleRate + 9; // minimum attack to prevent pop
-    decay *= sampleRate;
-    sustain *= sampleRate;
-    release *= sampleRate;
-    delay *= sampleRate;
-    deltaSlide *= 500 * PI2 / sampleRate**3;
-    modulation *= PI2 / sampleRate;
-    pitchJump *= PI2 / sampleRate;
-    pitchJumpTime *= sampleRate;
-    repeatTime = repeatTime * sampleRate | 0;
+        // scale by sample rate
+        const minAttack = 9; // prevent pop if attack is 0
+        attack = attack * sampleRate || minAttack;
+        decay *= sampleRate;
+        sustain *= sampleRate;
+        release *= sampleRate;
+        delay *= sampleRate;
+        deltaSlide *= 500 * PI2 / sampleRate**3;
+        modulation *= PI2 / sampleRate;
+        pitchJump *= PI2 / sampleRate;
+        pitchJumpTime *= sampleRate;
+        repeatTime = repeatTime * sampleRate | 0;
 
     // generate waveform
     for(length = attack + decay + sustain + release + delay | 0;
-        i < length; b[i++] = s * volume)               // sample
+        i < length; b[i++] = s * volume)                   // sample
     {
-        if (!(++c%(bitCrush*100|0)))                   // bit crush
+        if (!(++crush%(bitCrush*100|0)))                   // bit crush
         {
-            s = shape? shape>1? shape>2? shape>3?      // wave shape
-                Math.sin(t**3) :                       // 4 noise
-                clamp(Math.tan(t),1,-1):               // 3 tan
-                1-(2*t/PI2%2+2)%2:                     // 2 saw
-                1-4*abs(Math.round(t/PI2)-t/PI2):      // 1 triangle
-                Math.sin(t);                           // 0 sin
+            s = shape? shape>1? shape>2? shape>3? shape>4? // wave shape
+                (t/PI2%1 < shapeCurve/2? 1 : -1) :         // 5 square duty
+                Math.sin(t**3) :                           // 4 noise
+                Math.max(Math.min(Math.tan(t),1),-1):      // 3 tan
+                1-(2*t/PI2%2+2)%2:                         // 2 saw
+                1-4*abs(Math.round(t/PI2)-t/PI2):          // 1 triangle
+                Math.sin(t);                               // 0 sin
 
             s = (repeatTime ?
                     1 - tremolo + tremolo*Math.sin(PI2*i/repeatTime) // tremolo
                     : 1) *
-                sign(s)*(abs(s)**shapeCurve) *           // curve
+                (shape>4?s:sign(s)*abs(s)**shapeCurve) * // shape curve
                 (i < attack ? i/attack :                 // attack
                 i < attack + decay ?                     // decay
                 1-((i-attack)/decay)*(1-sustainVolume) : // decay falloff
@@ -461,133 +436,28 @@ function zzfxG
                 (i<length-delay? 1 : (length-i)/delay) * // release delay 
                 b[i-delay|0]/2/volume) : s;              // sample delay
 
-            if (filter)                                   // apply filter
+            if (filter)                                  // apply filter
                 s = y1 = b2*x2 + b1*(x2=x1) + b0*(x1=s) - a2*y2 - a1*(y2=y1);
         }
 
         f = (frequency += slide += deltaSlide) *// frequency
-            Math.cos(modulation*tm++);          // modulation
+            Math.cos(modulation*modOffset++);   // modulation
         t += f + f*noise*Math.sin(i**5);        // noise
 
-        if (j && ++j > pitchJumpTime)           // pitch jump
+        if (jump && ++jump > pitchJumpTime)     // pitch jump
         { 
             frequency += pitchJump;             // apply pitch jump
             startFrequency += pitchJump;        // also apply to start
-            j = 0;                              // stop pitch jump time
+            jump = 0;                           // stop pitch jump time
         } 
 
-        if (repeatTime && !(++r % repeatTime))  // repeat
+        if (repeatTime && !(++repeat % repeatTime)) // repeat
         { 
-            frequency = startFrequency;         // reset frequency
-            slide = startSlide;                 // reset slide
-            j = j || 1;                         // reset pitch jump time
+            frequency = startFrequency;   // reset frequency
+            slide = startSlide;           // reset slide
+            jump ||= 1;                   // reset pitch jump time
         }
     }
 
-    return b;
+    return b; // return sample buffer
 }
-
-///////////////////////////////////////////////////////////////////////////////
-// ZzFX Music Renderer v2.0.3 by Keith Clark and Frank Force
-
-/** Generate samples for a ZzFM song with given parameters
- *  @param {Array} instruments - Array of ZzFX sound parameters
- *  @param {Array} patterns - Array of pattern data
- *  @param {Array} sequence - Array of pattern indexes
- *  @param {number} [BPM] - Playback speed of the song in BPM
- *  @return {Array} - Left and right channel sample data
- *  @memberof Audio */
-function zzfxM(instruments, patterns, sequence, BPM = 125) 
-{
-  let i, j, k;
-  let instrumentParameters;
-  let note;
-  let sample;
-  let patternChannel;
-  let notFirstBeat;
-  let stop;
-  let instrument;
-  let attenuation;
-  let outSampleOffset;
-  let isSequenceEnd;
-  let sampleOffset = 0;
-  let nextSampleOffset;
-  let sampleBuffer = [];
-  let leftChannelBuffer = [];
-  let rightChannelBuffer = [];
-  let channelIndex = 0;
-  let panning = 0;
-  let hasMore = 1;
-  let sampleCache = {};
-  let beatLength = zzfxR / BPM * 60 >> 2;
-
-  // for each channel in order until there are no more
-  for (; hasMore; channelIndex++) {
-
-    // reset current values
-    sampleBuffer = [hasMore = notFirstBeat = outSampleOffset = 0];
-
-    // for each pattern in sequence
-    sequence.forEach((patternIndex, sequenceIndex) => {
-      // get pattern for current channel, use empty 1 note pattern if none found
-      patternChannel = patterns[patternIndex][channelIndex] || [0, 0, 0];
-
-      // check if there are more channels
-      hasMore |= patterns[patternIndex][channelIndex]&&1;
-
-      // get next offset, use the length of first channel
-      nextSampleOffset = outSampleOffset + (patterns[patternIndex][0].length - 2 - (notFirstBeat?0:1)) * beatLength;
-      // for each beat in pattern, plus one extra if end of sequence
-      isSequenceEnd = sequenceIndex == sequence.length - 1;
-      for (i = 2, k = outSampleOffset; i < patternChannel.length + isSequenceEnd; notFirstBeat = ++i) {
-
-        // <channel-note>
-        note = patternChannel[i];
-
-        // stop if end, different instrument or new note
-        stop = i == patternChannel.length + isSequenceEnd - 1 && isSequenceEnd ||
-            instrument != (patternChannel[0] || 0) || note | 0;
-
-        // fill buffer with samples for previous beat, most cpu intensive part
-        for (j = 0; j < beatLength && notFirstBeat;
-
-            // fade off attenuation at end of beat if stopping note, prevents clicking
-            j++ > beatLength - 99 && stop && attenuation < 1? attenuation += 1 / 99 : 0
-        ) {
-          // copy sample to stereo buffers with panning
-          sample = (1 - attenuation) * sampleBuffer[sampleOffset++] / 2 || 0;
-          leftChannelBuffer[k] = (leftChannelBuffer[k] || 0) - sample * panning + sample;
-          rightChannelBuffer[k] = (rightChannelBuffer[k++] || 0) + sample * panning + sample;
-        }
-
-        // set up for next note
-        if (note) {
-          // set attenuation
-          attenuation = note % 1;
-          panning = patternChannel[1] || 0;
-          if (note |= 0) {
-            // get cached sample
-            sampleBuffer = sampleCache[
-              [
-                instrument = patternChannel[sampleOffset = 0] || 0,
-                note
-              ]
-            ] = sampleCache[[instrument, note]] || (
-                // add sample to cache
-                instrumentParameters = [...instruments[instrument]],
-                instrumentParameters[2] *= 2 ** ((note - 12) / 12),
-
-                // allow negative values to stop notes
-                note > 0 ? zzfxG(...instrumentParameters) : []
-            );
-          }
-        }
-      }
-
-      // update the sample offset
-      outSampleOffset = nextSampleOffset;
-    });
-  }
-
-  return [leftChannelBuffer, rightChannelBuffer];
-}

package/src/engineBuild.js

@@ -13,6 +13,7 @@
 const ENGINE_NAME = 'littlejs';
 const BUILD_FOLDER = 'dist';
 const SOURCE_FOLDER = 'src';
+const PLUGIN_FOLDER = 'plugins';
 const engineSourceFiles =
 [
     `${SOURCE_FOLDER}/engineUtilities.js`,
@@ -27,6 +28,14 @@ const engineSourceFiles =
     `${SOURCE_FOLDER}/engineWebGL.js`,
     `${SOURCE_FOLDER}/engine.js`,
 ];
+const enginePluginFiles =
+[
+    `${PLUGIN_FOLDER}/newgrounds.js`,
+    `${PLUGIN_FOLDER}/postProcess.js`,
+    `${PLUGIN_FOLDER}/zzfxm.js`,
+    `${PLUGIN_FOLDER}/uiSystem.js`,
+    `${PLUGIN_FOLDER}/box2d.js`,
+];
 const asciiArt =`
       ~~~~°°°°ooo°oOo°ooOooOooOo.
  __________   ________   ____'°oO.
@@ -55,7 +64,11 @@ Build
 (
     'Build Engine -- all',
     `${BUILD_FOLDER}/${ENGINE_NAME}.js`,
-    [`${SOURCE_FOLDER}/engineDebug.js`, ...engineSourceFiles],
+    [
+        `${SOURCE_FOLDER}/engineDebug.js`, 
+        ...engineSourceFiles, 
+        ...enginePluginFiles
+    ],
     [], true
 );
 
@@ -63,7 +76,11 @@ Build
 (
     'Build Engine -- release',
     `${BUILD_FOLDER}/${ENGINE_NAME}.release.js`,
-    [`${SOURCE_FOLDER}/engineRelease.js`, ...engineSourceFiles],
+    [
+        `${SOURCE_FOLDER}/engineRelease.js`, 
+        ...engineSourceFiles, 
+        ...enginePluginFiles
+    ],
     [], true
 );
 
@@ -79,7 +96,11 @@ Build
 (
     'Build Engine -- ESM',
     `${BUILD_FOLDER}/${ENGINE_NAME}.esm.js`,
-    [`${BUILD_FOLDER}/${ENGINE_NAME}.js`, `${SOURCE_FOLDER}/engineExport.js`],
+    [
+        `${BUILD_FOLDER}/${ENGINE_NAME}.js`, 
+        `${SOURCE_FOLDER}/engineExport.js`, 
+        `${PLUGIN_FOLDER}/pluginExport.js`
+    ],
     [typeScriptBuildStep]
 );
 
@@ -87,7 +108,11 @@ Build
 (
     'Build Engine -- ESM minified release',
     `${BUILD_FOLDER}/${ENGINE_NAME}.esm.min.js`,
-    [`${BUILD_FOLDER}/${ENGINE_NAME}.min.js`, `${SOURCE_FOLDER}/engineExport.js`],
+    [
+        `${BUILD_FOLDER}/${ENGINE_NAME}.release.js`, 
+        `${SOURCE_FOLDER}/engineExport.js`, 
+        `${PLUGIN_FOLDER}/pluginExport.js`
+    ],
     [uglifyBuildStep]
 );