babylon.quarks 0.27.0 → 0.29.0

package/src/shaderProgram.ts

@@ -1,5 +1,11 @@
 import {Constants} from '@babylonjs/core/Engines/constants';
+import type {IImageProcessingConfigurationDefines} from '@babylonjs/core/Materials/imageProcessingConfiguration.defines';
+import {
+    PrepareSamplersForImageProcessing,
+    PrepareUniformsForImageProcessing,
+} from '@babylonjs/core/Materials/imageProcessingConfiguration.functions';
 import {hasSizeLimits, takesPivotAndSizeLimits, tilesSheet} from './batchKey';
+import {readsUV1, RenderMode, StoredBatchSettings} from './batchSettings';
 import local_particle_physics_vert from './shaders/local_particle_physics_vert.glsl';
 import local_particle_physics_vert_wgsl from './shaders/local_particle_physics_vert.wgsl';
 import particle_frag from './shaders/particle_frag.glsl';
@@ -15,7 +21,6 @@ import trail_frag from './shaders/trail_frag.glsl';
 import trail_frag_wgsl from './shaders/trail_frag.wgsl';
 import trail_vert from './shaders/trail_vert.glsl';
 import trail_vert_wgsl from './shaders/trail_vert.wgsl';
-import {readsUV1, RenderMode, StoredBatchSettings} from './VFXBatch';
 
 /**
  * The part of a batch's settings that decides its shader: the render mode, which textures and
@@ -35,6 +40,7 @@ export type ShaderSettings = Pick<
     | 'materialTransparent'
     | 'materialBlendMode'
     | 'applyFog'
+    | 'applyImageProcessing'
     | 'pivot'
     | 'minParticleSize'
     | 'maxParticleSize'
@@ -66,8 +72,41 @@ export interface ShaderContext {
     envAtlasReady: boolean;
     /** Whether the mesh batch has a second UV set to read for {@link UVChannel} 1. */
     meshUV2: boolean;
+    /**
+     * The scene's image processing as `ImageProcessingConfiguration.prepareDefines` writes it;
+     * null or left out for none. Compiled in only when the settings apply it, see
+     * {@link ParticleSystem.applyImageProcessing}.
+     */
+    imageProcessing?: ShaderImageProcessing | null;
 }
 
+/**
+ * The defines an `ImageProcessingConfiguration` prepares for a material
+ * (`ImageProcessingConfigurationDefines`): which of its effects are on, and whether a post
+ * process applies it instead.
+ */
+export type ShaderImageProcessing = Readonly<IImageProcessingConfigurationDefines>;
+
+/** The keys of {@link ShaderImageProcessing}, in the order Babylon writes them. @internal */
+export const IMAGE_PROCESSING_DEFINES: readonly (keyof IImageProcessingConfigurationDefines)[] = [
+    'IMAGEPROCESSING',
+    'WHITEBALANCE',
+    'VIGNETTE',
+    'VIGNETTEBLENDMODEMULTIPLY',
+    'VIGNETTEBLENDMODEOPAQUE',
+    'TONEMAPPING',
+    'CONTRAST',
+    'COLORCURVES',
+    'COLORGRADING',
+    'COLORGRADING3D',
+    'SAMPLER3DGREENDEPTH',
+    'SAMPLER3DBGRMAP',
+    'DITHER',
+    'IMAGEPROCESSINGPOSTPROCESS',
+    'EXPOSURE',
+    'SKIPFINALCOLORCLAMP',
+];
+
 /**
  * One compiled shader of the library: the sources in both languages and the defines, attributes,
  * uniforms and samplers the material is built with. Built by {@link shaderProgram} from a
@@ -111,12 +150,94 @@ export function samplesMap(settings: {renderMode: RenderMode; texture: unknown})
     return settings.texture !== null || settings.renderMode === RenderMode.Mesh;
 }
 
-/** Whether the blend mode adds to the frame, in which case fog and fade darken instead of mixing. */
-export function blendsAdditively(settings: {materialTransparent: boolean; materialBlendMode: number}): boolean {
-    return (
-        settings.materialTransparent &&
-        (settings.materialBlendMode === Constants.ALPHA_ADD || settings.materialBlendMode === Constants.ALPHA_ONEONE)
-    );
+/**
+ * How a particle's colour has to leave the fragment shader for its blend mode, so that its alpha
+ * means coverage: alpha 0 leaves the frame as it was, alpha 1 draws the colour in full, and the
+ * fades (soft particles, erosion, a rim fade, alpha over life) only lower alpha. Unity's particle
+ * shaders do the same for their Alpha, Premultiply, Additive and Multiply modes. Alpha has no
+ * such meaning for an opaque material, nor under `ALPHA_INTERPOLATE` (constant blend colour),
+ * `ALPHA_REPLACE_COLOR` (replaces the frame) and `ALPHA_DUAL_SRC0_ADD_SRC1xDST` (reads a second
+ * shader output the particle shaders do not write); these leave the colour as it is.
+ *
+ * - `'straight'`: the blend weighs the colour by its alpha itself (Babylon's `ALPHA_COMBINE`,
+ *   `ALPHA_ADD`, `ALPHA_LAYER_ACCUMULATE`, …) or does not blend; the colour leaves as it is.
+ * - `'premultiply'`: the blend takes the colour at full weight, or the frame by one minus the
+ *   colour (`ALPHA_PREMULTIPLIED`, `ALPHA_ONEONE`, `ALPHA_SCREENMODE`, `ALPHA_SUBTRACT`,
+ *   `ALPHA_MAXIMIZED`, `ALPHA_MAX`, …), so the shader multiplies it by its alpha: black, which
+ *   these modes leave the frame alone with, at alpha 0. Textures stay straight alpha, as in
+ *   Unity's Premultiply mode. The fade is linear in alpha except under `ALPHA_MAXIMIZED`, whose
+ *   blend weighs the colour by alpha once more, and `ALPHA_MAX`.
+ * - `'multiply'`: the blend multiplies the frame by the colour (`ALPHA_MULTIPLY`, `ALPHA_MIN`), so
+ *   the shader moves it toward white, which leaves the frame alone, as alpha falls. `ALPHA_MIN`
+ *   clamps a frame brighter than 1 (an HDR target) to 1 where a particle draws, even at alpha 0.
+ */
+export type BlendOutput = 'straight' | 'premultiply' | 'multiply';
+
+/**
+ * What the scene's fog turns a particle's colour into with distance: the fog colour where the
+ * particle covers the frame (`'color'`), black where it adds to it (`'black'`, or the fog would
+ * add itself to the whole screen), white where it multiplies it (`'white'`). Unity fogs its
+ * additive and multiply particles toward black and white for the same reason.
+ */
+export type FogTarget = 'color' | 'black' | 'white';
+
+/** The {@link BlendOutput} and {@link FogTarget} of a blend mode. */
+export interface BlendCategory {
+    /** How the colour leaves the shader. */
+    output: BlendOutput;
+    /** Where the fog takes the colour. */
+    fogTarget: FogTarget;
+}
+
+const PREMULTIPLY_MODES = new Set<number>([
+    Constants.ALPHA_SUBTRACT,
+    Constants.ALPHA_MAXIMIZED,
+    Constants.ALPHA_ONEONE,
+    Constants.ALPHA_PREMULTIPLIED,
+    Constants.ALPHA_PREMULTIPLIED_PORTERDUFF,
+    Constants.ALPHA_SCREENMODE,
+    Constants.ALPHA_ONEONE_ONEONE,
+    Constants.ALPHA_ALPHATOCOLOR,
+    Constants.ALPHA_REVERSEONEMINUS,
+    Constants.ALPHA_SRC_DSTONEMINUSSRCALPHA,
+    Constants.ALPHA_ONEONE_ONEZERO,
+    Constants.ALPHA_EXCLUSION,
+    Constants.ALPHA_MAX,
+]);
+const MULTIPLY_MODES = new Set<number>([Constants.ALPHA_MULTIPLY, Constants.ALPHA_MIN]);
+/** The modes whose fog is the fog colour: those that lay the colour over the frame or replace it. */
+const OVER_MODES = new Set<number>([
+    Constants.ALPHA_COMBINE,
+    Constants.ALPHA_PREMULTIPLIED,
+    Constants.ALPHA_PREMULTIPLIED_PORTERDUFF,
+    Constants.ALPHA_INTERPOLATE,
+    Constants.ALPHA_SRC_DSTONEMINUSSRCALPHA,
+    Constants.ALPHA_LAYER_ACCUMULATE,
+    Constants.ALPHA_REPLACE_COLOR,
+]);
+
+/**
+ * The {@link BlendCategory} of a material: an opaque one (`materialTransparent` false, or
+ * `ALPHA_DISABLE`) is straight and fogs toward the fog colour; a transparent one by its Babylon
+ * alpha mode. A mode this table does not know is straight and fogs toward the fog colour.
+ */
+export function blendCategory(settings: {materialTransparent: boolean; materialBlendMode: number}): BlendCategory {
+    const mode = settings.materialBlendMode;
+    if (!settings.materialTransparent || mode === Constants.ALPHA_DISABLE) {
+        return {output: 'straight', fogTarget: 'color'};
+    }
+    const output: BlendOutput = PREMULTIPLY_MODES.has(mode)
+        ? 'premultiply'
+        : MULTIPLY_MODES.has(mode)
+          ? 'multiply'
+          : 'straight';
+    const fogTarget: FogTarget =
+        output === 'multiply'
+            ? 'white'
+            : OVER_MODES.has(mode) || (output === 'straight' && mode !== Constants.ALPHA_ADD)
+              ? 'color'
+              : 'black';
+    return {output, fogTarget};
 }
 
 /** The shader program a batch with `settings` compiles, given what it knows about its textures. */
@@ -146,7 +267,7 @@ function spriteShaderProgram(settings: ShaderSettings, context: ShaderContext):
         fragment = {glsl: particle_frag, wgsl: particle_frag_wgsl};
     }
 
-    const defines = fogDefines(settings);
+    const defines = blendDefines(settings);
     const attributes = [...SPRITE_ATTRIBUTES];
     const uniforms = ['world', 'view', 'projection', ...FOG_UNIFORMS];
     const samplers: string[] = [];
@@ -210,6 +331,7 @@ function spriteShaderProgram(settings: ShaderSettings, context: ShaderContext):
         uniforms.push('eyePosition');
     }
     surfaceDefines(settings, defines, uniforms, samplers);
+    imageProcessingDefines(settings, context, defines, uniforms, samplers);
     if (isMesh) {
         attributes.push('normal');
         if (readsUV1(settings) && context.meshUV2) {
@@ -225,7 +347,7 @@ function spriteShaderProgram(settings: ShaderSettings, context: ShaderContext):
 
 /** The program of a trail batch. */
 function trailShaderProgram(settings: ShaderSettings, context: ShaderContext): ShaderProgram {
-    const defines = fogDefines(settings);
+    const defines = blendDefines(settings);
     const attributes = [...TRAIL_ATTRIBUTES];
     const uniforms = ['view', 'projection', ...FOG_UNIFORMS];
     const samplers: string[] = [];
@@ -235,6 +357,7 @@ function trailShaderProgram(settings: ShaderSettings, context: ShaderContext): S
     }
     surfaceDefines(settings, defines, uniforms, samplers);
     softDefines(settings, context, defines, uniforms, samplers);
+    imageProcessingDefines(settings, context, defines, uniforms, samplers);
     if (readsUV1(settings)) {
         // A trail's channel 1 arrives as its own vertex buffer.
         attributes.push('uv2');
@@ -251,15 +374,89 @@ function trailShaderProgram(settings: ShaderSettings, context: ShaderContext): S
 }
 
 /**
- * The fog defines: `FOG` when the settings apply the scene's fog, and `FOG_ADDITIVE` when the
- * particles add to the frame, so that they fade toward black instead of the fog colour, which
- * would fog the whole screen (what Unity does for additive materials).
+ * The blend defines: `BLEND_PREMULTIPLY` or `BLEND_MULTIPLY` for how the colour leaves the shader,
+ * and with `FOG` (when the settings apply the scene's fog) `FOG_ADDITIVE` or `FOG_MULTIPLY` for a
+ * fog toward black or white. See {@link blendCategory}.
  */
-function fogDefines(settings: ShaderSettings): string[] {
-    if (!settings.applyFog) {
-        return [];
+function blendDefines(settings: ShaderSettings): string[] {
+    const {output, fogTarget} = blendCategory(settings);
+    const defines: string[] = [];
+    if (output === 'premultiply') {
+        defines.push('BLEND_PREMULTIPLY');
+    } else if (output === 'multiply') {
+        defines.push('BLEND_MULTIPLY');
     }
-    return blendsAdditively(settings) ? ['FOG', 'FOG_ADDITIVE'] : ['FOG'];
+    if (settings.applyFog) {
+        defines.push('FOG');
+        if (fogTarget === 'black') {
+            defines.push('FOG_ADDITIVE');
+        } else if (fogTarget === 'white') {
+            defines.push('FOG_MULTIPLY');
+        }
+    }
+    return defines;
+}
+
+/**
+ * Whether a batch with `settings` compiles the scene's image processing `ip` in: when the settings
+ * apply it and it does something, either in the material (`IMAGEPROCESSING`) or through a post
+ * process the colour is left in linear space for (`IMAGEPROCESSINGPOSTPROCESS`). A material that
+ * multiplies the frame takes no in-material processing: its colour is a factor, and tone mapping
+ * white would darken the frame where the particle is fully faded. See `chunks/imageProcessing.ts`.
+ */
+export function compilesImageProcessing(
+    settings: Pick<ShaderSettings, 'applyImageProcessing' | 'materialTransparent' | 'materialBlendMode'>,
+    ip: ShaderImageProcessing | null | undefined
+): boolean {
+    if (settings.applyImageProcessing === false || !ip) {
+        return false;
+    }
+    if (ip.IMAGEPROCESSINGPOSTPROCESS) {
+        return true;
+    }
+    return ip.IMAGEPROCESSING && blendCategory(settings).output !== 'multiply';
+}
+
+/**
+ * The defines, uniforms and samplers the scene's image processing `ip` adds to a material with
+ * `settings`: nothing unless {@link compilesImageProcessing}, otherwise its defines as Babylon
+ * writes them (a number always, a flag when set) and the uniforms and samplers its effects read.
+ * A batch swaps these in place on its material when the configuration changes what compiles.
+ * @internal
+ */
+export function imageProcessingParts(
+    settings: Pick<ShaderSettings, 'applyImageProcessing' | 'materialTransparent' | 'materialBlendMode'>,
+    ip: ShaderImageProcessing | null | undefined
+): {defines: string[]; uniforms: string[]; samplers: string[]} {
+    const parts = {defines: [] as string[], uniforms: [] as string[], samplers: [] as string[]};
+    if (!ip || !compilesImageProcessing(settings, ip)) {
+        return parts;
+    }
+    for (const key of IMAGE_PROCESSING_DEFINES) {
+        const value = ip[key];
+        if (typeof value === 'number') {
+            parts.defines.push(`${key} ${value}`);
+        } else if (value) {
+            parts.defines.push(key);
+        }
+    }
+    PrepareUniformsForImageProcessing(parts.uniforms, ip);
+    PrepareSamplersForImageProcessing(parts.samplers, ip);
+    return parts;
+}
+
+/** Appends {@link imageProcessingParts} to a program's lists. */
+function imageProcessingDefines(
+    settings: ShaderSettings,
+    context: ShaderContext,
+    defines: string[],
+    uniforms: string[],
+    samplers: string[]
+): void {
+    const parts = imageProcessingParts(settings, context.imageProcessing);
+    defines.push(...parts.defines);
+    uniforms.push(...parts.uniforms);
+    samplers.push(...parts.samplers);
 }
 
 /** Soft particles, when on and a depth texture is there to read, and the alpha test. */

package/src/shaderVariants.ts

@@ -1,7 +1,7 @@
 import {Constants} from '@babylonjs/core/Engines/constants';
 import type {BaseTexture} from '@babylonjs/core/Materials/Textures/baseTexture';
 import {Vector3} from 'quarks.core';
-import {ShaderContext, shaderProgram, ShaderProgram, ShaderSettings} from './shaderProgram';
+import {ShaderContext, ShaderImageProcessing, shaderProgram, ShaderProgram, ShaderSettings} from './shaderProgram';
 import {
     normalizeErosion,
     normalizeGradientMap,
@@ -25,7 +25,10 @@ export interface ShaderVariant {
 /** A texture reference for settings that only ask whether one is set; it is never sampled. */
 const TEXTURE = {} as BaseTexture;
 
-/** The settings of a bare batch in `renderMode`: no texture, no effects, fog off, 1×1 sheet. */
+/**
+ * The settings of a bare batch in `renderMode`: no texture, no effects, fog off, 1×1 sheet. Image
+ * processing is applied, and compiles in only with an image processing axis in the context.
+ */
 function bare(renderMode: RenderMode): ShaderSettings {
     return {
         renderMode,
@@ -39,6 +42,7 @@ function bare(renderMode: RenderMode): ShaderSettings {
         materialTransparent: true,
         materialBlendMode: Constants.ALPHA_COMBINE,
         applyFog: false,
+        applyImageProcessing: true,
         pivot: undefined,
         minParticleSize: 0,
         maxParticleSize: Infinity,
@@ -123,6 +127,21 @@ const FOG: Axis[] = [
     {name: 'fog additive', settings: {applyFog: true, materialBlendMode: Constants.ALPHA_ADD}},
 ];
 
+/** The blend resolves (see `blendCategory`), with and without the fog each one takes. */
+const BLEND: Axis[] = [
+    {name: 'premultiplied', settings: {materialBlendMode: Constants.ALPHA_PREMULTIPLIED}},
+    {name: 'premultiplied fog', settings: {materialBlendMode: Constants.ALPHA_PREMULTIPLIED, applyFog: true}},
+    {name: 'one-one', settings: {materialBlendMode: Constants.ALPHA_ONEONE}},
+    {name: 'one-one fog', settings: {materialBlendMode: Constants.ALPHA_ONEONE, applyFog: true}},
+    {name: 'multiply', settings: {materialBlendMode: Constants.ALPHA_MULTIPLY}},
+    {name: 'multiply fog', settings: {materialBlendMode: Constants.ALPHA_MULTIPLY, applyFog: true}},
+    {
+        name: 'multiply fog alpha test',
+        settings: {materialBlendMode: Constants.ALPHA_MULTIPLY, applyFog: true, materialAlphaTest: 0.5},
+    },
+    {name: 'opaque', settings: {materialTransparent: false}},
+];
+
 /** Texture effects (`chunks/surface.ts`), alone and together, on both UV channels. */
 const SURFACE: Axis[] = (() => {
     const uv0 = normalizeMapUV({tiling: [2, 2]});
@@ -169,20 +188,105 @@ const SURFACE_TARGETS = [
     'trail',
 ];
 
+/** A scene configuration's defines with `on` set and the rest off, see {@link ShaderImageProcessing}. */
+function imageProcessing(on: Partial<ShaderImageProcessing>): ShaderImageProcessing {
+    return {
+        IMAGEPROCESSING: false,
+        WHITEBALANCE: false,
+        VIGNETTE: false,
+        VIGNETTEBLENDMODEMULTIPLY: false,
+        VIGNETTEBLENDMODEOPAQUE: false,
+        TONEMAPPING: 0,
+        CONTRAST: false,
+        EXPOSURE: false,
+        COLORCURVES: false,
+        COLORGRADING: false,
+        COLORGRADING3D: false,
+        SAMPLER3DGREENDEPTH: false,
+        SAMPLER3DBGRMAP: false,
+        DITHER: false,
+        IMAGEPROCESSINGPOSTPROCESS: false,
+        SKIPFINALCOLORCLAMP: false,
+        ...on,
+    };
+}
+
+/**
+ * The scene's image processing: applied by a post process, and in the material with each of its
+ * effects and tone mappers at least once.
+ */
+const IMAGE_PROCESSING: Axis[] = [
+    {name: 'post-processed', context: {imageProcessing: imageProcessing({IMAGEPROCESSINGPOSTPROCESS: true})}},
+    {name: 'tone mapped', context: {imageProcessing: imageProcessing({IMAGEPROCESSING: true, TONEMAPPING: 1})}},
+    {
+        name: 'aces exposure contrast',
+        context: {
+            imageProcessing: imageProcessing({IMAGEPROCESSING: true, TONEMAPPING: 2, EXPOSURE: true, CONTRAST: true}),
+        },
+    },
+    {
+        name: 'neutral vignette dither',
+        context: {
+            imageProcessing: imageProcessing({
+                IMAGEPROCESSING: true,
+                TONEMAPPING: 3,
+                VIGNETTE: true,
+                VIGNETTEBLENDMODEMULTIPLY: true,
+                DITHER: true,
+            }),
+        },
+    },
+    {
+        name: 'opaque vignette curves white balance grading',
+        context: {
+            imageProcessing: imageProcessing({
+                IMAGEPROCESSING: true,
+                VIGNETTE: true,
+                VIGNETTEBLENDMODEOPAQUE: true,
+                COLORCURVES: true,
+                WHITEBALANCE: true,
+                COLORGRADING: true,
+                SKIPFINALCOLORCLAMP: true,
+            }),
+        },
+    },
+    {
+        name: 'grading 3d green depth bgr',
+        context: {
+            imageProcessing: imageProcessing({
+                IMAGEPROCESSING: true,
+                COLORGRADING: true,
+                COLORGRADING3D: true,
+                SAMPLER3DGREENDEPTH: true,
+                SAMPLER3DBGRMAP: true,
+            }),
+        },
+    },
+];
+
+/** The blends image processing is tried with: over, premultiplied, additive and multiply. */
+const IMAGE_PROCESSING_BLEND: Axis[] = [
+    NONE,
+    {name: 'premultiplied', settings: {materialBlendMode: Constants.ALPHA_PREMULTIPLIED}},
+    {name: 'additive fog', settings: {materialBlendMode: Constants.ALPHA_ADD, applyFog: true}},
+    {name: 'multiply', settings: {materialBlendMode: Constants.ALPHA_MULTIPLY}},
+];
+
 /** A mesh batch whose geometry has a second UV set. */
 const MESH_UV2: Axis = {name: 'uv2', context: {meshUV2: true}};
 
 /** Soft, alpha-tested and fogged at once, to try the effects with the rest of the fragment. */
 const EVERYTHING_ELSE: Axis = {
-    name: 'soft packed alpha test fog additive',
-    settings: {softParticles: true, materialAlphaTest: 0.5, applyFog: true, materialBlendMode: Constants.ALPHA_ADD},
+    name: 'soft packed alpha test fog one-one',
+    settings: {softParticles: true, materialAlphaTest: 0.5, applyFog: true, materialBlendMode: Constants.ALPHA_ONEONE},
     context: {depth: {packed: true}},
 };
 
 /**
  * Every shader program the library can compile, one per distinct set of defines: every render
- * mode with every combination of sheet, map, soft particles, alpha test and fog, and the texture
- * effects alone and together on each shader family. What a shader validator compiles, and what
+ * mode with every combination of sheet, map, soft particles, alpha test and fog, every blend
+ * resolve with and without fog and soft particles, the texture effects alone and together on
+ * each shader family, and the scene's image processing on every render mode. What a shader validator compiles, and what
  * an application can warm the shader cache with before its first frame (Unity's
  * ShaderVariantCollection). Built by {@link shaderProgram}, so a variant here is a material a
  * batch would build.
@@ -192,7 +296,7 @@ export function shaderVariants(): ShaderVariant[] {
     const out: ShaderVariant[] = [];
     const add = (axes: Axis[]) => {
         const settings = bare(RenderMode.BillBoard);
-        const context: ShaderContext = {depth: null, envAtlasReady: false, meshUV2: false};
+        const context: ShaderContext = {depth: null, envAtlasReady: false, meshUV2: false, imageProcessing: null};
         for (const axis of axes) {
             Object.assign(settings, axis.settings);
             Object.assign(context, axis.context);
@@ -215,11 +319,24 @@ export function shaderVariants(): ShaderVariant[] {
                         for (const alphaTest of ALPHA_TEST)
                             for (const fog of FOG) add([target, quad, tile, map, soft, alphaTest, fog]);
 
+    for (const target of TARGETS)
+        for (const blend of BLEND)
+            for (const soft of SOFT.slice(0, 2)) for (const map of MAP) add([target, blend, soft, map]);
+
     for (const target of TARGETS.filter((t) => SURFACE_TARGETS.includes(t.name)))
         for (const uv2 of target.settings?.renderMode === RenderMode.Mesh ? [NONE, MESH_UV2] : [NONE])
             for (const surface of SURFACE)
                 for (const map of MAP)
                     for (const tile of [NONE, TILE[2]])
                         for (const rest of [NONE, EVERYTHING_ELSE]) add([target, uv2, surface, map, tile, rest]);
+
+    for (const target of TARGETS)
+        for (const ip of IMAGE_PROCESSING)
+            for (const blend of IMAGE_PROCESSING_BLEND) for (const map of MAP) add([target, ip, blend, map]);
+
+    // With the rest of the fragment: soft, alpha-tested, fogged and with every texture effect.
+    const everySurface = SURFACE[SURFACE.length - 3];
+    for (const target of TARGETS.filter((t) => SURFACE_TARGETS.includes(t.name)))
+        for (const ip of IMAGE_PROCESSING) add([target, ip, everySurface, MAP[MAP.length - 1], EVERYTHING_ELSE]);
     return out;
 }

package/src/shaders/chunks/blend.ts

@@ -0,0 +1,39 @@
+/**
+ * The blend resolve for the particle shaders, in both shader languages.
+ *
+ * Every fade in the shaders (soft particles, erosion, a rim fade, alpha over life) lowers alpha
+ * only, so that alpha means coverage. Blend modes that take the colour at full weight
+ * (`BLEND_PREMULTIPLY`: one-one, premultiplied, screen, subtract, …) would ignore it, so the
+ * resolve multiplies the colour by its alpha; modes that multiply the frame (`BLEND_MULTIPLY`)
+ * move it toward white instead. It runs last, after fog and the soft fade, with the scene's image
+ * processing (`imageProcessing.ts`) around it. See `blendCategory`.
+ */
+
+import {
+    imageProcessingFragmentGLSL,
+    imageProcessingFragmentWGSL,
+    imageProcessingResolvedGLSL,
+    imageProcessingResolvedWGSL,
+} from './imageProcessing';
+
+/** Processes and resolves the vec4 lvalue `color` for the blend mode, GLSL. */
+export function blendFragmentGLSL(color: string): string {
+    return /* glsl */ `${imageProcessingFragmentGLSL(color)}
+#if defined(BLEND_PREMULTIPLY)
+    ${color}.rgb *= ${color}.a;
+#elif defined(BLEND_MULTIPLY)
+    ${color}.rgb = mix(vec3(1.0), ${color}.rgb, ${color}.a);
+#endif
+${imageProcessingResolvedGLSL(color)}`;
+}
+
+/** Processes and resolves the `var` vec4 `color` for the blend mode, WGSL. */
+export function blendFragmentWGSL(color: string): string {
+    return /* wgsl */ `${imageProcessingFragmentWGSL(color)}
+#if defined(BLEND_PREMULTIPLY)
+    ${color} = vec4f(${color}.rgb * ${color}.a, ${color}.a);
+#elif defined(BLEND_MULTIPLY)
+    ${color} = vec4f(mix(vec3f(1.0), ${color}.rgb, ${color}.a), ${color}.a);
+#endif
+${imageProcessingResolvedWGSL(color)}`;
+}

package/src/shaders/chunks/fog.ts

@@ -11,7 +11,8 @@
  *
  * 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.
+ * and multiplying particles (`FOG_MULTIPLY`) toward white, which leaves the
+ * frame as it is: what Unity does for additive and multiply materials.
  */
 
 /** Vertex-side declaration, GLSL. */
@@ -62,8 +63,10 @@ export function fogFragmentGLSL(rgb: string): string {
 #ifdef FOG
     {
         float fogFactor = quarksFogFactor();
-#ifdef FOG_ADDITIVE
+#if defined(FOG_ADDITIVE)
         ${rgb} *= fogFactor;
+#elif defined(FOG_MULTIPLY)
+        ${rgb} = mix(vec3(1.0), ${rgb}, fogFactor);
 #else
         ${rgb} = mix(vFogColor, ${rgb}, fogFactor);
 #endif
@@ -110,8 +113,10 @@ fn quarksFog(rgb: vec3f, fogDistanceVector: vec3f) -> vec3f {
         fogCoeff = exp(-fogDistance * fogDistance * fogDensity * fogDensity);
     }
     let fogFactor = clamp(fogCoeff, 0.0, 1.0);
-#ifdef FOG_ADDITIVE
+#if defined(FOG_ADDITIVE)
     return rgb * fogFactor;
+#elif defined(FOG_MULTIPLY)
+    return mix(vec3f(1.0), rgb, fogFactor);
 #else
     return mix(uniforms.vFogColor, rgb, fogFactor);
 #endif