@woosh/meep-engine 2.29.0 → 2.30.0

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

@@ -1,175 +1,20 @@
 import { ManagedAtlas } from "../../../../texture/atlas/ManagedTextureAtlas.js";
-import { ParameterSheet } from "../parameter/ParameterSheet.js";
 import {
     ClampToEdgeWrapping,
     DataTexture,
     LinearFilter,
     LinearMipMapLinearFilter,
     Matrix4,
-    NearestFilter,
     RGBAFormat,
-    ShaderMaterial,
-    UnsignedByteType,
-    Vector2 as ThreeVector2
+    UnsignedByteType
 } from "three";
-import { SignalBinding } from "../../../../../../core/events/signal/SignalBinding.js";
 import Vector2 from "../../../../../../core/geom/Vector2.js";
-import Vector4 from "../../../../../../core/geom/Vector4.js";
-import { ParticleParameters } from "../emitter/ParticleParameters.js";
-import { capitalize } from "../../../../../../core/primitives/strings/StringUtils.js";
 import { HashMap } from "../../../../../../core/collection/HashMap.js";
-import { blendingType2three } from "../../../../texture/sampler/blendingType2Three.js";
 import { ParticleEmitterFlag } from "../emitter/ParticleEmitterFlag.js";
 import { writeSample2DDataToDataTexture } from "../../../../texture/sampler/writeSampler2DDataToDataTexture.js";
 import { TextureAtlasDebugger } from "../../../../texture/atlas/TextureAtlasDebugger.js";
 import { MaterialRecord } from "./MaterialRecord.js";
-import { AtlasLookupTexture } from "../../../../texture/atlas/AtlasLookupTexture.js";
-
-/**
- *
- * @param {number} itemCount
- * @return {string}
- */
-function itemCountToGLType(itemCount) {
-    switch (itemCount) {
-        case 1:
-            return 'float';
-        case 2:
-            return 'vec2';
-        case 3:
-            return 'vec3';
-        case 4:
-            return 'vec4';
-        default:
-            throw new TypeError(`Unsupported itemCount '${itemCount}'`);
-    }
-}
-
-/**
- *
- * @param {number} num
- * @returns {string}
- */
-function genFloat(num) {
-    const str = num.toString();
-    if (str.indexOf('.') === -1) {
-        return str + '.0';
-    } else {
-        return str;
-    }
-}
-
-function genParameterDecoderScalar() {
-    return `float decodeParameterValueScalar(const in vec4 value, const in float offset, const in float rangeMultiplier){
-        float unscaled = (value.x * 255.0 + value.y * 65280.0 + value.z * 16711680.0 + value.w * 4278190080.0);
-        return unscaled * rangeMultiplier + offset;
-    }`;
-}
-
-function genParameterDecoderVector2() {
-    return `vec2 decodeParameterValueVector2(const in vec4 value, const in float offset, const in float rangeMultiplier){
-        vec2 unscaled = vec2(value.x * 255.0 + value.y * 65280.0, value.z * 255.0 + value.w * 65280.0);
-        return unscaled * rangeMultiplier + offset;
-    }`;
-}
-
-function genParameterDecoderVector3() {
-    return `vec3 decodeParameterValueVector3(const in vec4 value, const in float offset, const in float rangeMultiplier){
-        vec3 unscaled = vec3(value.x * 255.0, value.y * 255.0, value.z * 255.0);
-        return unscaled * rangeMultiplier + offset;
-    }`;
-}
-
-function genParameterDecoderVector4() {
-    return `vec4 decodeParameterValueVector4(const in vec4 value, const in float offset, const in float rangeMultiplier){
-        vec4 unscaled =  vec4(value.x * 255.0, value.y * 255.0, value.z * 255.0, value.w * 255.0);
-        return unscaled * rangeMultiplier + offset;
-    }`;
-}
-
-/**
- *
- * @param {ParticleParameter} parameter
- * @returns {string}
- */
-function computeDecoderFunctionName(parameter) {
-    const itemSize = parameter.itemSize;
-    if (itemSize === 1) {
-        return 'decodeParameterValueScalar';
-    } else if (itemSize === 2) {
-        return 'decodeParameterValueVector2';
-    } else if (itemSize === 3) {
-        return 'genParameterDecoderVector3';
-    } else if (itemSize === 4) {
-        return 'decodeParameterValueVector4';
-    } else {
-        throw new Error(`Unsupported parameter itemSize(=${itemSize})`);
-    }
-}
-
-/**
- *
- * @param {ParticleParameter} parameter
- * @returns {number}
- */
-function computeDecoderValueRangeMultiplier(parameter) {
-    const valueRange = parameter.valueMax - parameter.valueMin;
-
-    const itemSize = parameter.itemSize;
-
-    let multiplier;
-
-    if (itemSize === 1) {
-        multiplier = 4294967295;
-    } else if (itemSize === 2) {
-        multiplier = 65535;
-    } else if (itemSize === 3 || itemSize === 4) {
-        multiplier = 255;
-    } else {
-        throw new Error(`Unsupported itemSize(=${itemSize})`);
-    }
-
-    return valueRange / multiplier;
-}
-
-/**
- *
- * @param {string} samplePosition
- * @param {string} uniformName
- * @returns {string}
- */
-function genParameterSampleTexel(samplePosition, uniformName) {
-    const u = `${uniformName}.x + ${samplePosition} * ${uniformName}.z`;
-    const v = `${uniformName}.y + layerPosition * ${uniformName}.w`;
-
-    const textureCoordinates = `vec2( ${u}, ${v} )`;
-
-    return `texture2D( tParameterSheet, ${textureCoordinates} )`;
-}
-
-/**
- *
- * @param {string|number} samplePosition
- * @param {ParticleParameter} parameter
- * @returns {string}
- */
-function genParameterSampleValue(samplePosition, parameter) {
-    const uniformName = computeParameterUniformName(parameter);
-
-    const decoderFunctionName = computeDecoderFunctionName(parameter);
-
-    const v4Texel = genParameterSampleTexel(samplePosition, uniformName);
-
-    const rangeMultiplier = computeDecoderValueRangeMultiplier(parameter);
-
-    if (rangeMultiplier === 0) {
-        const glType = itemCountToGLType(parameter.itemSize);
-        //no range, don't need to read
-        return `${glType}( ${genFloat(parameter.valueMin)} )`;
-    }
-
-    return `${decoderFunctionName}(${v4Texel}, ${genFloat(parameter.valueMin)}, ${genFloat(rangeMultiplier)})`;
-}
+import { make_particle_billboard_shader } from "../renderers/billboard/ParticleBillboardMaterial.js";
 
 const EMITTER_MATERIAL_FLAGS = ParticleEmitterFlag.DepthSoftDisabled | ParticleEmitterFlag.DepthReadDisabled | ParticleEmitterFlag.AlignOnVelocity;
 
@@ -179,9 +24,8 @@ const EMITTER_MATERIAL_FLAGS = ParticleEmitterFlag.DepthSoftDisabled | ParticleE
  * @returns {number}
  */
 function computeEmitterMaterialHash(emitter) {
-    const paramHash = emitter.parameters.hash();
 
-    return paramHash ^ (emitter.flags & EMITTER_MATERIAL_FLAGS);
+    return (emitter.flags & EMITTER_MATERIAL_FLAGS);
 }
 
 /**
@@ -194,7 +38,7 @@ function computeEmitterMaterialEquality(a, b) {
     const aFlags = a.flags & EMITTER_MATERIAL_FLAGS;
     const bFlags = b.flags & EMITTER_MATERIAL_FLAGS;
 
-    return (aFlags === bFlags) && a.parameters.equals(b.parameters);
+    return (aFlags === bFlags);
 }
 
 
@@ -260,12 +104,6 @@ export class ShaderManager {
         this.spriteAtlas = new ManagedAtlas(assetManager);
         this.spriteAtlas.autoUpdate = false;
 
-        /**
-         *
-         * @type {ParameterSheet}
-         */
-        this.parameterSheet = new ParameterSheet();
-
         /**
          *
          * @type {DataTexture|null}
@@ -283,20 +121,6 @@ export class ShaderManager {
          */
         this.depthTexture = null;
 
-        /**
-         *
-         * @type {DataTexture|null}
-         */
-        this.parameterTexture = buildDataTexture({
-            generateMipmaps: false,
-            magFilter: LinearFilter,
-            minFilter: NearestFilter,
-            anisotropy: 0
-        });
-
-        this.parameterLookup = new AtlasLookupTexture();
-        this.parameterLookup.attach(this.parameterSheet.atlas);
-
         /**
          * material map is identified by parameter hash
          * @readonly
@@ -333,8 +157,6 @@ export class ShaderManager {
         //watch atlas updates
         this.spriteAtlas.atlas.on.painted.add(this.updateSpriteTexture, this);
 
-        this.parameterSheet.atlas.on.painted.add(this.updateParameterTexture, this);
-
         // debugAtlas(this.parameterSheet.atlas, { scale: new Vector2(16, 16) });
         // debugAtlas(this.spriteAtlas.atlas, { scale: new Vector2(0.5, 0.5) });
     }
@@ -344,24 +166,8 @@ export class ShaderManager {
      */
     update() {
         this.spriteAtlas.atlas.update();
-        this.parameterSheet.update();
     }
 
-    /**
-     * @private
-     */
-    updateParameterTexture() {
-        const atlas = this.parameterSheet.atlas.sampler;
-
-        const dataTexture = this.parameterTexture;
-
-        writeSample2DDataToDataTexture(atlas, dataTexture);
-
-        this.materialMap.forEach(function (entry) {
-            const material = entry.material;
-            material.uniforms.tParameterSheet.value = dataTexture;
-        });
-    }
 
     /**
      * @private
@@ -394,280 +200,19 @@ export class ShaderManager {
      * @param {ParticleEmitter} emitter
      */
     buildMaterial(emitter) {
-        const parameters = emitter.parameters;
-
-        const parameterArray = parameters.asArray();
-
-        function vertexShader() {
-            const paramScale = parameters.getParameterByName(ParticleParameters.Scale);
-            const paramColor = parameters.getParameterByName(ParticleParameters.Color);
-
-
-            const parameterUniforms = parameterArray.map(function (param) {
-                return `uniform vec4 ${computeParameterUniformName(param)};`;
-            }).join('\n');
-
-            return `
-                uniform float cameraNear;
-                uniform float cameraFar;
-                uniform vec2 resolution;
-                uniform sampler2D tParameterSheet;
-                
-                ${parameterUniforms}
-                
-                attribute float size;
-                attribute vec4 atlasPatch;
-                attribute float age;
-                attribute float deathAge;
-                attribute float layerPosition;
-                attribute float rotation;
-                attribute vec3 velocity;
-                
-                varying vec4 vPatch;
-                            
-                varying float vSize;
-            
-                varying float vFadeDistance;
-                
-                varying vec4 vColor;
-                
-                varying vec2 vRotationMultiplier;
-                
-                ${genParameterDecoderScalar()}
-                ${genParameterDecoderVector4()}
-                
-                void main() {
-                    float relativeAge = clamp(age / deathAge, 0.0, 1.0);
-                    
-                    float paramScale = ${genParameterSampleValue('relativeAge', paramScale)};
-                    vColor = ${genParameterSampleValue('relativeAge', paramColor)};
-                    
-                    
-                    vSize = size * paramScale;
-                    vPatch = atlasPatch;
-                    
-                    mat4 modelViewProjectionMatrix = projectionMatrix * modelViewMatrix;
-                                                    
-                    vec4 position4 = vec4( position, 1.0 );
-                                                    
-                    gl_Position = modelViewProjectionMatrix * position4;
-                    
-                    float rotationGlobal = rotation;
-                    
-                    //
-                    #ifdef ALIGN_DIRECTION_ENABLED 
-                        if(velocity != vec3(0.0)){
-                    
-                            vec4 vecNext = modelViewProjectionMatrix * (position4 + vec4(velocity,0.0) );
-                            
-                            vec2 p_2 = gl_Position.xy / gl_Position.w;
-                            vec2 vecNext_2 = vecNext.xy / vecNext.w;
-                            
-                            vec2 direction = vecNext_2 - p_2;
-                            
-                            float upAngle = atan(direction.y, direction.x) - 1.57079632679;
-                            
-                            rotationGlobal = rotationGlobal + upAngle;
-                            
-                        }
-                    #endif
-                    //
-                    
-                    vRotationMultiplier = vec2( cos(rotationGlobal),sin(rotationGlobal) );
-                    
-                    float radius = vSize/2.0;
-                    
-                    #ifdef DEPTH_SOFT_ENABLED
-                    
-                    vFadeDistance = 1.0 / radius;
-                    
-                    #endif
-                                    
-                    gl_PointSize = resolution.y * projectionMatrix[1][1] * radius / gl_Position.w;
-                }`;
-        }
-
-        const DEPTH_ERROR_MARGIN = 0.0001;
-
-        /**
-         * depthToLinear pulled from here: https://stackoverflow.com/questions/6652253/getting-the-true-z-value-from-the-depth-buffer
-         * @returns {string}
-         */
-        function fragmentShader() {
-            return `
-                uniform sampler2D tSpriteAtlas;
-                uniform sampler2D tDepth;
-                uniform float cameraNear;
-                uniform float cameraFar;
-                uniform mat4 modelViewMatrix;
-                uniform mat4 projectionMatrix;
-                uniform vec2 resolution;
-                
-                varying float vFadeDistance;
-                varying vec4 vPatch;
-                varying float vSize;
-                varying vec4 vColor;
-                varying vec2 vRotationMultiplier;
-                
-                float depthToLinear( float z ) {
-                    float f = cameraFar;
-                    float n = cameraNear;
-                    
-                    float d_n = 2.0*z - 1.0;
-                    
-                    float fn = f*n;
-                    
-                    float z_diff = f - n;
-                    
-                    float denominator = (f + n - d_n * z_diff );
-                
-                    float z_view = (2.0*fn) / denominator;
-                
-                    return z_view-n;
-                }
-                
-                
-                float calculateFade(in float particleDepth, in float sceneDepth){
-                    float zFade;
-                                                            
-                    float linearParticleDepth = depthToLinear(particleDepth);
-                    
-                    float linearSceneDepth = depthToLinear(sceneDepth);
-                                    
-                    float depthDelta = (linearSceneDepth - linearParticleDepth);
-                                                    
-                    float inputDepth = depthDelta* vFadeDistance;
-                    
-                    if(inputDepth <= 0.0){
-                        return 0.0;
-                    }
-                    
-                    if(inputDepth >= 1.0){
-                        return 1.0;
-                    }
-                    
-                    if(inputDepth <= 0.5){
-                        zFade = 0.5 * pow( clamp(2.0*inputDepth, 0.0, 1.0), 2.0);
-                    }else{
-                        zFade = 1.0 - 0.5 * pow( clamp(2.0*(1.0 - inputDepth), 0.0, 1.0), 2.0);
-                    }
-                    
-                    return zFade;
-                }
-                
-                void main() {
-                    float fragmentDepth = gl_FragCoord.z;
-                    
-                    vec2 pixelPosition = gl_FragCoord.xy / resolution;
-                    
-                    float sceneDepth =  texture2D( tDepth, pixelPosition ).x;
-                    
-                    #ifdef DEPTH_READ_ENABLED
-                    
-                    if(fragmentDepth + ${DEPTH_ERROR_MARGIN} > sceneDepth){
-                        discard;
-                    }
-                    
-                    #endif
-                   
-                    vec2 centeredUv = gl_PointCoord.xy - 0.5;
-                    
-                    vec2 texelCoordinate = vec2( centeredUv.x* vRotationMultiplier.x - centeredUv.y* vRotationMultiplier.y, centeredUv.x * vRotationMultiplier.y + centeredUv.y * vRotationMultiplier.x) + 0.5;
-                    
-                    texelCoordinate = clamp(texelCoordinate, vec2(0.0), vec2(1.0) );
-                                                   
-                    vec2 uv = texelCoordinate*vPatch.zw + vPatch.xy;
-                    
-                    vec4 spriteColor = texture2D( tSpriteAtlas, uv );
-                    
-                    if(spriteColor.a == 0.0){
-                        discard;
-                    }
-                    
-                    vec4 texel = spriteColor *vColor;
-                    
-                    
-                    #ifdef DEPTH_SOFT_ENABLED
-                    
-                    float zFade = calculateFade(fragmentDepth, sceneDepth);
-                    
-                    texel.a *= zFade;
-                    
-                    #endif
-                                    
-                    gl_FragColor = texel;
-                    
-                }`;
-        }
-
-        const uniforms = {
-            tSpriteAtlas: {
-                type: 't',
-                value: this.spriteTexture
-            },
-            tParameterSheet: {
-                type: 't',
-                value: this.parameterTexture
-            },
-            cameraNear: {
-                type: 'f',
-                value: 1,
-            },
-            cameraFar: {
-                type: 'f',
-                value: 1,
-            },
-            tDepth: {
-                type: 't',
-                value: this.depthTexture
-            },
-            modelViewMatrix: {
-                type: 'm4',
-                value: new Matrix4()
-            },
-            projectionMatrix: {
-                type: 'm4',
-                value: new Matrix4()
-            },
-            resolution: {
-                type: 'v2',
-                value: new ThreeVector2(this.viewportSize.x, this.viewportSize.y)
-            }
-        };
-
-        //add parameter uniforms
-        parameterArray.forEach(function (param) {
-            const uniformName = computeParameterUniformName(param);
-            const vec4 = new Vector4();
-            computeParameterSamplingRegion(param, vec4);
-            uniforms[uniformName] = {
-                type: 'v4',
-                value: vec4
-            };
-        });
+        const shader = make_particle_billboard_shader();
 
-        const blending = blendingType2three(emitter.blendingMode);
+        shader.uniforms.tSpriteAtlas.value = this.spriteTexture;
+        shader.uniforms.tDepth.value = this.depthTexture;
+        shader.uniforms.resolution.value.set(this.viewportSize.x, this.viewportSize.y)
 
-        const defines = {
+        shader.defines = {
             DEPTH_READ_ENABLED: !emitter.getFlag(ParticleEmitterFlag.DepthReadDisabled),
             DEPTH_SOFT_ENABLED: !emitter.getFlag(ParticleEmitterFlag.DepthSoftDisabled),
             ALIGN_DIRECTION_ENABLED: emitter.getFlag(ParticleEmitterFlag.AlignOnVelocity)
         };
 
-        const material = new ShaderMaterial({
-            defines,
-            uniforms,
-            vertexShader: vertexShader(),
-            fragmentShader: fragmentShader(),
-            blending,
-            lights: false,
-            depthTest: true,
-            depthWrite: false,
-            transparent: true,
-            vertexColors: false
-        });
-
-        return material;
+        return shader;
     }
 
     /**
@@ -861,64 +406,6 @@ export class ShaderManager {
     }
 }
 
-/**
- *
- * @param {ParticleParameter} parameter
- * @param {Vector4} result
- */
-function computeParameterSamplingRegion(parameter, result) {
-    const patch = parameter.patch;
-
-    if (patch === null) {
-        result.set(0, 0, 0, 0);
-        return;
-    }
-
-    const uv = patch.uv;
-
-    const uHalfPixelOffset = (patch.uv.size.x) / (patch.size.x * 2);
-
-    const u = uv.position.x + uHalfPixelOffset;
-    const uRange = uv.size.x * ((patch.size.x - 1) / patch.size.x);
-
-    const trackCount = parameter.getTrackCount();
-
-    let vHalfTrackOffset;
-
-
-    if (trackCount === 0) {
-        //avoid division by zero
-        vHalfTrackOffset = 0;
-    } else {
-        vHalfTrackOffset = patch.uv.size.y / (trackCount * 2);
-    }
-
-    const v = uv.position.y + vHalfTrackOffset;
-
-    const patchHeight = patch.size.y;
-
-    let vRange;
-
-    if (patchHeight === 0) {
-        //avoid division by zero
-        vRange = 0;
-    } else {
-        vRange = uv.size.y * ((patchHeight - 1) / (patchHeight));
-    }
-
-    result.set(u, v, uRange, vRange);
-}
-
-/**
- *
- * @param {ParticleParameter} parameter
- * @returns {string}
- */
-function computeParameterUniformName(parameter) {
-    return 'uPatch' + capitalize(parameter.name);
-}
-
-
 /**
  *
  * @param {ParticleEmitter} emitter
@@ -930,38 +417,6 @@ function createShaderEntry(emitter, shaderManager) {
     entry.count = 0;
     entry.parameters = emitter.parameters;
 
-    const parameters = emitter.parameters.asArray();
-
-    function updatePatches() {
-        const material = entry.material;
-
-        parameters.forEach(function (param) {
-            const uniformName = computeParameterUniformName(param);
-            const uniform = material.uniforms[uniformName];
-
-            computeParameterSamplingRegion(param, uniform.value);
-        });
-    }
-
-    //add parameters to parameter sheet
-    const parameterCount = parameters.length;
-
-    for (let i = 0; i < parameterCount; i++) {
-        const particleParameter = parameters[i];
-        shaderManager.parameterSheet.add(particleParameter);
-
-        //watch for UV patch changes. These can occur when atlas is re-packed or re-sized
-        const uv = particleParameter.patch.uv;
-
-        const sbSize = new SignalBinding(uv.size.onChanged, updatePatches);
-        const sbPosition = new SignalBinding(uv.position.onChanged, updatePatches);
-
-        entry.signalBindings.push(
-            sbSize,
-            sbPosition
-        );
-    }
-
     const material = shaderManager.buildMaterial(emitter);
 
     entry.material = material;

package/engine/graphics/particles/particular/engine/simulator/AbstractSimulationStep.js

@@ -13,6 +13,12 @@ export class AbstractSimulationStep {
          */
         this.particles = null;
 
+        /**
+         *
+         * @type {ParticleEmitter}
+         */
+        this.emitter = null;
+
         /**
          *
          * @type {Object[]}

package/engine/graphics/particles/particular/engine/simulator/SimulationStepFixedPhysics.js

@@ -8,6 +8,7 @@ import {
     PARTICLE_ATTRIBUTE_ROTATION_SPEED,
     PARTICLE_ATTRIBUTE_VELOCITY
 } from "../emitter/PARTICLE_ATTRIBUTES.js";
+import { update_parameters } from "./update_parameters.js";
 
 const velocity = [];
 const position = [];
@@ -23,6 +24,14 @@ export class SimulationStepFixedPhysics extends AbstractSimulationStep {
 
         const layerMask = this.layer_mask;
 
+        const emitter = this.emitter;
+
+        /**
+         *
+         * @type {ParticleLayer[]}
+         */
+        const layers = emitter.layers.asArray();
+
         for (let i = 0; i < liveParticleCount; i++) {
 
             const layer_position = particles.readAttributeScalar(i, PARTICLE_ATTRIBUTE_LAYER_POSITION);
@@ -40,8 +49,10 @@ export class SimulationStepFixedPhysics extends AbstractSimulationStep {
 
             const newAge = age + timeDelta;
 
+            const normalized_age = newAge / deathAge;
+
             //retire dead particles
-            if (newAge >= deathAge) {
+            if (normalized_age >= 1) {
                 //add to trash
                 particles.remove(i);
                 //we're done with this particle
@@ -67,6 +78,10 @@ export class SimulationStepFixedPhysics extends AbstractSimulationStep {
             const p_z = position[2] + velocity[2] * timeDelta;
 
             particles.writeAttributeVector3(i, PARTICLE_ATTRIBUTE_POSITION, p_x, p_y, p_z);
+
+            const layer = layers[layer_index];
+
+            update_parameters(i, particles, layer, normalized_age);
         }
     }