@driftengine/core 4.8.4 → 4.8.6

package/src/render/shaders/generated/particle.wgsl.ts

@@ -11,7 +11,9 @@ export const PARTICLE_SMOKE_FRAG_WGSL = "struct Uniforms {\n    uTime: f32,\n
 
 export const PARTICLE_SPARK_FRAG_WGSL = "struct Uniforms {\n    uTime: f32,\n    uCameraPos: vec3<f32>,\n    uCoreGain: f32,\n    uFogColor: vec3<f32>,\n    uFogDensity: f32,\n    uFogHeightFalloff: f32,\n    uFogEyeY: f32,\n    uUnderwaterColor: vec3<f32>,\n    uUnderwaterFogDensity: f32,\n    uUnderwaterFactor: f32,\n    uFogMode: i32,\n    uFogNear: f32,\n    uFogFar: f32,\n    uOutputTransform: i32,\n    uOutputExposure: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vUv_1: vec2<f32>;\nvar<private> vSeed_1: f32;\nvar<private> vAge_1: f32;\nvar<private> vAlpha_1: f32;\nvar<private> vWorldPos_1: vec3<f32>;\nvar<private> outColor: vec4<f32>;\nvar<private> vColor_1: vec3<f32>;\nvar<private> vNormal_1: vec3<f32>;\n\nfn linearToSrgb_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var low: vec3<f32>;\n    var high: vec3<f32>;\n\n    let _e90 = (*c);\n    low = (_e90 * 12.92f);\n    let _e92 = (*c);\n    high = ((pow(max(_e92, vec3<f32>(0f, 0f, 0f)), vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3(0.055f));\n    let _e98 = high;\n    let _e99 = low;\n    let _e100 = (*c);\n    return mix(_e98, _e99, step(_e100, vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f)));\n}\n\nfn highlightShoulder_u0028_vf3_u003b(c_1: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var m: f32;\n    var e: f32;\n\n    let _e91 = (*c_1)[0u];\n    let _e93 = (*c_1)[1u];\n    let _e95 = (*c_1)[2u];\n    m = max(_e91, max(_e93, _e95));\n    let _e98 = m;\n    if (_e98 <= 0.8f) {\n        let _e100 = (*c_1);\n        return _e100;\n    }\n    let _e101 = m;\n    e = (_e101 - 0.8f);\n    let _e103 = (*c_1);\n    let _e104 = e;\n    let _e106 = e;\n    let _e110 = m;\n    return (_e103 * ((0.8f + ((0.2f * _e104) / (_e106 + 0.2f))) / _e110));\n}\n\nfn rrtAndOdtFit_u0028_vf3_u003b(v: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var a: vec3<f32>;\n    var b: vec3<f32>;\n\n    let _e90 = (*v);\n    let _e91 = (*v);\n    a = ((_e90 * (_e91 + vec3(0.0245786f))) - vec3(0.000090537f));\n    let _e97 = (*v);\n    let _e98 = (*v);\n    b = ((_e97 * ((_e98 * 0.983729f) + vec3(0.432951f))) + vec3(0.238081f));\n    let _e105 = a;\n    let _e106 = b;\n    return (_e105 / _e106);\n}\n\nfn acesFilmic_u0028_vf3_u003b(x: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param: vec3<f32>;\n\n    let _e90 = unnamed.uOutputExposure;\n    let _e91 = (*x);\n    (*x) = (_e91 * _e90);\n    let _e93 = (*x);\n    param = (mat3x3<f32>(vec3<f32>(0.59719f, 0.076f, 0.0284f), vec3<f32>(0.35458f, 0.90834f, 0.13383f), vec3<f32>(0.04823f, 0.01566f, 0.83777f)) * _e93);\n    let _e95 = rrtAndOdtFit_u0028_vf3_u003b((&param));\n    return clamp((mat3x3<f32>(vec3<f32>(1.60475f, -0.10208f, -0.00327f), vec3<f32>(-0.53108f, 1.10813f, -0.07276f), vec3<f32>(-0.07367f, -0.00605f, 1.07602f)) * _e95), vec3(0f), vec3(1f));\n}\n\nfn applyOutputTransform_u0028_vf3_u003b(c_2: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param_1: vec3<f32>;\n    var param_2: vec3<f32>;\n    var param_3: vec3<f32>;\n\n    let _e92 = unnamed.uOutputTransform;\n    if (_e92 == 0i) {\n        let _e94 = (*c_2);\n        return _e94;\n    }\n    let _e96 = unnamed.uOutputTransform;\n    if (_e96 == 2i) {\n        let _e98 = (*c_2);\n        param_1 = _e98;\n        let _e99 = acesFilmic_u0028_vf3_u003b((&param_1));\n        (*c_2) = _e99;\n    }\n    let _e101 = unnamed.uOutputTransform;\n    if (_e101 == 3i) {\n        let _e103 = (*c_2);\n        let _e105 = unnamed.uOutputExposure;\n        param_2 = (_e103 * _e105);\n        let _e107 = highlightShoulder_u0028_vf3_u003b((&param_2));\n        (*c_2) = _e107;\n    }\n    let _e108 = (*c_2);\n    param_3 = _e108;\n    let _e109 = linearToSrgb_u0028_vf3_u003b((&param_3));\n    return _e109;\n}\n\nfn mediumFog_u0028_f1_u003b_f1_u003b(dist: ptr<function, f32>, pointY: ptr<function, f32>) -> f32 {\n    var span: f32;\n    var ramp: f32;\n    var wetLinear: f32;\n    var t: f32;\n    var denom: f32;\n    var air: f32;\n    var wet: f32;\n\n    let _e97 = unnamed.uFogMode;\n    if (_e97 == 1i) {\n        let _e100 = unnamed.uFogFar;\n        let _e102 = unnamed.uFogNear;\n        span = max((_e100 - _e102), 0.0001f);\n        let _e105 = (*dist);\n        let _e107 = unnamed.uFogNear;\n        let _e109 = span;\n        ramp = clamp(((_e105 - _e107) / _e109), 0f, 1f);\n        let _e113 = unnamed.uUnderwaterFactor;\n        if (_e113 <= 0f) {\n            let _e115 = ramp;\n            return _e115;\n        }\n        let _e117 = unnamed.uUnderwaterFogDensity;\n        let _e118 = (*dist);\n        wetLinear = (_e117 * _e118);\n        let _e120 = ramp;\n        let _e121 = wetLinear;\n        let _e123 = wetLinear;\n        let _e129 = unnamed.uUnderwaterFactor;\n        return mix(_e120, (1f - exp2(((-(_e121) * _e123) * 1.442695f))), _e129);\n    }\n    let _e131 = (*pointY);\n    let _e133 = unnamed.uFogEyeY;\n    let _e136 = unnamed.uFogHeightFalloff;\n    t = ((_e131 - _e133) * _e136);\n    let _e138 = t;\n    let _e141 = t;\n    denom = select(_e141, 0.0001f, (abs(_e138) < 0.0001f));\n    let _e144 = unnamed.uFogDensity;\n    let _e146 = (*dist);\n    let _e148 = denom;\n    let _e153 = denom;\n    air = (1f - exp((((-(_e144) * _e146) * (1f - exp(-(_e148)))) / _e153)));\n    let _e158 = unnamed.uUnderwaterFactor;\n    if (_e158 <= 0f) {\n        let _e160 = air;\n        return _e160;\n    }\n    let _e162 = unnamed.uUnderwaterFogDensity;\n    let _e163 = (*dist);\n    wet = (_e162 * _e163);\n    let _e165 = air;\n    let _e166 = wet;\n    let _e168 = wet;\n    let _e174 = unnamed.uUnderwaterFactor;\n    return mix(_e165, (1f - exp2(((-(_e166) * _e168) * 1.442695f))), _e174);\n}\n\nfn hash21_u0028_vf2_u003b(p: ptr<function, vec2<f32>>) -> f32 {\n    let _e88 = (*p);\n    return fract((sin(dot(_e88, vec2<f32>(127.1f, 311.7f))) * 43758.547f));\n}\n\nfn valueNoise_u0028_vf2_u003b(p_1: ptr<function, vec2<f32>>) -> f32 {\n    var i: vec2<f32>;\n    var f: vec2<f32>;\n    var u: vec2<f32>;\n    var param_4: vec2<f32>;\n    var param_5: vec2<f32>;\n    var param_6: vec2<f32>;\n    var param_7: vec2<f32>;\n\n    let _e95 = (*p_1);\n    i = floor(_e95);\n    let _e97 = (*p_1);\n    f = fract(_e97);\n    let _e99 = f;\n    let _e100 = f;\n    let _e102 = f;\n    u = ((_e99 * _e100) * (vec2(3f) - (_e102 * 2f)));\n    let _e107 = i;\n    param_4 = _e107;\n    let _e108 = hash21_u0028_vf2_u003b((&param_4));\n    let _e109 = i;\n    param_5 = (_e109 + vec2<f32>(1f, 0f));\n    let _e111 = hash21_u0028_vf2_u003b((&param_5));\n    let _e113 = u[0u];\n    let _e115 = i;\n    param_6 = (_e115 + vec2<f32>(0f, 1f));\n    let _e117 = hash21_u0028_vf2_u003b((&param_6));\n    let _e118 = i;\n    param_7 = (_e118 + vec2<f32>(1f, 1f));\n    let _e120 = hash21_u0028_vf2_u003b((&param_7));\n    let _e122 = u[0u];\n    let _e125 = u[1u];\n    return mix(mix(_e108, _e111, _e113), mix(_e117, _e120, _e122), _e125);\n}\n\nfn main_1() {\n    var r: f32;\n    var core: f32;\n    var halo: f32;\n    var flick: f32;\n    var param_8: vec2<f32>;\n    var cool: f32;\n    var energy: f32;\n    var fog: f32;\n    var param_9: f32;\n    var param_10: f32;\n    var param_11: vec3<f32>;\n\n    let _e98 = vUv_1;\n    r = length(_e98);\n    let _e100 = r;\n    if (_e100 > 1f) {\n        discard;\n    }\n    let _e102 = r;\n    core = pow((1f - clamp(_e102, 0f, 1f)), 6f);\n    let _e106 = r;\n    halo = pow((1f - clamp(_e106, 0f, 1f)), 1.6f);\n    let _e111 = unnamed.uTime;\n    let _e113 = vSeed_1;\n    let _e116 = vSeed_1;\n    param_8 = vec2<f32>(((_e111 * 9f) + (_e113 * 13f)), _e116);\n    let _e118 = valueNoise_u0028_vf2_u003b((&param_8));\n    flick = (0.7f + (0.3f * _e118));\n    let _e121 = vAge_1;\n    let _e122 = vAge_1;\n    cool = (1f - (_e121 * _e122));\n    let _e125 = halo;\n    let _e127 = core;\n    let _e129 = unnamed.uCoreGain;\n    let _e132 = flick;\n    let _e134 = cool;\n    let _e136 = vAlpha_1;\n    energy = (((((_e125 * 0.55f) + (_e127 * _e129)) * _e132) * _e134) * _e136);\n    let _e138 = vWorldPos_1;\n    let _e140 = unnamed.uCameraPos;\n    param_9 = distance(_e138, _e140);\n    let _e143 = vWorldPos_1[1u];\n    param_10 = _e143;\n    let _e144 = mediumFog_u0028_f1_u003b_f1_u003b((&param_9), (&param_10));\n    fog = _e144;\n    let _e145 = fog;\n    let _e147 = energy;\n    energy = (_e147 * (1f - _e145));\n    let _e149 = vColor_1;\n    let _e150 = energy;\n    param_11 = (_e149 * _e150);\n    let _e152 = applyOutputTransform_u0028_vf3_u003b((&param_11));\n    outColor = vec4<f32>(_e152.x, _e152.y, _e152.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>, @location(4) vSeed: f32, @location(3) vAge: f32, @location(2) vAlpha: f32, @location(5) vWorldPos: vec3<f32>, @location(1) vColor: vec3<f32>, @location(6) vNormal: vec3<f32>) -> @location(0) vec4<f32> {\n    vUv_1 = vUv;\n    vSeed_1 = vSeed;\n    vAge_1 = vAge;\n    vAlpha_1 = vAlpha;\n    vWorldPos_1 = vWorldPos;\n    vColor_1 = vColor;\n    vNormal_1 = vNormal;\n    main_1();\n    let _e15 = outColor;\n    return _e15;\n}\n";
 
-export const PARTICLE_VERT_WGSL = "struct Uniforms {\n    uViewProj: mat4x4<f32>,\n    uCameraPos: vec3<f32>,\n    uStretchSec: f32,\n    uCameraFacing: f32,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec2<f32>,\n    @location(1) member_1: vec3<f32>,\n    @location(2) member_2: f32,\n    @location(3) member_3: f32,\n    @location(4) member_4: f32,\n    @location(5) member_5: vec3<f32>,\n    @location(6) member_6: vec3<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n}\n\nvar<private> aSpin_1: f32;\nvar<private> aCorner_1: vec2<f32>;\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> aPos_1: vec3<f32>;\nvar<private> aBlade_1: f32;\nvar<private> aSize_1: f32;\nvar<private> aVelocity_1: vec3<f32>;\nvar<private> vUv: vec2<f32>;\nvar<private> vColor: vec3<f32>;\nvar<private> aColor_1: vec3<f32>;\nvar<private> vAlpha: f32;\nvar<private> aAlpha_1: f32;\nvar<private> vAge: f32;\nvar<private> aAge_1: f32;\nvar<private> vSeed: f32;\nvar<private> aSeed_1: f32;\nvar<private> vWorldPos: vec3<f32>;\nvar<private> vNormal: vec3<f32>;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\n\nfn main_1() {\n    var s: f32;\n    var c: f32;\n    var rolled: vec2<f32>;\n    var toCamera: vec3<f32>;\n    var reference: vec3<f32>;\n    var across: vec3<f32>;\n    var up: vec3<f32>;\n    var bladeGain: f32;\n    var offset: vec3<f32>;\n    var travel: vec3<f32>;\n    var along: f32;\n    var world: vec3<f32>;\n    var face: vec3<f32>;\n    var toEye: vec3<f32>;\n    var local: vec3<f32>;\n\n    let _e49 = aSpin_1;\n    s = sin(_e49);\n    let _e51 = aSpin_1;\n    c = cos(_e51);\n    let _e54 = aCorner_1[0u];\n    let _e55 = c;\n    let _e58 = aCorner_1[1u];\n    let _e59 = s;\n    let _e63 = aCorner_1[0u];\n    let _e64 = s;\n    let _e67 = aCorner_1[1u];\n    let _e68 = c;\n    rolled = vec2<f32>(((_e54 * _e55) - (_e58 * _e59)), ((_e63 * _e64) + (_e67 * _e68)));\n    let _e73 = unnamed.uCameraFacing;\n    if (_e73 > 0.5f) {\n        let _e76 = unnamed.uCameraPos;\n        let _e77 = aPos_1;\n        toCamera = normalize((_e76 - _e77));\n        let _e81 = toCamera[1u];\n        reference = select(vec3<f32>(0f, 1f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e81) > 0.999f)));\n        let _e86 = reference;\n        let _e87 = toCamera;\n        across = normalize(cross(_e86, _e87));\n        let _e90 = toCamera;\n        let _e91 = across;\n        up = cross(_e90, _e91);\n        let _e93 = aBlade_1;\n        bladeGain = select(0f, 1f, (_e93 < 0.5f));\n    } else {\n        let _e96 = aBlade_1;\n        across = select(vec3<f32>(0f, 0f, 1f), vec3<f32>(1f, 0f, 0f), vec3((_e96 < 0.5f)));\n        up = vec3<f32>(0f, 1f, 0f);\n        bladeGain = 1f;\n    }\n    let _e100 = across;\n    let _e102 = rolled[0u];\n    let _e104 = up;\n    let _e106 = rolled[1u];\n    let _e109 = aSize_1;\n    offset = (((_e100 * _e102) + (_e104 * _e106)) * _e109);\n    let _e112 = unnamed.uStretchSec;\n    if (_e112 > 0f) {\n        let _e114 = aVelocity_1;\n        let _e116 = unnamed.uStretchSec;\n        travel = (_e114 * _e116);\n        let _e118 = offset;\n        let _e121 = travel;\n        along = dot(normalize((_e118 + vec3<f32>(0.000001f, 0.000001f, 0.000001f))), normalize((_e121 + vec3<f32>(0.000001f, 0.000001f, 0.000001f))));\n        let _e125 = travel;\n        let _e126 = along;\n        let _e129 = offset;\n        offset = (_e129 + ((_e125 * _e126) * 0.5f));\n    }\n    let _e131 = aPos_1;\n    let _e132 = offset;\n    let _e133 = bladeGain;\n    world = (_e131 + (_e132 * _e133));\n    let _e136 = aCorner_1;\n    vUv = _e136;\n    let _e137 = aColor_1;\n    vColor = _e137;\n    let _e138 = aAlpha_1;\n    vAlpha = _e138;\n    let _e139 = aAge_1;\n    vAge = _e139;\n    let _e140 = aSeed_1;\n    vSeed = _e140;\n    let _e141 = world;\n    vWorldPos = _e141;\n    let _e142 = across;\n    let _e143 = up;\n    face = cross(_e142, _e143);\n    let _e146 = unnamed.uCameraPos;\n    let _e147 = world;\n    toEye = normalize((_e146 - _e147));\n    let _e150 = face;\n    let _e151 = toEye;\n    if (dot(_e150, _e151) < 0f) {\n        let _e154 = face;\n        local = -(_e154);\n    } else {\n        let _e156 = face;\n        local = _e156;\n    }\n    let _e157 = local;\n    vNormal = _e157;\n    let _e159 = unnamed.uViewProj;\n    let _e160 = world;\n    unnamed_1.gl_Position = (_e159 * vec4<f32>(_e160.x, _e160.y, _e160.z, 1f));\n    return;\n}\n\n@vertex \nfn main(@location(4) aSpin: f32, @location(0) aCorner: vec2<f32>, @location(2) aPos: vec3<f32>, @location(1) aBlade: f32, @location(3) aSize: f32, @location(9) aVelocity: vec3<f32>, @location(5) aColor: vec3<f32>, @location(6) aAlpha: f32, @location(7) aAge: f32, @location(8) aSeed: f32) -> VertexOutput {\n    aSpin_1 = aSpin;\n    aCorner_1 = aCorner;\n    aPos_1 = aPos;\n    aBlade_1 = aBlade;\n    aSize_1 = aSize;\n    aVelocity_1 = aVelocity;\n    aColor_1 = aColor;\n    aAlpha_1 = aAlpha;\n    aAge_1 = aAge;\n    aSeed_1 = aSeed;\n    main_1();\n    let _e30 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e30);\n    let _e32 = vUv;\n    let _e33 = vColor;\n    let _e34 = vAlpha;\n    let _e35 = vAge;\n    let _e36 = vSeed;\n    let _e37 = vWorldPos;\n    let _e38 = vNormal;\n    let _e39 = unnamed_1.gl_Position;\n    return VertexOutput(_e32, _e33, _e34, _e35, _e36, _e37, _e38, _e39);\n}\n";
+export const PARTICLE_SPRITE_FRAG_WGSL = "struct Uniforms {\n    uCells: vec4<f32>,\n    uFade: vec4<f32>,\n    uDepthToViewZ: vec4<f32>,\n    uViewport: vec2<f32>,\n    uCameraPos: vec3<f32>,\n    uFogEnabled: i32,\n    uFogColor: vec3<f32>,\n    uFogDensity: f32,\n    uFogHeightFalloff: f32,\n    uFogEyeY: f32,\n    uUnderwaterColor: vec3<f32>,\n    uUnderwaterFogDensity: f32,\n    uUnderwaterFactor: f32,\n    uFogMode: i32,\n    uFogNear: f32,\n    uFogFar: f32,\n    uOutputTransform: i32,\n    uOutputExposure: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vUv_1: vec2<f32>;\nvar<private> vFrame_1: f32;\n@group(0) @binding(32) \nvar uSprite_t: texture_2d_array<f32>;\n@group(0) @binding(33) \nvar uSprite_s: sampler;\n@group(0) @binding(34) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(35) \nvar uDepth_s: sampler;\nvar<private> gl_FragCoord_1: vec4<f32>;\nvar<private> vViewDepth_1: f32;\nvar<private> vAlpha_1: f32;\nvar<private> vColor_1: vec3<f32>;\nvar<private> vWorldPos_1: vec3<f32>;\nvar<private> outColor: vec4<f32>;\nvar<private> vAge_1: f32;\nvar<private> vSeed_1: f32;\nvar<private> vNormal_1: vec3<f32>;\n\nfn linearToSrgb_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var low: vec3<f32>;\n    var high: vec3<f32>;\n\n    let _e89 = (*c);\n    low = (_e89 * 12.92f);\n    let _e91 = (*c);\n    high = ((pow(max(_e91, vec3<f32>(0f, 0f, 0f)), vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3(0.055f));\n    let _e97 = high;\n    let _e98 = low;\n    let _e99 = (*c);\n    return mix(_e97, _e98, step(_e99, vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f)));\n}\n\nfn highlightShoulder_u0028_vf3_u003b(c_1: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var m: f32;\n    var e: f32;\n\n    let _e90 = (*c_1)[0u];\n    let _e92 = (*c_1)[1u];\n    let _e94 = (*c_1)[2u];\n    m = max(_e90, max(_e92, _e94));\n    let _e97 = m;\n    if (_e97 <= 0.8f) {\n        let _e99 = (*c_1);\n        return _e99;\n    }\n    let _e100 = m;\n    e = (_e100 - 0.8f);\n    let _e102 = (*c_1);\n    let _e103 = e;\n    let _e105 = e;\n    let _e109 = m;\n    return (_e102 * ((0.8f + ((0.2f * _e103) / (_e105 + 0.2f))) / _e109));\n}\n\nfn rrtAndOdtFit_u0028_vf3_u003b(v: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var a: vec3<f32>;\n    var b: vec3<f32>;\n\n    let _e89 = (*v);\n    let _e90 = (*v);\n    a = ((_e89 * (_e90 + vec3(0.0245786f))) - vec3(0.000090537f));\n    let _e96 = (*v);\n    let _e97 = (*v);\n    b = ((_e96 * ((_e97 * 0.983729f) + vec3(0.432951f))) + vec3(0.238081f));\n    let _e104 = a;\n    let _e105 = b;\n    return (_e104 / _e105);\n}\n\nfn acesFilmic_u0028_vf3_u003b(x: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param: vec3<f32>;\n\n    let _e89 = unnamed.uOutputExposure;\n    let _e90 = (*x);\n    (*x) = (_e90 * _e89);\n    let _e92 = (*x);\n    param = (mat3x3<f32>(vec3<f32>(0.59719f, 0.076f, 0.0284f), vec3<f32>(0.35458f, 0.90834f, 0.13383f), vec3<f32>(0.04823f, 0.01566f, 0.83777f)) * _e92);\n    let _e94 = rrtAndOdtFit_u0028_vf3_u003b((&param));\n    return clamp((mat3x3<f32>(vec3<f32>(1.60475f, -0.10208f, -0.00327f), vec3<f32>(-0.53108f, 1.10813f, -0.07276f), vec3<f32>(-0.07367f, -0.00605f, 1.07602f)) * _e94), vec3(0f), vec3(1f));\n}\n\nfn applyOutputTransform_u0028_vf3_u003b(c_2: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param_1: vec3<f32>;\n    var param_2: vec3<f32>;\n    var param_3: vec3<f32>;\n\n    let _e91 = unnamed.uOutputTransform;\n    if (_e91 == 0i) {\n        let _e93 = (*c_2);\n        return _e93;\n    }\n    let _e95 = unnamed.uOutputTransform;\n    if (_e95 == 2i) {\n        let _e97 = (*c_2);\n        param_1 = _e97;\n        let _e98 = acesFilmic_u0028_vf3_u003b((&param_1));\n        (*c_2) = _e98;\n    }\n    let _e100 = unnamed.uOutputTransform;\n    if (_e100 == 3i) {\n        let _e102 = (*c_2);\n        let _e104 = unnamed.uOutputExposure;\n        param_2 = (_e102 * _e104);\n        let _e106 = highlightShoulder_u0028_vf3_u003b((&param_2));\n        (*c_2) = _e106;\n    }\n    let _e107 = (*c_2);\n    param_3 = _e107;\n    let _e108 = linearToSrgb_u0028_vf3_u003b((&param_3));\n    return _e108;\n}\n\nfn mediumColor_u0028_() -> vec3<f32> {\n    let _e87 = unnamed.uFogColor;\n    let _e89 = unnamed.uUnderwaterColor;\n    let _e91 = unnamed.uUnderwaterFactor;\n    return mix(_e87, _e89, vec3(_e91));\n}\n\nfn mediumFog_u0028_f1_u003b_f1_u003b(dist: ptr<function, f32>, pointY: ptr<function, f32>) -> f32 {\n    var span: f32;\n    var ramp: f32;\n    var wetLinear: f32;\n    var t: f32;\n    var denom: f32;\n    var air: f32;\n    var wet: f32;\n\n    let _e96 = unnamed.uFogMode;\n    if (_e96 == 1i) {\n        let _e99 = unnamed.uFogFar;\n        let _e101 = unnamed.uFogNear;\n        span = max((_e99 - _e101), 0.0001f);\n        let _e104 = (*dist);\n        let _e106 = unnamed.uFogNear;\n        let _e108 = span;\n        ramp = clamp(((_e104 - _e106) / _e108), 0f, 1f);\n        let _e112 = unnamed.uUnderwaterFactor;\n        if (_e112 <= 0f) {\n            let _e114 = ramp;\n            return _e114;\n        }\n        let _e116 = unnamed.uUnderwaterFogDensity;\n        let _e117 = (*dist);\n        wetLinear = (_e116 * _e117);\n        let _e119 = ramp;\n        let _e120 = wetLinear;\n        let _e122 = wetLinear;\n        let _e128 = unnamed.uUnderwaterFactor;\n        return mix(_e119, (1f - exp2(((-(_e120) * _e122) * 1.442695f))), _e128);\n    }\n    let _e130 = (*pointY);\n    let _e132 = unnamed.uFogEyeY;\n    let _e135 = unnamed.uFogHeightFalloff;\n    t = ((_e130 - _e132) * _e135);\n    let _e137 = t;\n    let _e140 = t;\n    denom = select(_e140, 0.0001f, (abs(_e137) < 0.0001f));\n    let _e143 = unnamed.uFogDensity;\n    let _e145 = (*dist);\n    let _e147 = denom;\n    let _e152 = denom;\n    air = (1f - exp((((-(_e143) * _e145) * (1f - exp(-(_e147)))) / _e152)));\n    let _e157 = unnamed.uUnderwaterFactor;\n    if (_e157 <= 0f) {\n        let _e159 = air;\n        return _e159;\n    }\n    let _e161 = unnamed.uUnderwaterFogDensity;\n    let _e162 = (*dist);\n    wet = (_e161 * _e162);\n    let _e164 = air;\n    let _e165 = wet;\n    let _e167 = wet;\n    let _e173 = unnamed.uUnderwaterFactor;\n    return mix(_e164, (1f - exp2(((-(_e165) * _e167) * 1.442695f))), _e173);\n}\n\nfn viewZ_u0028_f1_u003b(depth: ptr<function, f32>) -> f32 {\n    var ndc: f32;\n\n    let _e88 = (*depth);\n    ndc = (1f - (_e88 * 2f));\n    let _e93 = unnamed.uDepthToViewZ[0u];\n    let _e94 = ndc;\n    let _e98 = unnamed.uDepthToViewZ[1u];\n    let _e102 = unnamed.uDepthToViewZ[2u];\n    let _e103 = ndc;\n    let _e107 = unnamed.uDepthToViewZ[3u];\n    return (((_e93 * _e94) + _e98) / ((_e102 * _e103) + _e107));\n}\n\nfn cellUv_u0028_i1_u003b_vf2_u003b(cell: ptr<function, i32>, uv: ptr<function, vec2<f32>>) -> vec2<f32> {\n    var columns: i32;\n    var rows: i32;\n    var wrapped: i32;\n    var column: i32;\n    var row: i32;\n\n    let _e95 = unnamed.uCells[0u];\n    columns = max(i32((_e95 + 0.5f)), 1i);\n    let _e101 = unnamed.uCells[1u];\n    rows = max(i32((_e101 + 0.5f)), 1i);\n    let _e105 = (*cell);\n    let _e106 = columns;\n    let _e107 = rows;\n    let _e108 = (_e106 * _e107);\n    wrapped = (_e105 - (i32(floor((f32(_e105) / f32(_e108)))) * _e108));\n    let _e116 = wrapped;\n    let _e117 = columns;\n    column = (_e116 - (i32(floor((f32(_e116) / f32(_e117)))) * _e117));\n    let _e125 = wrapped;\n    let _e126 = columns;\n    row = (_e125 / _e126);\n    let _e128 = column;\n    let _e130 = row;\n    let _e133 = (*uv);\n    let _e135 = columns;\n    let _e137 = rows;\n    return ((vec2<f32>(f32(_e128), f32(_e130)) + _e133) / vec2<f32>(f32(_e135), f32(_e137)));\n}\n\nfn main_1() {\n    var uv_1: vec2<f32>;\n    var frame: f32;\n    var first: i32;\n    var image: vec4<f32>;\n    var param_4: i32;\n    var param_5: vec2<f32>;\n    var next: vec4<f32>;\n    var param_6: i32;\n    var param_7: vec2<f32>;\n    var fade: f32;\n    var depth_1: f32;\n    var param_8: f32;\n    var alpha: f32;\n    var color: vec3<f32>;\n    var fog: f32;\n    var param_9: f32;\n    var param_10: f32;\n    var param_11: vec3<f32>;\n    var phi_484_: bool;\n\n    let _e105 = vUv_1[0u];\n    let _e109 = vUv_1[1u];\n    uv_1 = vec2<f32>(((_e105 * 0.5f) + 0.5f), (0.5f - (_e109 * 0.5f)));\n    let _e113 = vFrame_1;\n    frame = max(_e113, 0f);\n    let _e115 = frame;\n    first = i32(floor(_e115));\n    let _e118 = first;\n    param_4 = _e118;\n    let _e119 = uv_1;\n    param_5 = _e119;\n    let _e120 = cellUv_u0028_i1_u003b_vf2_u003b((&param_4), (&param_5));\n    let _e123 = vec3<f32>(_e120.x, _e120.y, 0f);\n    let _e129 = textureSample(uSprite_t, uSprite_s, vec2<f32>(_e123.x, _e123.y), i32(_e123.z));\n    image = _e129;\n    let _e132 = unnamed.uCells[2u];\n    if (_e132 > 0.5f) {\n        let _e134 = first;\n        param_6 = (_e134 + 1i);\n        let _e136 = uv_1;\n        param_7 = _e136;\n        let _e137 = cellUv_u0028_i1_u003b_vf2_u003b((&param_6), (&param_7));\n        let _e140 = vec3<f32>(_e137.x, _e137.y, 0f);\n        let _e146 = textureSample(uSprite_t, uSprite_s, vec2<f32>(_e140.x, _e140.y), i32(_e140.z));\n        next = _e146;\n        let _e147 = image;\n        let _e148 = next;\n        let _e149 = frame;\n        image = mix(_e147, _e148, vec4(fract(_e149)));\n    }\n    fade = 1f;\n    let _e155 = unnamed.uFade[2u];\n    let _e156 = (_e155 > 0.5f);\n    phi_484_ = _e156;\n    if _e156 {\n        let _e159 = unnamed.uFade[0u];\n        phi_484_ = (_e159 > 0f);\n    }\n    let _e162 = phi_484_;\n    if _e162 {\n        let _e163 = gl_FragCoord_1;\n        let _e166 = unnamed.uViewport;\n        let _e168 = textureSampleLevel(uDepth_t, uDepth_s, (_e163.xy / _e166), 0f);\n        depth_1 = _e168.x;\n        let _e170 = depth_1;\n        if !((_e170 <= 0f)) {\n            let _e173 = depth_1;\n            param_8 = _e173;\n            let _e174 = viewZ_u0028_f1_u003b((&param_8));\n            let _e176 = vViewDepth_1;\n            let _e180 = unnamed.uFade[0u];\n            fade = clamp(((abs(_e174) - _e176) / _e180), 0f, 1f);\n        }\n    }\n    let _e185 = unnamed.uFade[1u];\n    if (_e185 > 0f) {\n        let _e187 = vViewDepth_1;\n        let _e190 = unnamed.uFade[1u];\n        let _e193 = fade;\n        fade = (_e193 * clamp((_e187 / _e190), 0f, 1f));\n    }\n    let _e195 = vAlpha_1;\n    let _e197 = image[3u];\n    let _e199 = fade;\n    alpha = ((_e195 * _e197) * _e199);\n    let _e201 = alpha;\n    if (_e201 <= 0.001f) {\n        discard;\n    }\n    let _e203 = vColor_1;\n    let _e204 = image;\n    color = (_e203 * _e204.xyz);\n    let _e208 = unnamed.uFogEnabled;\n    if (_e208 != 0i) {\n        let _e210 = vWorldPos_1;\n        let _e212 = unnamed.uCameraPos;\n        param_9 = distance(_e210, _e212);\n        let _e215 = vWorldPos_1[1u];\n        param_10 = _e215;\n        let _e216 = mediumFog_u0028_f1_u003b_f1_u003b((&param_9), (&param_10));\n        fog = _e216;\n        let _e217 = color;\n        let _e218 = mediumColor_u0028_();\n        let _e219 = fog;\n        color = mix(_e217, _e218, vec3(_e219));\n    }\n    let _e222 = color;\n    param_11 = _e222;\n    let _e223 = applyOutputTransform_u0028_vf3_u003b((&param_11));\n    let _e224 = alpha;\n    outColor = vec4<f32>(_e223.x, _e223.y, _e223.z, _e224);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>, @location(7) vFrame: f32, @builtin(position) gl_FragCoord: vec4<f32>, @location(8) vViewDepth: f32, @location(2) vAlpha: f32, @location(1) vColor: vec3<f32>, @location(5) vWorldPos: vec3<f32>, @location(3) vAge: f32, @location(4) vSeed: f32, @location(6) vNormal: vec3<f32>) -> @location(0) vec4<f32> {\n    vUv_1 = vUv;\n    vFrame_1 = vFrame;\n    gl_FragCoord_1 = gl_FragCoord;\n    vViewDepth_1 = vViewDepth;\n    vAlpha_1 = vAlpha;\n    vColor_1 = vColor;\n    vWorldPos_1 = vWorldPos;\n    vAge_1 = vAge;\n    vSeed_1 = vSeed;\n    vNormal_1 = vNormal;\n    main_1();\n    let _e21 = outColor;\n    return _e21;\n}\n";
+
+export const PARTICLE_VERT_WGSL = "struct Uniforms {\n    uViewProj: mat4x4<f32>,\n    uCameraPos: vec3<f32>,\n    uStretchSec: f32,\n    uCameraFacing: f32,\n    uCameraOffset: f32,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec2<f32>,\n    @location(7) member_1: f32,\n    @location(1) member_2: vec3<f32>,\n    @location(2) member_3: f32,\n    @location(3) member_4: f32,\n    @location(4) member_5: f32,\n    @location(5) member_6: vec3<f32>,\n    @location(6) member_7: vec3<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n    @location(8) member_8: f32,\n}\n\nvar<private> aSpin_1: f32;\nvar<private> aCorner_1: vec2<f32>;\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> aPos_1: vec3<f32>;\nvar<private> aVelocity_1: vec3<f32>;\nvar<private> aBlade_1: f32;\nvar<private> aSize_1: f32;\nvar<private> aSprite_1: vec2<f32>;\nvar<private> vUv: vec2<f32>;\nvar<private> vFrame: f32;\nvar<private> vColor: vec3<f32>;\nvar<private> aColor_1: vec3<f32>;\nvar<private> vAlpha: f32;\nvar<private> aAlpha_1: f32;\nvar<private> vAge: f32;\nvar<private> aAge_1: f32;\nvar<private> vSeed: f32;\nvar<private> aSeed_1: f32;\nvar<private> vWorldPos: vec3<f32>;\nvar<private> vNormal: vec3<f32>;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\nvar<private> vViewDepth: f32;\n\nfn main_1() {\n    var s: f32;\n    var c: f32;\n    var rolled: vec2<f32>;\n    var viewer: vec3<f32>;\n    var alongView: vec3<f32>;\n    var up: vec3<f32>;\n    var across: vec3<f32>;\n    var bladeGain: f32;\n    var toCamera: vec3<f32>;\n    var reference: vec3<f32>;\n    var offset: vec3<f32>;\n    var extent: vec2<f32>;\n    var turned: vec2<f32>;\n    var travel: vec3<f32>;\n    var along: f32;\n    var world: vec3<f32>;\n    var face: vec3<f32>;\n    var toEye: vec3<f32>;\n    var local: vec3<f32>;\n    var phi_84_: bool;\n\n    let _e60 = aSpin_1;\n    s = sin(_e60);\n    let _e62 = aSpin_1;\n    c = cos(_e62);\n    let _e65 = aCorner_1[0u];\n    let _e66 = c;\n    let _e69 = aCorner_1[1u];\n    let _e70 = s;\n    let _e74 = aCorner_1[0u];\n    let _e75 = s;\n    let _e78 = aCorner_1[1u];\n    let _e79 = c;\n    rolled = vec2<f32>(((_e65 * _e66) - (_e69 * _e70)), ((_e74 * _e75) + (_e78 * _e79)));\n    let _e84 = unnamed.uCameraPos;\n    let _e85 = aPos_1;\n    viewer = normalize((_e84 - _e85));\n    let _e88 = aVelocity_1;\n    let _e89 = viewer;\n    let _e90 = aVelocity_1;\n    let _e91 = viewer;\n    alongView = (_e88 - (_e89 * dot(_e90, _e91)));\n    let _e96 = unnamed.uCameraFacing;\n    let _e97 = (_e96 > 1.5f);\n    phi_84_ = _e97;\n    if _e97 {\n        let _e98 = alongView;\n        let _e99 = alongView;\n        phi_84_ = (dot(_e98, _e99) > 0.0000000001f);\n    }\n    let _e103 = phi_84_;\n    if _e103 {\n        let _e104 = alongView;\n        up = normalize(_e104);\n        let _e106 = up;\n        let _e107 = viewer;\n        across = cross(_e106, _e107);\n        let _e109 = aBlade_1;\n        bladeGain = select(0f, 1f, (_e109 < 0.5f));\n    } else {\n        let _e113 = unnamed.uCameraFacing;\n        if (_e113 > 0.5f) {\n            let _e116 = unnamed.uCameraPos;\n            let _e117 = aPos_1;\n            toCamera = normalize((_e116 - _e117));\n            let _e121 = toCamera[1u];\n            reference = select(vec3<f32>(0f, 1f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e121) > 0.999f)));\n            let _e126 = reference;\n            let _e127 = toCamera;\n            across = normalize(cross(_e126, _e127));\n            let _e130 = toCamera;\n            let _e131 = across;\n            up = cross(_e130, _e131);\n            let _e133 = aBlade_1;\n            bladeGain = select(0f, 1f, (_e133 < 0.5f));\n        } else {\n            let _e136 = aBlade_1;\n            across = select(vec3<f32>(0f, 0f, 1f), vec3<f32>(1f, 0f, 0f), vec3((_e136 < 0.5f)));\n            up = vec3<f32>(0f, 1f, 0f);\n            bladeGain = 1f;\n        }\n    }\n    let _e140 = across;\n    let _e142 = rolled[0u];\n    let _e144 = up;\n    let _e146 = rolled[1u];\n    let _e149 = aSize_1;\n    offset = (((_e140 * _e142) + (_e144 * _e146)) * _e149);\n    let _e152 = aSprite_1[1u];\n    if (_e152 > 0f) {\n        let _e155 = aCorner_1[0u];\n        let _e156 = aSize_1;\n        let _e159 = aCorner_1[1u];\n        let _e161 = aSprite_1[1u];\n        extent = vec2<f32>((_e155 * _e156), (_e159 * _e161));\n        let _e165 = extent[0u];\n        let _e166 = c;\n        let _e169 = extent[1u];\n        let _e170 = s;\n        let _e174 = extent[0u];\n        let _e175 = s;\n        let _e178 = extent[1u];\n        let _e179 = c;\n        turned = vec2<f32>(((_e165 * _e166) - (_e169 * _e170)), ((_e174 * _e175) + (_e178 * _e179)));\n        let _e183 = across;\n        let _e185 = turned[0u];\n        let _e187 = up;\n        let _e189 = turned[1u];\n        offset = ((_e183 * _e185) + (_e187 * _e189));\n    }\n    let _e193 = unnamed.uStretchSec;\n    if (_e193 > 0f) {\n        let _e195 = aVelocity_1;\n        let _e197 = unnamed.uStretchSec;\n        travel = (_e195 * _e197);\n        let _e199 = offset;\n        let _e202 = travel;\n        along = dot(normalize((_e199 + vec3<f32>(0.000001f, 0.000001f, 0.000001f))), normalize((_e202 + vec3<f32>(0.000001f, 0.000001f, 0.000001f))));\n        let _e206 = travel;\n        let _e207 = along;\n        let _e210 = offset;\n        offset = (_e210 + ((_e206 * _e207) * 0.5f));\n    }\n    let _e212 = aPos_1;\n    let _e213 = offset;\n    let _e214 = bladeGain;\n    world = (_e212 + (_e213 * _e214));\n    let _e217 = viewer;\n    let _e219 = unnamed.uCameraOffset;\n    let _e221 = bladeGain;\n    let _e223 = world;\n    world = (_e223 + ((_e217 * _e219) * _e221));\n    let _e225 = aCorner_1;\n    vUv = _e225;\n    let _e227 = aSprite_1[0u];\n    vFrame = _e227;\n    let _e228 = aColor_1;\n    vColor = _e228;\n    let _e229 = aAlpha_1;\n    vAlpha = _e229;\n    let _e230 = aAge_1;\n    vAge = _e230;\n    let _e231 = aSeed_1;\n    vSeed = _e231;\n    let _e232 = world;\n    vWorldPos = _e232;\n    let _e233 = across;\n    let _e234 = up;\n    face = cross(_e233, _e234);\n    let _e237 = unnamed.uCameraPos;\n    let _e238 = world;\n    toEye = normalize((_e237 - _e238));\n    let _e241 = face;\n    let _e242 = toEye;\n    if (dot(_e241, _e242) < 0f) {\n        let _e245 = face;\n        local = -(_e245);\n    } else {\n        let _e247 = face;\n        local = _e247;\n    }\n    let _e248 = local;\n    vNormal = _e248;\n    let _e250 = unnamed.uViewProj;\n    let _e251 = world;\n    unnamed_1.gl_Position = (_e250 * vec4<f32>(_e251.x, _e251.y, _e251.z, 1f));\n    let _e260 = unnamed_1.gl_Position[3u];\n    vViewDepth = _e260;\n    return;\n}\n\n@vertex \nfn main(@location(4) aSpin: f32, @location(0) aCorner: vec2<f32>, @location(2) aPos: vec3<f32>, @location(9) aVelocity: vec3<f32>, @location(1) aBlade: f32, @location(3) aSize: f32, @location(10) aSprite: vec2<f32>, @location(5) aColor: vec3<f32>, @location(6) aAlpha: f32, @location(7) aAge: f32, @location(8) aSeed: f32) -> VertexOutput {\n    aSpin_1 = aSpin;\n    aCorner_1 = aCorner;\n    aPos_1 = aPos;\n    aVelocity_1 = aVelocity;\n    aBlade_1 = aBlade;\n    aSize_1 = aSize;\n    aSprite_1 = aSprite;\n    aColor_1 = aColor;\n    aAlpha_1 = aAlpha;\n    aAge_1 = aAge;\n    aSeed_1 = aSeed;\n    main_1();\n    let _e34 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e34);\n    let _e36 = vUv;\n    let _e37 = vFrame;\n    let _e38 = vColor;\n    let _e39 = vAlpha;\n    let _e40 = vAge;\n    let _e41 = vSeed;\n    let _e42 = vWorldPos;\n    let _e43 = vNormal;\n    let _e44 = unnamed_1.gl_Position;\n    let _e45 = vViewDepth;\n    return VertexOutput(_e36, _e37, _e38, _e39, _e40, _e41, _e42, _e43, _e44, _e45);\n}\n";
 
 /**
  * What the transform assigned, so the renderer binds the same numbers.
@@ -313,6 +315,114 @@ export const PARTICLE_BINDINGS = {
     },
     "textures": {}
   },
+  "PARTICLE_SPRITE_FRAG": {
+    "uniforms": 1,
+    "uniformSize": 160,
+    "fields": {
+      "uCells": {
+        "offset": 0,
+        "size": 16,
+        "type": "vec4"
+      },
+      "uFade": {
+        "offset": 16,
+        "size": 16,
+        "type": "vec4"
+      },
+      "uDepthToViewZ": {
+        "offset": 32,
+        "size": 16,
+        "type": "vec4"
+      },
+      "uViewport": {
+        "offset": 48,
+        "size": 8,
+        "type": "vec2"
+      },
+      "uCameraPos": {
+        "offset": 64,
+        "size": 12,
+        "type": "vec3"
+      },
+      "uFogEnabled": {
+        "offset": 76,
+        "size": 4,
+        "type": "int"
+      },
+      "uFogColor": {
+        "offset": 80,
+        "size": 12,
+        "type": "vec3"
+      },
+      "uFogDensity": {
+        "offset": 92,
+        "size": 4,
+        "type": "float"
+      },
+      "uFogHeightFalloff": {
+        "offset": 96,
+        "size": 4,
+        "type": "float"
+      },
+      "uFogEyeY": {
+        "offset": 100,
+        "size": 4,
+        "type": "float"
+      },
+      "uUnderwaterColor": {
+        "offset": 112,
+        "size": 12,
+        "type": "vec3"
+      },
+      "uUnderwaterFogDensity": {
+        "offset": 124,
+        "size": 4,
+        "type": "float"
+      },
+      "uUnderwaterFactor": {
+        "offset": 128,
+        "size": 4,
+        "type": "float"
+      },
+      "uFogMode": {
+        "offset": 132,
+        "size": 4,
+        "type": "int"
+      },
+      "uFogNear": {
+        "offset": 136,
+        "size": 4,
+        "type": "float"
+      },
+      "uFogFar": {
+        "offset": 140,
+        "size": 4,
+        "type": "float"
+      },
+      "uOutputTransform": {
+        "offset": 144,
+        "size": 4,
+        "type": "int"
+      },
+      "uOutputExposure": {
+        "offset": 148,
+        "size": 4,
+        "type": "float"
+      }
+    },
+    "textures": {
+      "uSprite": {
+        "texture": 32,
+        "sampler": 33,
+        "type": "sampler2DArray"
+      },
+      "uDepth": {
+        "texture": 34,
+        "sampler": 35,
+        "type": "sampler2D"
+      }
+    }
+  },
   "PARTICLE_VERT": {
     "uniforms": 0,
     "uniformSize": 96,
@@ -336,6 +446,11 @@ export const PARTICLE_BINDINGS = {
         "offset": 80,
         "size": 4,
         "type": "float"
+      },
+      "uCameraOffset": {
+        "offset": 84,
+        "size": 4,
+        "type": "float"
       }
     },
     "textures": {}

package/src/render/shaders/generated/skinBlur.wgsl.ts

@@ -5,7 +5,7 @@
  * the next generation, and `npm run wgsl:check` fails the build when this is stale.
  */
 
-export const SKIN_BLUR_FRAG_WGSL = "struct Uniforms {\n    uStep: vec2<f32>,\n    uDepthToViewZ: vec4<f32>,\n    uFocal: f32,\n    uProfiles: array<vec4<f32>, 8>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(32) \nvar uSkin_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uSkin_s: sampler;\nvar<private> vUv_1: vec2<f32>;\nvar<private> fragColor: vec4<f32>;\n@group(0) @binding(34) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(35) \nvar uDepth_s: sampler;\n\nfn burleyMass_u0028_f1_u003b_vf3_u003b(x: ptr<function, f32>, d: ptr<function, vec3<f32>>) -> vec3<f32> {\n    let _e51 = (*x);\n    let _e53 = (*d);\n    let _e57 = (*x);\n    let _e59 = (*d);\n    return (vec3(0.5f) - ((exp((vec3(-(_e51)) / _e53)) + (exp((vec3(-(_e57)) / (_e59 * 3f))) * 3f)) * 0.125f));\n}\n\nfn viewZ_u0028_f1_u003b(depth: ptr<function, f32>) -> f32 {\n    var ndc: f32;\n\n    let _e51 = (*depth);\n    ndc = (1f - (_e51 * 2f));\n    let _e56 = unnamed.uDepthToViewZ[0u];\n    let _e57 = ndc;\n    let _e61 = unnamed.uDepthToViewZ[1u];\n    let _e65 = unnamed.uDepthToViewZ[2u];\n    let _e66 = ndc;\n    let _e70 = unnamed.uDepthToViewZ[3u];\n    return (((_e56 * _e57) + _e61) / ((_e65 * _e66) + _e70));\n}\n\nfn main_1() {\n    var own: vec4<f32>;\n    var depth_1: f32;\n    var profile: i32;\n    var d_1: vec3<f32>;\n    var widest: f32;\n    var z: f32;\n    var param: f32;\n    var pixels: f32;\n    var centre: vec3<f32>;\n    var param_1: f32;\n    var param_2: vec3<f32>;\n    var sum: vec3<f32>;\n    var weight: vec3<f32>;\n    var i: i32;\n    var outer: vec3<f32>;\n    var local: vec3<f32>;\n    var indexable: array<f32, 6>;\n    var param_3: f32;\n    var param_4: vec3<f32>;\n    var w: vec3<f32>;\n    var indexable_1: array<f32, 6>;\n    var param_5: f32;\n    var param_6: vec3<f32>;\n    var side: i32;\n    var uv: vec2<f32>;\n    var indexable_2: array<f32, 7>;\n    var tap: vec4<f32>;\n    var tapZ: f32;\n    var param_7: f32;\n    var keep: f32;\n    var cover: f32;\n\n    let _e80 = vUv_1;\n    let _e81 = textureSampleLevel(uSkin_t, uSkin_s, _e80, 0f);\n    own = _e81;\n    let _e83 = own[3u];\n    if (_e83 < 0.0001f) {\n        fragColor = vec4<f32>(0f, 0f, 0f, 0f);\n        return;\n    }\n    let _e85 = vUv_1;\n    let _e86 = textureSampleLevel(uDepth_t, uDepth_s, _e85, 0f);\n    depth_1 = _e86.x;\n    let _e88 = depth_1;\n    if (_e88 <= 0f) {\n        let _e90 = own;\n        fragColor = _e90;\n        return;\n    }\n    let _e92 = own[3u];\n    profile = clamp((i32(((_e92 * 8f) + 0.5f)) - 1i), 0i, 7i);\n    let _e98 = profile;\n    let _e101 = unnamed.uProfiles[_e98];\n    d_1 = max(_e101.xyz, vec3<f32>(0.000001f, 0.000001f, 0.000001f));\n    let _e105 = d_1[0u];\n    let _e107 = d_1[1u];\n    let _e109 = d_1[2u];\n    widest = max(_e105, max(_e107, _e109));\n    let _e112 = depth_1;\n    param = _e112;\n    let _e113 = viewZ_u0028_f1_u003b((&param));\n    z = abs(_e113);\n    let _e115 = widest;\n    let _e117 = unnamed.uFocal;\n    let _e119 = z;\n    pixels = ((_e115 * _e117) / max(_e119, 0.0001f));\n    let _e122 = pixels;\n    if (_e122 < 0.5f) {\n        let _e124 = own;\n        fragColor = _e124;\n        return;\n    }\n    let _e125 = widest;\n    param_1 = (0.2f * _e125);\n    let _e127 = d_1;\n    param_2 = _e127;\n    let _e128 = burleyMass_u0028_f1_u003b_vf3_u003b((&param_1), (&param_2));\n    centre = (_e128 * 2f);\n    let _e130 = own;\n    let _e132 = centre;\n    sum = (_e130.xyz * _e132);\n    let _e134 = centre;\n    weight = _e134;\n    i = 1i;\n    loop {\n        let _e135 = i;\n        if (_e135 < 7i) {\n            let _e137 = i;\n            if (_e137 < 6i) {\n                let _e139 = i;\n                indexable = array<f32, 6>(0.2f, 0.75f, 1.6f, 2.8f, 4.55f, 7.3f);\n                let _e142 = indexable[min(_e139, 5i)];\n                let _e143 = widest;\n                param_3 = (_e142 * _e143);\n                let _e145 = d_1;\n                param_4 = _e145;\n                let _e146 = burleyMass_u0028_f1_u003b_vf3_u003b((&param_3), (&param_4));\n                local = _e146;\n            } else {\n                local = vec3<f32>(0.5f, 0.5f, 0.5f);\n            }\n            let _e147 = local;\n            outer = _e147;\n            let _e148 = outer;\n            let _e149 = i;\n            indexable_1 = array<f32, 6>(0.2f, 0.75f, 1.6f, 2.8f, 4.55f, 7.3f);\n            let _e152 = indexable_1[(_e149 - 1i)];\n            let _e153 = widest;\n            param_5 = (_e152 * _e153);\n            let _e155 = d_1;\n            param_6 = _e155;\n            let _e156 = burleyMass_u0028_f1_u003b_vf3_u003b((&param_5), (&param_6));\n            w = (_e148 - _e156);\n            side = -1i;\n            loop {\n                let _e158 = side;\n                if (_e158 <= 1i) {\n                    let _e160 = vUv_1;\n                    let _e162 = unnamed.uStep;\n                    let _e163 = side;\n                    let _e165 = i;\n                    indexable_2 = array<f32, 7>(0f, 0.4f, 1.1f, 2.1f, 3.5f, 5.6f, 9f);\n                    let _e167 = indexable_2[_e165];\n                    let _e169 = pixels;\n                    uv = (_e160 + (_e162 * ((f32(_e163) * _e167) * _e169)));\n                    let _e173 = uv;\n                    let _e174 = textureSampleLevel(uSkin_t, uSkin_s, _e173, 0f);\n                    tap = _e174;\n                    let _e175 = uv;\n                    let _e176 = textureSampleLevel(uDepth_t, uDepth_s, _e175, 0f);\n                    param_7 = _e176.x;\n                    let _e178 = viewZ_u0028_f1_u003b((&param_7));\n                    tapZ = abs(_e178);\n                    let _e180 = tapZ;\n                    let _e181 = z;\n                    let _e184 = widest;\n                    keep = clamp((1f - (abs((_e180 - _e181)) / (4f * _e184))), 0f, 1f);\n                    let _e190 = tap[3u];\n                    let _e192 = own[3u];\n                    cover = clamp((_e190 / _e192), 0f, 1f);\n                    let _e195 = tap;\n                    let _e197 = w;\n                    let _e199 = keep;\n                    let _e201 = sum;\n                    sum = (_e201 + ((_e195.xyz * _e197) * _e199));\n                    let _e203 = w;\n                    let _e204 = cover;\n                    let _e205 = keep;\n                    let _e208 = weight;\n                    weight = (_e208 + (_e203 * (_e204 * _e205)));\n                    continue;\n                } else {\n                    break;\n                }\n                continuing {\n                    let _e210 = side;\n                    side = (_e210 + 2i);\n                }\n            }\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e212 = i;\n            i = (_e212 + 1i);\n        }\n    }\n    let _e214 = sum;\n    let _e215 = weight;\n    let _e216 = (_e214 / _e215);\n    let _e218 = own[3u];\n    fragColor = vec4<f32>(_e216.x, _e216.y, _e216.z, _e218);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>) -> @location(0) vec4<f32> {\n    vUv_1 = vUv;\n    main_1();\n    let _e3 = fragColor;\n    return _e3;\n}\n";
+export const SKIN_BLUR_FRAG_WGSL = "struct Uniforms {\n    uStep: vec2<f32>,\n    uDepthToViewZ: vec4<f32>,\n    uFocal: f32,\n    uProfiles: array<vec4<f32>, 8>,\n    uApplyAlbedo: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(36) \nvar uAlbedo_t: texture_2d<f32>;\n@group(0) @binding(37) \nvar uAlbedo_s: sampler;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(32) \nvar uSkin_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uSkin_s: sampler;\nvar<private> fragColor: vec4<f32>;\n@group(0) @binding(34) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(35) \nvar uDepth_s: sampler;\n\nfn burleyMass_u0028_f1_u003b_vf3_u003b(x: ptr<function, f32>, d: ptr<function, vec3<f32>>) -> vec3<f32> {\n    let _e54 = (*x);\n    let _e56 = (*d);\n    let _e60 = (*x);\n    let _e62 = (*d);\n    return (vec3(0.5f) - ((exp((vec3(-(_e54)) / _e56)) + (exp((vec3(-(_e60)) / (_e62 * 3f))) * 3f)) * 0.125f));\n}\n\nfn viewZ_u0028_f1_u003b(depth: ptr<function, f32>) -> f32 {\n    var ndc: f32;\n\n    let _e54 = (*depth);\n    ndc = (1f - (_e54 * 2f));\n    let _e59 = unnamed.uDepthToViewZ[0u];\n    let _e60 = ndc;\n    let _e64 = unnamed.uDepthToViewZ[1u];\n    let _e68 = unnamed.uDepthToViewZ[2u];\n    let _e69 = ndc;\n    let _e73 = unnamed.uDepthToViewZ[3u];\n    return (((_e59 * _e60) + _e64) / ((_e68 * _e69) + _e73));\n}\n\nfn withAlbedo_u0028_vf3_u003b(light: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var albedo: vec4<f32>;\n\n    let _e55 = unnamed.uApplyAlbedo;\n    if (_e55 < 0.5f) {\n        let _e57 = (*light);\n        return _e57;\n    }\n    let _e58 = vUv_1;\n    let _e59 = textureSampleLevel(uAlbedo_t, uAlbedo_s, _e58, 0f);\n    albedo = _e59;\n    let _e60 = (*light);\n    let _e61 = albedo;\n    let _e65 = albedo[3u];\n    return ((_e60 * _e61.xyz) / vec3(max(_e65, 0.0001f)));\n}\n\nfn main_1() {\n    var own: vec4<f32>;\n    var depth_1: f32;\n    var param: vec3<f32>;\n    var profile: i32;\n    var d_1: vec3<f32>;\n    var widest: f32;\n    var z: f32;\n    var param_1: f32;\n    var pixels: f32;\n    var param_2: vec3<f32>;\n    var centre: vec3<f32>;\n    var param_3: f32;\n    var param_4: vec3<f32>;\n    var sum: vec3<f32>;\n    var weight: vec3<f32>;\n    var i: i32;\n    var outer: vec3<f32>;\n    var local: vec3<f32>;\n    var indexable: array<f32, 6>;\n    var param_5: f32;\n    var param_6: vec3<f32>;\n    var w: vec3<f32>;\n    var indexable_1: array<f32, 6>;\n    var param_7: f32;\n    var param_8: vec3<f32>;\n    var side: i32;\n    var uv: vec2<f32>;\n    var indexable_2: array<f32, 7>;\n    var tap: vec4<f32>;\n    var tapZ: f32;\n    var param_9: f32;\n    var keep: f32;\n    var cover: f32;\n    var param_10: vec3<f32>;\n\n    let _e86 = vUv_1;\n    let _e87 = textureSampleLevel(uSkin_t, uSkin_s, _e86, 0f);\n    own = _e87;\n    let _e89 = own[3u];\n    if (_e89 < 0.0001f) {\n        fragColor = vec4<f32>(0f, 0f, 0f, 0f);\n        return;\n    }\n    let _e91 = vUv_1;\n    let _e92 = textureSampleLevel(uDepth_t, uDepth_s, _e91, 0f);\n    depth_1 = _e92.x;\n    let _e94 = depth_1;\n    if (_e94 <= 0f) {\n        let _e96 = own;\n        param = _e96.xyz;\n        let _e98 = withAlbedo_u0028_vf3_u003b((&param));\n        let _e100 = own[3u];\n        fragColor = vec4<f32>(_e98.x, _e98.y, _e98.z, _e100);\n        return;\n    }\n    let _e106 = own[3u];\n    profile = clamp((i32(((_e106 * 8f) + 0.5f)) - 1i), 0i, 7i);\n    let _e112 = profile;\n    let _e115 = unnamed.uProfiles[_e112];\n    d_1 = max(_e115.xyz, vec3<f32>(0.000001f, 0.000001f, 0.000001f));\n    let _e119 = d_1[0u];\n    let _e121 = d_1[1u];\n    let _e123 = d_1[2u];\n    widest = max(_e119, max(_e121, _e123));\n    let _e126 = depth_1;\n    param_1 = _e126;\n    let _e127 = viewZ_u0028_f1_u003b((&param_1));\n    z = abs(_e127);\n    let _e129 = widest;\n    let _e131 = unnamed.uFocal;\n    let _e133 = z;\n    pixels = ((_e129 * _e131) / max(_e133, 0.0001f));\n    let _e136 = pixels;\n    if (_e136 < 0.5f) {\n        let _e138 = own;\n        param_2 = _e138.xyz;\n        let _e140 = withAlbedo_u0028_vf3_u003b((&param_2));\n        let _e142 = own[3u];\n        fragColor = vec4<f32>(_e140.x, _e140.y, _e140.z, _e142);\n        return;\n    }\n    let _e147 = widest;\n    param_3 = (0.2f * _e147);\n    let _e149 = d_1;\n    param_4 = _e149;\n    let _e150 = burleyMass_u0028_f1_u003b_vf3_u003b((&param_3), (&param_4));\n    centre = (_e150 * 2f);\n    let _e152 = own;\n    let _e154 = centre;\n    sum = (_e152.xyz * _e154);\n    let _e156 = centre;\n    weight = _e156;\n    i = 1i;\n    loop {\n        let _e157 = i;\n        if (_e157 < 7i) {\n            let _e159 = i;\n            if (_e159 < 6i) {\n                let _e161 = i;\n                indexable = array<f32, 6>(0.2f, 0.75f, 1.6f, 2.8f, 4.55f, 7.3f);\n                let _e164 = indexable[min(_e161, 5i)];\n                let _e165 = widest;\n                param_5 = (_e164 * _e165);\n                let _e167 = d_1;\n                param_6 = _e167;\n                let _e168 = burleyMass_u0028_f1_u003b_vf3_u003b((&param_5), (&param_6));\n                local = _e168;\n            } else {\n                local = vec3<f32>(0.5f, 0.5f, 0.5f);\n            }\n            let _e169 = local;\n            outer = _e169;\n            let _e170 = outer;\n            let _e171 = i;\n            indexable_1 = array<f32, 6>(0.2f, 0.75f, 1.6f, 2.8f, 4.55f, 7.3f);\n            let _e174 = indexable_1[(_e171 - 1i)];\n            let _e175 = widest;\n            param_7 = (_e174 * _e175);\n            let _e177 = d_1;\n            param_8 = _e177;\n            let _e178 = burleyMass_u0028_f1_u003b_vf3_u003b((&param_7), (&param_8));\n            w = (_e170 - _e178);\n            side = -1i;\n            loop {\n                let _e180 = side;\n                if (_e180 <= 1i) {\n                    let _e182 = vUv_1;\n                    let _e184 = unnamed.uStep;\n                    let _e185 = side;\n                    let _e187 = i;\n                    indexable_2 = array<f32, 7>(0f, 0.4f, 1.1f, 2.1f, 3.5f, 5.6f, 9f);\n                    let _e189 = indexable_2[_e187];\n                    let _e191 = pixels;\n                    uv = (_e182 + (_e184 * ((f32(_e185) * _e189) * _e191)));\n                    let _e195 = uv;\n                    let _e196 = textureSampleLevel(uSkin_t, uSkin_s, _e195, 0f);\n                    tap = _e196;\n                    let _e197 = uv;\n                    let _e198 = textureSampleLevel(uDepth_t, uDepth_s, _e197, 0f);\n                    param_9 = _e198.x;\n                    let _e200 = viewZ_u0028_f1_u003b((&param_9));\n                    tapZ = abs(_e200);\n                    let _e202 = tapZ;\n                    let _e203 = z;\n                    let _e206 = widest;\n                    keep = clamp((1f - (abs((_e202 - _e203)) / (4f * _e206))), 0f, 1f);\n                    let _e212 = tap[3u];\n                    let _e214 = own[3u];\n                    cover = clamp((_e212 / _e214), 0f, 1f);\n                    let _e217 = tap;\n                    let _e219 = w;\n                    let _e221 = keep;\n                    let _e223 = sum;\n                    sum = (_e223 + ((_e217.xyz * _e219) * _e221));\n                    let _e225 = w;\n                    let _e226 = cover;\n                    let _e227 = keep;\n                    let _e230 = weight;\n                    weight = (_e230 + (_e225 * (_e226 * _e227)));\n                    continue;\n                } else {\n                    break;\n                }\n                continuing {\n                    let _e232 = side;\n                    side = (_e232 + 2i);\n                }\n            }\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e234 = i;\n            i = (_e234 + 1i);\n        }\n    }\n    let _e236 = sum;\n    let _e237 = weight;\n    param_10 = (_e236 / _e237);\n    let _e239 = withAlbedo_u0028_vf3_u003b((&param_10));\n    let _e241 = own[3u];\n    fragColor = vec4<f32>(_e239.x, _e239.y, _e239.z, _e241);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>) -> @location(0) vec4<f32> {\n    vUv_1 = vUv;\n    main_1();\n    let _e3 = fragColor;\n    return _e3;\n}\n";
 
 /**
  * What the transform assigned, so the renderer binds the same numbers.
@@ -15,7 +15,7 @@ export const SKIN_BLUR_FRAG_WGSL = "struct Uniforms {\n    uStep: vec2<f32>,\n
 export const SKINBLUR_BINDINGS = {
   "SKIN_BLUR_FRAG": {
     "uniforms": 1,
-    "uniformSize": 176,
+    "uniformSize": 192,
     "fields": {
       "uStep": {
         "offset": 0,
@@ -38,6 +38,11 @@ export const SKINBLUR_BINDINGS = {
         "type": "vec4",
         "length": 8,
         "stride": 16
+      },
+      "uApplyAlbedo": {
+        "offset": 176,
+        "size": 4,
+        "type": "float"
       }
     },
     "textures": {
@@ -50,6 +55,11 @@ export const SKINBLUR_BINDINGS = {
         "texture": 34,
         "sampler": 35,
         "type": "sampler2D"
+      },
+      "uAlbedo": {
+        "texture": 36,
+        "sampler": 37,
+        "type": "sampler2D"
       }
     }
   }

package/src/render/shaders/particle.ts

@@ -1,5 +1,6 @@
 import { FOG_GLSL } from './fog.ts';
 import { OUTPUT_TRANSFORM_GLSL } from './outputTransform.ts';
+import { glslIsFarDepth, glslSceneDepthToNdc } from '../depthConvention.ts';
 import { MAX_POINT_LIGHTS } from '../lightBudget.ts';
 
 /**
@@ -87,6 +88,11 @@ layout(location = 6) in float aAlpha;
 layout(location = 7) in float aAge;
 layout(location = 8) in float aSeed;
 layout(location = 9) in vec3 aVelocity;
+/**
+ * A sprite's flipbook frame and its half-height: \`ParticleInstances.frames\` and \`heights\`. The
+ * procedural materials read neither, and a height of 0 is a square, its height its width.
+ */
+layout(location = 10) in vec2 aSprite;
 
 uniform mat4 uViewProj;
 uniform vec3 uCameraPos;
@@ -126,6 +132,8 @@ uniform float uStretchSec;
  * from everywhere.
  */
 uniform float uCameraFacing;
+/** How far each particle is moved toward the eye, in metres: \`ParticleBatchOptions.cameraOffset\`. */
+uniform float uCameraOffset;
 
 out vec2 vUv;
 out vec3 vColor;
@@ -134,6 +142,9 @@ out float vAge;
 out float vSeed;
 out vec3 vWorldPos;
 out vec3 vNormal;
+/** The flipbook frame, for the sprite material; and the depth from the eye, for its fades. */
+out float vFrame;
+out float vViewDepth;
 
 void main() {
   float s = sin(aSpin);
@@ -150,7 +161,18 @@ void main() {
   vec3 across;
   vec3 up;
   float bladeGain;
-  if (uCameraFacing > 0.5) {
+  /*
+   * **Along its travel**, \`facing: 'velocity'\` (2): the quad's up is the velocity seen across
+   * the view, so a streak of light or a stretched spark lies along its motion and still faces the
+   * eye. A particle at rest has no such direction and faces the camera as the default does.
+   */
+  vec3 viewer = normalize(uCameraPos - aPos);
+  vec3 alongView = aVelocity - viewer * dot(aVelocity, viewer);
+  if (uCameraFacing > 1.5 && dot(alongView, alongView) > 1e-10) {
+    up = normalize(alongView);
+    across = cross(up, viewer);
+    bladeGain = aBlade < 0.5 ? 1.0 : 0.0;
+  } else if (uCameraFacing > 0.5) {
     vec3 toCamera = normalize(uCameraPos - aPos);
     /* Any reference not parallel to the view. World up serves everywhere except looking
        straight up or down it, where the two are the same line and the cross product
@@ -173,6 +195,16 @@ void main() {
     bladeGain = 1.0;
   }
   vec3 offset = (across * rolled.x + up * rolled.y) * aSize;
+  /*
+   * **A sprite of two sizes** — a half-width and a half-height — rolls as a rectangle: the corner
+   * is scaled first and turned after. Only where a height was given, so a square particle keeps
+   * the arithmetic it always had to the bit.
+   */
+  if (aSprite.y > 0.0) {
+    vec2 extent = vec2(aCorner.x * aSize, aCorner.y * aSprite.y);
+    vec2 turned = vec2(extent.x * c - extent.y * s, extent.x * s + extent.y * c);
+    offset = across * turned.x + up * turned.y;
+  }
 
   /*
    * Stretched along travel. Applied as an extra displacement on the component of
@@ -188,7 +220,10 @@ void main() {
   /* bladeGain applied here, after the stretch rather than before it, so a dropped blade
      is degenerate whatever the stretch added: all four of its corners land on aPos. */
   vec3 world = aPos + offset * bladeGain;
+  /* Toward the eye, so a sprite set into a surface is drawn in front of it. 0 moves nothing. */
+  world += viewer * uCameraOffset * bladeGain;
   vUv = aCorner;
+  vFrame = aSprite.x;
   vColor = aColor;
   vAlpha = aAlpha;
   vAge = aAge;
@@ -207,6 +242,8 @@ void main() {
   vNormal = dot(face, toEye) < 0.0 ? -face : face;
 
   gl_Position = uViewProj * vec4(world, 1.0);
+  /* A perspective projection's w is the depth from the eye, which is what the fades measure. */
+  vViewDepth = gl_Position.w;
 }
 `;
 
@@ -436,3 +473,99 @@ void main() {
   outColor = vec4(applyOutputTransform(color), alpha);
 }
 `;
+
+/**
+ * A textured sprite: an image a consumer supplies, a cell of it at a time, at the colour and opacity
+ * each particle carries — what another engine's sprite renderer draws, and the material the three
+ * procedural ones above cannot be. Unlit: the colour is the particle's times the image's.
+ *
+ * **A flipbook** of `uCells.x` by `uCells.y` cells, numbered across then down from the top-left,
+ * a particle's frame naming one; with `uCells.z` at 1 the frame's fraction blends toward the next,
+ * so a slow flipbook does not step.
+ *
+ * **Two fades, each 0 for off.** A soft edge where the sprite meets the scene, by how far in front
+ * of the opaque depth it is over `uFade.x` metres — the hard line a flat card draws where it cuts
+ * a floor — and a fade over `uFade.y` metres in front of the eye, so a card the camera passes
+ * through does not fill the screen and vanish. The first reads a copy of the frame's depth, which
+ * is `uFade.z` at 1; where no copy can be had it is 0 and the edge stays hard.
+ */
+export const PARTICLE_SPRITE_FRAG = `#version 300 es
+precision highp float;
+
+/* Every output of the vertex stage, in its order, read or not: the generated stages number their
+   locations in declaration order, so a fragment declaring a subset reads the wrong ones. */
+in vec2 vUv;
+in vec3 vColor;
+in float vAlpha;
+in float vAge;
+in float vSeed;
+in vec3 vWorldPos;
+in vec3 vNormal;
+in float vFrame;
+in float vViewDepth;
+
+/** The image, a surface texture: its first layer. */
+uniform mediump sampler2DArray uSprite;
+/** The frame's opaque depth, copied, for the soft edge. highp for the reason depth always is. */
+uniform highp sampler2D uDepth;
+/** Columns, rows, and 1 to blend between cells. */
+uniform vec4 uCells;
+/** The soft edge's distance, the eye fade's, and whether the depth copy is there to read. */
+uniform vec4 uFade;
+/** A depth sample to view-space metres, as the skin blur takes it. */
+uniform vec4 uDepthToViewZ;
+/** The target's size in pixels, so a fragment finds its own texel of the depth copy. */
+uniform vec2 uViewport;
+uniform vec3 uCameraPos;
+/** Whether the colour recedes into the medium: \`ParticleBatchOptions.fog\`. */
+uniform int uFogEnabled;
+${FOG_GLSL}
+
+out vec4 outColor;
+${OUTPUT_TRANSFORM_GLSL}
+
+/** Cell \`cell\` of the flipbook, at \`uv\` inside it. Integer arithmetic: see AGENTS.md. */
+vec2 cellUv(int cell, vec2 uv) {
+  int columns = max(int(uCells.x + 0.5), 1);
+  int rows = max(int(uCells.y + 0.5), 1);
+  int wrapped = cell % (columns * rows);
+  int column = wrapped % columns;
+  int row = wrapped / columns;
+  return (vec2(float(column), float(row)) + uv) / vec2(float(columns), float(rows));
+}
+
+float viewZ(float depth) {
+  float ndc = ${glslSceneDepthToNdc('depth')};
+  return (uDepthToViewZ.x * ndc + uDepthToViewZ.y) / (uDepthToViewZ.z * ndc + uDepthToViewZ.w);
+}
+
+void main() {
+  /* The corner's square to the image's: v runs down an image, and up a quad. */
+  vec2 uv = vec2(vUv.x * 0.5 + 0.5, 0.5 - vUv.y * 0.5);
+  float frame = max(vFrame, 0.0);
+  int first = int(floor(frame));
+  vec4 image = texture(uSprite, vec3(cellUv(first, uv), 0.0));
+  if (uCells.z > 0.5) {
+    vec4 next = texture(uSprite, vec3(cellUv(first + 1, uv), 0.0));
+    image = mix(image, next, fract(frame));
+  }
+
+  float fade = 1.0;
+  if (uFade.z > 0.5 && uFade.x > 0.0) {
+    float depth = textureLod(uDepth, gl_FragCoord.xy / uViewport, 0.0).r;
+    if (!(${glslIsFarDepth('depth')})) {
+      fade = clamp((abs(viewZ(depth)) - vViewDepth) / uFade.x, 0.0, 1.0);
+    }
+  }
+  if (uFade.y > 0.0) fade *= clamp(vViewDepth / uFade.y, 0.0, 1.0);
+
+  float alpha = vAlpha * image.a * fade;
+  if (alpha <= 0.001) discard;
+  vec3 color = vColor * image.rgb;
+  if (uFogEnabled != 0) {
+    float fog = mediumFog(distance(vWorldPos, uCameraPos), vWorldPos.y);
+    color = mix(color, mediumColor(), fog);
+  }
+  outColor = vec4(applyOutputTransform(color), alpha);
+}
+`;

package/src/render/shaders/skinBlur.ts

@@ -6,6 +6,11 @@
  * **One pass, run twice**: along x into a target of its own, keeping the profile in the alpha, then
  * along y blended additively into the frame — its colour added, the frame's alpha kept.
  *
+ * **What it spreads is light, and the colour is applied after**, from the skin's own colour half at
+ * this pixel. Light travels beneath skin; the pigment a brow, a lip line or a freckle is made of
+ * does not, so spreading the coloured diffuse — as this did until 4.8.6 — smeared every mark on a
+ * face into the skin around it, and the blur's taps laid faint copies of each mark beside it.
+ *
  * **Refuses what is not the same skin**: a neighbour that wrote no skin, or one further in depth
  * than four of the profile's widest distances, takes no weight, and what is kept is divided by
  * what was kept, so a cheek's light does not pull toward the black beside its silhouette. A tap
@@ -34,6 +39,12 @@ uniform vec4 uDepthToViewZ;
 uniform float uFocal;
 /** Each profile's scatter distance per channel, in metres. */
 uniform vec4 uProfiles[${SKIN_PROFILES}];
+/**
+ * The skin's colour, and its coverage in the alpha: what the spread light is multiplied by on the
+ * second axis, where \`uApplyAlbedo\` is 1. Read at this pixel alone, because pigment does not move.
+ */
+uniform sampler2D uAlbedo;
+uniform float uApplyAlbedo;
 
 out vec4 fragColor;
 
@@ -50,6 +61,17 @@ vec3 burleyMass(float x, vec3 d) {
   return 0.5 - (exp(-x / d) + 3.0 * exp(-x / (3.0 * d))) * 0.125;
 }
 
+/**
+ * The spread light times the skin's colour here, on the second axis; the light as it is on the
+ * first. The colour target holds colour times coverage over coverage, so dividing gives the skin's
+ * own colour at an edge, which the light — weighted for coverage already — is then multiplied by.
+ */
+vec3 withAlbedo(vec3 light) {
+  if (uApplyAlbedo < 0.5) return light;
+  vec4 albedo = textureLod(uAlbedo, vUv, 0.0);
+  return light * albedo.rgb / max(albedo.a, 1e-4);
+}
+
 void main() {
   vec4 own = textureLod(uSkin, vUv, 0.0);
   /*
@@ -63,7 +85,7 @@ void main() {
   }
   float depth = textureLod(uDepth, vUv, 0.0).r;
   if (${glslIsFarDepth('depth')}) {
-    fragColor = own;
+    fragColor = vec4(withAlbedo(own.rgb), own.a);
     return;
   }
   /* A part-covered pixel's code is its share of the whole: read it as the nearest, which is the
@@ -75,7 +97,7 @@ void main() {
   /* The widest distance in pixels here: under half of one, there is nothing to spread across. */
   float pixels = widest * uFocal / max(z, 1e-4);
   if (pixels < 0.5) {
-    fragColor = own;
+    fragColor = vec4(withAlbedo(own.rgb), own.a);
     return;
   }
   vec3 centre = 2.0 * burleyMass(EDGES[0] * widest, d);
@@ -100,6 +122,6 @@ void main() {
       weight += w * (cover * keep);
     }
   }
-  fragColor = vec4(sum / weight, own.a);
+  fragColor = vec4(withAlbedo(sum / weight), own.a);
 }
 `;

package/src/render/skinBlur.ts

@@ -3,11 +3,14 @@
  * the kernel to, and nothing at run time calls it.
  *
  * **What it spreads.** With `skinScattering: 'screen-space'`, a skin draw writes its specular to the
- * frame and its diffuse — the light that went beneath the surface — to a target of its own, with the
- * profile it scatters by in the alpha. Before anything blended is drawn, that target is blurred
- * along the screen's two axes by Burley's normalised diffusion, one width per channel, and added
- * back: light that entered a cheek leaves it a centimetre away, reddest furthest, across the
- * pixels that centimetre covers at the cheek's distance. The pre-integrated fit stays in the lit
+ * frame, the light its diffuse is made of — the light that went beneath the surface, shaded on a
+ * white surface — to a target of its own with the profile it scatters by in the alpha, and its
+ * colour to a third. Before anything blended is drawn, the light is blurred along the screen's two
+ * axes by Burley's normalised diffusion, one width per channel, multiplied by the colour at each
+ * pixel and added back: light that entered a cheek leaves it a centimetre away, reddest furthest,
+ * across the pixels that centimetre covers at the cheek's distance, and a brow stays where it is
+ * drawn. **Until 4.8.6 the coloured diffuse was spread**, which smeared every mark on a face into
+ * the skin around it and laid faint copies of each mark at the taps' offsets. The pre-integrated fit stays in the lit
  * stage for what this cannot see — a terminator's curvature — and this carries what that cannot:
  * light crossing a shadow's edge, or a nostril's rim, in the picture rather than in a fit.
  *