@woosh/meep-engine 2.35.14 → 2.35.17

package/engine/graphics/micron/plugin/GLTFAssetTransformer.js

@@ -35,6 +35,25 @@ function max_polycount(object) {
     return r;
 }
 
+/**
+ *
+ * @param {THREE.Object3D} object
+ */
+function ensureProxy(object) {
+    if (object.isMicronMesh) {
+
+        /**
+         * @type {MicronGeometry}
+         */
+        const micron_geo = object.geometry;
+
+        if (micron_geo.proxy === null) {
+            // proxy geometry doesn't exist, build one
+            micron_geo.buildProxy();
+        }
+    }
+}
+
 export class GLTFAssetTransformer extends AssetTransformer {
     /**
      *
@@ -171,6 +190,8 @@ export class GLTFAssetTransformer extends AssetTransformer {
 
         source.override_mesh = micron_root;
 
+        traverseThreeObject(micron_root, ensureProxy);
+
         return source;
     }
 }

package/engine/graphics/micron/prototypeMicronProxyBuild.js

@@ -0,0 +1,227 @@
+import { PLYLoader } from "three/examples/jsm/loaders/PLYLoader.js";
+import {
+    AmbientLight,
+    CubeTextureLoader,
+    DirectionalLight,
+    FrontSide,
+    Mesh,
+    MeshBasicMaterial,
+    MeshStandardMaterial,
+    PerspectiveCamera,
+    PointLight,
+    RepeatWrapping,
+    Scene,
+    SphereGeometry,
+    sRGBEncoding,
+    TextureLoader,
+    VSMShadowMap,
+    WebGLRenderer
+} from "three";
+import Stats from "three/examples/jsm/libs/stats.module.js";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
+import { buildMicronGeometryFromBufferGeometry } from "./build/buildMicronGeometryFromBufferGeometry.js";
+
+const background = new TextureLoader().load('data/textures/utility/checkers_white_grey_256x256.png');
+background.repeat.set(50, 30);
+background.wrapS = RepeatWrapping;
+background.wrapT = RepeatWrapping;
+
+let container, stats;
+
+let camera, scene, renderer;
+let directionalLight;
+let pointLight;
+
+let windowHalfX = window.innerWidth / 2;
+let windowHalfY = window.innerHeight / 2;
+
+
+function init() {
+
+    container = document.createElement("div");
+    document.body.appendChild(container);
+
+    camera = new PerspectiveCamera(45, window.innerWidth / window.innerHeight, 1, 1000000);
+    camera.position.z = -4000;
+
+    //
+
+
+    scene = new Scene();
+
+    window.scene = scene;
+
+    // LIGHTS
+
+    const ambient = new AmbientLight(0xffffff, 0.1);
+    scene.add(ambient);
+
+    pointLight = new PointLight(0x6666ff, 0.5);
+    pointLight.position.y = 1000;
+    scene.add(pointLight);
+
+    // light representation
+
+    const sphere = new SphereGeometry(100, 16, 8);
+
+    const mesh = new Mesh(sphere, new MeshBasicMaterial({ color: 0xffffff }));
+    mesh.scale.set(0.5, 0.5, 0.5);
+    pointLight.add(mesh);
+
+    // add directional light
+    directionalLight = new DirectionalLight(0xFFAAAA, 0.8);
+    directionalLight.position.set(-500, 1000, 300);
+    directionalLight.castShadow = true;
+    const shadow_camera = directionalLight.shadow.camera;
+    // small bias to prevent shadow acne
+    directionalLight.shadow.bias = -0.0001;
+    // directionalLight.shadow.mapSize.set(4096, 4096);
+    directionalLight.shadow.mapSize.set(1024, 1024);
+    directionalLight.shadow.autoUpdate = false;
+
+    window.light = directionalLight;
+    // directionalLight.shadow.autoUpdate = true;
+
+    shadow_camera.near = 0.1;
+    shadow_camera.far = 2000;
+
+    const shadow_camera_size = 15;
+
+    shadow_camera.left = -shadow_camera_size / 2;
+    shadow_camera.right = shadow_camera_size / 2;
+
+    shadow_camera.bottom = -shadow_camera_size / 2;
+    shadow_camera.top = shadow_camera_size / 2;
+
+    shadow_camera.updateProjectionMatrix();
+
+
+    scene.add(directionalLight);
+    // material samples
+
+    const cubeMaterial1 = new MeshStandardMaterial({
+        wireframe: false,
+        side: FrontSide,
+        color: 0xffffff
+    });
+
+    //
+
+    renderer = new WebGLRenderer({
+        antialias: true,
+        preserveDrawingBuffer: true,
+        stencil: false
+    });
+
+    renderer.shadowMap.enabled = true;
+    renderer.shadowMap.type = VSMShadowMap;
+    // renderer.shadowMap.type = BasicShadowMap;
+    renderer.sortObjects = false;
+
+    renderer.setPixelRatio(window.devicePixelRatio);
+    renderer.setSize(window.innerWidth, window.innerHeight);
+    container.appendChild(renderer.domElement);
+
+    stats = new Stats();
+    container.appendChild(stats.dom);
+
+
+    window.addEventListener("resize", onWindowResize);
+
+// envmap
+    const genCubeUrls = function (prefix, postfix) {
+
+        return [
+            prefix + "posx" + postfix, prefix + "negx" + postfix,
+            prefix + "posy" + postfix, prefix + "negy" + postfix,
+            prefix + "posz" + postfix, prefix + "negz" + postfix
+        ];
+
+    };
+
+    const urls = genCubeUrls("data/textures/cubemaps/hip_miramar/32/", ".png");
+
+    new CubeTextureLoader().load(urls, function (cubeTexture) {
+
+        cubeTexture.encoding = sRGBEncoding;
+
+        // scene.background = new Color(0.1, 0.1, 0.1);
+        // scene.background = new ThreeColor(1, 0.3, 0.3);
+        // scene.background = new Color(0.3, 1, 0.3);
+
+        scene.background = background;
+        scene.environment = cubeTexture;
+
+
+        // const lightProbe = new LightProbe();
+        //
+        // lightProbe.copy(LightProbeGenerator.fromCubeTexture(cubeTexture));
+        // lightProbe.intensity = 1.2;
+
+        // scene.add(lightProbe);
+    });
+
+    onWindowResize();
+
+    new PLYLoader().load("data/models/stanford/Lucy100k.ply", async geometry => {
+        geometry.computeVertexNormals();
+
+        const source = new Mesh(geometry, new MeshStandardMaterial({ color: 0xFFFFFF }));
+
+        const micron_g = await buildMicronGeometryFromBufferGeometry(geometry);
+
+        micron_g.buildProxy();
+
+        const proxy = new Mesh(micron_g.proxy, new MeshStandardMaterial({ color: 0xFF0000 }));
+
+        source.position.x += 700;
+        proxy.position.x -= 700;
+
+        console.warn(geometry, micron_g);
+
+        scene.add(source);
+        scene.add(proxy);
+    })
+}
+
+function onWindowResize() {
+
+    const w = window.innerWidth;
+    const h = window.innerHeight;
+
+    windowHalfX = w / 2;
+    windowHalfY = h / 2;
+
+    camera.aspect = w / h;
+    camera.updateProjectionMatrix();
+
+    renderer.setSize(w, h);
+
+    background.repeat.set(w / 20, h / 20);
+}
+
+function animate() {
+
+    requestAnimationFrame(animate);
+
+    render();
+    stats.update();
+
+}
+
+function render() {
+    if (orbitControls !== undefined) {
+        orbitControls.update();
+    }
+
+    const timer = -0.0002 * Date.now();
+
+    pointLight.position.x = 10000 * Math.cos(timer);
+    pointLight.position.z = 10000 * Math.sin(timer);
+
+    renderer.render(scene, camera);
+}
+
+init();
+const orbitControls = new OrbitControls(camera, container);
+animate();

package/engine/graphics/util/composeMatrix4RotationScale.js

@@ -1,3 +1,6 @@
+import { compose_matrix4_array } from "./composeMatrix4.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+
 /**
  *
  * @param {Matrix4} result
@@ -7,31 +10,5 @@
 export function composeMatrix4RotationScale(result, rotation, scale) {
     const te = result.elements;
 
-    const x = rotation.x, y = rotation.y, z = rotation.z, w = rotation.w;
-    const x2 = x + x, y2 = y + y, z2 = z + z;
-    const xx = x * x2, xy = x * y2, xz = x * z2;
-    const yy = y * y2, yz = y * z2, zz = z * z2;
-    const wx = w * x2, wy = w * y2, wz = w * z2;
-
-    const sx = scale.x, sy = scale.y, sz = scale.z;
-
-    te[0] = (1 - (yy + zz)) * sx;
-    te[1] = (xy + wz) * sx;
-    te[2] = (xz - wy) * sx;
-    te[3] = 0;
-
-    te[4] = (xy - wz) * sy;
-    te[5] = (1 - (xx + zz)) * sy;
-    te[6] = (yz + wx) * sy;
-    te[7] = 0;
-
-    te[8] = (xz + wy) * sz;
-    te[9] = (yz - wx) * sz;
-    te[10] = (1 - (xx + yy)) * sz;
-    te[11] = 0;
-
-    te[12] = 0;
-    te[13] = 0;
-    te[14] = 0;
-    te[15] = 1;
+    compose_matrix4_array(te, Vector3.zero, rotation, scale);
 }

package/engine/intelligence/behavior/ecs/BehaviorComponent.js

@@ -31,7 +31,7 @@ export class BehaviorComponent {
 
     /**
      *
-     * @param {function} f
+     * @param {function(timeDelta:number)} f
      * @param {*} [thisArg]
      * @returns {BehaviorComponent}
      */

package/engine/navigation/grid/FastBinaryHeap.js

@@ -6,12 +6,15 @@ import { assert } from "../../../core/assert.js";
  */
 class BinaryHeap {
     /**
-     * @template T
-     * @param {function(T):number} scoreFunction
+     * @param {(T)=>number} scoreFunction
      * @constructor
      */
     constructor(scoreFunction) {
 
+        /**
+         *
+         * @type {function(T): number}
+         */
         this.scoreFunction = scoreFunction;
 
         /**
@@ -165,6 +168,14 @@ class BinaryHeap {
         }
     }
 
+    /**
+     *
+     * @returns {T|undefined}
+     */
+    peek() {
+        return this.data[0];
+    }
+
     /**
      *
      * @param {T} node

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.35.14",
+  "version": "2.35.17",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",