babylon.quarks 0.23.0 → 0.24.0

package/src/instanceSort.ts

@@ -0,0 +1,121 @@
+/**
+ * Sorting a batch's instances by a per-instance key, fast enough to run every
+ * frame over tens of thousands of particles: a three-pass radix sort on 32-bit
+ * keys (no comparator calls, linear time) and a gather of each attribute buffer
+ * in the resulting order.
+ */
+
+const RADIX_BITS = 11;
+const RADIX_SIZE = 1 << RADIX_BITS;
+const RADIX_MASK = RADIX_SIZE - 1;
+
+/** Scratch space for {@link sortByKey}, sized for a given instance count. */
+export class SortScratch {
+    keys: Uint32Array;
+    orderA: Uint32Array;
+    orderB: Uint32Array;
+    readonly counts = new Uint32Array(RADIX_SIZE);
+    private readonly floatView = new Float32Array(1);
+    private readonly uintView = new Uint32Array(this.floatView.buffer);
+
+    constructor(capacity: number) {
+        this.keys = new Uint32Array(capacity);
+        this.orderA = new Uint32Array(capacity);
+        this.orderB = new Uint32Array(capacity);
+    }
+
+    ensure(capacity: number): void {
+        if (this.keys.length < capacity) {
+            this.keys = new Uint32Array(capacity);
+            this.orderA = new Uint32Array(capacity);
+            this.orderB = new Uint32Array(capacity);
+        }
+    }
+
+    /**
+     * The bits of a non-negative float, which order the same way the float
+     * does, so they can be radix sorted. `descending` flips the order.
+     */
+    floatKey(value: number, descending: boolean): number {
+        this.floatView[0] = value;
+        const bits = this.uintView[0];
+        return descending ? ~bits >>> 0 : bits;
+    }
+}
+
+/**
+ * Fills `order` with the instance indices `[0, count)` sorted by ascending
+ * `scratch.keys`. Returns the array holding the result, one of the two order
+ * buffers of the scratch.
+ */
+export function sortByKey(scratch: SortScratch, count: number): Uint32Array {
+    const keys = scratch.keys;
+    const counts = scratch.counts;
+    let from = scratch.orderA;
+    let to = scratch.orderB;
+    for (let i = 0; i < count; i++) {
+        from[i] = i;
+    }
+    for (let shift = 0; shift < 32; shift += RADIX_BITS) {
+        counts.fill(0);
+        for (let i = 0; i < count; i++) {
+            counts[(keys[from[i]] >>> shift) & RADIX_MASK]++;
+        }
+        // A pass whose keys all share one digit changes nothing; skip the scatter.
+        if (counts[(keys[from[0]] >>> shift) & RADIX_MASK] === count) {
+            continue;
+        }
+        let sum = 0;
+        for (let b = 0; b < RADIX_SIZE; b++) {
+            const c = counts[b];
+            counts[b] = sum;
+            sum += c;
+        }
+        for (let i = 0; i < count; i++) {
+            const index = from[i];
+            to[counts[(keys[index] >>> shift) & RADIX_MASK]++] = index;
+        }
+        const swap = from;
+        from = to;
+        to = swap;
+    }
+    return from;
+}
+
+/** Copies `count` instances of `stride` floats from `source` into `target` in `order`. */
+export function gather(
+    source: Float32Array,
+    target: Float32Array,
+    order: Uint32Array,
+    count: number,
+    stride: number
+): void {
+    if (stride === 1) {
+        for (let i = 0; i < count; i++) {
+            target[i] = source[order[i]];
+        }
+    } else if (stride === 3) {
+        for (let i = 0, o = 0; i < count; i++, o += 3) {
+            const s = order[i] * 3;
+            target[o] = source[s];
+            target[o + 1] = source[s + 1];
+            target[o + 2] = source[s + 2];
+        }
+    } else if (stride === 4) {
+        for (let i = 0, o = 0; i < count; i++, o += 4) {
+            const s = order[i] * 4;
+            target[o] = source[s];
+            target[o + 1] = source[s + 1];
+            target[o + 2] = source[s + 2];
+            target[o + 3] = source[s + 3];
+        }
+    } else {
+        for (let i = 0; i < count; i++) {
+            const s = order[i] * stride;
+            const o = i * stride;
+            for (let k = 0; k < stride; k++) {
+                target[o + k] = source[s + k];
+            }
+        }
+    }
+}

package/src/shaders/chunks/fog.ts

@@ -0,0 +1,127 @@
+/**
+ * Scene fog for the particle shaders, in both shader languages.
+ *
+ * Babylon's own fog includes expect variables the particle shaders do not have
+ * (`worldPos`, a `color` the fragment writes), so the few lines involved live
+ * here instead and are spliced into each shader. The maths is Babylon's
+ * (`fogFragmentDeclaration`): the fog mode, start, end and density arrive in
+ * `vFogInfos`, the colour in `vFogColor`, and the distance is the view-space
+ * position's length. Mode 0 is "no fog", so a scene that turns its fog off
+ * needs no recompile — the uniform does it.
+ *
+ * Additive particles cannot fade toward a fog colour (that would add fog to
+ * the whole screen), so under `FOG_ADDITIVE` they fade toward black instead,
+ * which is what Unity does for additive materials.
+ */
+
+/** Vertex-side declaration, GLSL. */
+export const fogVertexDeclarationGLSL = /* glsl */ `
+#ifdef FOG
+varying vec3 vFogDistance;
+#endif
+`;
+
+/** Writes the view-space position the fragment measures its distance from, GLSL. */
+export function fogVertexGLSL(viewPosition: string): string {
+    return /* glsl */ `
+#ifdef FOG
+    vFogDistance = ${viewPosition};
+#endif
+`;
+}
+
+/** Fragment-side declaration and fog factor, GLSL. */
+export const fogFragmentDeclarationGLSL = /* glsl */ `
+#ifdef FOG
+uniform vec4 vFogInfos;
+uniform vec3 vFogColor;
+varying vec3 vFogDistance;
+
+float quarksFogFactor() {
+    float fogCoeff = 1.0;
+    float fogStart = vFogInfos.y;
+    float fogEnd = vFogInfos.z;
+    float fogDensity = vFogInfos.w;
+    float fogDistance = length(vFogDistance);
+    if (vFogInfos.x == 3.0) {
+        fogCoeff = (fogEnd - fogDistance) / (fogEnd - fogStart);
+    } else if (vFogInfos.x == 1.0) {
+        fogCoeff = exp(-fogDistance * fogDensity);
+    } else if (vFogInfos.x == 2.0) {
+        fogCoeff = exp(-fogDistance * fogDistance * fogDensity * fogDensity);
+    }
+    return clamp(fogCoeff, 0.0, 1.0);
+}
+#endif
+`;
+
+/** Applies the fog to an rgb lvalue (`color` or `baseColor.rgb`), GLSL. */
+export function fogFragmentGLSL(rgb: string): string {
+    return /* glsl */ `
+#ifdef FOG
+    {
+        float fogFactor = quarksFogFactor();
+#ifdef FOG_ADDITIVE
+        ${rgb} *= fogFactor;
+#else
+        ${rgb} = mix(vFogColor, ${rgb}, fogFactor);
+#endif
+    }
+#endif
+`;
+}
+
+/** Vertex-side declaration, WGSL. */
+export const fogVertexDeclarationWGSL = /* wgsl */ `
+#ifdef FOG
+varying vFogDistance: vec3f;
+#endif
+`;
+
+/** Writes the view-space position the fragment measures its distance from, WGSL. */
+export function fogVertexWGSL(viewPosition: string): string {
+    return /* wgsl */ `
+#ifdef FOG
+    vertexOutputs.vFogDistance = ${viewPosition};
+#endif
+`;
+}
+
+/** Fragment-side declaration and fog function, WGSL. */
+export const fogFragmentDeclarationWGSL = /* wgsl */ `
+#ifdef FOG
+uniform vFogInfos: vec4f;
+uniform vFogColor: vec3f;
+varying vFogDistance: vec3f;
+
+fn quarksFog(rgb: vec3f, fogDistanceVector: vec3f) -> vec3f {
+    var fogCoeff = 1.0;
+    let fogStart = uniforms.vFogInfos.y;
+    let fogEnd = uniforms.vFogInfos.z;
+    let fogDensity = uniforms.vFogInfos.w;
+    let fogDistance = length(fogDistanceVector);
+    if (uniforms.vFogInfos.x == 3.0) {
+        fogCoeff = (fogEnd - fogDistance) / (fogEnd - fogStart);
+    } else if (uniforms.vFogInfos.x == 1.0) {
+        fogCoeff = exp(-fogDistance * fogDensity);
+    } else if (uniforms.vFogInfos.x == 2.0) {
+        fogCoeff = exp(-fogDistance * fogDistance * fogDensity * fogDensity);
+    }
+    let fogFactor = clamp(fogCoeff, 0.0, 1.0);
+#ifdef FOG_ADDITIVE
+    return rgb * fogFactor;
+#else
+    return mix(uniforms.vFogColor, rgb, fogFactor);
+#endif
+}
+#endif
+`;
+
+/** Applies the fog to a `var` vec4 colour, WGSL. */
+export function fogFragmentWGSL(color: string): string {
+    return /* wgsl */ `
+#ifdef FOG
+    ${color} = vec4f(quarksFog(${color}.rgb, fragmentInputs.vFogDistance), ${color}.a);
+#endif
+`;
+}

package/src/shaders/local_particle_physics_vert.glsl.ts

@@ -1,3 +1,5 @@
+import {fogVertexDeclarationGLSL, fogVertexGLSL} from './chunks/fog';
+
 export default /* glsl */ `
 attribute vec3 position;
 attribute vec2 uv;
@@ -39,6 +41,7 @@ vec3 applyQuaternion(vec3 v, vec4 q) {
     return v + qW * t + cross(qVec, t);
 }
 
+${fogVertexDeclarationGLSL}
 void main() {
     vec3 scaledPosition = position * size;
     vec3 rotatedPosition = applyQuaternion(scaledPosition, rotation);
@@ -48,6 +51,7 @@ void main() {
     vec4 worldPos = world * vec4(localPos, 1.0);
     vec4 viewPos = view * worldPos;
     gl_Position = projection * viewPos;
+${fogVertexGLSL('viewPos.xyz')}
 
     vWorldPos = worldPos.xyz;
     vNormal = normalize((world * vec4(rotatedNormal, 0.0)).xyz);

package/src/shaders/local_particle_physics_vert.wgsl.ts

@@ -1,3 +1,5 @@
+import {fogVertexDeclarationWGSL, fogVertexWGSL} from './chunks/fog';
+
 export default /* wgsl */ `
 attribute position: vec3f;
 attribute uv: vec2f;
@@ -39,6 +41,7 @@ fn applyQuaternion(v: vec3f, q: vec4f) -> vec3f {
     return v + qW * t + cross(qVec, t);
 }
 
+${fogVertexDeclarationWGSL}
 @vertex
 fn main(input: VertexInputs) -> FragmentInputs {
     let scaledPosition = vertexInputs.position * vertexInputs.size;
@@ -50,6 +53,7 @@ fn main(input: VertexInputs) -> FragmentInputs {
     let viewPos = uniforms.view * worldPos;
     let clipPosition = uniforms.projection * viewPos;
     vertexOutputs.position = clipPosition;
+${fogVertexWGSL('viewPos.xyz')}
 
     vertexOutputs.vWorldPos = worldPos.xyz;
     vertexOutputs.vNormal = normalize((uniforms.world * vec4f(rotatedNormal, 0.0)).xyz);

package/src/shaders/particle_frag.glsl.ts

@@ -1,3 +1,5 @@
+import {fogFragmentDeclarationGLSL, fogFragmentGLSL} from './chunks/fog';
+
 export default /* glsl */ `
 varying vec2 vUV;
 varying vec4 vColor;
@@ -23,6 +25,7 @@ varying float linearDepth;
 uniform float alphaTest;
 #endif
 
+${fogFragmentDeclarationGLSL}
 void main() {
     vec4 baseColor = vColor;
 
@@ -45,6 +48,7 @@ void main() {
     if (baseColor.a < 0.01) discard;
 #endif
 
+${fogFragmentGLSL('baseColor.rgb')}
     gl_FragColor = baseColor;
 
 #ifdef SOFT_PARTICLES

package/src/shaders/particle_frag.wgsl.ts

@@ -1,3 +1,5 @@
+import {fogFragmentDeclarationWGSL, fogFragmentWGSL} from './chunks/fog';
+
 export default /* wgsl */ `
 varying vUV: vec2f;
 varying vColor: vec4f;
@@ -25,6 +27,7 @@ varying linearDepth: f32;
 uniform alphaTest: f32;
 #endif
 
+${fogFragmentDeclarationWGSL}
 @fragment
 fn main(input: FragmentInputs) -> FragmentOutputs {
     var baseColor = fragmentInputs.vColor;
@@ -59,6 +62,7 @@ fn main(input: FragmentInputs) -> FragmentOutputs {
     baseColor *= fade;
 #endif
 
+${fogFragmentWGSL('baseColor')}
     fragmentOutputs.color = baseColor;
 }
 `;

package/src/shaders/particle_physics_frag.glsl.ts

@@ -1,3 +1,5 @@
+import {fogFragmentDeclarationGLSL, fogFragmentGLSL} from './chunks/fog';
+
 export default /* glsl */ `
 varying vec2 vUV;
 varying vec4 vColor;
@@ -85,6 +87,7 @@ varying float linearDepth;
 uniform float alphaTest;
 #endif
 
+${fogFragmentDeclarationGLSL}
 void main() {
     vec4 baseColor = vColor;
 
@@ -131,6 +134,7 @@ void main() {
     #endif
 #endif
 
+${fogFragmentGLSL('color')}
     gl_FragColor = vec4(color, baseColor.a);
 
 #ifdef SOFT_PARTICLES

package/src/shaders/particle_physics_frag.wgsl.ts

@@ -1,3 +1,5 @@
+import {fogFragmentDeclarationWGSL, fogFragmentWGSL} from './chunks/fog';
+
 export default /* wgsl */ `
 varying vUV: vec2f;
 varying vColor: vec4f;
@@ -85,6 +87,7 @@ varying linearDepth: f32;
 uniform alphaTest: f32;
 #endif
 
+${fogFragmentDeclarationWGSL}
 @fragment
 fn main(input: FragmentInputs) -> FragmentOutputs {
     var baseColor = fragmentInputs.vColor;
@@ -145,6 +148,7 @@ fn main(input: FragmentInputs) -> FragmentOutputs {
     finalColor *= fade;
 #endif
 
+${fogFragmentWGSL('finalColor')}
     fragmentOutputs.color = finalColor;
 }
 `;

package/src/shaders/particle_vert.glsl.ts

@@ -1,3 +1,5 @@
+import {fogVertexDeclarationGLSL, fogVertexGLSL} from './chunks/fog';
+
 export default /* glsl */ `
 // Per-vertex attributes
 attribute vec3 position;
@@ -38,15 +40,31 @@ varying vec4 projPosition;
 varying float linearDepth;
 #endif
 
+#ifdef SIZE_LIMITS
+// Smallest and largest size a particle may have on screen, as fractions of the viewport height.
+uniform vec2 sizeLimits;
+#endif
+${fogVertexDeclarationGLSL}
 void main() {
     float c = cos(rotation);
     float s = sin(rotation);
 
+#ifdef SIZE_LIMITS
+    // The particle's size on screen as a fraction of the viewport height, held
+    // between the limits; a perspective projection divides by the view depth.
+    vec4 limitCenter = view * world * vec4(offset, 1.0);
+    float limitDepth = abs(projection[2][3]) > 0.0 ? abs(limitCenter.z) : 1.0;
+    float screenSize = max(abs(size.x), abs(size.y)) * projection[1][1] / (2.0 * limitDepth);
+    float sizeScale = screenSize > 0.0 ? clamp(screenSize, sizeLimits.x, sizeLimits.y) / screenSize : 1.0;
+    vec3 limitedSize = size * sizeScale;
+#else
+    vec3 limitedSize = size;
+#endif
     // A negative size mirrors the quad, which is how flipped particles arrive.
-    vec2 alignedPosition = position.xy * size.xy;
+    vec2 alignedPosition = position.xy * limitedSize.xy;
 #ifdef PIVOT
     // The pivot turns with the particle but is not mirrored with it.
-    alignedPosition += pivot.xy * abs(size.xy);
+    alignedPosition += pivot.xy * abs(limitedSize.xy);
 #endif
     vec2 rotatedPosition;
     rotatedPosition.x = c * alignedPosition.x - s * alignedPosition.y;
@@ -57,7 +75,7 @@ void main() {
     mvPosition.x += rotatedPosition.x;
     mvPosition.z -= rotatedPosition.y;
 #ifdef PIVOT
-    mvPosition.y += pivot.z * abs(size.x);
+    mvPosition.y += pivot.z * abs(limitedSize.x);
 #endif
     mvPosition = view * mvPosition;
 #elif defined(VERTICAL)
@@ -73,11 +91,12 @@ void main() {
 #ifndef HORIZONTAL
     // Toward the camera along its view axis, whichever way the view space
     // faces: anything in front of the camera has the sign of the far side.
-    mvPosition.z -= sign(mvPosition.z) * pivot.z * abs(size.x);
+    mvPosition.z -= sign(mvPosition.z) * pivot.z * abs(limitedSize.x);
 #endif
 #endif
 
     gl_Position = projection * mvPosition;
+${fogVertexGLSL('mvPosition.xyz')}
 #ifdef SOFT_PARTICLES
     projPosition = gl_Position;
     linearDepth = -mvPosition.z;

package/src/shaders/particle_vert.wgsl.ts

@@ -1,3 +1,5 @@
+import {fogVertexDeclarationWGSL, fogVertexWGSL} from './chunks/fog';
+
 export default /* wgsl */ `
 // Per-vertex attributes
 attribute position: vec3f;
@@ -37,16 +39,32 @@ varying projPosition: vec4f;
 varying linearDepth: f32;
 #endif
 
+#ifdef SIZE_LIMITS
+// Smallest and largest size a particle may have on screen, as fractions of the viewport height.
+uniform sizeLimits: vec2f;
+#endif
+${fogVertexDeclarationWGSL}
 @vertex
 fn main(input: VertexInputs) -> FragmentInputs {
     let c = cos(vertexInputs.rotation);
     let s = sin(vertexInputs.rotation);
 
+#ifdef SIZE_LIMITS
+    // The particle's size on screen as a fraction of the viewport height, held
+    // between the limits; a perspective projection divides by the view depth.
+    let limitCenter = uniforms.view * uniforms.world * vec4f(vertexInputs.offset, 1.0);
+    let limitDepth = select(1.0, abs(limitCenter.z), abs(uniforms.projection[2][3]) > 0.0);
+    let screenSize = max(abs(vertexInputs.size.x), abs(vertexInputs.size.y)) * uniforms.projection[1][1] / (2.0 * limitDepth);
+    let sizeScale = select(1.0, clamp(screenSize, uniforms.sizeLimits.x, uniforms.sizeLimits.y) / screenSize, screenSize > 0.0);
+    let limitedSize = vertexInputs.size * sizeScale;
+#else
+    let limitedSize = vertexInputs.size;
+#endif
     // A negative size mirrors the quad, which is how flipped particles arrive.
-    var alignedPosition = vertexInputs.position.xy * vertexInputs.size.xy;
+    var alignedPosition = vertexInputs.position.xy * limitedSize.xy;
 #ifdef PIVOT
     // The pivot turns with the particle but is not mirrored with it.
-    alignedPosition += uniforms.pivot.xy * abs(vertexInputs.size.xy);
+    alignedPosition += uniforms.pivot.xy * abs(limitedSize.xy);
 #endif
     let rotatedPosition = vec2f(
         c * alignedPosition.x - s * alignedPosition.y,
@@ -57,7 +75,7 @@ fn main(input: VertexInputs) -> FragmentInputs {
     mvPosition.x += rotatedPosition.x;
     mvPosition.z -= rotatedPosition.y;
 #ifdef PIVOT
-    mvPosition.y += uniforms.pivot.z * abs(vertexInputs.size.x);
+    mvPosition.y += uniforms.pivot.z * abs(limitedSize.x);
 #endif
     mvPosition = uniforms.view * mvPosition;
 #elif defined(VERTICAL)
@@ -74,12 +92,13 @@ fn main(input: VertexInputs) -> FragmentInputs {
 #ifndef HORIZONTAL
     // Toward the camera along its view axis, whichever way the view space
     // faces: anything in front of the camera has the sign of the far side.
-    mvPosition.z -= sign(mvPosition.z) * uniforms.pivot.z * abs(vertexInputs.size.x);
+    mvPosition.z -= sign(mvPosition.z) * uniforms.pivot.z * abs(limitedSize.x);
 #endif
 #endif
 
     let clipPosition = uniforms.projection * mvPosition;
     vertexOutputs.position = clipPosition;
+${fogVertexWGSL('mvPosition.xyz')}
 #ifdef SOFT_PARTICLES
     vertexOutputs.projPosition = clipPosition;
     vertexOutputs.linearDepth = -mvPosition.z;

package/src/shaders/stretched_bb_particle_vert.glsl.ts

@@ -1,3 +1,5 @@
+import {fogVertexDeclarationGLSL, fogVertexGLSL} from './chunks/fog';
+
 export default /* glsl */ `
 // Per-vertex attributes
 attribute vec3 position;
@@ -39,12 +41,26 @@ varying vec4 projPosition;
 varying float linearDepth;
 #endif
 
+#ifdef SIZE_LIMITS
+// Smallest and largest size a particle may have on screen, as fractions of the viewport height.
+uniform vec2 sizeLimits;
+#endif
+${fogVertexDeclarationGLSL}
 void main() {
     float lengthFactor = velocity.w;
     // A flipped particle arrives with a negative size: the streak keeps its
     // extent and mirrors its texture instead (see quadUV below).
     float avgSize = (abs(size.x) + abs(size.y)) * 0.5;
     vec4 mvPosition = view * world * vec4(offset, 1.0);
+#ifdef SIZE_LIMITS
+    // The streak's width on screen as a fraction of the viewport height, held
+    // between the limits; a perspective projection divides by the view depth.
+    float limitDepth = abs(projection[2][3]) > 0.0 ? abs(mvPosition.z) : 1.0;
+    float screenSize = avgSize * projection[1][1] / (2.0 * limitDepth);
+    if (screenSize > 0.0) {
+        avgSize *= clamp(screenSize, sizeLimits.x, sizeLimits.y) / screenSize;
+    }
+#endif
     vec3 viewVelocity = mat3(view * world) * velocity.xyz;
     float vlength = length(viewVelocity);
     // Stretch direction is the velocity direction; only a genuinely motionless particle has none.
@@ -61,6 +77,7 @@ void main() {
     mvPosition.xyz += (pivot.y * side - pivot.x * vdir) * avgSize;
 #endif
     gl_Position = projection * mvPosition;
+${fogVertexGLSL('mvPosition.xyz')}
     vec2 quadUV = vec2(size.x < 0.0 ? 1.0 - uv.x : uv.x, size.y < 0.0 ? 1.0 - uv.y : uv.y);
 #ifdef SOFT_PARTICLES
     projPosition = gl_Position;

package/src/shaders/stretched_bb_particle_vert.wgsl.ts

@@ -1,3 +1,5 @@
+import {fogVertexDeclarationWGSL, fogVertexWGSL} from './chunks/fog';
+
 export default /* wgsl */ `
 // Per-vertex attributes
 attribute position: vec3f;
@@ -39,13 +41,27 @@ varying projPosition: vec4f;
 varying linearDepth: f32;
 #endif
 
+#ifdef SIZE_LIMITS
+// Smallest and largest size a particle may have on screen, as fractions of the viewport height.
+uniform sizeLimits: vec2f;
+#endif
+${fogVertexDeclarationWGSL}
 @vertex
 fn main(input: VertexInputs) -> FragmentInputs {
     let lengthFactor = vertexInputs.velocity.w;
     // A flipped particle arrives with a negative size: the streak keeps its
     // extent and mirrors its texture instead (see quadUV below).
-    let avgSize = (abs(vertexInputs.size.x) + abs(vertexInputs.size.y)) * 0.5;
+    var avgSize = (abs(vertexInputs.size.x) + abs(vertexInputs.size.y)) * 0.5;
     var mvPosition = uniforms.view * uniforms.world * vec4f(vertexInputs.offset, 1.0);
+#ifdef SIZE_LIMITS
+    // The streak's width on screen as a fraction of the viewport height, held
+    // between the limits; a perspective projection divides by the view depth.
+    let limitDepth = select(1.0, abs(mvPosition.z), abs(uniforms.projection[2][3]) > 0.0);
+    let screenSize = avgSize * uniforms.projection[1][1] / (2.0 * limitDepth);
+    if (screenSize > 0.0) {
+        avgSize *= clamp(screenSize, uniforms.sizeLimits.x, uniforms.sizeLimits.y) / screenSize;
+    }
+#endif
     let viewWorld = uniforms.view * uniforms.world;
     let viewWorld3 = mat3x3f(viewWorld[0].xyz, viewWorld[1].xyz, viewWorld[2].xyz);
     let viewVelocity = viewWorld3 * vertexInputs.velocity.xyz;
@@ -73,6 +89,7 @@ fn main(input: VertexInputs) -> FragmentInputs {
 
     let clipPosition = uniforms.projection * mvPosition;
     vertexOutputs.position = clipPosition;
+${fogVertexWGSL('mvPosition.xyz')}
     let quadUV = select(vertexInputs.uv, 1.0 - vertexInputs.uv, vertexInputs.size.xy < vec2f(0.0));
 #ifdef SOFT_PARTICLES
     vertexOutputs.projPosition = clipPosition;

package/src/shaders/trail_frag.glsl.ts

@@ -1,3 +1,5 @@
+import {fogFragmentDeclarationGLSL, fogFragmentGLSL} from './chunks/fog';
+
 export default /* glsl */ `
 varying vec2 vUV;
 varying vec4 vColor;
@@ -6,6 +8,7 @@ varying vec4 vColor;
 uniform sampler2D map;
 #endif
 
+${fogFragmentDeclarationGLSL}
 void main() {
     vec4 baseColor = vColor;
 
@@ -16,6 +19,7 @@ void main() {
 
     if (baseColor.a < 0.01) discard;
 
+${fogFragmentGLSL('baseColor.rgb')}
     gl_FragColor = baseColor;
 }
 `;

package/src/shaders/trail_frag.wgsl.ts

@@ -1,3 +1,5 @@
+import {fogFragmentDeclarationWGSL, fogFragmentWGSL} from './chunks/fog';
+
 export default /* wgsl */ `
 varying vUV: vec2f;
 varying vColor: vec4f;
@@ -7,6 +9,7 @@ var mapSampler: sampler;
 var map: texture_2d<f32>;
 #endif
 
+${fogFragmentDeclarationWGSL}
 @fragment
 fn main(input: FragmentInputs) -> FragmentOutputs {
     var baseColor = fragmentInputs.vColor;
@@ -18,6 +21,7 @@ fn main(input: FragmentInputs) -> FragmentOutputs {
 
     if (baseColor.a < 0.01) { discard; }
 
+${fogFragmentWGSL('baseColor')}
     fragmentOutputs.color = baseColor;
 }
 `;

package/src/shaders/trail_vert.glsl.ts

@@ -1,3 +1,5 @@
+import {fogVertexDeclarationGLSL, fogVertexGLSL} from './chunks/fog';
+
 export default /* glsl */ `
 attribute vec3 position;
 attribute vec3 previous;
@@ -22,6 +24,7 @@ vec2 fix(vec4 i, float aspect) {
     return res;
 }
 
+${fogVertexDeclarationGLSL}
 void main() {
     float aspect = resolution.x / resolution.y;
     vec4 finalPosition = projection * view * vec4(position, 1.0);
@@ -52,6 +55,7 @@ void main() {
     }
     finalPosition.xy += normal.xy * side;
     gl_Position = finalPosition;
+${fogVertexGLSL('(view * vec4(position, 1.0)).xyz')}
     vUV = uv;
     vColor = color;
 }

package/src/shaders/trail_vert.wgsl.ts

@@ -1,3 +1,5 @@
+import {fogVertexDeclarationWGSL, fogVertexWGSL} from './chunks/fog';
+
 export default /* wgsl */ `
 attribute position: vec3f;
 attribute previous: vec3f;
@@ -22,6 +24,7 @@ fn fix(i: vec4f, aspect: f32) -> vec2f {
     return res;
 }
 
+${fogVertexDeclarationWGSL}
 @vertex
 fn main(input: VertexInputs) -> FragmentInputs {
     let aspect = uniforms.resolution.x / uniforms.resolution.y;
@@ -57,6 +60,7 @@ fn main(input: VertexInputs) -> FragmentInputs {
     finalPosition.y += normal.y * vertexInputs.side;
 
     vertexOutputs.position = finalPosition;
+${fogVertexWGSL('(uniforms.view * vec4f(vertexInputs.position, 1.0)).xyz')}
     vertexOutputs.vUV = vertexInputs.uv;
     vertexOutputs.vColor = vertexInputs.color;
 }