@woosh/meep-engine 3.0.0 → 3.0.2

package/src/engine/asset/loaders/texture/loadStandardImageTexture.js

@@ -1,38 +0,0 @@
-import { Asset } from "../../Asset.js";
-import { cloneTexture } from "./cloneTexture.js";
-import { TextureLoader as ThreeTextureLoader } from "three";
-
-const textureLoader = new ThreeTextureLoader();
-
-/**
- *
- * @param {Texture} texture
- * @return {number}
- */
-export function computeTextureByteSize(texture) {
-    const image = texture.image;
-    if (image instanceof ImageData) {
-        return image.array.length;
-    } else {
-        //TODO do actual computation
-        //don't know
-        return 1;
-    }
-}
-export function loadStandardImageTexture(path, success, failure, progress) {
-
-
-
-    textureLoader.load(path, function (texture) {
-
-        texture.flipY = false;
-
-        const byteSize = computeTextureByteSize(texture);
-
-        const asset = new Asset(function () {
-            return cloneTexture(texture);
-        }, byteSize);
-
-        success(asset);
-    }, progress, failure);
-}

package/src/engine/ecs/animation/AnimationOptimizer.d.ts

@@ -1,15 +0,0 @@
-export class AnimationOptimizer {
-    /**
-     *
-     * @param {KeyframeTrack} track
-     */
-    optimizeTrack(track: KeyframeTrack): this;
-    times: any;
-    values: any;
-    /**
-     *
-     * @param {AnimationClip} clip
-     */
-    optimize(clip: AnimationClip): void;
-}
-//# sourceMappingURL=AnimationOptimizer.d.ts.map

package/src/engine/ecs/animation/AnimationOptimizer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AnimationOptimizer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/animation/AnimationOptimizer.js"],"names":[],"mappings":"AAMA;IAKI;;;OAGG;IACH,0CAqGC;IANO,WAA4D;IAC5D,YAAuE;IAO/E;;;OAGG;IACH,oCAQC;CACJ"}

package/src/engine/ecs/animation/AnimationOptimizer.js

@@ -1,132 +0,0 @@
-import { AnimationUtils, InterpolateSmooth } from "three";
-
-function copyArray(array) {
-    return new array.constructor(array);
-}
-
-export class AnimationOptimizer {
-    constructor() {
-
-    }
-
-    /**
-     *
-     * @param {KeyframeTrack} track
-     */
-    optimizeTrack(track) {
-
-        var times = copyArray(track.times),
-            values = copyArray(track.values),
-            stride = track.getValueSize(),
-
-            smoothInterpolation = track.getInterpolation() === InterpolateSmooth,
-
-            writeIndex = 1,
-            lastIndex = times.length - 1;
-
-        for (var i = 1; i < lastIndex; ++i) {
-
-            var keep = false;
-
-            var time = times[i];
-            var timeNext = times[i + 1];
-
-            // remove adjacent keyframes scheduled at the same time
-
-            if (time !== timeNext && (i !== 1 || time !== time[0])) {
-
-                if (!smoothInterpolation) {
-
-                    // remove unnecessary keyframes same as their neighbors
-
-                    var offset = i * stride,
-                        offsetP = offset - stride,
-                        offsetN = offset + stride;
-
-                    for (var j = 0; j !== stride; ++j) {
-
-                        var value = values[offset + j];
-
-                        if (value !== values[offsetP + j] ||
-                            value !== values[offsetN + j]) {
-
-                            keep = true;
-                            break;
-
-                        }
-
-                    }
-
-                } else {
-
-                    keep = true;
-
-                }
-
-            }
-
-            // in-place compaction
-
-            if (keep) {
-
-                if (i !== writeIndex) {
-
-                    times[writeIndex] = times[i];
-
-                    var readOffset = i * stride,
-                        writeOffset = writeIndex * stride;
-
-                    for (var j = 0; j !== stride; ++j) {
-
-                        values[writeOffset + j] = values[readOffset + j];
-
-                    }
-
-                }
-
-                ++writeIndex;
-
-            }
-
-        }
-
-        // flush last keyframe (compaction looks ahead)
-
-        if (lastIndex > 0) {
-
-            times[writeIndex] = times[lastIndex];
-
-            for (var readOffset = lastIndex * stride, writeOffset = writeIndex * stride, j = 0; j !== stride; ++j) {
-
-                values[writeOffset + j] = values[readOffset + j];
-
-            }
-
-            ++writeIndex;
-
-        }
-
-        if (writeIndex !== times.length) {
-
-            this.times = AnimationUtils.arraySlice(times, 0, writeIndex);
-            this.values = AnimationUtils.arraySlice(values, 0, writeIndex * stride);
-
-        }
-
-        return this;
-    }
-
-    /**
-     *
-     * @param {AnimationClip} clip
-     */
-    optimize(clip) {
-        const tracks = clip.tracks;
-        const n = tracks.length;
-        for (let i = 0; i < n; i++) {
-            const keyframeTrack = tracks[i];
-
-            this.optimizeTrack(keyframeTrack);
-        }
-    }
-}

package/src/engine/ecs/fow/shader/screenSpaceFogOfWarShader.d.ts

@@ -1,7 +0,0 @@
-/**
- Shader for drawing fog of war as a screen-space post-process effect
- @returns {ShaderMaterial}
- */
-export function buildScreenSpaceFogOfWarShader(): ShaderMaterial;
-import { ShaderMaterial } from "three";
-//# sourceMappingURL=screenSpaceFogOfWarShader.d.ts.map

package/src/engine/ecs/fow/shader/screenSpaceFogOfWarShader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"screenSpaceFogOfWarShader.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/fow/shader/screenSpaceFogOfWarShader.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,kDAFW,cAAc,CAmNxB;+BAxNyE,OAAO"}

package/src/engine/ecs/fow/shader/screenSpaceFogOfWarShader.js

@@ -1,217 +0,0 @@
-import { Matrix4, NormalBlending, ShaderMaterial, Vector2, Vector4 } from "three";
-import { FULL_SCREEN_QUAD_VERTEX_SHADER } from "../../../graphics/FULL_SCREEN_QUAD_VERTEX_SHADER.js";
-
-/**
- Shader for drawing fog of war as a screen-space post-process effect
- @returns {ShaderMaterial}
- */
-export function buildScreenSpaceFogOfWarShader() {
-    function vertexShader() {
-        return FULL_SCREEN_QUAD_VERTEX_SHADER;
-    }
-
-    function fragmentShader() {
-        return `
-        #include <packing>
-        uniform sampler2D tDepth;
-        uniform sampler2D tFog; 
-        uniform vec4 uFogUvTransform;
-        
-        uniform mat4 uProjectionInverse;
-        uniform mat4 uViewInverse;
-        uniform vec2 uResolution;
-                
-        uniform vec4 uColor;
-
-        // FogOfWarEdgeMode as a float: 0 = Conceal (legacy), 1 = Extend
-        uniform float uEdgeExtend;
-
-        varying vec2 vUv;
-
-        const float   c_samplesX    = 5.0;
-        const float   c_samplesY    = 5.0;
-
-        // True kernel centre is (N-1)/2, so a 5-tap kernel is centred on index 2.
-        const float   c_halfSamplesX = (c_samplesX - 1.0) / 2.0;
-        const float   c_halfSamplesY = (c_samplesY - 1.0) / 2.0;
-        
-        // Std-dev in *sample-index* units (kernel is only c_samples wide), NOT
-        // fog-resolution units. ~1.2 gives a real bell over the 5 taps.
-        const vec2 sigma = vec2(1.2, 1.2);
-        
-        const vec2 sigma2_sq = sigma*sigma*2.0;
-        
-        // Spacing between adjacent taps, in fog texels. Controls blur width and
-        // therefore how strongly the coarse fog grid is smoothed. 1.0 = one texel
-        // per tap, so a 5-tap kernel reaches +/-2 texels either side of centre.
-        const float texelSpacing = 1.0;
-        
-	     vec3 computeWorldPosition(const in float normalizedDepth){
-                // Convert screen coordinates to normalized device coordinates (NDC)
-
-                vec4 ndc = vec4(
-                    (vUv.x - 0.5) * 2.0,
-                    (vUv.y - 0.5) * 2.0,
-                    (normalizedDepth - 0.5) * 2.0,
-                    1.0);
-                
-                vec4 clip = uProjectionInverse * ndc;
-                vec3 result = (uViewInverse* (clip / clip.w) ).xyz;
-                
-                return result;
-	     }
-	     
-	     
-	     float sampleFog(const in vec2 uv){
-	       return texture2D( tFog, uv ).r;
-	     }
-	     
-	     float Gaussian(float sigma2_sq, float x){
-           return exp(-(x*x) / sigma2_sq);
-         }
-
-	     // interleaved gradient noise (Jimenez 2014, "Next Generation Post Processing in Call of Duty")
-	     float gradientNoise(const in vec2 fragCoord){
-	       return fract(52.9829189 * fract(dot(fragCoord, vec2(0.06711056, 0.00583715))));
-	     }
-	     
-	     float getFog(const in vec2 uv){
-	        
-	        // size of one fog texel, in UV space, scaled by the desired tap spacing
-	        vec2 texelSize = texelSpacing / uResolution;
-	     
-			float total = 0.0;
-            
-            float ret = 0.0;
-
-            for (float iy = 0.0; iy < c_samplesY; ++iy){
-            
-                float fy = Gaussian(sigma2_sq.y, iy - c_halfSamplesY);
-                float offsety = (iy - c_halfSamplesY) * texelSize.y;
-                
-                for (float ix = 0.0; ix < c_samplesX; ++ix){
-                
-                    float fx = Gaussian(sigma2_sq.x, ix - c_halfSamplesX);
-                    float offsetx = (ix - c_halfSamplesX) * texelSize.x;
-                    
-                    float weight = fx * fy;
-                    
-                    total += weight;
-                    
-                    ret += texture2D(tFog, uv + vec2(offsetx, offsety)).x * weight;
-                }
-            }
-            
-            return ret / total;
-	     }
-	     	        
-        void main(){
-            float sceneDepth = texture2D( tDepth, vUv ).x;
-
-            vec3 worldPosition;
-
-            if (uEdgeExtend > 0.5 && sceneDepth >= 1.0) {
-                // NOTHING WAS DRAWN HERE, so there is no surface to locate: the
-                // depth is the buffer's clear value and computeWorldPosition would
-                // hand back a point on the far plane, unrelated to the scene, whose
-                // fog lookup is whatever the sampler's clamp happens to return.
-                //
-                // The fog is a GROUND field though — its sampler is indexed by
-                // world XZ and anchored at the world origin (uFogUvTransform is
-                // built from size and scale alone, with no Y term), so the
-                // meaningful position for such a pixel is where its camera ray
-                // crosses that field's own plane, y = 0.
-                //
-                // PROJECTING rather than skipping is what keeps a world boundary
-                // invisible. At the last pixel of ground the surface hit and the
-                // plane hit are the same point, so the fog value carries straight
-                // on across the edge; skipping instead steps it from whatever the
-                // edge reads to nothing at all, and that step is a visible line
-                // exactly where the world stops.
-                vec3 camPos = uViewInverse[3].xyz;
-                vec3 dir = computeWorldPosition(1.0) - camPos;
-
-                // parallel to the plane, or pointing away from it: nothing to
-                // sample, so leave the pixel alone
-                if (abs(dir.y) < 1e-6) {
-                    gl_FragColor = vec4(0.0);
-                    return;
-                }
-
-                float t = -camPos.y / dir.y;
-
-                if (t <= 0.0) {
-                    gl_FragColor = vec4(0.0);
-                    return;
-                }
-
-                worldPosition = camPos + dir * t;
-            } else {
-                //get world fragment position
-                worldPosition = computeWorldPosition(sceneDepth);
-            }
-
-            vec2 fogUv = worldPosition.xz * uFogUvTransform.zw + uFogUvTransform.xy;
-            
-            float fogValue = getFog( fogUv );
-            
-            gl_FragColor = uColor;
-            gl_FragColor.a *= fogValue;
-
-            // The fog is written to an 8-bit intermediate layer target; both channels of
-            // that target carry a quantized ramp: alpha holds fogValue, rgb holds
-            // uColor.rgb * alpha (multiplied by ROP blending). Dither each at +/-0.5 LSB
-            // of its own quantizer to break up banding. The rgb noise is attenuated by
-            // alpha in the blend, exactly matching how the rgb band amplitude scales.
-            gl_FragColor.a += gradientNoise(gl_FragCoord.xy) * (1.0 / 255.0) - (0.5 / 255.0);
-            gl_FragColor.rgb += vec3( gradientNoise(gl_FragCoord.xy + vec2(7.0, 13.0)) * (1.0 / 255.0) - (0.5 / 255.0) );
-        }
-        `;
-    }
-
-    const uniforms = {
-        tFog: {
-            type: 't',
-            /**
-             * @type {Texture}
-             */
-            value: null
-        },
-        tDepth: {
-            type: 't',
-            /**
-             * @type {Texture}
-             */
-            value: null
-        },
-        uViewInverse: { type: 'm4', value: new Matrix4() },
-        uProjectionInverse: { type: 'm4', value: new Matrix4() },
-        uColor: { type: 'c', value: new Vector4(0, 0, 0, 1) },
-        /**
-         * {@link FogOfWarEdgeMode} as a float. Defaults to Conceal, so a consumer
-         * that never sets it keeps the pre-option behaviour.
-         */
-        uEdgeExtend: { type: 'f', value: 0 },
-        uFogUvTransform: { type: 'v4', value: new Vector4(0, 0, 1, 1) },
-        /**
-         * Fog texture resolution
-         */
-        uResolution: { type: 'v2', value: new Vector2(0, 0) }
-    };
-
-    const material = new ShaderMaterial({
-        uniforms,
-        vertexShader: vertexShader(),
-        fragmentShader: fragmentShader(),
-        blending: NormalBlending,
-        lights: false,
-        fog: false,
-        depthTest: false,
-        depthWrite: false,
-        transparent: true,
-        vertexColors: false,
-        extensions: {}
-    });
-
-    return material;
-}

package/src/engine/graphics/context/WebGLContextFailureReason.d.ts

@@ -1,9 +0,0 @@
-/**
- * Why {@link WebGLContextMonitor } gave up on recovery.
- */
-export type WebGLContextFailureReason = string;
-export namespace WebGLContextFailureReason {
-    let RestoreTimeout: string;
-    let TooManyLosses: string;
-}
-//# sourceMappingURL=WebGLContextFailureReason.d.ts.map

package/src/engine/graphics/context/WebGLContextFailureReason.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"WebGLContextFailureReason.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/context/WebGLContextFailureReason.js"],"names":[],"mappings":";;;wCAEU,MAAM"}

package/src/engine/graphics/context/WebGLContextFailureReason.js

@@ -1,17 +0,0 @@
-/**
- * Why {@link WebGLContextMonitor} gave up on recovery.
- * @enum {string}
- */
-export const WebGLContextFailureReason = {
-    /**
-     * The browser never delivered `webglcontextrestored` within the allotted time. Happens when the
-     * browser refuses to restore, for example because the page itself caused the loss by exceeding the
-     * per-page context limit, or because acceleration was disabled for the page.
-     */
-    RestoreTimeout: 'restore-timeout',
-    /**
-     * The context was lost more times than {@link WebGLContextMonitor#max_loss_count}. Recovering again
-     * would most likely just lead to another loss.
-     */
-    TooManyLosses: 'too-many-losses'
-};

package/src/engine/graphics/context/WebGLContextMonitor.d.ts

@@ -1,106 +0,0 @@
-/**
- * Detects WebGL context loss on a canvas and tracks whether the context may be used.
- *
- * The browser is only allowed to restore a lost context if `preventDefault()` was called on the loss
- * event, which is what this class does. Restoration is still the browser's decision - it will refuse
- * when the page caused the loss itself (typically by exceeding the per-page context limit) or when
- * acceleration has been disabled for the page. That is why recovery is bounded: after
- * {@link WebGLContextMonitor#restore_timeout} seconds without a restore, or after more than
- * {@link WebGLContextMonitor#max_loss_count} losses, the monitor gives up and reports
- * {@link WebGLContextMonitor#on}.failed so the application can tell the user instead of presenting a
- * permanently black canvas.
- *
- * The restore deadline only runs while the page is visible. The browser does not restore a context in a
- * hidden tab, so counting hidden time would fail sessions that were merely backgrounded when the loss
- * happened - a common case, since background tabs are where the browser prefers to evict contexts. Each
- * return to visibility restarts the full {@link WebGLContextMonitor#restore_timeout} wait.
- *
- * Detection is entirely event driven. Nothing here runs per frame; consumers read
- * {@link WebGLContextMonitor#is_live} (a single field compare) and subscribe to the signals.
- */
-export class WebGLContextMonitor {
-    /**
-     * How long to wait for the browser to restore a lost context before declaring failure, in seconds.
-     * Only visible time counts - the browser will not restore while the tab is hidden, so the deadline is
-     * suspended for as long as the page is, and restarts in full when the page is revealed.
-     * @type {number}
-     */
-    restore_timeout: number;
-    /**
-     * How many losses within {@link WebGLContextMonitor#loss_window} to recover from before giving up. A
-     * context that keeps dying is usually a symptom of something recovery cannot fix, such as a driver
-     * that crashes on our workload.
-     * @type {number}
-     */
-    max_loss_count: number;
-    /**
-     * Window over which {@link WebGLContextMonitor#max_loss_count} is counted, in seconds
-     * @type {number}
-     */
-    loss_window: number;
-    on: {
-        /**
-         * Context has been lost. Rendering must stop until `restored` or `failed`.
-         * @type {Signal}
-         */
-        lost: Signal;
-        /**
-         * Context has been restored, carries the new generation number. GPU-side state must be
-         * considered empty; anything not re-derivable from CPU-side data has to be rebuilt here.
-         * @type {Signal<number>}
-         */
-        restored: any;
-        /**
-         * Recovery was abandoned, carries a {@link WebGLContextFailureReason}. Terminal.
-         * @type {Signal<string>}
-         */
-        failed: any;
-    };
-    /**
-     * @returns {WebGLContextState}
-     */
-    get state(): number;
-    /**
-     * @returns {number}
-     */
-    get generation(): number;
-    /**
-     * Total number of losses observed since {@link WebGLContextMonitor#attach}
-     * @returns {number}
-     */
-    get loss_count(): number;
-    /**
-     * Number of losses within the last {@link WebGLContextMonitor#loss_window} seconds, including the
-     * current one if the context is presently lost
-     * @returns {number}
-     */
-    get recent_loss_count(): number;
-    /**
-     * Duration of the most recent recovery in seconds, `-1` if the context has never been restored
-     * @returns {number}
-     */
-    get restore_duration(): number;
-    /**
-     * Whether the context may be used for rendering. This is the per-frame gate, keep it cheap.
-     * @returns {boolean}
-     */
-    get is_live(): boolean;
-    /**
-     * Start watching a canvas, whose context is assumed to be live. Must be called before the context is
-     * used, and at most once without an intervening {@link WebGLContextMonitor#detach}.
-     *
-     * Loss bookkeeping is reset, so attaching to a freshly created canvas after giving up on the previous
-     * one starts with a clean slate. The generation counter is not reset - it is monotonic for the
-     * lifetime of the monitor, so that stale async results can always be recognised.
-     *
-     * @param {HTMLCanvasElement} canvas
-     */
-    attach(canvas: HTMLCanvasElement): void;
-    /**
-     * Stop watching the canvas and cancel any pending watchdog
-     */
-    detach(): void;
-    #private;
-}
-import Signal from "../../../core/events/signal/Signal.js";
-//# sourceMappingURL=WebGLContextMonitor.d.ts.map

package/src/engine/graphics/context/WebGLContextMonitor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"WebGLContextMonitor.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/context/WebGLContextMonitor.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAsDI;;;;;OAKG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;;OAKG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,aAFU,MAAM,CAEC;IAEjB;QACI;;;WAGG;cADO,MAAM;QAGhB;;;;WAIG;;QAEH;;;WAGG;;MAEL;IAEF;;OAEG;IACH,oBAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;OAIG;IACH,gCAcC;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;;;;;OASG;IACH,eAFW,iBAAiB,QAe3B;IAED;;OAEG;IACH,eAeC;;CAsHJ;mBAnVkB,uCAAuC"}