@woosh/meep-engine 2.43.22 → 2.43.23

package/core/geom/3d/topology/struct/binary/io/create_edge.js

@@ -0,0 +1,106 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_from
+ * @param {number} edge_to
+ * @param {number} vertex
+ */
+function edge_link_disk_forward(mesh, edge_from, edge_to, vertex) {
+    const from_v1 = mesh.edge_read_vertex1(edge_from);
+
+    let displaced_edge;
+
+    if (from_v1 === vertex) {
+        displaced_edge = mesh.edge_read_v1_disk_next(edge_from);
+
+        mesh.edge_write_v1_disk_next(edge_from, edge_to);
+
+    } else {
+        displaced_edge = mesh.edge_read_v2_disk_next(edge_from);
+
+        mesh.edge_write_v2_disk_next(edge_from, edge_to);
+    }
+
+    return displaced_edge;
+}
+
+function edge_link_disk_back(mesh, edge_from, edge_to, vertex) {
+    const from_v1 = mesh.edge_read_vertex1(edge_from);
+
+    let displaced_edge;
+
+    if (from_v1 === vertex) {
+        displaced_edge = mesh.edge_read_v1_disk_prev(edge_from);
+
+        mesh.edge_write_v1_disk_prev(edge_from, edge_to);
+
+    } else {
+        displaced_edge = mesh.edge_read_v2_disk_prev(edge_from);
+
+        mesh.edge_write_v2_disk_prev(edge_from, edge_to);
+    }
+
+    return displaced_edge;
+}
+
+/**
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_source anchor edge, new edge is inserted after this one
+ * @param {number} edge_new edge that is being introduced
+ * @param {number} vertex
+ */
+function edge_link_disk(mesh, edge_source, edge_new, vertex) {
+    const forward_link = edge_link_disk_forward(mesh, edge_source, edge_new, vertex);
+    edge_link_disk_forward(mesh, edge_new, forward_link, vertex);
+
+    edge_link_disk_back(mesh, forward_link, edge_new, vertex);
+    edge_link_disk_back(mesh, edge_new, edge_source, vertex);
+}
+
+/**
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} v0
+ * @param {number} v1
+ * @return {number}
+ */
+export function create_edge(mesh, v0, v1) {
+    const edge_id = mesh.edges.allocate();
+
+    mesh.edge_write_vertex1(edge_id, v0);
+    mesh.edge_write_vertex2(edge_id, v1);
+
+    // initialize rest of the edge
+    mesh.edge_write_loop(edge_id, NULL_POINTER);
+
+    // process disk links
+    const first_v0_edge = mesh.vertex_read_edge(v0);
+
+    if (first_v0_edge !== NULL_POINTER) {
+        edge_link_disk(mesh, first_v0_edge, edge_id, v0);
+    } else {
+        // no edges attached yet, attach this one as the first
+        mesh.vertex_write_edge(v0, edge_id);
+        // link to self
+        mesh.edge_write_v1_disk_next(edge_id, edge_id);
+        mesh.edge_write_v1_disk_prev(edge_id, edge_id);
+    }
+
+    const first_v1_edge = mesh.vertex_read_edge(v1);
+
+    if (first_v1_edge !== NULL_POINTER) {
+
+        edge_link_disk(mesh, first_v1_edge, edge_id, v1);
+
+    } else {
+        // no edges attached yet, attach this one as the first
+        mesh.vertex_write_edge(v1, edge_id);
+        // link to self
+        mesh.edge_write_v2_disk_next(edge_id, edge_id);
+        mesh.edge_write_v2_disk_prev(edge_id, edge_id);
+    }
+    return edge_id;
+}

package/core/geom/3d/topology/struct/binary/io/get_or_create_edge_map.js

@@ -0,0 +1,26 @@
+import { OrderedEdge } from "./OrderedEdge.js";
+import { create_edge } from "./create_edge.js";
+
+/**
+ *
+ * @param {number} v0
+ * @param {number} v1
+ * @param {HashMap<OrderedEdge,number>} map
+ * @param {BinaryTopology} mesh
+ */
+function get_or_create_edge_map(v0, v1, map, mesh) {
+    const scratch_ordered_edge = new OrderedEdge(v0, v1);
+
+    const existing = map.get(scratch_ordered_edge);
+
+    if (existing !== undefined) {
+        return existing;
+    }
+
+    // doesn't exist - create
+    const edge_id = create_edge(mesh, v0, v1);
+
+    map.set(scratch_ordered_edge, edge_id);
+
+    return edge_id;
+}

package/core/geom/3d/topology/struct/binary/query/bt_mesh_edge_has_vertex.js

@@ -0,0 +1,16 @@
+/**
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_id
+ * @param {number} vertex_id
+ * @returns {boolean}
+ */
+export function bt_mesh_edge_has_vertex(mesh, edge_id, vertex_id) {
+    const v1 = mesh.edge_read_vertex1(edge_id);
+
+    if (v1 === vertex_id) {
+        return true;
+    }
+
+    return mesh.edge_read_vertex2(edge_id) === vertex_id;
+}

package/core/geom/3d/topology/struct/binary/query/bt_mesh_edge_has_vertex.spec.js

@@ -0,0 +1,15 @@
+import { BinaryTopology } from "../BinaryTopology.js";
+import { bt_mesh_edge_has_vertex } from "./bt_mesh_edge_has_vertex.js";
+
+test('main', () => {
+    const mesh = new BinaryTopology();
+
+    const edge = mesh.edges.allocate();
+
+    mesh.edge_write_vertex1(edge, 7);
+    mesh.edge_write_vertex2(edge, 3);
+
+    expect(bt_mesh_edge_has_vertex(mesh, edge, 7)).toBe(true);
+    expect(bt_mesh_edge_has_vertex(mesh, edge, 3)).toBe(true);
+    expect(bt_mesh_edge_has_vertex(mesh, edge, 1)).toBe(false);
+});

package/core/geom/3d/topology/struct/binary/query/bt_mesh_edge_other_vertex.js

@@ -0,0 +1,21 @@
+/**
+ * Returns other vertex ID
+ * Assumes that given vertex belongs to this edge
+ * Assumes that given edge exists
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_id edge ID
+ * @param {number} vertex_id
+ * @returns {number}
+ */
+export function bt_mesh_edge_other_vertex(mesh, edge_id, vertex_id) {
+
+    const v1 = mesh.edge_read_vertex1(edge_id);
+    const v2 = mesh.edge_read_vertex2(edge_id);
+
+    if (v1 === vertex_id) {
+        return v2;
+    } else {
+        return v1;
+    }
+
+}

package/core/geom/3d/topology/struct/binary/query/bt_mesh_edge_other_vertex.spec.js

@@ -0,0 +1,16 @@
+import { BinaryTopology } from "../BinaryTopology.js";
+import { bt_mesh_edge_other_vertex } from "./bt_mesh_edge_other_vertex.js";
+
+test('main', () => {
+
+    const mesh = new BinaryTopology();
+
+    const edge = mesh.edges.allocate();
+
+    mesh.edge_write_vertex1(edge, 7);
+    mesh.edge_write_vertex2(edge, 3);
+
+    expect(bt_mesh_edge_other_vertex(mesh, edge, 7)).toBe(3);
+    expect(bt_mesh_edge_other_vertex(mesh, edge, 3)).toBe(7);
+
+});

package/core/geom/3d/topology/struct/prototypeBinaryTopology.js

@@ -1,7 +1,7 @@
 import { PLYLoader } from "three/examples/jsm/loaders/PLYLoader.js";
 import { noop } from "../../../../function/Functions.js";
-import { bt_index_geometry_to_topology } from "./bt_index_geometry_to_topology.js";
-import { BinaryTopology } from "./BinaryTopology.js";
+import { bt_index_geometry_to_topology } from "./binary/io/bt_index_geometry_to_topology.js";
+import { BinaryTopology } from "./binary/BinaryTopology.js";
 import {
     compute_buffer_geometry_byte_size
 } from "../../../../../engine/graphics/geometry/buffered/compute_buffer_geometry_byte_size.js";
@@ -18,27 +18,27 @@ function promise_ply(url) {
 
 async function main() {
 
-    // const url = "data/models/stanford/Lucy100k.ply";
-    const url = "data/models/stanford/dragon_recon/dragon_vrip.ply";
+    const url = "data/models/stanford/Lucy100k.ply";
+    // const url = "data/models/stanford/dragon_recon/dragon_vrip.ply";
     const lucy_geom = await promise_ply(url);
 
     const mesh = new BinaryTopology();
+    const topoMesh = new TopoMesh();
 
     const positions_array = lucy_geom.getAttribute('position').array;
     const index_array = lucy_geom.getIndex().array;
 
 
-    const topoMesh = new TopoMesh();
-
-    console.time('topo build - obj');
-    topoMesh.build(positions_array, index_array);
-    console.timeEnd('topo build - obj');
-
-    // console.time('topo build - bin');
-    console.profile('topo build - bin');
+    console.time('topo build - bin');
+    // console.profile('topo build - bin');
     bt_index_geometry_to_topology(mesh, index_array, positions_array);
-    console.profileEnd('topo build - bin');
-    // console.timeEnd('topo build - bin');
+    // console.profileEnd('topo build - bin');
+    console.timeEnd('topo build - bin');
+
+    //
+    // console.time('topo build - obj');
+    // topoMesh.build(positions_array, index_array);
+    // console.timeEnd('topo build - obj');
 
     mesh.trim();
 

package/core/path/PATH_SEPARATOR.js

@@ -0,0 +1 @@
+export const PATH_SEPARATOR = '/';

package/core/path/computeFileExtension.js

@@ -0,0 +1,24 @@
+import { computePathBase } from "./computePathBase.js";
+
+/**
+ *
+ * @param {string} path
+ * @returns {String|null}
+ */
+export function computeFileExtension(path) {
+    if (typeof path !== "string") {
+        throw new Error('path is not a string');
+    }
+
+    //get base
+    const pathBase = computePathBase(path);
+
+    const lastDotIndex = pathBase.lastIndexOf('.');
+
+    if (lastDotIndex !== -1) {
+        return pathBase.substring(lastDotIndex + 1);
+    } else {
+        //no extension
+        return null;
+    }
+}

package/core/path/computeFileExtension.spec.js

@@ -0,0 +1,13 @@
+import { computeFileExtension } from "./computeFileExtension.js";
+
+test('extract extension of cat.txt', () => {
+    expect(computeFileExtension('cat.txt')).toEqual('txt');
+});
+
+test('extract extension of ../hmm/cat.txt', () => {
+    expect(computeFileExtension('../hmm/cat.txt')).toEqual('txt');
+});
+
+test('extract extension of empty string', () => {
+    expect(computeFileExtension('')).toBeNull();
+});

package/core/path/computePathBase.js

@@ -0,0 +1,21 @@
+import { PATH_SEPARATOR } from "./PATH_SEPARATOR.js";
+
+/**
+ * Strips all directories from the path.
+ * @example 'a/b/c' -> 'c'
+ * @param {string} path
+ * @returns {string}
+ */
+export function computePathBase(path) {
+    if (typeof path !== "string") {
+        throw new Error('path is not a string');
+    }
+
+    const lastSlashIndex = path.lastIndexOf(PATH_SEPARATOR);
+
+    if (lastSlashIndex !== -1) {
+        return path.substring(lastSlashIndex + 1);
+    } else {
+        return path;
+    }
+}

package/core/path/computePathBase.spec.js

@@ -0,0 +1,13 @@
+import { computePathBase } from "./computePathBase.js";
+
+test('extract base path of empty string', () => {
+    expect(computePathBase('')).toBe('');
+});
+
+test('extract base path of hello', () => {
+    expect(computePathBase('hello')).toBe('hello');
+});
+
+test('extract base path of hello/there/world', () => {
+    expect(computePathBase('hello/there/world')).toBe('world');
+});

package/core/path/computePathDirectory.js

@@ -0,0 +1,25 @@
+import { PATH_SEPARATOR } from "./PATH_SEPARATOR.js";
+
+/**
+ * Returns the directory name of a path, similar to the Unix dirname command.
+ * @param {string} path
+ * @return {string}
+ */
+export function computePathDirectory(path) {
+    if (typeof path !== "string") {
+        throw new Error('path is not a string');
+    }
+
+    let lastSlashIndex = path.lastIndexOf(PATH_SEPARATOR);
+
+    //rewind in case of trailing slashes
+    while (lastSlashIndex > 0 && path.charAt(lastSlashIndex - 1) === PATH_SEPARATOR) {
+        lastSlashIndex--;
+    }
+
+    if (lastSlashIndex !== -1) {
+        return path.substring(0, lastSlashIndex);
+    } else {
+        return path;
+    }
+}

package/editor/view/library/MeshLibraryView.js

@@ -2,13 +2,13 @@ import View from "../../../view/View.js";
 import { makeModelView } from "../../../view/renderModel.js";
 import Vector2 from "../../../core/geom/Vector2.js";
 import domify from "../../../view/DOM.js";
-import { computePathBase } from "../../../core/FilePath.js";
 import LabelView from "../../../view/common/LabelView.js";
 import List from "../../../core/collection/list/List.js";
 import AABB2 from "../../../core/geom/AABB2.js";
 import { DragEvents } from "../../../engine/input/devices/events/DragEvents.js";
 import { MouseEvents } from "../../../engine/input/devices/events/MouseEvents.js";
 import { TouchEvents } from "../../../engine/input/devices/events/TouchEvents.js";
+import { computePathBase } from "../../../core/path/computePathBase.js";
 
 
 const ICON_SIZE = 50;

package/engine/asset/guessAssetType.js

@@ -1,4 +1,4 @@
-import { computeFileExtension } from "../../core/FilePath.js";
+import { computeFileExtension } from "../../core/path/computeFileExtension.js";
 
 /**
  *

package/engine/asset/loaders/image/ImageRGBADataLoader.js

@@ -1,5 +1,4 @@
 import { AssetLoader } from "../AssetLoader.js";
-import { computeFileExtension } from "../../../../core/FilePath.js";
 import { GameAssetType } from "../../GameAssetType.js";
 import { convertTexture2Sampler2D } from "../../../graphics/texture/sampler/convertTexture2Sampler2D.js";
 import { ImageRGBADataAsset } from "./ImageRGBADataAsset.js";
@@ -7,6 +6,7 @@ import { ArrayBufferLoader } from "../ArrayBufferLoader.js";
 import { CodecWithFallback } from "./codec/CodecWithFallback.js";
 import { ThreadedImageDecoder } from "./codec/ThreadedImageDecoder.js";
 import { NativeImageDecoder } from "./codec/NativeImageDecoder.js";
+import { computeFileExtension } from "../../../../core/path/computeFileExtension.js";
 
 const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
 

package/engine/asset/loaders/texture/TextureAssetLoader.js

@@ -1,7 +1,7 @@
 import { AssetLoader } from "../AssetLoader.js";
-import { computeFileExtension } from "../../../../core/FilePath.js";
 import { loadDDSTexture } from "./loadDDSTexture.js";
 import { loadStandardImageTexture } from "./loadStandardImageTexture.js";
+import { computeFileExtension } from "../../../../core/path/computeFileExtension.js";
 
 export class TextureAssetLoader extends AssetLoader {
     load(path, success, failure, progress) {

package/engine/ecs/storage/BinaryBufferSerializer.js

@@ -55,6 +55,11 @@ class BinaryBufferSerializer {
          * @type {BinarySerializationRegistry}
          */
         this.registry = null;
+        /**
+         *
+         * @type {Engine|null}
+         */
+        this.engine = null;
     }
 
     /**
@@ -92,6 +97,8 @@ class BinaryBufferSerializer {
 
         let i;
 
+        const engine = this.engine;
+
         for (i = 0; i < numSerializableTypes; i++) {
 
             const componentType = serializableComponentTypes[i];

package/engine/graphics/material/composeCompile.js

@@ -13,6 +13,7 @@ export function composeCompile(previous, next) {
     let t1_cache = cache.get(previous);
 
     if (t1_cache === undefined) {
+        // no caches starting from previous
         t1_cache = new WeakMap();
 
         cache.set(previous, t1_cache);
@@ -21,14 +22,11 @@ export function composeCompile(previous, next) {
     let result_function = t1_cache.get(next);
 
     if (result_function === undefined) {
+        // no matching function found for pair, let's create it
+
         // we create a custom function just to be able to name our function, this is because of how three.js caches onBeforeCompile by just turning it into the string, so changing the function name will result in altered cache key
         const f = new Function('previous, next', `return function f${id_counter++}(a,b,c,d){ previous(a,b,c,d); next(a,b,c,d); };`);
 
-        // result_function = function (a, b, c, d) {
-        //     previous(a, b, c, d);
-        //     next(a, b, c, d);
-        // };
-        //
 
         result_function = f(previous, next);
 

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

@@ -1,5 +1,4 @@
 import { AssetTransformer } from "../../../asset/AssetTransformer.js";
-import { computePathDirectory } from "../../../../core/FilePath.js";
 import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
 import { MicronGeometry } from "../format/MicronGeometry.js";
 import { MICRON_GEOMETRY_FIELD } from "../MICRON_GEOMETRY_FIELD.js";
@@ -12,6 +11,7 @@ import {
     deserialize_geometry_collection
 } from "../format/serialization/collection/geometry_collection_serialization.js";
 import { GLTF_MICRON_ID_FIELD } from "./GLTF_MICRON_ID_FIELD.js";
+import { computePathDirectory } from "../../../../core/path/computePathDirectory.js";
 
 export const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
 

package/engine/graphics/sh3/README.md

@@ -3,3 +3,5 @@ Path tracing ideas:
 * [smallpt](https://www.kevinbeason.com/smallpt/) (100 line c implementation of path tracer)
 * [three path tracer](https://github.com/gkjohnson/three-gpu-pathtracer)
 * http://blog.hvidtfeldts.net/index.php/2015/01/path-tracing-3d-fractals/
+* [Global Illumination and Path Tracing](https://www.scratchapixel.com/lessons/3d-basic-rendering/global-illumination-path-tracing/global-illumination-path-tracing-practical-implementation)
+* [Path Tracing, by Steve Rotenberg](https://cseweb.ucsd.edu/classes/sp17/cse168-a/CSE168_08_PathTracing.pdf)

package/engine/graphics/sh3/path_tracer/PathTracer.js

@@ -20,7 +20,6 @@ import {
     UnsignedByteType
 } from "three";
 import { linear_to_sRGB } from "../../../../core/color/linear_to_sRGB.js";
-import { random_in_hemisphere } from "./random_in_hemisphere.js";
 import { sample_triangle_attribute } from "./sample_triangle_attribute.js";
 import { vec3_uint8_to_float } from "./vec3_uint8_to_float.js";
 import { apply_texture_clamping_to_coordinate } from "./apply_texture_clamping_to_coordinate.js";
@@ -527,10 +526,6 @@ export class PathTracer {
                 break;
             }
 
-
-            // irradiance[0] += m;
-            // irradiance[1] += m;
-            // irradiance[2] += m;
             this.sample_material(tmp_0, trace_result);
 
             // adjust normal on the hit
@@ -541,7 +536,6 @@ export class PathTracer {
             array_copy(trace_result, 0, _ray_0, 0, 3);
 
             getBiasedNormalSample(_ray_0, 3, tmp_0, 3, 1, random);
-            // random_in_hemisphere(random, _ray_0, 3, tmp_0, 3);
 
             // accumulate
             vec3.multiply(irradiance, irradiance, tmp_0);
@@ -556,14 +550,6 @@ export class PathTracer {
             vec3.multiply(irradiance, irradiance, tmp_1);
         }
 
-        //
-        // if (got_emission === false) {
-        //     // no light source was hit, propagate shadow(darkness) along the ray
-        //     irradiance[0] = 0;
-        //     irradiance[1] = 0;
-        //     irradiance[2] = 0;
-        // }
-
         array_copy(irradiance, 0, out, 0, 3);
     }
 }

package/engine/graphics/sh3/path_tracer/prototypePathTracer.js

@@ -7,8 +7,7 @@ import {
     OctahedronBufferGeometry,
     PerspectiveCamera,
     PlaneBufferGeometry,
-    Sphere,
-    SphereBufferGeometry
+    Sphere
 } from "three";
 import { Sampler2D } from "../../texture/sampler/Sampler2D.js";
 import sampler2D2Canvas from "../../texture/sampler/Sampler2D2Canvas.js";
@@ -134,8 +133,13 @@ function make_sun({
 function prepare_scene_sphere_01(pt, camera) {
     camera.position.set(0, 0, -2.1);
     camera.lookAt(0, 0, 0);
+
+
+    const sphere_geo = new OctahedronBufferGeometry(1, 9);
+    makeGeometryIndexed(sphere_geo);
+
     pt.addMesh(
-        new SphereBufferGeometry(1, 16, 16),
+        sphere_geo,
         // new MeshStandardMaterial({ color: '#FF0000' }),
         new MeshStandardMaterial({ color: '#FFFFFF' }),
         Transform.fromJSON({
@@ -460,7 +464,7 @@ function* render(target, pt, camera, progress = { current: 0, total: 0 }) {
                             ray_direction.x, ray_direction.y, ray_direction.z
                         );
 
-                        pt.path_trace(out, ray, Infinity, 16, random);
+                        pt.path_trace(out, ray, Infinity, 4, random);
 
                         out2[0] += out[0];
                         out2[1] += out[1];
@@ -510,13 +514,13 @@ const camera = new PerspectiveCamera();
 async function start_renderer(camera) {
     camera.aspect = vCanvas.size.x / vCanvas.size.y;
 
-    const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
+    // const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
     // const path = 'data/models/road_bike/road_bike.gltf'; //large CAD-type model
 
     // await prepare_scene_lucy(pt, camera);
     // await prepare_scene_rtiow(pt, camera);
-    // await prepare_scene_sphere_01(pt, camera);
-    await prepare_scene_gltf(pt, camera, path);
+    await prepare_scene_sphere_01(pt, camera);
+    // await prepare_scene_gltf(pt, camera, path);
 
     pt.build();
     pt.optimize();

package/engine/graphics/texture/cubemap/load_environment_map.js

@@ -1,8 +1,8 @@
 import { EXRLoader } from "three/examples/jsm/loaders/EXRLoader.js";
 import { CubeTextureLoader, LinearFilter, PMREMGenerator, sRGBEncoding, TextureLoader, UnsignedByteType } from "three";
 import { noop } from "../../../../core/function/Functions.js";
-import { computeFileExtension } from "../../../../core/FilePath.js";
 import { HDRCubeTextureLoader } from "three/examples/jsm/loaders/HDRCubeTextureLoader.js";
+import { computeFileExtension } from "../../../../core/path/computeFileExtension.js";
 
 /**
  *

package/engine/graphics/util/makeMeshPreviewScene.js

@@ -15,39 +15,51 @@ import AABB2 from "../../../core/geom/AABB2.js";
 
 /**
  *
- * @param {Mesh} mesh trhee.js mesh
- * @param {Vector2} size
- * @param {AABB2} focus
- * @returns {{scene: Scene, camera: PerspectiveCamera}}
+ * @param {THREE.OrthographicCamera} camera
  */
-export function makeMeshPreviewScene(mesh, size, focus = new AABB2(0, 0, size.x, size.y)) {
-    const scene = new ThreeScene();
+function setShadowCamera(camera) {
+    const sqrt2 = Math.sqrt(2);
+    let sqrt2_2 = sqrt2 / 2;
+    camera.left = -sqrt2_2;
+    camera.right = sqrt2_2;
+
+    camera.bottom = -sqrt2_2;
+    camera.top = sqrt2_2;
+}
 
-    //lights
-    const l0 = new ThreeDirectionalLight(0xffffff, 1);
-    l0.position.set(-1, 1, 1);
-    l0.castShadow = true;
-    l0.shadow.mapSize.set(1024, 1024);
+/**
+ *
+ * @param {THREE.Scene} scene
+ */
+function setupLights(scene) {
+    const lightKey = new ThreeDirectionalLight(0xffffff, 1);
+    lightKey.position.set(-1, 1, 1);
+    lightKey.castShadow = true;
+    lightKey.shadow.mapSize.set(1024, 1024);
 
-    function setShadowCamera(camera) {
-        const sqrt2 = Math.sqrt(2);
-        let sqrt2_2 = sqrt2 / 2;
-        camera.left = -sqrt2_2;
-        camera.right = sqrt2_2;
 
-        camera.bottom = -sqrt2_2;
-        camera.top = sqrt2_2;
-    }
+    setShadowCamera(lightKey.shadow.camera);
+    scene.add(lightKey);
 
-    setShadowCamera(l0.shadow.camera);
-    scene.add(l0);
+    const lightHighlight = new ThreeDirectionalLight(0xffffff, 0.50);
+    lightHighlight.position.set(0, 0, 1);
+    scene.add(lightHighlight);
 
-    const l1 = new ThreeDirectionalLight(0xffffff, 0.50);
-    l1.position.set(0, 0, 1);
-    scene.add(l1);
+    const lightFill = new ThreeAmbientLight(0xFFFFFF, 0.5);
+    scene.add(lightFill);
+}
+
+/**
+ *
+ * @param {Mesh} mesh trhee.js mesh
+ * @param {Vector2} size
+ * @param {AABB2} focus
+ * @returns {{scene: Scene, camera: THREE.PerspectiveCamera}}
+ */
+export function makeMeshPreviewScene(mesh, size, focus = new AABB2(0, 0, size.x, size.y)) {
+    const scene = new ThreeScene();
 
-    const l2 = new ThreeAmbientLight(0xFFFFFF, 0.5);
-    scene.add(l2);
+    setupLights(scene);
 
     scaleObject3ToBox(mesh, new Vector3(1, 1, 1), mesh.scale);
     scene.add(mesh);