@woosh/meep-engine 2.36.26 → 2.36.29

package/engine/graphics/ecs/mesh-v2/render/optimization/RuntimeDrawMethodOptimizer.js

@@ -54,6 +54,12 @@ export class RuntimeDrawMethodOptimizer {
 
         const entity = next.value;
 
+        if (!ecd.entityExists(entity)) {
+            // seems that iterator is stale, reset iterator
+            this.__entity_iterator = null;
+            return false;
+        }
+
         /**
          *
          * @type {ShadedGeometry}
@@ -102,6 +108,11 @@ export class RuntimeDrawMethodOptimizer {
             return false;
         }
 
+        if (!adapters[best_adapter].intend_draw(sg)) {
+            // unable to draw, don't do anything
+            return false;
+        }
+
         sg.draw_method = best_adapter;
 
         return true;

package/engine/graphics/ecs/mesh-v2/sample/load_gltf.js

@@ -7,6 +7,7 @@ import { three_object_to_entity_composition } from "../three_object_to_entity_co
 import { AttachmentSystem } from "../../../../ecs/attachment/AttachmentSystem.js";
 import { TransformAttachmentSystem } from "../../../../ecs/transform-attachment/TransformAttachmentSystem.js";
 import { Camera } from "../../camera/Camera.js";
+import { MicronRenderPlugin } from "../../../micron/plugin/MicronRenderPlugin.js";
 
 const eh = new EngineHarness();
 
@@ -25,6 +26,8 @@ async function init(harness) {
     config.addSystem(new TransformAttachmentSystem());
     config.addLoader(GameAssetType.ModelGLTF_JSON, new GLTFAssetLoader());
 
+    config.addPlugin( MicronRenderPlugin);
+
     await config.apply(engine);
 
     eh.initialize().then(main);

package/engine/graphics/geometry/instancing/InstancedMeshGroup.js

@@ -78,6 +78,22 @@ export class InstancedMeshGroup {
          */
         this.__attributeTransformArray = null;
 
+
+        /**
+         *
+         * TODO implement usage
+         * @type {InstancedBufferAttribute}
+         * @private
+         */
+        this.__attributeColor = null;
+
+        /**
+         * TODO implement usage
+         * @type {Uint8Array}
+         * @private
+         */
+        this.__attributeColorArray = null;
+
         /**
          *
          * @type {Usage}
@@ -409,4 +425,19 @@ export class InstancedMeshGroup {
 
         this.mesh.geometry = geometry;
     }
+
+    /**
+     *
+     * @param {THREE.BufferGeometry} geometry
+     * @param {Material} material
+     * @returns {InstancedMeshGroup}
+     */
+    static from(geometry, material) {
+        const r = new InstancedMeshGroup();
+
+        r.setGeometry(geometry);
+        r.setMaterial(material);
+
+        return r;
+    }
 }

package/engine/graphics/micron/build/fill_patch_geometry_data.js

@@ -4,8 +4,8 @@ import { to_half_float_uint16 } from "../../../../core/binary/to_half_float_uint
 import { compute_micron_buffer_array_constructor } from "./compute_micron_buffer_array_constructor.js";
 import { typedArrayToDataType } from "../../../../core/collection/array/typedArrayToDataType.js";
 import { dataTypeByteSize } from "../../../../core/collection/table/DataTypeByteSizes.js";
-import { clamp } from "../../../../core/math/clamp.js";
 import { UintArrayForCount } from "../../../../core/collection/array/typed/uint_array_for_count.js";
+import { clamp01 } from "../../../../core/math/clamp01.js";
 
 /**
  * @param {number} vertex_count
@@ -82,7 +82,7 @@ function copy_attribute_data(vertex_count, index_map_backward, itemSize, attribu
  * @returns {number}
  */
 function resample_normalized_uint16_to_uint8(value) {
-    const normalized = clamp(value / 65535, 0, 1);
+    const normalized = clamp01(value / 65535);
 
     return Math.round(normalized * 255);
 }

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

@@ -37,13 +37,6 @@ export class MicronRenderPlugin extends EnginePlugin {
         layer.managed = true;
         layer.renderPass = RenderPassType.Opaque;
 
-        /**
-         *
-         * @type {RenderLayer|null}
-         * @private
-         */
-        this.__micron_render_layer = layer;
-
         this.__vgtr.on.contextAdded.add(ctx => {
             const visibleSet = layer.visibleSet;
 
@@ -54,8 +47,6 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         });
 
-        this.__view_observers = new Map();
-
         /**
          *
          * @type {AsyncRemoteHashMap}
@@ -97,55 +88,6 @@ export class MicronRenderPlugin extends EnginePlugin {
         this.__sg_system = null;
     }
 
-    /**
-     *
-     * @param {THREE.WebGLRenderer} renderer
-     * @param {THREE.Camera} camera
-     * @param {THREE.Object3D[]} elements
-     * @param element_count
-     */
-    render(renderer, camera, elements, element_count = elements.length) {
-        const vgtr = this.__vgtr;
-
-        vgtr.clear();
-
-        vgtr.attachMany(elements, element_count);
-
-        vgtr.update(renderer, camera);
-        vgtr.render();
-    }
-
-    /**
-     *
-     * @param {CameraView} view
-     * @private
-     */
-    __handle_view_added(view) {
-        const observer = () => {
-            const ge = this.engine.graphics;
-
-            this.render(ge.renderer, view.camera, view.visible_objects.elements, view.visible_objects.size);
-        };
-
-        this.__view_observers.set(view, observer);
-
-
-        view.on.preRender.add(observer);
-    }
-
-    /**
-     *
-     * @param {CameraView} view
-     * @private
-     */
-    __handle_view_removed(view) {
-        const observer = this.__view_observers.get(view);
-
-        this.__view_observers.delete(view);
-
-        view.on.preRender.remove(observer);
-    }
-
     /**
      *
      * @param {System} system
@@ -214,20 +156,6 @@ export class MicronRenderPlugin extends EnginePlugin {
         am.registerTransformer("model/gltf", this.__asset_transformer);
         am.registerTransformer("model/gltf+json", this.__asset_transformer);
 
-        /**
-         *
-         * @type {GraphicsEngine}
-         */
-        const ge = engine.graphics;
-
-        ge.layers.add(this.__micron_render_layer);
-
-        ge.views.elements.on.added.add(this.__handle_view_added, this);
-        ge.views.elements.on.removed.add(this.__handle_view_removed, this);
-
-        // link all views
-        ge.views.elements.forEach(this.__handle_view_added, this);
-
         this.__persisted_geometry.attach_storage(engine.storage);
 
         engine.entityManager.on.systemAdded.add(this.__handle_system_added, this);
@@ -250,16 +178,6 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         this.__asset_transformer.assetManager = null;
 
-        const ge = engine.graphics;
-
-        ge.layers.remove(this.__micron_render_layer);
-
-        ge.views.elements.on.added.remove(this.__handle_view_added, this);
-        ge.views.elements.on.removed.remove(this.__handle_view_removed, this);
-
-        // clear all observer
-        ge.views.elements.forEach(this.__handle_view_removed, this);
-
         engine.entityManager.on.systemAdded.remove(this.__handle_system_added, this);
         engine.entityManager.on.systemRemoved.remove(this.__handle_system_removed, this);
 

package/engine/graphics/micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js

@@ -56,13 +56,22 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
         return inverseLerp(MICRON_POLYCOUNT_THRESHOLD_MIN, MICRON_POLYCOUNT_THRESHOLD_MAX, polycount);
     }
 
-    add(sg) {
-
+    /**
+     *
+     * @param {ShadedGeometry} sg
+     * @returns {MicronGeometry}
+     * @private
+     */
+    __obtain_micron_geometry(sg) {
         const geometry_id = sg.geometry.id;
 
         const micron_geometry = this.__geometry_map.get(geometry_id);
 
-        if (micron_geometry === undefined) {
+        if (micron_geometry !== undefined) {
+
+            return micron_geometry;
+
+        } else {
             // no micron geometry
             if (!this.__geometry_building_promises.has(geometry_id)) {
                 const p = buildMicronGeometryFromBufferGeometry(sg.geometry);
@@ -71,6 +80,20 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
 
                 p.then(mg => this.__geometry_map.set(geometry_id, mg));
             }
+            return undefined;
+        }
+
+    }
+
+    intend_draw(sg) {
+        return this.__obtain_micron_geometry(sg) !== undefined;
+    }
+
+    add(sg) {
+        const micron_geometry = this.__obtain_micron_geometry(sg);
+
+        if (micron_geometry === undefined) {
+            // no micron geometry
             return;
         }
 
@@ -94,6 +117,8 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
      * @param {CameraView} view
      */
     build_start(renderer, view) {
+        this.__object_count = 0;
+
         const resolution = new Vector2();
         let pixelRatio = 1;
 

package/engine/graphics/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -28,7 +28,9 @@ import RenderSystem from "../../../../../../ecs/systems/RenderSystem.js";
 import { makeEngineOptionsModel } from "../../../../../../../../model/game/options/makeEngineOptionsModel.js";
 import { enableEditor } from "../../../../../../../editor/enableEditor.js";
 import { buildCubeURLs } from "../../../../../texture/cubemap/buildCubeURLs.js";
-import { AmbientOcclusionPostProcessEffect } from "../../../../../render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
+import {
+    AmbientOcclusionPostProcessEffect
+} from "../../../../../render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
 import Vector2 from "../../../../../../../core/geom/Vector2.js";
 import Vector3 from "../../../../../../../core/geom/Vector3.js";
 import EntityBuilder from "../../../../../../ecs/EntityBuilder.js";
@@ -49,7 +51,6 @@ import ViewportPosition from "../../../../../../ecs/gui/position/ViewportPositio
 import { CanvasView } from "../../../../../../../view/elements/CanvasView.js";
 import convertSampler2D2Canvas from "../../../../../texture/sampler/Sampler2D2Canvas.js";
 import Vector1 from "../../../../../../../core/geom/Vector1.js";
-import { clamp } from "../../../../../../../core/math/clamp.js";
 import { UnitCubeShape3D } from "../../../../../../../core/geom/3d/shape/UnitCubeShape3D.js";
 import { ShadedGeometrySystem } from "../../../../../ecs/mesh-v2/ShadedGeometrySystem.js";
 import { lut_to_sampler } from "./lut_to_sampler.js";
@@ -77,6 +78,7 @@ import { randomFloatBetween } from "../../../../../../../core/math/random/random
 import { MicronRenderPlugin } from "../../../../../micron/plugin/MicronRenderPlugin.js";
 import { obtainTerrain } from "../../../../../../ecs/terrain/util/obtainTerrain.js";
 import { pick } from "../../../../../../../ecs/grid/pick.js";
+import { clamp01 } from "../../../../../../../core/math/clamp01.js";
 
 const engineHarness = new EngineHarness();
 
@@ -1225,7 +1227,7 @@ async function make_demo_volume({
 
             const _t = pingpong(time_total + period_offset, period);
 
-            const f = clamp(_t / period, 0, 1);
+            const f = clamp01(_t / period);
 
             symbol.position.set(f);
 

package/engine/graphics/render/gizmo/Gizmo.js

@@ -0,0 +1,3 @@
+import { GizmoShapeRenderingInterface } from "./GizmoShapeRenderingInterface.js";
+
+export const Gizmo = GizmoShapeRenderingInterface.INSTANCE;

package/engine/graphics/render/gizmo/GizmoRenderingPlugin.js

@@ -0,0 +1,5 @@
+import { EnginePlugin } from "../../../plugin/EnginePlugin.js";
+
+export class GizmoRenderingPlugin extends EnginePlugin {
+
+}

package/engine/graphics/render/gizmo/GizmoShapeRenderingInterface.js

@@ -0,0 +1,91 @@
+import { array_copy } from "../../../../core/collection/array/copyArray.js";
+import { assert } from "../../../../core/assert.js";
+import { InstancedMeshGroup } from "../../geometry/instancing/InstancedMeshGroup.js";
+import { BoxBufferGeometry, MeshBasicMaterial } from "three";
+import { compose_matrix4_array } from "../../../../core/geom/3d/compose_matrix4_array.js";
+import Vector3 from "../../../../core/geom/Vector3.js";
+import Quaternion from "../../../../core/geom/Quaternion.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const scratch_m4 = [];
+
+export class GizmoShapeRenderingInterface {
+    constructor() {
+
+        /**
+         *
+         * @type {number[]}
+         * @private
+         */
+        this.__color = [1, 1, 1, 1];
+
+        this.__boxes_solid = InstancedMeshGroup.from(new BoxBufferGeometry(), new MeshBasicMaterial());
+    }
+
+    /**
+     * RGBA
+     * @param {number[]} color
+     */
+    set color(color) {
+        assert.defined(color, 'color');
+        assert.isArray(color, 'color');
+        assert.greaterThanOrEqual(color.length, 4);
+
+        array_copy(color, 0, this.__color, 0, 4);
+    }
+
+    /**
+     *
+     * @param {number[]} center
+     * @param {number[]} size
+     */
+    draw_solid_cube(center, size) {
+        compose_matrix4_array(scratch_m4, Vector3.fromArray(center), Quaternion.identity, Vector3.fromArray(size));
+        const i = this.__boxes_solid.count;
+
+        this.__boxes_solid.setCount(i + 1);
+        this.__boxes_solid.setTransformAt(i, scratch_m4);
+    }
+
+    /**
+     *
+     * @param {number[]} center
+     * @param {number[]} size
+     */
+    draw_wire_cube(center, size) {
+
+    }
+
+    /**
+     *
+     * @param {number[]} from
+     * @param {number[]} to
+     */
+    draw_line(from, to) {
+
+    }
+
+
+    /**
+     *
+     * @param {number[]} center
+     * @param {number} radius
+     */
+    draw_solid_sphere(center, radius) {
+
+    }
+
+    /**
+     *
+     * @param {number[]} center
+     * @param {number} radius
+     */
+    draw_wire_sphere() {
+
+    }
+}
+
+GizmoShapeRenderingInterface.INSTANCE = new GizmoShapeRenderingInterface();

package/engine/graphics/texture/sampler/Sampler2D.js

@@ -10,6 +10,7 @@ import { mix } from "../../../../core/math/mix.js";
 import { BlendingType } from "./BlendingType.js";
 import { assert } from "../../../../core/assert.js";
 import { typedArrayConstructorByInstance } from "./typedArrayConstructorByInstance.js";
+import { fract } from "../../../../core/math/fract.js";
 
 function v2CrossMag(ax, ay, bx, by) {
     return ax * by - ay * bx;
@@ -530,17 +531,18 @@ Sampler2D.prototype.get = function (x, y, result) {
 };
 
 /**
- * Based on code from From reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
- * @param {number} t
- * @param {number} a
- * @param {number} b
- * @param {number} c
- * @param {number} d
- * @returns {number}
+ *
+ * @param {number} u
+ * @param {number} v
+ * @param {number[]} result
  */
-function bicubic_terp(t, a, b, c, d) {
-    return 0.5 * (c - a + (2.0 * a - 5.0 * b + 4.0 * c - d + (3.0 * (b - c) + d - a) * t) * t) * t + b;
-}
+Sampler2D.prototype.sampleCatmullRomUV = function (u, v, result) {
+    const itemSize = this.itemSize;
+
+    for (let i = 0; i < itemSize; i++) {
+        result[i] = this.sampleChannelCatmullRomUV(u, v, i);
+    }
+};
 
 /**
  *
@@ -549,13 +551,87 @@ function bicubic_terp(t, a, b, c, d) {
  * @param {number} channel
  * @returns {number}
  */
-Sampler2D.prototype.sampleChannelBicubicUV = function (u, v, channel) {
+Sampler2D.prototype.sampleChannelCatmullRomUV = function (u, v, channel) {
     const x = u * (this.width - 1);
     const y = v * (this.height - 1);
 
-    return this.sampleChannelBicubic(x, y, channel);
+    return this.sampleChannelCatmullRom(x, y, channel);
 };
 
+/**
+ *
+ * @see https://www.shadertoy.com/view/NsBfRG
+ * @see https://www.decarpentier.nl/2d-catmull-rom-in-4-samples
+ * @param {number} x
+ * @param {number} y
+ * @param {number} channel
+ * @returns {number}
+ */
+Sampler2D.prototype.sampleChannelCatmullRom = function (x, y, channel) {
+    // Based on the standard Catmull-Rom spline: w1*C1+w2*C2+w3*C3+w4*C4, where
+    // w1 = ((-0.5*f + 1.0)*f - 0.5)*f, w2 = (1.5*f - 2.5)*f*f + 1.0,
+    // w3 = ((-1.5*f + 2.0)*f + 0.5)*f and w4 = (0.5*f - 0.5)*f*f with f as the
+    // normalized interpolation position between C2 (at f=0) and C3 (at f=1).
+
+    // half_f is a sort of sub-pixelquad fraction, -1 <= half_f < 1.
+    const half_f_x = 2.0 * fract(0.5 * x - 0.25) - 1.0;
+    const half_f_y = 2.0 * fract(0.5 * y - 0.25) - 1.0;
+
+    // f is the regular sub-pixel fraction, 0 <= f < 1. This is equivalent to
+    // fract(uv * texSize - 0.5), but based on half_f to prevent rounding issues.
+    const f_x = fract(half_f_x);
+    const f_y = fract(half_f_y);
+
+    const s1_x = (0.5 * f_x - 0.5) * f_x;            // = w1 / (1 - f)
+    const s1_y = (0.5 * f_y - 0.5) * f_y;            // = w1 / (1 - f)
+
+    const s12_x = (-2.0 * f_x + 1.5) * f_x + 1.0;      // = (w2 - w1) / (1 - f)
+    const s12_y = (-2.0 * f_y + 1.5) * f_y + 1.0;      // = (w2 - w1) / (1 - f)
+
+    const s34_x = (2.0 * f_x - 2.5) * f_x - 0.5;      // = (w4 - w3) / f
+    const s34_y = (2.0 * f_y - 2.5) * f_y - 0.5;      // = (w4 - w3) / f
+
+    // positions is equivalent to: (floor(uv * texSize - 0.5).xyxy + 0.5 +
+    // vec4(-1.0 + w2 / (w2 - w1), 1.0 + w4 / (w4 - w3))) / texSize.xyxy.
+    const positions_x = (-f_x * s12_x + s1_x) / (s12_x) + x;
+    const positions_y = (-f_y * s12_y + s1_y) / (s12_y) + y;
+    const positions_z = (-f_x * s34_x + s1_x + s34_x) / (s34_x) + x;
+    const positions_w = (-f_y * s34_y + s1_y + s34_y) / (s34_y) + y;
+
+    // Determine if the output needs to be sign-flipped. Equivalent to .x*.y of
+    // (1.0 - 2.0 * floor(t - 2.0 * floor(0.5 * t))), where t is uv * texSize - 0.5.
+    const sign_flip = half_f_x * half_f_y > 0.0 ? 1.0 : -1.0;
+
+    // = (w2 - w1, w4 - w3)
+    const w_x = -f_x * s12_x + s12_x;
+    const w_y = -f_y * s12_y + s12_y;
+    const w_z = s34_x * f_x
+    const w_w = s34_y * f_y
+
+    const weights_x = w_x * w_y * sign_flip;
+    const weights_y = w_z * w_y * sign_flip;
+    const weights_z = w_x * w_w * sign_flip;
+    const weights_w = w_z * w_w * sign_flip;
+
+    return this.sampleChannelBilinear(positions_x, positions_y, channel) * weights_x +
+        this.sampleChannelBilinear(positions_z, positions_y, channel) * weights_y +
+        this.sampleChannelBilinear(positions_x, positions_w, channel) * weights_z +
+        this.sampleChannelBilinear(positions_z, positions_w, channel) * weights_w;
+}
+
+/**
+ * Based on code from From reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
+ * @param {number} t
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @returns {number}
+ */
+function bicubic_terp(t, a, b, c, d) {
+    return 0.5 * (c - a + (2.0 * a - 5.0 * b + 4.0 * c - d + (3.0 * (b - c) + d - a) * t) * t) * t + b;
+}
+
 /**
  *
  * @param {number} u
@@ -570,6 +646,20 @@ Sampler2D.prototype.sampleBicubicUV = function (u, v, result) {
     }
 };
 
+/**
+ *
+ * @param {number} u
+ * @param {number} v
+ * @param {number} channel
+ * @returns {number}
+ */
+Sampler2D.prototype.sampleChannelBicubicUV = function (u, v, channel) {
+    const x = u * (this.width - 1);
+    const y = v * (this.height - 1);
+
+    return this.sampleChannelBicubic(x, y, channel);
+};
+
 /**
  * Bicubic-filtered sampling
  * @param {number} x
@@ -687,7 +777,6 @@ Sampler2D.prototype.sampleChannelBilinearUV = function (u, v, channel) {
     return this.sampleChannelBilinear(x, y, channel);
 };
 
-
 /**
  *
  * @param {number} x
@@ -1287,15 +1376,18 @@ Sampler2D.prototype.zeroFill = function (x, y, width, height) {
  */
 Sampler2D.prototype.fill = function (x, y, width, height, value) {
 
-    const x0 = clamp(x, 0, this.width);
-    const y0 = clamp(y, 0, this.height);
-    const x1 = clamp(x + width, 0, this.width);
-    const y1 = clamp(y + height, 0, this.height);
+    const _w = this.width;
+    const _h = this.height;
+
+    const x0 = clamp(x, 0, _w);
+    const y0 = clamp(y, 0, _h);
+    const x1 = clamp(x + width, 0, _w);
+    const y1 = clamp(y + height, 0, _h);
 
     const data = this.data;
     const itemSize = this.itemSize;
 
-    const rowSize = itemSize * this.width;
+    const rowSize = itemSize * _w;
 
     let _y, _x, i;
 

package/engine/graphics/three/OrbitControls.js

@@ -8,6 +8,7 @@
 
 
 import * as THREE from 'three';
+import { DEG_TO_RAD } from "../../../core/math/DEG_TO_RAD.js";
 
 // This set of controls performs orbiting, dollying (zooming), and panning.
 // Unlike TrackballControls, it maintains the "up" direction object.up (+Y by default).
@@ -360,7 +361,7 @@ function OrbitControls(object, domElement) {
                 var targetDistance = offset.length();
 
                 // half of the fov is center to top of screen
-                targetDistance *= Math.tan((scope.object.fov / 2) * Math.PI / 180.0);
+                targetDistance *= Math.tan((scope.object.fov / 2) * DEG_TO_RAD);
 
                 // we use only clientHeight here so aspect ratio does not distort speed
                 panLeft(2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix);
@@ -1041,4 +1042,4 @@ Object.defineProperties(OrbitControls.prototype, {
 
 });
 
-export { OrbitControls };
+export { OrbitControls };

package/engine/graphics/trail/x/simulator/RibbonXFixedPhysicsSimulator.js

@@ -1,5 +1,5 @@
-import { clamp } from "../../../../../core/math/clamp.js";
 import { RIBBON_ATTRIBUTE_ADDRESS_AGE, RIBBON_ATTRIBUTE_ADDRESS_UV_OFFSET } from "../ribbon_attributes_spec.js";
+import { clamp01 } from "../../../../../core/math/clamp01.js";
 
 /**
  * Fixed function simulation engine for ribbons
@@ -22,7 +22,7 @@ export class RibbonXFixedPhysicsSimulator {
             // age the ribbon
             const age = ribbon.incrementPointAttribute_Scalar(i, RIBBON_ATTRIBUTE_ADDRESS_AGE, timeDelta);
 
-            const relative_age = clamp(age / max_age, 0, 1);
+            const relative_age = clamp01(age / max_age);
 
             // apply alpha over-time
             ribbon.setPointAlpha(i, 1.0 - relative_age);

package/engine/graphics/util/makeMeshPreviewScene.js

@@ -1,8 +1,16 @@
-import { AmbientLight as ThreeAmbientLight, Box3, DirectionalLight as ThreeDirectionalLight, PerspectiveCamera as ThreePerspectiveCamera, Scene as ThreeScene, Vector3 as ThreeVector3 } from "three";
+import {
+    AmbientLight as ThreeAmbientLight,
+    Box3,
+    DirectionalLight as ThreeDirectionalLight,
+    PerspectiveCamera as ThreePerspectiveCamera,
+    Scene as ThreeScene,
+    Vector3 as ThreeVector3
+} from "three";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { rootObject3DFastMatrixUpdate } from "../ecs/mesh/rootObject3DFastMatrixUpdate.js";
 import { computeMeshPreviewCameraDistance } from "./computeMeshPreviewCameraDistance.js";
 import { scaleObject3ToBox } from "./ScaleObject3ToBox.js";
+import { DEG_TO_RAD } from "../../../core/math/DEG_TO_RAD.js";
 
 /**
  *
@@ -62,7 +70,7 @@ export function makeMeshPreviewScene(mesh, size, focus) {
     const focusHeight = (focus.y1 - focus.y0);
 
 
-    const fov = camera.fov * (Math.PI / 180);
+    const fov = camera.fov * DEG_TO_RAD;
     const distance = computeMeshPreviewCameraDistance(focusHeight, fov, bBox.max.z);
 
     const cameraPositionX = focus.x0 + (focus.x1 - focus.x0) / 2 - 0.5;
@@ -76,4 +84,4 @@ export function makeMeshPreviewScene(mesh, size, focus) {
     // camera.far = bBox.size.z * mesh.scale.z+distance;
 
     return { scene: scene, camera: camera };
-}
+}