@woosh/meep-engine 2.37.17 → 2.37.20

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -46,7 +46,7 @@ import { StaticMaterialCache } from "../../asset/loaders/material/StaticMaterial
 import convertSampler2D2Canvas from "../texture/sampler/Sampler2D2Canvas.js";
 import { CanvasView } from "../../../view/elements/CanvasView.js";
 import { Sampler2D } from "../texture/sampler/Sampler2D.js";
-import { downsampleSampler2D } from "../texture/sampler/downsampleSampler2D.js";
+import { sampler2D_scale_down_linear } from "../texture/sampler/sampler2D_scale_down_linear.js";
 import { ShadowMapRenderer } from "../shadows/ShadowMapRenderer.js";
 import { mat4 } from "gl-matrix";
 
@@ -129,7 +129,7 @@ function debug_shadow_map() {
 
     const resampled = Sampler2D.uint8(4, 512, 512);
 
-    downsampleSampler2D(sampler, resampled);
+    sampler2D_scale_down_linear(sampler, resampled);
 
     convertSampler2D2Canvas(resampled, 1, 0, cv.el);
 

package/engine/graphics/micron/render/instanced/shader/shader_rewrite_standard.js

@@ -187,17 +187,17 @@ export function shader_rewrite_standard(shader, uniforms, spec, column_count) {
     }
 
     // shader.defines.USE_COLOR  = true;
-
+    //
     // rewrittenVertexShader = rewrittenVertexShader.replace(
     //     '#include <color_vertex>',
     //     `
     //     #include <color_vertex>
-    //              vColor = vec3(1.0);
-    //              //vColor.xyz = vec3(
-    //              //       sin(float(micron_patch_address)*123.1),
-    //              //       sin(float(micron_patch_address)*11.7),
-    //              //       sin(float(micron_patch_address)*932.183)
-    //              //       );
+    //              //vColor = vec3(1.0);
+    //              vColor.xyz = vec3(
+    //                     sin(float(micron_patch_address)*123.1),
+    //                     sin(float(micron_patch_address)*11.7),
+    //                     sin(float(micron_patch_address)*932.183)
+    //                     );
     //             `
     // );
 
@@ -229,16 +229,16 @@ export function shader_rewrite_standard(shader, uniforms, spec, column_count) {
 
         shader.fragmentShader = shader.fragmentShader.replace(
             '#include <dithering_fragment>',
-            // `gl_FragColor.rgb =  vec3(
-            //           sin(v_micron_patch_address*123.1)*0.5 + 0.5,
-            //           sin(v_micron_patch_address*11.7)*0.5 + 0.5,
-            //           sin(v_micron_patch_address*932.183)*0.5 + 0.5
-            // );`
             `gl_FragColor.rgb =  vec3(
-                      sin(v_micron_instance_id*123.1)*0.5 + 0.5,
-                      sin(v_micron_instance_id*11.7)*0.5 + 0.5,
-                      sin(v_micron_instance_id*932.183)*0.5 + 0.5
+                      sin(v_micron_patch_address*123.1)*0.5 + 0.5,
+                      sin(v_micron_patch_address*11.7)*0.5 + 0.5,
+                      sin(v_micron_patch_address*932.183)*0.5 + 0.5
             );`
+            // `gl_FragColor.rgb =  vec3(
+            //           sin(v_micron_instance_id*123.1)*0.5 + 0.5,
+            //           sin(v_micron_instance_id*11.7)*0.5 + 0.5,
+            //           sin(v_micron_instance_id*932.183)*0.5 + 0.5
+            // );`
             //     `gl_FragColor.rgb =  vec3(
             //           v_vertex_id*0.0026041666666666665,
             //           1.0,

package/engine/graphics/particles/particular/engine/ParticularEngine.js

@@ -140,6 +140,11 @@ ParticularEngine.prototype.advanceEmitter = function (emitter, timeDelta) {
 
             const step = steps[type];
 
+            if (step === undefined) {
+                // no step definition
+                continue;
+            }
+
             step.emitter = emitter;
             step.timeDelta = timeDelta;
             step.particles = emitter.particles;

package/engine/graphics/particles/particular/engine/emitter/ParticleLayer.js

@@ -14,6 +14,8 @@ import { EmissionShapeType } from "./EmissionShapeType.js";
 import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
 import { computeHashFloat } from "../../../../../../core/math/hash/computeHashFloat.js";
 
+const aabb3 = new AABB3(0, 0, 0, 0, 0, 0);
+
 function ParticleLayer() {
     /**
      *
@@ -30,24 +32,26 @@ function ParticleLayer() {
 
     /**
      * Determines a range of particle life expectancy
+     * @readonly
      * @type {NumericInterval}
      */
     this.particleLife = new NumericInterval(1, 1);
 
     /**
-     *
+     * @readonly
      * @type {NumericInterval}
      */
     this.particleSize = new NumericInterval(0.1, 0.2);
 
     /**
-     *
+     * @readonly
      * @type {NumericInterval}
      */
     this.particleRotation = new NumericInterval(0, 0);
 
     /**
      * Rotation speed of individual particles in Rad/s
+     * @readonly
      * @type {NumericInterval}
      */
     this.particleRotationSpeed = new NumericInterval(0, 0);
@@ -77,31 +81,31 @@ function ParticleLayer() {
     this.emissionImmediate = 0;
 
     /**
-     *
+     * @readonly
      * @type {ParameterTrackSet}
      */
     this.parameterTracks = new ParameterTrackSet();
 
     /**
-     *
+     * @readonly
      * @type {Vector3}
      */
     this.position = new Vector3(0, 0, 0);
 
     /**
-     *
+     * @readonly
      * @type {Vector3}
      */
     this.scale = new Vector3(1, 1, 1);
 
     /**
-     *
+     * @readonly
      * @type {ConicRay}
      */
     this.particleVelocityDirection = new ConicRay();
 
     /**
-     *
+     * @readonly
      * @type {NumericInterval}
      */
     this.particleSpeed = new NumericInterval(0, 0);
@@ -120,14 +124,19 @@ function ParticleLayer() {
 
     /**
      * Simulation steps that are to be applied
+     * @readonly
      * @type {List<SimulationStepDefinition>}
      */
     this.steps = new List();
 
+    /**
+     * transient property
+     * @type {number}
+     */
     this.scaledSpriteHalfSize = -1;
 
     /**
-     *
+     * @readonly
      * @type {AABB3}
      */
     this.baseBoundingBox = new AABB3(0, 0, 0, 0, 0, 0);
@@ -159,7 +168,6 @@ ParticleLayer.prototype.computeScaledSpriteHalfSize = function () {
     return maxParticleSize / 2;
 };
 
-const aabb3 = new AABB3(0, 0, 0, 0, 0, 0);
 
 /**
  * Bounding box without taking sprite size into account

package/engine/graphics/particles/particular/engine/renderers/ParticleRenderer.js

@@ -1,26 +1,28 @@
-import { Group } from "three";
-
 /**
  * Abstract base class for a particle renderer
  */
 export class ParticleRenderer {
 
+
     constructor() {
 
 
-        /**
-         * Base object where data is added
-         * @type {Group}
-         */
-        this.mesh = new Group();
+    }
+
+    build_start() {
+
+    }
+
+    build_end() {
 
     }
 
     /**
-     * Render collection of particle layers
-     * @param {ParticlePool[]} pools
+     *
+     * @param {ParticleLayer} layer
      */
-    render(pools) {
+    add(layer) {
 
     }
+
 }

package/engine/graphics/particles/particular/engine/renderers/billboard/ParticleBillboardMaterial.js

@@ -314,11 +314,16 @@ function make_fragment_shader() {
                     
                     struct LambertMaterial {
                         vec3 diffuseColor;
+                        float opacity;
                     };
                     
                     void RE_Direct_Lambert( const in IncidentLight directLight, const in GeometricContext geometry, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {
-                        float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
+                        float unsaturated_direction_dot = dot( geometry.normal, directLight.direction );
+                        
+                        float dotNL = saturate( unsaturated_direction_dot );
+                        
                         vec3 irradiance =  dotNL * directLight.color;
+                        
                         reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
                     }
                     
@@ -373,7 +378,7 @@ function make_fragment_shader() {
                         
                         vec3 transformedNormal = construct_spherical_normal_from_point_coord(gl_PointCoord.xy);
                         
-                        LambertMaterial material = LambertMaterial(texel.rgb);
+                        LambertMaterial material = LambertMaterial(texel.rgb, texel.a);
                         ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
                         
                         ${CHUNK_LAMBERT_LIGHTING}

package/engine/graphics/particles/particular/engine/renderers/billboard/SoftBillboardParticlePool.js

@@ -0,0 +1,27 @@
+import { ParticlePool } from "../../emitter/ParticlePool.js";
+import { PARTICULAR_PARTICLE_SPECIFICATION } from "../../emitter/PARTICULAR_PARTICLE_SPECIFICATION.js";
+
+export class SoftBillboardParticlePool {
+    __pool = new ParticlePool(PARTICULAR_PARTICLE_SPECIFICATION);
+
+    get particle_count() {
+        // TODO implement
+    }
+
+    /**
+     *
+     * @param {ParticleLayer} layer
+     */
+    add(layer) {
+        // TODO implement
+
+    }
+
+    sort() {
+        // TODO implement
+    }
+
+    dispose() {
+        // TODO implement
+    }
+}

package/engine/graphics/particles/particular/engine/renderers/billboard/SoftBillboardParticleRenderer.js

@@ -0,0 +1,80 @@
+import { ParticleRenderer } from "../ParticleRenderer.js";
+import { ShaderManager } from "../../shader/ShaderManager.js";
+
+export class SoftBillboardParticleRenderer extends ParticleRenderer {
+    /**
+     *
+     * @type {Map<Material, SoftBillboardParticlePool>}
+     * @private
+     */
+    __pools = new Map();
+    /**
+     *
+     * @private
+     * @type {ShaderManager}
+     */
+    __shaders;
+
+    /**
+     *
+     * @param {Engine} engine
+     */
+    constructor(engine) {
+        super();
+
+
+        this.__shaders = new ShaderManager(engine.assetManager, engine.graphics.getMaterialManager());
+    }
+
+    build_start() {
+
+    }
+
+    build_end() {
+
+
+    }
+
+    /**
+     *
+     * @param {ParticleLayer} layer
+     * @returns {SoftBillboardParticlePool}
+     * @private
+     */
+    __obtain_pool(layer) {
+
+    }
+
+    /**
+     *
+     * @param {ParticleLayer} layer
+     */
+    add(layer) {
+        // TODO test frustum visibility
+
+        const pool = this.__obtain_pool(layer);
+
+        pool.add(layer);
+    }
+
+    __sort() {
+        for (const [mat, pool] of this.__pools) {
+            pool.sort();
+        }
+
+        // TODO sort pools themselves
+    }
+
+    /**
+     * Release resources
+     */
+    dispose() {
+        for (const [mat, pool] of this.__pools) {
+            pool.dispose();
+        }
+
+        this.__pools.clear();
+
+        this.__shaders.dispose();
+    }
+}

package/engine/graphics/particles/particular/engine/shader/ShaderManager.js

@@ -219,17 +219,22 @@ export class ShaderManager {
 
         this.materialMap.forEach(function (entry) {
 
-            entry.emitters.forEach(function (emitter) {
+            const emitters = entry.emitters;
+            const emitter_count = emitters.length;
+
+            for (let i = 0; i < emitter_count; i++) {
+                const emitter = emitters[i];
                 //mark sprites for an update
                 emitter.setFlag(ParticleEmitterFlag.SpritesNeedUpdate);
-            });
+            }
+
         });
 
         // console.timeEnd("ShaderManager.updateSpriteTexture");
     }
 
     /**
-     *
+     * @private
      * @returns {Material}
      * @param {ParticleEmitter} emitter
      */
@@ -249,7 +254,7 @@ export class ShaderManager {
 
         const ref = this.__material_manager.obtain(shader);
 
-        // TODO track referecen and release it eventually
+        // TODO track reference and release it eventually
 
         return ref.getValue();
     }
@@ -424,6 +429,13 @@ export class ShaderManager {
 
         this.__common_uniforms.resolution.value.set(x, y);
     }
+
+    /**
+     * Dispose of any used resources
+     */
+    dispose() {
+        // TODO implement
+    }
 }
 
 /**

package/engine/graphics/shaders/TerrainShader.js

@@ -6,7 +6,6 @@ import ShaderChunks from './lib/ShaderChunks.js';
 
 function vertex() {
     return `
-    
     #define PHYSICAL
     #define STANDARD
     
@@ -86,7 +85,6 @@ function vertex() {
 
 function fragment() {
     return `
-    
     #define PHYSICAL
     #define STANDARD
     
@@ -305,6 +303,8 @@ function fragment() {
     
     ${ShaderChunks.clouds_pars_fragment}
     
+    out highp vec4 pc_fragColor;
+    
     void main() { 
         vec4 splatDiffuseColor = computeSplatMix(vUv);
                 
@@ -363,30 +363,30 @@ function fragment() {
         
         vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
                     
-        gl_FragColor  = vec4( outgoingLight, diffuseColor.a );
+        pc_fragColor  = vec4( outgoingLight, diffuseColor.a );
       
         #if defined( TONE_MAPPING )
-            gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );
+            pc_fragColor.rgb = toneMapping( pc_fragColor.rgb );
         #endif
         
         //encode fragment
-        gl_FragColor = linearToOutputTexel( gl_FragColor );
+        pc_fragColor = linearToOutputTexel( pc_fragColor );
         #ifdef USE_FOG
             #ifdef FOG_EXP2
                 float fogFactor = 1.0 - exp( - fogDensity * fogDensity * fogDepth * fogDepth );
             #else
                 float fogFactor = smoothstep( fogNear, fogFar, fogDepth );
             #endif
-            gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );
+            pc_fragColor.rgb = mix( pc_fragColor.rgb, fogColor, fogFactor );
         #endif
         
         #ifdef PREMULTIPLIED_ALPHA
             // Get get normal blending with premultipled, use with CustomBlending, OneFactor, OneMinusSrcAlphaFactor, AddEquation.
-            gl_FragColor.rgb *= gl_FragColor.a;
+            pc_fragColor.rgb *= pc_fragColor.a;
         #endif
         
         #ifdef DITHERING
-            gl_FragColor.rgb = dithering( gl_FragColor.rgb );
+            pc_fragColor.rgb = dithering( pc_fragColor.rgb );
         #endif
     }
     `;

package/engine/graphics/texture/atlas/TextureAtlasDebugger.js

@@ -21,7 +21,8 @@ export class TextureAtlasDebugger {
             left: "0",
             zIndex: 1000,
             border: "1px solid red",
-            pointerEvents: 'none'
+            pointerEvents: 'none',
+            background: 'rgba(0,0,0,0.8)'
         });
 
         const ctx = this.vAtlasContent.el.getContext('2d');