babylon.quarks 0.28.0 → 0.29.0

package/src/QuarksUtil.ts

@@ -2,12 +2,20 @@ import {InstancedMesh} from '@babylonjs/core/Meshes/instancedMesh';
 import {Mesh} from '@babylonjs/core/Meshes/mesh';
 import {TransformNode} from '@babylonjs/core/Meshes/transformNode';
 import {Node} from '@babylonjs/core/node';
-import {ConstantValue, EmitSubParticleSystem, FunctionValueGenerator, IntervalValue, ValueGenerator} from 'quarks.core';
+import {
+    ConstantValue,
+    EmitSubParticleSystem,
+    FunctionValueGenerator,
+    IntervalValue,
+    RandomBetweenCurves,
+    ValueGenerator,
+} from 'quarks.core';
 import {BatchedRenderer} from './BatchedRenderer';
 import {shareEffectResources} from './effectResources';
 import {MeshSurfaceEmitter} from './MeshSurfaceEmitter';
 import {ParticleEmitter} from './ParticleEmitter';
 import {ParticleSystem} from './ParticleSystem';
+import type {StopAction} from './system/types';
 
 /**
  * Helpers that act on a whole effect: every particle system under a root node, as a loaded effect
@@ -71,7 +79,17 @@ export class QuarksUtil {
         });
     }
 
-    /** Sets {@link ParticleSystem.autoDestroy} on every system under `root`. */
+    /** Sets {@link ParticleSystem.stopAction} on every system under `root`. */
+    static setStopAction(root: Node, stopAction: StopAction): void {
+        QuarksUtil.runOnAllParticleEmitters(root, (emitter) => {
+            (emitter.system as unknown as ParticleSystem).stopAction = stopAction;
+        });
+    }
+
+    /**
+     * Sets {@link ParticleSystem.autoDestroy} on every system under `root`.
+     * @deprecated Use {@link QuarksUtil.setStopAction} with `'destroy'`.
+     */
     static setAutoDestroy(root: Node, autoDestroy: boolean): void {
         QuarksUtil.runOnAllParticleEmitters(root, (emitter) => {
             (emitter.system as unknown as ParticleSystem).autoDestroy = autoDestroy;
@@ -272,6 +290,10 @@ export class QuarksUtil {
         if (generator instanceof IntervalValue) {
             return Math.max(generator.a, generator.b);
         }
+        if (generator instanceof RandomBetweenCurves) {
+            // Every mix lies between the two curves.
+            return Math.max(QuarksUtil.maxOf(generator.curve1, at), QuarksUtil.maxOf(generator.curve2, at));
+        }
         let max = -Infinity;
         const samples = 32;
         for (let i = 0; i <= samples; i++) {

package/src/SpriteBatch.ts

@@ -333,10 +333,12 @@ export class SpriteBatch extends VFXBatch {
             }
         }
         const useEnvAtlas = this.usesEnvAtlas();
+        const imageProcessing = this.imageProcessing();
         const program = shaderProgram(this.settings, {
             depth: this.depth,
             envAtlasReady: useEnvAtlas,
             meshUV2: this.meshUV2(),
+            imageProcessing,
         });
         const {defines, attributes, uniforms, samplers} = program;
         const shaderName = program.name;
@@ -407,6 +409,7 @@ export class SpriteBatch extends VFXBatch {
         }
 
         this.bindFog(mat);
+        this.bindImageProcessing(mat, imageProcessing);
         this.bindSurface(mat);
         // Billboards, beams and the like are flat sheets: both faces, whatever the setting says.
         mat.backFaceCulling = this.settings.renderFace !== 'both';

package/src/TrailBatch.ts

@@ -234,7 +234,13 @@ export class TrailBatch extends VFXBatch {
 
     /** @internal */
     rebuildMaterial(): void {
-        const program = shaderProgram(this.settings, {depth: this.depth, envAtlasReady: false, meshUV2: false});
+        const imageProcessing = this.imageProcessing();
+        const program = shaderProgram(this.settings, {
+            depth: this.depth,
+            envAtlasReady: false,
+            meshUV2: false,
+            imageProcessing,
+        });
         const {defines, attributes, uniforms, samplers} = program;
         // Stable name: the trail shader source never varies, so registering it once
         // keeps Effect.ShadersStore bounded and lets Babylon reuse compiled effects.
@@ -260,6 +266,7 @@ export class TrailBatch extends VFXBatch {
             mat.setTexture('map', this.settings.texture);
         }
         this.bindFog(mat);
+        this.bindImageProcessing(mat, imageProcessing);
         this.bindSoft(mat);
         this.bindSurface(mat);
         mat.backFaceCulling = false;

package/src/VFXBatch.ts

@@ -1,9 +1,11 @@
 import {BoundingInfo} from '@babylonjs/core/Culling/boundingInfo';
 import {BaseTexture} from '@babylonjs/core/Materials/Textures/baseTexture';
 import type {Effect} from '@babylonjs/core/Materials/effect';
+import type {ImageProcessingConfiguration} from '@babylonjs/core/Materials/imageProcessingConfiguration';
 import {ShaderMaterial} from '@babylonjs/core/Materials/shaderMaterial';
 import {Vector2 as BVector2, Vector3 as BVector3, Vector4 as BVector4, Matrix} from '@babylonjs/core/Maths/math.vector';
 import {Mesh} from '@babylonjs/core/Meshes/mesh';
+import type {Observer} from '@babylonjs/core/Misc/observable';
 import type {Node} from '@babylonjs/core/node';
 import {Scene} from '@babylonjs/core/scene';
 import {IParticleSystem, Vector3} from 'quarks.core';
@@ -11,6 +13,7 @@ import {VFXBatchSettings} from './BatchedRenderer';
 import type {ParticleSystem} from './ParticleSystem';
 import {storedBatchSettings} from './batchKey';
 import {GRADIENT_MAP_WEIGHTS, MeshLightingSettings, readsUV1, StoredBatchSettings, TextureUV} from './batchSettings';
+import {imageProcessingParts, ShaderImageProcessing} from './shaderProgram';
 import {DepthBinding, softDepthParams} from './softDepth';
 
 export * from './batchSettings';
@@ -199,6 +202,100 @@ export abstract class VFXBatch {
         });
     }
 
+    /** The observer of the scene's image processing that rebuilds the material when its defines change. */
+    private imageProcessingObserver: Observer<ImageProcessingConfiguration> | null = null;
+
+    /**
+     * The scene's image processing as the material compiles it, see {@link ShaderContext.imageProcessing}:
+     * null when the batch does not apply it.
+     * @internal
+     */
+    protected imageProcessing(): ShaderImageProcessing | null {
+        if (this.settings.applyImageProcessing === false) {
+            return null;
+        }
+        const defines: ShaderImageProcessing = {
+            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,
+        };
+        this.scene.imageProcessingConfiguration.prepareDefines(defines);
+        return defines;
+    }
+
+    /**
+     * Binds the scene's image processing to a material compiled with `compiled`: its values on every
+     * bind, unless a post process applies them, and the material's defines, uniforms and samplers
+     * swapped in place whenever the configuration changes what it has to compile (tone mapping
+     * switched on, a vignette, a colour grading texture, a post process taking over). The material
+     * stays the same one: a configuration that flips back and forth within a frame, as a reflection
+     * probe rendering in linear space does, only switches between the effects the engine has
+     * cached for each set of defines. A colour grading texture is set on the material too, so
+     * that the batch, like Babylon's own materials, is not drawn before it has loaded.
+     * @internal
+     */
+    protected bindImageProcessing(material: ShaderMaterial, compiled: ShaderImageProcessing | null): void {
+        this.releaseImageProcessing();
+        if (this.settings.applyImageProcessing === false) {
+            return;
+        }
+        const config = this.scene.imageProcessingConfiguration;
+        let current = compiled;
+        let parts = imageProcessingParts(this.settings, current);
+        let key = parts.defines.join('\n');
+        const grading = () => {
+            if (parts.samplers.includes('txColorTransform') && config.colorGradingTexture) {
+                material.setTexture('txColorTransform', config.colorGradingTexture);
+            } else {
+                material.removeTexture('txColorTransform');
+            }
+        };
+        grading();
+        this.imageProcessingObserver = config.onUpdateParameters.add(() => {
+            const next = this.imageProcessing();
+            const nextParts = imageProcessingParts(this.settings, next);
+            const nextKey = nextParts.defines.join('\n');
+            if (nextKey !== key) {
+                const options = material.options;
+                swapEntries(options.defines as string[], parts.defines, nextParts.defines);
+                swapEntries(options.uniforms, parts.uniforms, nextParts.uniforms);
+                swapEntries(options.samplers, parts.samplers, nextParts.samplers);
+                current = next;
+                parts = nextParts;
+                key = nextKey;
+            }
+            grading();
+        });
+        material.onBindObservable.add(() => {
+            if (!current?.IMAGEPROCESSING || current.IMAGEPROCESSINGPOSTPROCESS || parts.defines.length === 0) {
+                return;
+            }
+            const effect = material.getEffect();
+            if (effect) {
+                config.bind(effect);
+            }
+        });
+    }
+
+    /** Stops following the scene's image processing. @internal */
+    protected releaseImageProcessing(): void {
+        this.imageProcessingObserver?.remove();
+        this.imageProcessingObserver = null;
+    }
+
     /**
      * Seconds of renderer time, set by the renderer before each fill; what UV
      * and erosion mask scrolling advance by.
@@ -477,6 +574,21 @@ export abstract class VFXBatch {
 
     /** @internal */
     dispose(): void {
+        this.releaseImageProcessing();
         this.mesh.dispose();
     }
 }
+
+/**
+ * Replaces, in a material option list, the entries `previous` added with those of `next`: one
+ * occurrence each, so an entry the rest of the program also lists is kept.
+ */
+function swapEntries(list: string[], previous: readonly string[], next: readonly string[]): void {
+    for (const entry of previous) {
+        const at = list.lastIndexOf(entry);
+        if (at !== -1) {
+            list.splice(at, 1);
+        }
+    }
+    list.push(...next);
+}

package/src/batchKey.ts

@@ -104,6 +104,7 @@ export function storedBatchSettings(settings: VFXBatchSettings): StoredBatchSett
         layerMask: settings.layerMask,
         renderingGroupId: settings.renderingGroupId ?? 0,
         applyFog: settings.applyFog ?? true,
+        applyImageProcessing: settings.applyImageProcessing ?? true,
         pivot: quad && pivot && (pivot.x !== 0 || pivot.y !== 0 || pivot.z !== 0) ? pivot.clone() : undefined,
         sortMode: settings.sortMode ?? 'none',
         renderFace: isMesh ? validRenderFace(settings.renderFace) : 'both',
@@ -155,6 +156,7 @@ export function shaderKeyEqual(a: StoredBatchSettings, b: StoredBatchSettings):
         a.renderingGroupId === b.renderingGroupId &&
         a.renderOrder === b.renderOrder &&
         a.applyFog === b.applyFog &&
+        a.applyImageProcessing === b.applyImageProcessing &&
         a.sortMode === b.sortMode &&
         a.renderFace === b.renderFace &&
         !a.pivot === !b.pivot &&

package/src/batchSettings.ts

@@ -521,6 +521,8 @@ export interface StoredBatchSettings {
     renderingGroupId: number;
     /** Whether the scene's fog is applied, see {@link VFXBatchSettings.applyFog}. */
     applyFog: boolean;
+    /** Whether the scene's image processing is applied, see {@link VFXBatchSettings.applyImageProcessing}. */
+    applyImageProcessing: boolean;
     /** Billboard pivot in particle-size units, see {@link VFXBatchSettings.pivot}. */
     pivot?: Vector3;
     /** Draw order within the batch, see {@link SortMode}. */

package/src/index.ts

@@ -48,7 +48,9 @@ export type {
     CullingMode,
     ParticleSystemJSONParameters,
     ParticleSystemParameters,
+    RingBufferMode,
     ScalingMode,
+    StopAction,
 } from './ParticleSystem';
 export {QuarksFormatError, QuarksLoader} from './QuarksLoader';
 export type {

package/src/shaderProgram.ts

@@ -1,4 +1,9 @@
 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';
@@ -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
@@ -292,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) {
@@ -317,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');
@@ -356,6 +397,68 @@ function blendDefines(settings: ShaderSettings): string[] {
     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. */
 function softDefines(
     settings: ShaderSettings,

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,
@@ -184,6 +188,90 @@ 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}};
 
@@ -197,8 +285,8 @@ const EVERYTHING_ELSE: Axis = {
 /**
  * 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, every blend
- * resolve with and without fog and soft particles, and the texture effects alone and together on
- * each shader family. What a shader validator compiles, and what
+ * 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.
@@ -208,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);
@@ -241,5 +329,14 @@ export function shaderVariants(): ShaderVariant[] {
                 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

@@ -5,27 +5,35 @@
  * 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. See `blendCategory`.
+ * 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`.
  */
 
-/** Resolves the vec4 lvalue `color` for the blend mode, GLSL. */
+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 */ `
+    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)}`;
 }
 
-/** Resolves the `var` vec4 `color` for the blend mode, WGSL. */
+/** Processes and resolves the `var` vec4 `color` for the blend mode, WGSL. */
 export function blendFragmentWGSL(color: string): string {
-    return /* wgsl */ `
+    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)}`;
 }