@woosh/meep-engine 2.33.2 → 2.33.6

package/engine/graphics/render/buffer/buffers/ColorAndDepthFrameBuffer.js

@@ -1,9 +1,10 @@
 import { FrameBuffer } from "../FrameBuffer.js";
 import {
+    DepthFormat,
     DepthTexture,
     FloatType,
     NearestFilter,
-    RGBAFormat,
+    RGBFormat,
     sRGBEncoding,
     Vector2,
     WebGLMultisampleRenderTarget
@@ -39,9 +40,9 @@ export class ColorAndDepthFrameBuffer extends FrameBuffer {
 
         renderer.getSize(size);
 
-        const target = new WebGLMultisampleRenderTarget(size.x, size.y);
+        const target = new WebGLMultisampleRenderTarget(size.x, size.y,{ignoreDepth: false});
 
-        target.texture.format = RGBAFormat; // note, three.js required RGBA render texture, even though RGB would do here
+        target.texture.format = RGBFormat; // note, three.js required RGBA render texture, even though RGB would do here
         target.texture.minFilter = NearestFilter;
         target.texture.magFilter = NearestFilter;
         target.texture.generateMipmaps = false;
@@ -51,6 +52,7 @@ export class ColorAndDepthFrameBuffer extends FrameBuffer {
         target.depthBuffer = true;
 
         target.depthTexture = new DepthTexture();
+        target.depthTexture.format = DepthFormat;
         target.depthTexture.type = FloatType;
         target.depthTexture.generateMipmaps = false;
         target.depthTexture.internalFormat = 'DEPTH_COMPONENT32F';

package/engine/graphics/render/buffer/buffers/NormalFrameBuffer.js

@@ -52,11 +52,15 @@ export class NormalFrameBuffer extends FrameBuffer {
         this.__material_skinned.side = DoubleSide;
 
 
+        const scene = new Scene();
         /**
          * @type {Scene}
          * @private
          */
-        this.__scene = new Scene();
+        this.__scene = scene;
+        scene.autoUpdate = false;
+        scene.matrixAutoUpdate = false;
+        scene.matrixWorldNeedsUpdate = false;
     }
 
 
@@ -90,7 +94,13 @@ export class NormalFrameBuffer extends FrameBuffer {
 
             if (source_material !== undefined) {
                 // assign normal map and color map
-                target_material.map = source_material.map;
+
+                if (source_material.alphaTest > 0) {
+                    target_material.map = source_material.map;
+                } else {
+                    target_material.map = null;
+                }
+
                 target_material.normalMap = source_material.normalMap;
             }
         }

package/engine/graphics/render/buffer/buffers/prototypeNormalFrameBuffer.js

@@ -50,8 +50,6 @@ import { enableEditor } from "../../../../../editor/enableEditor.js";
 import EntityBuilder from "../../../../ecs/EntityBuilder.js";
 import { Transform } from "../../../../ecs/transform/Transform.js";
 import Mesh from "../../../ecs/mesh/Mesh.js";
-import ViewportPosition from "../../../../ecs/gui/position/ViewportPosition.js";
-import GUIElement from "../../../../ecs/gui/GUIElement.js";
 import { CopyShader } from "three/examples/jsm/shaders/CopyShader.js";
 import {
     DoubleSide,
@@ -64,11 +62,11 @@ import {
     UniformsUtils,
     WebGLRenderTarget
 } from "three";
-import { buildCubeURLs } from "../../../GraphicsEngine.js";
 import { AmbientOcclusionPostProcessEffect } from "../simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
 import { PathDisplaySystem } from "../../../ecs/path/PathDisplaySystem.js";
 import { MicronRenderPlugin } from "../../../micron/plugin/MicronRenderPlugin.js";
 import { StandardFrameBuffers } from "../../../StandardFrameBuffers.js";
+import { buildCubeURLs } from "../../../texture/cubemap/buildCubeURLs.js";
 
 const engineHarness = new EngineHarness();
 
@@ -386,13 +384,13 @@ function main(engine) {
     //     .build(ecd);
 
     // const canvasView = makeCameraClippingDebug(engine);
-
-    new EntityBuilder()
-        .add(ViewportPosition.fromJSON({
-            offset: new Vector2(10, 10)
-        }))
-        .add(GUIElement.fromView(canvasView))
-        .build(ecd);
+    //
+    // new EntityBuilder()
+    //     .add(ViewportPosition.fromJSON({
+    //         offset: new Vector2(10, 10)
+    //     }))
+    //     .add(GUIElement.fromView(canvasView))
+    //     .build(ecd);
 
 
 }

package/engine/graphics/render/forward_plus/LightManager.js

@@ -11,15 +11,13 @@ import { compute_light_data_hash_0 } from "./cluster/compute_light_data_hash_0.j
 import { read_plane_pair } from "./cluster/read_plane_pair.js";
 import { read_frustum_planes_to_array } from "./cluster/read_frustum_planes_to_array.js";
 import { compute_cluster_planes_from_points } from "./cluster/compute_cluster_planes_from_points.js";
-import {
-    computeDataType,
-    computeThreeTextureInternalFormatFromDataType,
-    computeThreeTextureTypeFromDataType,
-    NumericType,
-    TextureBackedMemoryRegion
-} from "./TextureBackedMemoryRegion.js";
+import { TextureBackedMemoryRegion } from "./data/TextureBackedMemoryRegion.js";
 import { assert } from "../../../../core/assert.js";
 import { DataType2TypedArrayConstructorMapping } from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+import { NumericType } from "./data/NumericType.js";
+import { computeDataType } from "./data/computeDataType.js";
+import { computeThreeTextureTypeFromDataType } from "./data/computeThreeTextureTypeFromDataType.js";
+import { computeThreeTextureInternalFormatFromDataType } from "./data/computeThreeTextureInternalFormatFromDataType.js";
 
 const LOOKUP_CACHE_SIZE = 16384; // must be power of two
 /**

package/engine/graphics/render/forward_plus/data/NumericType.js

@@ -0,0 +1,9 @@
+/**
+ *
+ * @enum {number}
+ */
+export const NumericType = {
+    Uint: 0,
+    Int: 1,
+    Float: 2
+};

package/engine/graphics/render/forward_plus/{TextureBackedMemoryRegion.js → data/TextureBackedMemoryRegion.js}

@@ -1,36 +1,14 @@
-import {
-    ByteType,
-    DataTexture,
-    FloatType,
-    HalfFloatType,
-    IntType,
-    NearestFilter,
-    RedFormat,
-    RedIntegerFormat,
-    RGBAIntegerFormat,
-    RGBIntegerFormat,
-    RGIntegerFormat,
-    ShortType,
-    UnsignedByteType,
-    UnsignedIntType,
-    UnsignedShortType
-} from "three";
-import { DataType } from "../../../../core/collection/table/DataType.js";
-import { assert } from "../../../../core/assert.js";
-import { DataType2TypedArrayConstructorMapping } from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
-import { max2 } from "../../../../core/math/max2.js";
-import { channelCountToThreeTextureFormat } from "../../texture/channelCountToThreeTextureFormat.js";
-import { DataTypeByteSizes } from "../../../../core/collection/table/RowFirstTableSpec.js";
-
-/**
- *
- * @enum {number}
- */
-export const NumericType = {
-    Uint: 0,
-    Int: 1,
-    Float: 2
-};
+import { DataTexture, NearestFilter, RedFormat, UnsignedByteType } from "three";
+import { DataType } from "../../../../../core/collection/table/DataType.js";
+import { assert } from "../../../../../core/assert.js";
+import { DataType2TypedArrayConstructorMapping } from "../../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+import { max2 } from "../../../../../core/math/max2.js";
+import { DataTypeByteSizes } from "../../../../../core/collection/table/RowFirstTableSpec.js";
+import { NumericType } from "./NumericType.js";
+import { computeDataType } from "./computeDataType.js";
+import { computeThreeTextureTypeFromDataType } from "./computeThreeTextureTypeFromDataType.js";
+import { computeThreeTextureInternalFormatFromDataType } from "./computeThreeTextureInternalFormatFromDataType.js";
+import { computeThreeTextureFormat } from "./computeThreeTextureFormat.js";
 
 /**
  * How wide a data texture is
@@ -42,163 +20,6 @@ const SHRINK_FACTOR = 0.5;
 const GROW_FACTOR = 1.05;
 
 
-/**
- *
- * @param {NumericType} type
- * @param {number} precision
- * @returns {DataType}
- */
-export function computeDataType(type, precision) {
-    if (type === NumericType.Uint) {
-        if (precision <= 8) {
-            return DataType.Uint8;
-        } else if (precision <= 16) {
-            return DataType.Uint16;
-        } else if (precision <= 32) {
-            return DataType.Uint32;
-        }
-    } else if (type === NumericType.Int) {
-        if (precision <= 8) {
-            return DataType.Int8;
-        } else if (precision <= 16) {
-            return DataType.Int16;
-        } else if (precision <= 32) {
-            return DataType.Int32;
-        }
-    } else if (type === NumericType.Float) {
-        if (precision <= 32) {
-            return DataType.Float32;
-        } else if (precision <= 64) {
-            return DataType.Float64;
-        }
-    }
-
-    throw new Error(`Unsupported numeric type(=${type}) and precision(=${precision}) combination`);
-}
-
-/**
- *
- * @param {DataType} dt
- * @returns {number}
- */
-export function computeThreeTextureTypeFromDataType(dt) {
-    switch (dt) {
-        case DataType.Uint8:
-            return UnsignedByteType;
-        case DataType.Uint16:
-            return UnsignedShortType;
-        case DataType.Uint32:
-            return UnsignedIntType;
-        case DataType.Int8:
-            return ByteType;
-        case DataType.Int16:
-            return ShortType;
-        case DataType.Int32:
-            return IntType;
-        case DataType.Float16:
-            return HalfFloatType;
-        case DataType.Float32:
-            return FloatType;
-        case DataType.Float64:
-            return FloatType;
-        default:
-            throw new Error(`Unsupported data type '${dt}'`);
-    }
-}
-
-
-/**
- *
- * @param {DataType} dt
- * @param {number} channel_count
- * @returns {string|THREE.PixelFormatGPU}
- */
-export function computeThreeTextureInternalFormatFromDataType(dt, channel_count) {
-    let suffix = '';
-    switch (dt) {
-        case DataType.Uint8:
-            suffix = '8UI';
-            break;
-        case DataType.Uint16:
-            suffix = '16UI';
-            break;
-        case DataType.Uint32:
-            suffix = '32UI';
-            break;
-        case DataType.Int8:
-            suffix = '8I';
-            break;
-        case DataType.Int16:
-            suffix = '16I';
-            break;
-        case DataType.Int32:
-            suffix = '32I';
-            break;
-        case DataType.Float16:
-            suffix = '16F';
-            break;
-        case DataType.Float32:
-            suffix = '32F';
-            break;
-        case DataType.Float64:
-            suffix = '64F';
-            break;
-        default:
-            throw new Error(`Unsupported data type '${dt}'`);
-    }
-
-    let prefix = '';
-
-    switch (channel_count) {
-        case 1:
-            prefix = 'R';
-            break;
-        case 2:
-            prefix = 'RG';
-            break;
-        case 3:
-            prefix = 'RGB';
-            break;
-        case 4:
-            prefix = 'RGBA';
-            break;
-        default:
-            throw new Error(`Unsupported channel count '${channel_count}'`);
-    }
-
-    return prefix + suffix;
-}
-
-function channelCountToThreIntegerTextureType(channel_count) {
-    switch (channel_count) {
-        case 1:
-            return RedIntegerFormat;
-        case 2:
-            return RGIntegerFormat;
-        case 3:
-            return RGBIntegerFormat;
-        case 4:
-            return RGBAIntegerFormat;
-        default:
-            throw new Error(`Unsupported channel count '${channel_count}'`);
-    }
-}
-
-/**
- *
- * @param {NumericType} type
- * @param {number} channel_count
- */
-function computeThreeTextureFormat(type, channel_count) {
-    if (type === NumericType.Uint || type === NumericType.Int) {
-        return channelCountToThreIntegerTextureType(channel_count);
-    } else if (type === NumericType.Float) {
-        return channelCountToThreeTextureFormat(channel_count);
-    } else {
-        throw new Error(`Unsupported numeric type '${type}'`);
-    }
-}
-
 export class TextureBackedMemoryRegion {
 
     constructor() {

package/engine/graphics/render/forward_plus/data/channelCountToThreIntegerTextureType.js

@@ -0,0 +1,16 @@
+import { RedIntegerFormat, RGBAIntegerFormat, RGBIntegerFormat, RGIntegerFormat } from "three";
+
+export function channelCountToThreIntegerTextureType(channel_count) {
+    switch (channel_count) {
+        case 1:
+            return RedIntegerFormat;
+        case 2:
+            return RGIntegerFormat;
+        case 3:
+            return RGBIntegerFormat;
+        case 4:
+            return RGBAIntegerFormat;
+        default:
+            throw new Error(`Unsupported channel count '${channel_count}'`);
+    }
+}

package/engine/graphics/render/forward_plus/data/computeDataType.js

@@ -0,0 +1,36 @@
+import { NumericType } from "./NumericType.js";
+import { DataType } from "../../../../../core/collection/table/DataType.js";
+
+/**
+ *
+ * @param {NumericType} type
+ * @param {number} precision
+ * @returns {DataType}
+ */
+export function computeDataType(type, precision) {
+    if (type === NumericType.Uint) {
+        if (precision <= 8) {
+            return DataType.Uint8;
+        } else if (precision <= 16) {
+            return DataType.Uint16;
+        } else if (precision <= 32) {
+            return DataType.Uint32;
+        }
+    } else if (type === NumericType.Int) {
+        if (precision <= 8) {
+            return DataType.Int8;
+        } else if (precision <= 16) {
+            return DataType.Int16;
+        } else if (precision <= 32) {
+            return DataType.Int32;
+        }
+    } else if (type === NumericType.Float) {
+        if (precision <= 32) {
+            return DataType.Float32;
+        } else if (precision <= 64) {
+            return DataType.Float64;
+        }
+    }
+
+    throw new Error(`Unsupported numeric type(=${type}) and precision(=${precision}) combination`);
+}

package/engine/graphics/render/forward_plus/data/computeThreeTextureFormat.js

@@ -0,0 +1,18 @@
+import { NumericType } from "./NumericType.js";
+import { channelCountToThreIntegerTextureType } from "./channelCountToThreIntegerTextureType.js";
+import { channelCountToThreeTextureFormat } from "../../../texture/channelCountToThreeTextureFormat.js";
+
+/**
+ *
+ * @param {NumericType} type
+ * @param {number} channel_count
+ */
+export function computeThreeTextureFormat(type, channel_count) {
+    if (type === NumericType.Uint || type === NumericType.Int) {
+        return channelCountToThreIntegerTextureType(channel_count);
+    } else if (type === NumericType.Float) {
+        return channelCountToThreeTextureFormat(channel_count);
+    } else {
+        throw new Error(`Unsupported numeric type '${type}'`);
+    }
+}

package/engine/graphics/render/forward_plus/data/computeThreeTextureInternalFormatFromDataType.js

@@ -0,0 +1,63 @@
+import { DataType } from "../../../../../core/collection/table/DataType.js";
+
+/**
+ *
+ * @param {DataType} dt
+ * @param {number} channel_count
+ * @returns {string|THREE.PixelFormatGPU}
+ */
+export function computeThreeTextureInternalFormatFromDataType(dt, channel_count) {
+    let suffix = '';
+    switch (dt) {
+        case DataType.Uint8:
+            suffix = '8UI';
+            break;
+        case DataType.Uint16:
+            suffix = '16UI';
+            break;
+        case DataType.Uint32:
+            suffix = '32UI';
+            break;
+        case DataType.Int8:
+            suffix = '8I';
+            break;
+        case DataType.Int16:
+            suffix = '16I';
+            break;
+        case DataType.Int32:
+            suffix = '32I';
+            break;
+        case DataType.Float16:
+            suffix = '16F';
+            break;
+        case DataType.Float32:
+            suffix = '32F';
+            break;
+        case DataType.Float64:
+            suffix = '64F';
+            break;
+        default:
+            throw new Error(`Unsupported data type '${dt}'`);
+    }
+
+    let prefix = '';
+
+    switch (channel_count) {
+        case 1:
+            prefix = 'R';
+            break;
+        case 2:
+            prefix = 'RG';
+            break;
+        case 3:
+            prefix = 'RGB';
+            break;
+        case 4:
+            prefix = 'RGBA';
+            break;
+        default:
+            throw new Error(`Unsupported channel count '${channel_count}'`);
+    }
+
+    return prefix + suffix;
+}

package/engine/graphics/render/forward_plus/data/computeThreeTextureTypeFromDataType.js

@@ -0,0 +1,41 @@
+import { DataType } from "../../../../../core/collection/table/DataType.js";
+import {
+    ByteType,
+    FloatType,
+    HalfFloatType,
+    IntType,
+    ShortType,
+    UnsignedByteType,
+    UnsignedIntType,
+    UnsignedShortType
+} from "three";
+
+/**
+ *
+ * @param {DataType} dt
+ * @returns {number}
+ */
+export function computeThreeTextureTypeFromDataType(dt) {
+    switch (dt) {
+        case DataType.Uint8:
+            return UnsignedByteType;
+        case DataType.Uint16:
+            return UnsignedShortType;
+        case DataType.Uint32:
+            return UnsignedIntType;
+        case DataType.Int8:
+            return ByteType;
+        case DataType.Int16:
+            return ShortType;
+        case DataType.Int32:
+            return IntType;
+        case DataType.Float16:
+            return HalfFloatType;
+        case DataType.Float32:
+            return FloatType;
+        case DataType.Float64:
+            return FloatType;
+        default:
+            throw new Error(`Unsupported data type '${dt}'`);
+    }
+}

package/engine/graphics/render/forward_plus/plugin/ptototypeFPPlugin.js

@@ -45,7 +45,6 @@ import { SerializationMetadataSystem } from "../../../../ecs/systems/Serializati
 import { InverseKinematicsSystem } from "../../../../ecs/animation/InverseKinematicsSystem.js";
 import { PathDisplaySystem } from "../../../ecs/path/PathDisplaySystem.js";
 import { Line, LineBasicMaterial, MeshStandardMaterial, TorusKnotBufferGeometry } from "three";
-import { buildCubeURLs } from "../../../GraphicsEngine.js";
 import RenderSystem from "../../../../ecs/systems/RenderSystem.js";
 import { makeEngineOptionsModel } from "../../../../../../model/game/options/makeEngineOptionsModel.js";
 import { enableEditor } from "../../../../../editor/enableEditor.js";
@@ -77,6 +76,7 @@ import { GameAssetType } from "../../../../asset/GameAssetType.js";
 import { GLTFAssetLoader } from "../../../../asset/loaders/GLTFAssetLoader.js";
 import { ImageRGBADataLoader } from "../../../../asset/loaders/image/ImageRGBADataLoader.js";
 import { MicronRenderPlugin } from "../../../micron/plugin/MicronRenderPlugin.js";
+import { buildCubeURLs } from "../../../texture/cubemap/buildCubeURLs.js";
 
 const engineHarness = new EngineHarness();
 

package/engine/graphics/render/forward_plus/prototypeLightManager.js

@@ -233,7 +233,7 @@ function prepare_scene_0() {
 
     controls.minDistance = 2;
 
-    for (let i = 0; i < 5000; i++) {
+    for (let i = 0; i < 500; i++) {
         const radius = randomFloatBetween(random, 4, 4);
         const intensity = randomFloatBetween(random, 2, 2);
         addPointLight([

package/engine/graphics/render/utils/ThreeBypassRenderer.js

@@ -107,14 +107,12 @@ export class ThreeBypassRenderer {
 
                         mesh.matrix.copy(object3D.matrix);
                         mesh.matrixWorld.copy(object3D.matrixWorld);
-                        // mesh.modelViewMatrix.copy(object3D.modelViewMatrix);
+                        mesh.normalMatrix.copy(object3D.normalMatrix);
 
                         scene_children[j++] = mesh;
                         mesh.parent = scene;
 
                     }
-                } else if (object3D.isMicronMesh) {
-                    // scene_children[j++] = object3D;
                 }
             }