babylon.quarks 0.18.0 → 0.19.0

package/src/VFXBatch.ts

@@ -1,7 +1,7 @@
-import {Mesh} from '@babylonjs/core/Meshes/mesh';
-import {Scene} from '@babylonjs/core/scene';
 import {BaseTexture} from '@babylonjs/core/Materials/Textures/baseTexture';
 import {ShaderMaterial} from '@babylonjs/core/Materials/shaderMaterial';
+import {Mesh} from '@babylonjs/core/Meshes/mesh';
+import {Scene} from '@babylonjs/core/scene';
 import {IParticleSystem} from 'quarks.core';
 import {VFXBatchSettings} from './BatchedRenderer';
 
@@ -33,6 +33,10 @@ export interface StoredBatchSettings {
     materialDepthWrite: boolean;
     materialAlphaTest: number;
     texture: any;
+    reflectionTexture: BaseTexture | null;
+    reflectionLevel: number;
+    reflectionFaces: BaseTexture[] | null;
+    reflectionAtlas: BaseTexture | null;
     layerMask: number;
 }
 
@@ -42,6 +46,7 @@ export abstract class VFXBatch {
     settings: StoredBatchSettings;
     protected maxParticles: number;
     protected scene: Scene;
+    private readonly visibleSystems: IParticleSystem[] = [];
 
     protected constructor(settings: VFXBatchSettings, scene: Scene) {
         this.scene = scene;
@@ -66,6 +71,10 @@ export abstract class VFXBatch {
             materialDepthWrite: settings.materialDepthWrite,
             materialAlphaTest: settings.materialAlphaTest,
             texture: settings.texture,
+            reflectionTexture: settings.reflectionTexture ?? null,
+            reflectionLevel: settings.reflectionLevel ?? 1,
+            reflectionFaces: settings.reflectionFaces ?? null,
+            reflectionAtlas: settings.reflectionAtlas ?? null,
             layerMask: settings.layerMask,
         };
         this.mesh = new Mesh('vfxBatch', scene);
@@ -80,13 +89,20 @@ export abstract class VFXBatch {
         this.systems.delete(system);
     }
 
+    /**
+     * Visible systems of this batch, written into a buffer owned by the batch.
+     * Called once per frame per batch, so the result is reused rather than
+     * reallocated; treat it as valid only until the next call.
+     */
     getVisibleSystems(): IParticleSystem[] {
-        const visibleSystems: IParticleSystem[] = [];
+        const visibleSystems = this.visibleSystems;
+        let count = 0;
         for (const system of this.systems) {
             if (system.emitter.visible) {
-                visibleSystems.push(system);
+                visibleSystems[count++] = system;
             }
         }
+        visibleSystems.length = count;
         return visibleSystems;
     }
 

package/src/envAtlas.ts

@@ -0,0 +1,136 @@
+import {BaseTexture} from '@babylonjs/core/Materials/Textures/baseTexture';
+import {Texture} from '@babylonjs/core/Materials/Textures/texture';
+import {Scene} from '@babylonjs/core/scene';
+
+const atlasByCube = new WeakMap<BaseTexture, Texture>();
+const pendingByCube = new WeakMap<BaseTexture, Promise<Texture | null>>();
+
+/** Reads the six face URLs from a Babylon CubeTexture (px py pz nx ny nz). */
+export function cubeFaceUrls(reflection: BaseTexture | null | undefined): string[] | null {
+    if (!reflection?.isCube) {
+        return null;
+    }
+    const files =
+        (reflection as {files?: string[]; _files?: string[]}).files ?? (reflection as {_files?: string[]})._files;
+    return files?.length === 6 ? files.slice() : null;
+}
+
+/** Returns a previously built atlas for this cube, if any. */
+export function getCachedEnvAtlas(cube: BaseTexture): Texture | null {
+    return atlasByCube.get(cube) ?? null;
+}
+
+/** Stores an atlas for a cube source (tests / prebuilt atlases). */
+export function cacheEnvAtlas(cube: BaseTexture, atlas: Texture): void {
+    atlasByCube.set(cube, atlas);
+}
+
+/**
+ * Packs six cube-face images into one 3×2 atlas Texture (px py pz / nx ny nz).
+ * Uses invertY:false so UV cellY=0 maps to the +faces row matching the shader.
+ */
+export async function createEnvAtlasFromFaceUrls(urls: string[], scene: Scene): Promise<Texture> {
+    if (typeof document === 'undefined' || typeof Image === 'undefined') {
+        throw new Error('createEnvAtlasFromFaceUrls requires a DOM Image/canvas environment');
+    }
+    const images = await Promise.all(urls.map((url) => loadImage(url)));
+    const size = images[0].width || images[0].naturalWidth;
+    if (!size) {
+        throw new Error('Env atlas face image has zero size');
+    }
+    const canvas = document.createElement('canvas');
+    canvas.width = size * 3;
+    canvas.height = size * 2;
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        throw new Error('Could not create env atlas canvas');
+    }
+    for (let i = 0; i < 6; i++) {
+        ctx.drawImage(images[i], (i % 3) * size, Math.floor(i / 3) * size, size, size);
+    }
+    const atlas = new Texture(canvas.toDataURL('image/jpeg', 0.92), scene, {
+        noMipmap: true,
+        invertY: false,
+        samplingMode: Texture.LINEAR_LINEAR,
+    });
+    atlas.name = 'quarksEnvAtlas';
+    return atlas;
+}
+
+/** Overridable builder hook (tests replace this to avoid needing DOM Image/canvas). */
+export const envAtlasBuilder = {
+    createFromFaceUrls: createEnvAtlasFromFaceUrls,
+};
+
+/**
+ * Ensures a 3×2 env atlas exists for a CubeTexture. Returns a cached atlas
+ * synchronously when available; otherwise starts (or joins) an async build and
+ * invokes onReady when the atlas is usable.
+ */
+export function ensureEnvAtlasFromCube(
+    cube: BaseTexture,
+    scene: Scene,
+    onReady: (atlas: Texture) => void
+): Texture | null {
+    const cached = atlasByCube.get(cube);
+    if (cached) {
+        onReady(cached);
+        return cached;
+    }
+
+    const kick = () => {
+        const existingPending = pendingByCube.get(cube);
+        if (existingPending) {
+            existingPending.then((atlas) => {
+                if (atlas) {
+                    onReady(atlas);
+                }
+            });
+            return;
+        }
+
+        const urls = cubeFaceUrls(cube);
+        if (!urls) {
+            return;
+        }
+
+        const pending = envAtlasBuilder
+            .createFromFaceUrls(urls, scene)
+            .then((atlas) => {
+                atlasByCube.set(cube, atlas);
+                pendingByCube.delete(cube);
+                onReady(atlas);
+                return atlas;
+            })
+            .catch((err) => {
+                pendingByCube.delete(cube);
+                console.warn('[babylon.quarks] Failed to build env atlas from cubemap faces', err);
+                return null;
+            });
+        pendingByCube.set(cube, pending);
+    };
+
+    if (cube.isReady()) {
+        kick();
+    } else {
+        const observable = (cube as {onLoadObservable?: {addOnce: (cb: () => void) => void}}).onLoadObservable;
+        if (observable) {
+            observable.addOnce(() => kick());
+        } else {
+            kick();
+        }
+    }
+
+    return atlasByCube.get(cube) ?? null;
+}
+
+/** Loads one image URL as an HTMLImageElement. */
+function loadImage(url: string): Promise<HTMLImageElement> {
+    return new Promise((resolve, reject) => {
+        const image = new Image();
+        image.crossOrigin = 'anonymous';
+        image.onload = () => resolve(image);
+        image.onerror = () => reject(new Error(`Failed to load env face ${url}`));
+        image.src = url;
+    });
+}

package/src/index.ts

@@ -2,58 +2,63 @@ import {loadPlugin} from 'quarks.core';
 import {MeshSurfaceEmitterPlugin} from './MeshSurfaceEmitter';
 import {registerShaderChunks} from './shaders';
 
-export {BatchedRenderer} from './BatchedRenderer';
-export type {VFXBatchSettings, AdaptivePerformanceOptions, AdaptivePerformanceState} from './BatchedRenderer';
+export * from 'quarks.core';
 export {BatchedParticleRenderer} from './BatchedParticleRenderer';
-export {VFXBatch, RenderMode} from './VFXBatch';
-export type {StoredBatchSettings} from './VFXBatch';
-export {SpriteBatch} from './SpriteBatch';
-export {TrailBatch} from './TrailBatch';
+export {BatchedRenderer} from './BatchedRenderer';
+export type {AdaptivePerformanceOptions, AdaptivePerformanceState, VFXBatchSettings} from './BatchedRenderer';
+export {
+    cacheEnvAtlas,
+    createEnvAtlasFromFaceUrls,
+    cubeFaceUrls,
+    ensureEnvAtlasFromCube,
+    getCachedEnvAtlas,
+} from './envAtlas';
+export * from './materials/';
+export {MeshSurfaceEmitter, MeshSurfaceEmitterPlugin} from './MeshSurfaceEmitter';
+export {ParticleEmitter} from './ParticleEmitter';
 export {ParticleSystem} from './ParticleSystem';
 export type {
-    ParticleSystemParameters,
+    BabylonMetaData,
     BurstParameters,
     BurstParametersJSON,
     ParticleSystemJSONParameters,
-    BabylonMetaData,
+    ParticleSystemParameters,
 } from './ParticleSystem';
-export {ParticleEmitter} from './ParticleEmitter';
-export {QuarksUtil} from './QuarksUtil';
 export {QuarksLoader} from './QuarksLoader';
 export type {QuarksLoaderOptions} from './QuarksLoader';
 export {QuarksPrefab} from './QuarksPrefab';
 export type {AnimationData, QuarksTimelineClip} from './QuarksPrefab';
-export {MeshSurfaceEmitter, MeshSurfaceEmitterPlugin} from './MeshSurfaceEmitter';
+export {QuarksUtil} from './QuarksUtil';
 export * from './shaders/';
-export * from './materials/';
-export * from 'quarks.core';
-
+export {SpriteBatch} from './SpriteBatch';
+export {TrailBatch} from './TrailBatch';
+export {RenderMode, VFXBatch} from './VFXBatch';
+export type {StoredBatchSettings} from './VFXBatch';
 
 // Re-export quarks.core types (interfaces - type-only)
 export type {
-    IParticleSystem,
-    IParticle,
-    Particle,
-    EmissionState,
-    RendererEmitterSettings,
-    TrailSettings,
-    StretchedBillBoardSettings,
+    Behavior,
     BillBoardSettings,
-    MeshSettings,
+    ColorGenerator,
+    EmissionState,
+    EmitterShape,
+    FunctionColorGenerator,
+    FunctionValueGenerator,
     IEmitter,
+    IParticle,
+    IParticleSystem,
+    MeshSettings,
+    Particle,
     ParticleSystemEvent,
     ParticleSystemEventType,
+    RendererEmitterSettings,
+    RotationGenerator,
     SerializationOptions,
-    Behavior,
-    EmitterShape,
+    StretchedBillBoardSettings,
+    TrailSettings,
     ValueGenerator,
-    FunctionValueGenerator,
-    ColorGenerator,
-    FunctionColorGenerator,
-    RotationGenerator,
     Vector3Generator,
 } from 'quarks.core';
 
 registerShaderChunks();
 loadPlugin(MeshSurfaceEmitterPlugin);
-

package/src/materials/ParticleMaterials.ts

@@ -1,6 +1,6 @@
-import {Scene} from '@babylonjs/core/scene';
 import {PBRMaterial} from '@babylonjs/core/Materials/PBR/pbrMaterial';
 import {StandardMaterial} from '@babylonjs/core/Materials/standardMaterial';
+import {Scene} from '@babylonjs/core/scene';
 
 export type BabylonParticleMaterialParameters = Record<string, any>;
 

package/src/shaders/index.ts

@@ -1,9 +1,9 @@
 export * from './chunks';
-export {default as particleVertShader} from './particle_vert.glsl';
-export {default as particleFragShader} from './particle_frag.glsl';
-export {default as localParticleVertShader} from './local_particle_vert.glsl';
 export {default as localParticlePhysicsVertShader} from './local_particle_physics_vert.glsl';
+export {default as localParticleVertShader} from './local_particle_vert.glsl';
+export {default as particleFragShader} from './particle_frag.glsl';
 export {default as particlePhysicsFragShader} from './particle_physics_frag.glsl';
+export {default as particleVertShader} from './particle_vert.glsl';
 export {default as stretchedBillboardVertShader} from './stretched_bb_particle_vert.glsl';
-export {default as trailVertShader} from './trail_vert.glsl';
 export {default as trailFragShader} from './trail_frag.glsl';
+export {default as trailVertShader} from './trail_vert.glsl';

package/src/shaders/local_particle_physics_vert.wgsl.ts

@@ -0,0 +1,81 @@
+export default /* wgsl */ `
+attribute position: vec3f;
+attribute uv: vec2f;
+attribute normal: vec3f;
+attribute offset: vec3f;
+attribute color: vec4f;
+attribute size: vec3f;
+attribute rotation: vec4f;
+attribute uvTile: f32;
+
+uniform world: mat4x4f;
+uniform view: mat4x4f;
+uniform projection: mat4x4f;
+
+#ifdef UV_TILE
+uniform tileCountX: f32;
+uniform tileCountY: f32;
+#endif
+
+varying vUV: vec2f;
+varying vColor: vec4f;
+varying vNormal: vec3f;
+varying vWorldPos: vec3f;
+
+#ifdef TILE_BLEND
+varying vUV2: vec2f;
+varying vTileBlend: f32;
+#endif
+
+#ifdef SOFT_PARTICLES
+varying projPosition: vec4f;
+varying linearDepth: f32;
+#endif
+
+fn applyQuaternion(v: vec3f, q: vec4f) -> vec3f {
+    let qVec = q.xyz;
+    let qW = q.w;
+    let t = 2.0 * cross(qVec, v);
+    return v + qW * t + cross(qVec, t);
+}
+
+@vertex
+fn main(input: VertexInputs) -> FragmentInputs {
+    let scaledPosition = vertexInputs.position * vertexInputs.size;
+    let rotatedPosition = applyQuaternion(scaledPosition, vertexInputs.rotation);
+    let rotatedNormal = normalize(applyQuaternion(vertexInputs.normal, vertexInputs.rotation));
+    let localPos = rotatedPosition + vertexInputs.offset;
+
+    let worldPos = uniforms.world * vec4f(localPos, 1.0);
+    let viewPos = uniforms.view * worldPos;
+    let clipPosition = uniforms.projection * viewPos;
+    vertexOutputs.position = clipPosition;
+
+    vertexOutputs.vWorldPos = worldPos.xyz;
+    vertexOutputs.vNormal = normalize((uniforms.world * vec4f(rotatedNormal, 0.0)).xyz);
+
+#ifdef SOFT_PARTICLES
+    vertexOutputs.projPosition = clipPosition;
+    vertexOutputs.linearDepth = -viewPos.z;
+#endif
+
+#ifdef UV_TILE
+    let tc = vec2f(uniforms.tileCountX, uniforms.tileCountY);
+    let baseTile = floor(vertexInputs.uvTile);
+    let tileU = (baseTile % tc.x) / tc.x;
+    let tileV = 1.0 - floor(baseTile / tc.x) / tc.y - 1.0 / tc.y;
+    vertexOutputs.vUV = vertexInputs.uv / tc + vec2f(tileU, tileV);
+    #ifdef TILE_BLEND
+        let nextTile = ceil(vertexInputs.uvTile);
+        let nextU = (nextTile % tc.x) / tc.x;
+        let nextV = 1.0 - floor(nextTile / tc.x) / tc.y - 1.0 / tc.y;
+        vertexOutputs.vUV2 = vertexInputs.uv / tc + vec2f(nextU, nextV);
+        vertexOutputs.vTileBlend = fract(vertexInputs.uvTile);
+    #endif
+#else
+    vertexOutputs.vUV = vertexInputs.uv;
+#endif
+
+    vertexOutputs.vColor = vertexInputs.color;
+}
+`;

package/src/shaders/particle_frag.wgsl.ts

@@ -0,0 +1,64 @@
+export default /* wgsl */ `
+varying vUV: vec2f;
+varying vColor: vec4f;
+
+#ifdef TILE_BLEND
+varying vUV2: vec2f;
+varying vTileBlend: f32;
+#endif
+
+#ifdef USE_MAP
+var mapSampler: sampler;
+var map: texture_2d<f32>;
+#endif
+
+#ifdef SOFT_PARTICLES
+var depthTextureSampler: sampler;
+var depthTexture: texture_2d<f32>;
+uniform softParams: vec2f;
+uniform projParams: vec4f;
+varying projPosition: vec4f;
+varying linearDepth: f32;
+#endif
+
+#ifdef USE_ALPHATEST
+uniform alphaTest: f32;
+#endif
+
+@fragment
+fn main(input: FragmentInputs) -> FragmentOutputs {
+    var baseColor = fragmentInputs.vColor;
+
+#ifdef USE_MAP
+    var texColor = textureSample(map, mapSampler, fragmentInputs.vUV);
+    #ifdef TILE_BLEND
+        let texColor2 = textureSample(map, mapSampler, fragmentInputs.vUV2);
+        texColor = mix(texColor, texColor2, fragmentInputs.vTileBlend);
+    #endif
+    baseColor *= texColor;
+#endif
+
+#ifdef USE_COLOR_AS_ALPHA
+    baseColor.a *= (baseColor.r + baseColor.g + baseColor.b) / 3.0;
+#endif
+
+#ifdef USE_ALPHATEST
+    if (baseColor.a < uniforms.alphaTest) { discard; }
+#else
+    if (baseColor.a < 0.01) { discard; }
+#endif
+
+#ifdef SOFT_PARTICLES
+    var p2 = fragmentInputs.projPosition.xy / fragmentInputs.projPosition.w;
+    p2 = 0.5 * p2 + 0.5;
+    let readDepth = textureSample(depthTexture, depthTextureSampler, p2).r;
+    let zNear = uniforms.projParams.x;
+    let zFar = uniforms.projParams.y;
+    let viewDepth = (zFar * zNear) / (zFar - readDepth * (zFar - zNear));
+    let fade = clamp(uniforms.softParams.y * ((viewDepth - uniforms.softParams.x) - fragmentInputs.linearDepth), 0.0, 1.0);
+    baseColor *= fade;
+#endif
+
+    fragmentOutputs.color = baseColor;
+}
+`;

package/src/shaders/particle_physics_frag.glsl.ts

@@ -2,6 +2,7 @@ export default /* glsl */ `
 varying vec2 vUV;
 varying vec4 vColor;
 varying vec3 vNormal;
+varying vec3 vWorldPos;
 
 uniform vec3 lightDirection;
 uniform vec3 lightColor;
@@ -16,6 +17,52 @@ varying float vTileBlend;
 uniform sampler2D map;
 #endif
 
+// One 3×2 atlas (px py pz / nx ny nz). Avoids samplerCube and multi-face
+// sampler bindings that raise GL_INVALID_OPERATION on iOS WebKit.
+#ifdef USE_ENVMAP_ATLAS
+uniform sampler2D envAtlas;
+uniform vec3 eyePosition;
+uniform float reflectionLevel;
+
+vec3 sampleEnvAtlas(vec3 r) {
+    vec3 a = abs(r);
+    vec2 localUV;
+    float cellX;
+    float cellY;
+    // Atlas layout: +X +Y +Z on row 0, -X -Y -Z on row 1.
+    if (a.x >= a.y && a.x >= a.z) {
+        cellX = 0.0;
+        if (r.x >= 0.0) {
+            cellY = 0.0;
+            localUV = vec2(-r.z, -r.y) / a.x * 0.5 + 0.5;
+        } else {
+            cellY = 1.0;
+            localUV = vec2(r.z, -r.y) / a.x * 0.5 + 0.5;
+        }
+    } else if (a.y >= a.z) {
+        cellX = 1.0;
+        if (r.y >= 0.0) {
+            cellY = 0.0;
+            localUV = vec2(r.x, r.z) / a.y * 0.5 + 0.5;
+        } else {
+            cellY = 1.0;
+            localUV = vec2(r.x, -r.z) / a.y * 0.5 + 0.5;
+        }
+    } else {
+        cellX = 2.0;
+        if (r.z >= 0.0) {
+            cellY = 0.0;
+            localUV = vec2(r.x, -r.y) / a.z * 0.5 + 0.5;
+        } else {
+            cellY = 1.0;
+            localUV = vec2(-r.x, -r.y) / a.z * 0.5 + 0.5;
+        }
+    }
+    vec2 uv = (vec2(cellX, cellY) + clamp(localUV, 0.0, 1.0)) / vec2(3.0, 2.0);
+    return texture2D(envAtlas, uv).rgb;
+}
+#endif
+
 #ifdef SOFT_PARTICLES
 uniform sampler2D depthTexture;
 uniform vec2 softParams;
@@ -51,7 +98,15 @@ void main() {
     float NdotL = max(dot(N, L), 0.0);
     vec3 litColor = ambientColor + lightColor * NdotL;
 
-    gl_FragColor = vec4(baseColor.rgb * litColor, baseColor.a);
+    vec3 color = baseColor.rgb * litColor;
+
+#ifdef USE_ENVMAP_ATLAS
+    vec3 viewDir = normalize(vWorldPos - eyePosition);
+    vec3 reflectionCoords = reflect(viewDir, N);
+    color += sampleEnvAtlas(reflectionCoords) * reflectionLevel;
+#endif
+
+    gl_FragColor = vec4(color, baseColor.a);
 
 #ifdef SOFT_PARTICLES
     vec2 p2 = projPosition.xy / projPosition.w;

package/src/shaders/particle_physics_frag.wgsl.ts

@@ -0,0 +1,125 @@
+export default /* wgsl */ `
+varying vUV: vec2f;
+varying vColor: vec4f;
+varying vNormal: vec3f;
+varying vWorldPos: vec3f;
+
+uniform lightDirection: vec3f;
+uniform lightColor: vec3f;
+uniform ambientColor: vec3f;
+
+#ifdef TILE_BLEND
+varying vUV2: vec2f;
+varying vTileBlend: f32;
+#endif
+
+#ifdef USE_MAP
+var mapSampler: sampler;
+var map: texture_2d<f32>;
+#endif
+
+#ifdef USE_ENVMAP_ATLAS
+var envAtlasSampler: sampler;
+var envAtlas: texture_2d<f32>;
+uniform eyePosition: vec3f;
+uniform reflectionLevel: f32;
+
+fn sampleEnvAtlas(r: vec3f) -> vec3f {
+    let a = abs(r);
+    var localUV: vec2f;
+    var cellX: f32;
+    var cellY: f32;
+    if (a.x >= a.y && a.x >= a.z) {
+        cellX = 0.0;
+        if (r.x >= 0.0) {
+            cellY = 0.0;
+            localUV = vec2f(-r.z, -r.y) / a.x * 0.5 + 0.5;
+        } else {
+            cellY = 1.0;
+            localUV = vec2f(r.z, -r.y) / a.x * 0.5 + 0.5;
+        }
+    } else if (a.y >= a.z) {
+        cellX = 1.0;
+        if (r.y >= 0.0) {
+            cellY = 0.0;
+            localUV = vec2f(r.x, r.z) / a.y * 0.5 + 0.5;
+        } else {
+            cellY = 1.0;
+            localUV = vec2f(r.x, -r.z) / a.y * 0.5 + 0.5;
+        }
+    } else {
+        cellX = 2.0;
+        if (r.z >= 0.0) {
+            cellY = 0.0;
+            localUV = vec2f(r.x, -r.y) / a.z * 0.5 + 0.5;
+        } else {
+            cellY = 1.0;
+            localUV = vec2f(-r.x, -r.y) / a.z * 0.5 + 0.5;
+        }
+    }
+    let uv = (vec2f(cellX, cellY) + clamp(localUV, vec2f(0.0), vec2f(1.0))) / vec2f(3.0, 2.0);
+    return textureSample(envAtlas, envAtlasSampler, uv).rgb;
+}
+#endif
+
+#ifdef SOFT_PARTICLES
+var depthTextureSampler: sampler;
+var depthTexture: texture_2d<f32>;
+uniform softParams: vec2f;
+uniform projParams: vec4f;
+varying projPosition: vec4f;
+varying linearDepth: f32;
+#endif
+
+#ifdef USE_ALPHATEST
+uniform alphaTest: f32;
+#endif
+
+@fragment
+fn main(input: FragmentInputs) -> FragmentOutputs {
+    var baseColor = fragmentInputs.vColor;
+
+#ifdef USE_MAP
+    var texColor = textureSample(map, mapSampler, fragmentInputs.vUV);
+    #ifdef TILE_BLEND
+        let texColor2 = textureSample(map, mapSampler, fragmentInputs.vUV2);
+        texColor = mix(texColor, texColor2, fragmentInputs.vTileBlend);
+    #endif
+    baseColor *= texColor;
+#endif
+
+#ifdef USE_ALPHATEST
+    if (baseColor.a < uniforms.alphaTest) { discard; }
+#else
+    if (baseColor.a < 0.01) { discard; }
+#endif
+
+    let N = normalize(fragmentInputs.vNormal);
+    let L = normalize(-uniforms.lightDirection);
+    let NdotL = max(dot(N, L), 0.0);
+    let litColor = uniforms.ambientColor + uniforms.lightColor * NdotL;
+
+    var color = baseColor.rgb * litColor;
+
+#ifdef USE_ENVMAP_ATLAS
+    let viewDir = normalize(fragmentInputs.vWorldPos - uniforms.eyePosition);
+    let reflectionCoords = reflect(viewDir, N);
+    color += sampleEnvAtlas(reflectionCoords) * uniforms.reflectionLevel;
+#endif
+
+    var finalColor = vec4f(color, baseColor.a);
+
+#ifdef SOFT_PARTICLES
+    var p2 = fragmentInputs.projPosition.xy / fragmentInputs.projPosition.w;
+    p2 = 0.5 * p2 + 0.5;
+    let readDepth = textureSample(depthTexture, depthTextureSampler, p2).r;
+    let zNear = uniforms.projParams.x;
+    let zFar = uniforms.projParams.y;
+    let viewDepth = (zFar * zNear) / (zFar - readDepth * (zFar - zNear));
+    let fade = clamp(uniforms.softParams.y * ((viewDepth - uniforms.softParams.x) - fragmentInputs.linearDepth), 0.0, 1.0);
+    finalColor *= fade;
+#endif
+
+    fragmentOutputs.color = finalColor;
+}
+`;