@woosh/meep-engine 2.56.1 → 2.58.0

package/src/engine/graphics/texture/ImageLoader.js

@@ -1,33 +0,0 @@
-/**
- * Created by Alex on 16/10/2014.
- */
-
-
-
-export default function loadImage(url, callback) {
-    const img = new Image();
-    img.onload = function () {
-        const imgWidth = img.width;
-        const imgHeight = img.height;
-        //
-        const canvas = document.createElement('canvas');
-        canvas.width = imgWidth;
-        canvas.height = imgHeight;
-        const context = canvas.getContext('2d');
-
-        context.drawImage(img, 0, 0, imgWidth, imgHeight);
-        const imgd = context.getImageData(0, 0, imgWidth, imgHeight);
-
-        callback({
-            width: imgWidth,
-            height: imgHeight,
-            data: imgd.data,
-            canvas: canvas
-        });
-    };
-    img.onerror = function () {
-        console.error("failed to load image " + url);
-    };
-    // load img source
-    img.src = url;
-};

package/src/engine/graphics/three/DDSLoader.js

@@ -1,286 +0,0 @@
-import * as THREE from 'three';
-
-/*
- * @author mrdoob / http://mrdoob.com/
- */
-
-function DDSLoader() {
-
-    this._parser = DDSLoader.parse;
-
-}
-
-DDSLoader.prototype = Object.create(THREE.CompressedTextureLoader.prototype);
-DDSLoader.prototype.constructor = DDSLoader;
-
-DDSLoader.parse = function (buffer, loadMipmaps) {
-
-    const dds = { mipmaps: [], width: 0, height: 0, format: null, mipmapCount: 1 };
-
-    // Adapted from @toji's DDS utils
-    // https://github.com/toji/webgl-texture-utils/blob/master/texture-util/dds.js
-
-    // All values and structures referenced from:
-    // http://msdn.microsoft.com/en-us/library/bb943991.aspx/
-
-    const DDS_MAGIC = 0x20534444;
-
-    const DDSD_CAPS = 0x1,
-        DDSD_HEIGHT = 0x2,
-        DDSD_WIDTH = 0x4,
-        DDSD_PITCH = 0x8,
-        DDSD_PIXELFORMAT = 0x1000,
-        DDSD_MIPMAPCOUNT = 0x20000,
-        DDSD_LINEARSIZE = 0x80000,
-        DDSD_DEPTH = 0x800000;
-
-    const DDSCAPS_COMPLEX = 0x8,
-        DDSCAPS_MIPMAP = 0x400000,
-        DDSCAPS_TEXTURE = 0x1000;
-
-    const DDSCAPS2_CUBEMAP = 0x200,
-        DDSCAPS2_CUBEMAP_POSITIVEX = 0x400,
-        DDSCAPS2_CUBEMAP_NEGATIVEX = 0x800,
-        DDSCAPS2_CUBEMAP_POSITIVEY = 0x1000,
-        DDSCAPS2_CUBEMAP_NEGATIVEY = 0x2000,
-        DDSCAPS2_CUBEMAP_POSITIVEZ = 0x4000,
-        DDSCAPS2_CUBEMAP_NEGATIVEZ = 0x8000,
-        DDSCAPS2_VOLUME = 0x200000;
-
-    const DDPF_ALPHAPIXELS = 0x1,
-        DDPF_ALPHA = 0x2,
-        DDPF_FOURCC = 0x4,
-        DDPF_RGB = 0x40,
-        DDPF_YUV = 0x200,
-        DDPF_LUMINANCE = 0x20000;
-
-    function fourCCToInt32(value) {
-
-        return value.charCodeAt(0) +
-            (value.charCodeAt(1) << 8) +
-            (value.charCodeAt(2) << 16) +
-            (value.charCodeAt(3) << 24);
-
-    }
-
-    function int32ToFourCC(value) {
-
-        return String.fromCharCode(
-            value & 0xff,
-            (value >> 8) & 0xff,
-            (value >> 16) & 0xff,
-            (value >> 24) & 0xff
-        );
-
-    }
-
-    function loadARGBMip(buffer, dataOffset, width, height) {
-
-        const dataLength = width * height * 4;
-        const srcBuffer = new Uint8Array(buffer, dataOffset, dataLength);
-        const byteArray = new Uint8Array(dataLength);
-        let dst = 0;
-        let src = 0;
-        for (let y = 0; y < height; y++) {
-
-            for (let x = 0; x < width; x++) {
-
-                const b = srcBuffer[src];
-                src++;
-                const g = srcBuffer[src];
-                src++;
-                const r = srcBuffer[src];
-                src++;
-                const a = srcBuffer[src];
-                src++;
-                byteArray[dst] = r;
-                dst++;	//r
-                byteArray[dst] = g;
-                dst++;	//g
-                byteArray[dst] = b;
-                dst++;	//b
-                byteArray[dst] = a;
-                dst++;	//a
-
-            }
-
-        }
-        return byteArray;
-
-    }
-
-    const FOURCC_DXT1 = fourCCToInt32("DXT1");
-    const FOURCC_DXT3 = fourCCToInt32("DXT3");
-    const FOURCC_DXT5 = fourCCToInt32("DXT5");
-    const FOURCC_ETC1 = fourCCToInt32("ETC1");
-
-    const headerLengthInt = 31; // The header length in 32 bit ints
-
-    // Offsets into the header array
-
-    const off_magic = 0;
-
-    const off_size = 1;
-    const off_flags = 2;
-    const off_height = 3;
-    const off_width = 4;
-
-    const off_mipmapCount = 7;
-
-    const off_pfFlags = 20;
-    const off_pfFourCC = 21;
-    const off_RGBBitCount = 22;
-    const off_RBitMask = 23;
-    const off_GBitMask = 24;
-    const off_BBitMask = 25;
-    const off_ABitMask = 26;
-
-    const off_caps = 27;
-    const off_caps2 = 28;
-    const off_caps3 = 29;
-    const off_caps4 = 30;
-
-    // Parse header
-
-    const header = new Int32Array(buffer, 0, headerLengthInt);
-
-    if (header[off_magic] !== DDS_MAGIC) {
-
-        console.error('THREE.DDSLoader.parse: Invalid magic number in DDS header.');
-        return dds;
-
-    }
-
-    if (!header[off_pfFlags] & DDPF_FOURCC) {
-
-        console.error('THREE.DDSLoader.parse: Unsupported format, must contain a FourCC code.');
-        return dds;
-
-    }
-
-    let blockBytes;
-
-    const fourCC = header[off_pfFourCC];
-
-    let isRGBAUncompressed = false;
-
-    switch (fourCC) {
-
-        case FOURCC_DXT1:
-
-            blockBytes = 8;
-            dds.format = THREE.RGB_S3TC_DXT1_Format;
-            break;
-
-        case FOURCC_DXT3:
-
-            blockBytes = 16;
-            dds.format = THREE.RGBA_S3TC_DXT3_Format;
-            break;
-
-        case FOURCC_DXT5:
-
-            blockBytes = 16;
-            dds.format = THREE.RGBA_S3TC_DXT5_Format;
-            break;
-
-        case FOURCC_ETC1:
-
-            blockBytes = 8;
-            dds.format = THREE.RGB_ETC1_Format;
-            break;
-
-        default:
-
-            if (header[off_RGBBitCount] === 32
-                && header[off_RBitMask] & 0xff0000
-                && header[off_GBitMask] & 0xff00
-                && header[off_BBitMask] & 0xff
-                && header[off_ABitMask] & 0xff000000) {
-
-                isRGBAUncompressed = true;
-                blockBytes = 64;
-                dds.format = THREE.RGBAFormat;
-
-            } else {
-
-                console.error('THREE.DDSLoader.parse: Unsupported FourCC code ', int32ToFourCC(fourCC));
-                return dds;
-
-            }
-
-    }
-
-    dds.mipmapCount = 1;
-
-    if (header[off_flags] & DDSD_MIPMAPCOUNT && loadMipmaps !== false) {
-
-        dds.mipmapCount = Math.max(1, header[off_mipmapCount]);
-
-    }
-
-    const caps2 = header[off_caps2];
-    dds.isCubemap = caps2 & DDSCAPS2_CUBEMAP ? true : false;
-    if (dds.isCubemap && (
-        !(caps2 & DDSCAPS2_CUBEMAP_POSITIVEX) ||
-        !(caps2 & DDSCAPS2_CUBEMAP_NEGATIVEX) ||
-        !(caps2 & DDSCAPS2_CUBEMAP_POSITIVEY) ||
-        !(caps2 & DDSCAPS2_CUBEMAP_NEGATIVEY) ||
-        !(caps2 & DDSCAPS2_CUBEMAP_POSITIVEZ) ||
-        !(caps2 & DDSCAPS2_CUBEMAP_NEGATIVEZ)
-    )) {
-
-        console.error('THREE.DDSLoader.parse: Incomplete cubemap faces');
-        return dds;
-
-    }
-
-    dds.width = header[off_width];
-    dds.height = header[off_height];
-
-    let dataOffset = header[off_size] + 4;
-
-    // Extract mipmaps buffers
-
-    const faces = dds.isCubemap ? 6 : 1;
-
-    for (let face = 0; face < faces; face++) {
-
-        let width = dds.width;
-        let height = dds.height;
-
-        for (let i = 0; i < dds.mipmapCount; i++) {
-
-            let byteArray, dataLength;
-
-            if (isRGBAUncompressed) {
-
-                byteArray = loadARGBMip(buffer, dataOffset, width, height);
-                dataLength = byteArray.length;
-
-            } else {
-
-                dataLength = Math.max(4, width) / 4 * Math.max(4, height) / 4 * blockBytes;
-                byteArray = new Uint8Array(buffer, dataOffset, dataLength);
-
-            }
-
-            const mipmap = { "data": byteArray, "width": width, "height": height };
-            dds.mipmaps.push(mipmap);
-
-            dataOffset += dataLength;
-
-            width = Math.max(width >> 1, 1);
-            height = Math.max(height >> 1, 1);
-
-        }
-
-    }
-
-    return dds;
-
-};
-
-export {
-    DDSLoader
-};

package/src/engine/graphics/three/Water2.js

@@ -1,343 +0,0 @@
-/**
- * @author Mugen87 / https://github.com/Mugen87
- *
- * References:
- *    http://www.valvesoftware.com/publications/2010/siggraph2010_vlachos_waterflow.pdf
- *    http://graphicsrunner.blogspot.de/2010/08/water-using-flow-maps.html
- *
- */
-
-import {
-    Clock,
-    Color,
-    Matrix4,
-    Mesh,
-    RepeatWrapping,
-    ShaderMaterial,
-    TextureLoader,
-    UniformsLib,
-    UniformsUtils,
-    Vector2,
-    Vector4
-} from 'three';
-import { Reflector } from "./Reflector.js";
-import { Refractor } from "./Refractor.js";
-
-
-function Water(geometry, options) {
-
-    Mesh.call(this, geometry);
-
-    this.type = 'Water';
-
-    const scope = this;
-
-    options = options || {};
-
-    const color = (options.color !== undefined) ? new Color(options.color) : new Color(0xFFFFFF);
-    const textureWidth = options.textureWidth || 512;
-    const textureHeight = options.textureHeight || 512;
-    const clipBias = options.clipBias || 0;
-    const flowDirection = options.flowDirection || new Vector2(1, 0);
-    const flowSpeed = options.flowSpeed || 0.03;
-    const reflectivity = options.reflectivity || 0.02;
-    const scale = options.scale || 1;
-
-    const shader = WaterShader;
-
-    const textureLoader = new TextureLoader();
-
-    const flowMap = options.flowMap || undefined;
-    const normalMap0 = options.normalMap0 || textureLoader.load('textures/water/Water_1_M_Normal.jpg');
-    const normalMap1 = options.normalMap1 || textureLoader.load('textures/water/Water_2_M_Normal.jpg');
-
-    const cycle = 0.15; // a cycle of a flow map phase
-    const halfCycle = cycle * 0.5;
-    const textureMatrix = new Matrix4();
-    const clock = new Clock();
-
-    // internal components
-
-    const reflector = new Reflector(geometry, {
-        textureWidth: textureWidth,
-        textureHeight: textureHeight,
-        clipBias: clipBias
-    });
-
-    const refractor = new Refractor(geometry, {
-        textureWidth: textureWidth,
-        textureHeight: textureHeight,
-        clipBias: clipBias
-    });
-
-    reflector.matrixAutoUpdate = false;
-    refractor.matrixAutoUpdate = false;
-
-    // material
-
-    this.material = new ShaderMaterial({
-        uniforms: UniformsUtils.merge([
-            UniformsLib['fog'],
-            shader.uniforms
-        ]),
-        vertexShader: shader.vertexShader,
-        fragmentShader: shader.fragmentShader,
-        transparent: true,
-        fog: true
-    });
-
-    if (flowMap !== undefined) {
-
-        this.material.defines.USE_FLOWMAP = '';
-        this.material.uniforms.tFlowMap = {
-            type: 't',
-            value: flowMap
-        };
-
-    } else {
-
-        this.material.uniforms.flowDirection = {
-            type: 'v2',
-            value: flowDirection
-        };
-
-    }
-
-    // maps
-
-    normalMap0.wrapS = normalMap0.wrapT = RepeatWrapping;
-    normalMap1.wrapS = normalMap1.wrapT = RepeatWrapping;
-
-    this.material.uniforms.tReflectionMap.value = reflector.getRenderTarget().texture;
-    this.material.uniforms.tRefractionMap.value = refractor.getRenderTarget().texture;
-    this.material.uniforms.tNormalMap0.value = normalMap0;
-    this.material.uniforms.tNormalMap1.value = normalMap1;
-
-    // water
-
-    this.material.uniforms.color.value = color;
-    this.material.uniforms.reflectivity.value = reflectivity;
-    this.material.uniforms.textureMatrix.value = textureMatrix;
-
-    // inital values
-
-    this.material.uniforms.config.value.x = 0; // flowMapOffset0
-    this.material.uniforms.config.value.y = halfCycle; // flowMapOffset1
-    this.material.uniforms.config.value.z = halfCycle; // halfCycle
-    this.material.uniforms.config.value.w = scale; // scale
-
-    // functions
-
-    function updateTextureMatrix(camera) {
-
-        textureMatrix.set(
-            0.5, 0.0, 0.0, 0.5,
-            0.0, 0.5, 0.0, 0.5,
-            0.0, 0.0, 0.5, 0.5,
-            0.0, 0.0, 0.0, 1.0
-        );
-
-        textureMatrix.multiply(camera.projectionMatrix);
-        textureMatrix.multiply(camera.matrixWorldInverse);
-        textureMatrix.multiply(scope.matrixWorld);
-
-    }
-
-    function updateFlow() {
-
-        const delta = clock.getDelta();
-        const config = scope.material.uniforms.config;
-
-        config.value.x += flowSpeed * delta; // flowMapOffset0
-        config.value.y = config.value.x + halfCycle; // flowMapOffset1
-
-        // Important: The distance between offsets should be always the value of "halfCycle".
-        // Moreover, both offsets should be in the range of [ 0, cycle ].
-        // This approach ensures a smooth water flow and avoids "reset" effects.
-
-        if (config.value.x >= cycle) {
-
-            config.value.x = 0;
-            config.value.y = halfCycle;
-
-        } else if (config.value.y >= cycle) {
-
-            config.value.y = config.value.y - cycle;
-
-        }
-
-    }
-
-    //
-
-    this.onBeforeRender = function (renderer, scene, camera) {
-
-        updateTextureMatrix(camera);
-        updateFlow();
-
-        scope.visible = false;
-
-        reflector.matrixWorld.copy(scope.matrixWorld);
-        refractor.matrixWorld.copy(scope.matrixWorld);
-
-        reflector.onBeforeRender(renderer, scene, camera);
-        refractor.onBeforeRender(renderer, scene, camera);
-
-        scope.visible = true;
-
-    };
-
-}
-
-Water.prototype = Object.create(Mesh.prototype);
-Water.prototype.constructor = Water;
-
-const WaterShader = {
-
-    uniforms: {
-
-        'color': {
-            type: 'c',
-            value: null
-        },
-
-        'reflectivity': {
-            type: 'f',
-            value: 0
-        },
-
-        'tReflectionMap': {
-            type: 't',
-            value: null
-        },
-
-        'tRefractionMap': {
-            type: 't',
-            value: null
-        },
-
-        'tNormalMap0': {
-            type: 't',
-            value: null
-        },
-
-        'tNormalMap1': {
-            type: 't',
-            value: null
-        },
-
-        'textureMatrix': {
-            type: 'm4',
-            value: null
-        },
-
-        'config': {
-            type: 'v4',
-            value: new Vector4()
-        }
-
-    },
-
-    vertexShader: [
-
-        '#include <fog_pars_vertex>',
-
-        'uniform mat4 textureMatrix;',
-
-        'varying vec4 vCoord;',
-        'varying vec2 vUv;',
-        'varying vec3 vToEye;',
-
-        'void main() {',
-
-        '	vUv = uv;',
-        '	vCoord = textureMatrix * vec4( position, 1.0 );',
-
-        '	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );',
-        '	vToEye = cameraPosition - worldPosition.xyz;',
-
-        '	vec4 mvPosition =  viewMatrix * worldPosition;', // used in fog_vertex
-        '	gl_Position = projectionMatrix * mvPosition;',
-
-        '	#include <fog_vertex>',
-
-        '}'
-
-    ].join('\n'),
-
-    fragmentShader: [
-
-        '#include <fog_pars_fragment>',
-
-        'uniform sampler2D tReflectionMap;',
-        'uniform sampler2D tRefractionMap;',
-        'uniform sampler2D tNormalMap0;',
-        'uniform sampler2D tNormalMap1;',
-
-        '#ifdef USE_FLOWMAP',
-        '	uniform sampler2D tFlowMap;',
-        '#else',
-        '	uniform vec2 flowDirection;',
-        '#endif',
-
-        'uniform vec3 color;',
-        'uniform float reflectivity;',
-        'uniform vec4 config;',
-
-        'varying vec4 vCoord;',
-        'varying vec2 vUv;',
-        'varying vec3 vToEye;',
-
-        'void main() {',
-
-        '	float flowMapOffset0 = config.x;',
-        '	float flowMapOffset1 = config.y;',
-        '	float halfCycle = config.z;',
-        '	float scale = config.w;',
-
-        '	vec3 toEye = normalize( vToEye );',
-
-        // determine flow direction
-        '	vec2 flow;',
-        '	#ifdef USE_FLOWMAP',
-        '		flow = texture2D( tFlowMap, vUv ).rg * 2.0 - 1.0;',
-        '	#else',
-        '		flow = flowDirection;',
-        '	#endif',
-        '	flow.x *= - 1.0;',
-
-        // sample normal maps (distort uvs with flowdata)
-        '	vec4 normalColor0 = texture2D( tNormalMap0, ( vUv * scale ) + flow * flowMapOffset0 );',
-        '	vec4 normalColor1 = texture2D( tNormalMap1, ( vUv * scale ) + flow * flowMapOffset1 );',
-
-        // linear interpolate to get the final normal color
-        '	float flowLerp = abs( halfCycle - flowMapOffset0 ) / halfCycle;',
-        '	vec4 normalColor = mix( normalColor0, normalColor1, flowLerp );',
-
-        // calculate normal vector
-        '	vec3 normal = normalize( vec3( normalColor.r * 2.0 - 1.0, normalColor.b,  normalColor.g * 2.0 - 1.0 ) );',
-
-        // calculate the fresnel term to blend reflection and refraction maps
-        '	float theta = max( dot( toEye, normal ), 0.0 );',
-        '	float reflectance = reflectivity + ( 1.0 - reflectivity ) * pow( ( 1.0 - theta ), 5.0 );',
-
-        // calculate final uv coords
-        '	vec3 coord = vCoord.xyz / vCoord.w;',
-        '	vec2 uv = coord.xy + coord.z * normal.xz * 0.05;',
-
-        '	vec4 reflectColor = texture2D( tReflectionMap, vec2( 1.0 - uv.x, uv.y ) );',
-        '	vec4 refractColor = texture2D( tRefractionMap, uv );',
-
-        // multiply water color with the mix of both textures
-        '	gl_FragColor = vec4( color, 1.0 ) * mix( refractColor, reflectColor, reflectance );',
-
-        '	#include <tonemapping_fragment>',
-        '	#include <encodings_fragment>',
-        '	#include <fog_fragment>',
-
-        '}'
-
-    ].join('\n')
-};
-
-export { Water };

package/src/engine/physics/spring/computeHookeForce.js

@@ -1,9 +0,0 @@
-/**
- *
- * @param {number} displacement
- * @param {number} stiffness
- * @return {number}
- */
-export function computeHookeForce(displacement, stiffness) {
-    return -stiffness * displacement;
-}