babylon.quarks 0.17.0

package/src/TrailBatch.ts

@@ -0,0 +1,345 @@
+import {Mesh} from '@babylonjs/core/Meshes/mesh';
+import {VertexBuffer} from '@babylonjs/core/Buffers/buffer';
+import {Effect} from '@babylonjs/core/Materials/effect';
+import {ShaderMaterial} from '@babylonjs/core/Materials/shaderMaterial';
+import {Scene} from '@babylonjs/core/scene';
+import {BoundingInfo} from '@babylonjs/core/Culling/boundingInfo';
+import {Vector3 as BVector3} from '@babylonjs/core/Maths/math.vector';
+import {Vector2 as BVector2} from '@babylonjs/core/Maths/math.vector';
+import {Constants} from '@babylonjs/core/Engines/constants';
+import {Matrix4, Quaternion, RecordState, TrailParticle, Vector3} from 'quarks.core';
+import {VFXBatch, RenderMode} from './VFXBatch';
+import {VFXBatchSettings} from './BatchedRenderer';
+import trail_vert from './shaders/trail_vert.glsl';
+import trail_frag from './shaders/trail_frag.glsl';
+
+export class TrailBatch extends VFXBatch {
+    private positionBuffer!: Float32Array;
+    private previousBuffer!: Float32Array;
+    private nextBuffer!: Float32Array;
+    private uvBuffer!: Float32Array;
+    private sideBuffer!: Float32Array;
+    private widthBuffer!: Float32Array;
+    private colorBuffer!: Float32Array;
+    private indexBuffer!: Uint32Array;
+    private previousVB!: VertexBuffer;
+    private nextVB!: VertexBuffer;
+    private sideVB!: VertexBuffer;
+    private widthVB!: VertexBuffer;
+
+    constructor(settings: VFXBatchSettings, scene: Scene) {
+        super(settings, scene);
+        this.maxParticles = 10000;
+        this.setupBuffers();
+        this.rebuildMaterial();
+        this.mesh.setEnabled(false);
+    }
+
+    setupBuffers(): void {
+        this.mesh.dispose();
+        this.mesh = new Mesh('trailBatch', this.scene);
+        this.mesh.alwaysSelectAsActiveMesh = true;
+
+        this.positionBuffer = new Float32Array(this.maxParticles * 6);
+        this.previousBuffer = new Float32Array(this.maxParticles * 6);
+        this.nextBuffer = new Float32Array(this.maxParticles * 6);
+        this.uvBuffer = new Float32Array(this.maxParticles * 4);
+        this.sideBuffer = new Float32Array(this.maxParticles * 2);
+        this.widthBuffer = new Float32Array(this.maxParticles * 2);
+        this.colorBuffer = new Float32Array(this.maxParticles * 8);
+        this.indexBuffer = new Uint32Array(this.maxParticles * 6);
+
+        // Initialize with full-capacity buffers (updatable) and a dummy triangle
+        this.positionBuffer[0] = 0; this.positionBuffer[1] = 0; this.positionBuffer[2] = 0;
+        this.positionBuffer[3] = 1; this.positionBuffer[4] = 0; this.positionBuffer[5] = 0;
+        this.positionBuffer[6] = 0; this.positionBuffer[7] = 1; this.positionBuffer[8] = 0;
+        this.positionBuffer[9] = 1; this.positionBuffer[10] = 1; this.positionBuffer[11] = 0;
+        this.indexBuffer[0] = 0; this.indexBuffer[1] = 1; this.indexBuffer[2] = 2;
+        this.indexBuffer[3] = 1; this.indexBuffer[4] = 3; this.indexBuffer[5] = 2;
+
+        // Set standard vertex data with full buffer capacity (updatable)
+        this.mesh.setVerticesData(VertexBuffer.PositionKind, this.positionBuffer, true);
+        this.mesh.setVerticesData(VertexBuffer.UVKind, this.uvBuffer, true);
+        this.mesh.setVerticesData(VertexBuffer.ColorKind, this.colorBuffer, true, 4);
+        this.mesh.setIndices(Array.from(this.indexBuffer.subarray(0, 6)), null, true);
+        const engine = this.scene.getEngine();
+        this.previousVB = new VertexBuffer(engine, this.previousBuffer, 'previous', true, false, 3, false);
+        this.nextVB = new VertexBuffer(engine, this.nextBuffer, 'next', true, false, 3, false);
+        this.sideVB = new VertexBuffer(engine, this.sideBuffer, 'side', true, false, 1, false);
+        this.widthVB = new VertexBuffer(engine, this.widthBuffer, 'width', true, false, 1, false);
+        this.mesh.setVerticesBuffer(this.previousVB);
+        this.mesh.setVerticesBuffer(this.nextVB);
+        this.mesh.setVerticesBuffer(this.sideVB);
+        this.mesh.setVerticesBuffer(this.widthVB);
+
+        // Disable bounding info recomputation
+        this.mesh.doNotSyncBoundingInfo = true;
+        const min = new BVector3(-10000, -10000, -10000);
+        const max = new BVector3(10000, 10000, 10000);
+        this.mesh.setBoundingInfo(new BoundingInfo(min, max));
+        if (this.mesh.subMeshes) {
+            for (const sub of this.mesh.subMeshes) {
+                (sub as any)._boundingInfo = this.mesh.getBoundingInfo();
+            }
+        }
+
+    }
+
+    expandBuffers(target: number): void {
+        while (target >= this.maxParticles) {
+            this.maxParticles *= 2;
+        }
+        this.setupBuffers();
+        this.rebuildMaterial();
+    }
+
+    rebuildMaterial(): void {
+        const shaderName = `quarksTrail_${Date.now()}`;
+        const defines: string[] = [];
+
+        if (this.settings.texture) {
+            defines.push('USE_MAP');
+        }
+
+        Effect.ShadersStore[shaderName + 'VertexShader'] = trail_vert;
+        Effect.ShadersStore[shaderName + 'FragmentShader'] = trail_frag;
+
+        const attributes = ['position', 'previous', 'next', 'side', 'width', 'uv', 'color'];
+        const uniforms = ['world', 'view', 'projection', 'worldViewProjection', 'lineWidth', 'resolution', 'sizeAttenuation'];
+        const samplers: string[] = [];
+
+        if (this.settings.texture) {
+            samplers.push('map');
+        }
+
+        const mat = new ShaderMaterial(shaderName, this.scene,
+            {vertex: shaderName, fragment: shaderName},
+            {
+                attributes,
+                uniforms,
+                samplers,
+                defines,
+                needAlphaBlending: this.settings.materialTransparent,
+            }
+        );
+
+        if (this.settings.texture) {
+            mat.setTexture('map', this.settings.texture);
+        }
+        const engine = this.scene.getEngine();
+        mat.setFloat('lineWidth', 1);
+        mat.setVector2('resolution', new BVector2(engine.getRenderWidth(), engine.getRenderHeight()));
+        mat.setFloat('sizeAttenuation', 1);
+        mat.onBindObservable.add(() => {
+            const renderEngine = this.scene.getEngine();
+            mat.setVector2('resolution', new BVector2(renderEngine.getRenderWidth(), renderEngine.getRenderHeight()));
+        });
+
+        mat.backFaceCulling = false;
+
+        if (this.settings.materialTransparent) {
+            mat.alphaMode = this.settings.materialBlendMode;
+        } else {
+            mat.alphaMode = Constants.ALPHA_DISABLE;
+        }
+        mat.needDepthPrePass = this.settings.materialDepthWrite;
+        mat.forceDepthWrite = this.settings.materialDepthWrite;
+        mat.disableDepthWrite = !this.settings.materialDepthWrite;
+
+        this.mesh.material = mat;
+    }
+
+    private vector_ = new Vector3();
+    private vector2_ = new Vector3();
+    private vector3_ = new Vector3();
+    private quaternion_ = new Quaternion();
+
+    update(): void {
+        let index = 0;
+        let triangles = 0;
+
+        let particleCount = 0;
+        const visibleSystems = this.getVisibleSystems();
+        for (const system of visibleSystems) {
+            for (let j = 0; j < system.particleNum; j++) {
+                particleCount += (system.particles[j] as TrailParticle).previous.length * 2;
+            }
+        }
+        if (particleCount > this.maxParticles) {
+            this.expandBuffers(particleCount);
+        }
+
+        for (const system of visibleSystems) {
+            // Ensure world matrix is up to date
+            if ((system.emitter as any).computeWorldMatrix) {
+                (system.emitter as any).computeWorldMatrix(true);
+            }
+            const rotation = this.quaternion_;
+            const translation = this.vector2_;
+            const scale = this.vector3_;
+            system.emitter.matrixWorld.decompose(translation, rotation, scale);
+
+            const particles = system.particles;
+            const particleNum = system.particleNum;
+            const uTileCount = this.settings.uTileCount;
+            const vTileCount = this.settings.vTileCount;
+            const tileWidth = 1 / uTileCount;
+            const tileHeight = 1 / vTileCount;
+
+            for (let j = 0; j < particleNum; j++) {
+                const particle = particles[j] as TrailParticle;
+                const col = particle.uvTile % vTileCount;
+                const row = Math.floor(particle.uvTile / vTileCount + 0.001);
+
+                const iter = particle.previous.values();
+                let curIter = iter.next();
+                let previous: RecordState = curIter.value as RecordState;
+                let current: RecordState = previous;
+                if (!curIter.done) curIter = iter.next();
+                let next: RecordState;
+                if (curIter.value !== undefined) {
+                    next = curIter.value as RecordState;
+                } else {
+                    next = current;
+                }
+
+                for (let i = 0; i < particle.previous.length; i++, index += 2) {
+                    let pos: Vector3;
+                    if (system.worldSpace) {
+                        pos = current.position;
+                    } else {
+                        if (particle.parentMatrix) {
+                            this.vector_.copy(current.position).applyMatrix4(particle.parentMatrix as unknown as Matrix4);
+                        } else {
+                            this.vector_.copy(current.position).applyMatrix4(system.emitter.matrixWorld);
+                        }
+                        pos = this.vector_;
+                    }
+                    const pi = index * 3;
+                    this.positionBuffer[pi] = pos.x;
+                    this.positionBuffer[pi + 1] = pos.y;
+                    this.positionBuffer[pi + 2] = pos.z;
+                    this.positionBuffer[pi + 3] = pos.x;
+                    this.positionBuffer[pi + 4] = pos.y;
+                    this.positionBuffer[pi + 5] = pos.z;
+
+                    let prevPos: Vector3;
+                    if (system.worldSpace) {
+                        prevPos = previous.position;
+                    } else {
+                        if (particle.parentMatrix) {
+                            this.vector_.copy(previous.position).applyMatrix4(particle.parentMatrix as unknown as Matrix4);
+                        } else {
+                            this.vector_.copy(previous.position).applyMatrix4(system.emitter.matrixWorld);
+                        }
+                        prevPos = this.vector_;
+                    }
+                    this.previousBuffer[pi] = prevPos.x;
+                    this.previousBuffer[pi + 1] = prevPos.y;
+                    this.previousBuffer[pi + 2] = prevPos.z;
+                    this.previousBuffer[pi + 3] = prevPos.x;
+                    this.previousBuffer[pi + 4] = prevPos.y;
+                    this.previousBuffer[pi + 5] = prevPos.z;
+
+                    let nextPos: Vector3;
+                    if (system.worldSpace) {
+                        nextPos = next.position;
+                    } else {
+                        if (particle.parentMatrix) {
+                            this.vector_.copy(next.position).applyMatrix4(particle.parentMatrix as unknown as Matrix4);
+                        } else {
+                            this.vector_.copy(next.position).applyMatrix4(system.emitter.matrixWorld);
+                        }
+                        nextPos = this.vector_;
+                    }
+                    this.nextBuffer[pi] = nextPos.x;
+                    this.nextBuffer[pi + 1] = nextPos.y;
+                    this.nextBuffer[pi + 2] = nextPos.z;
+                    this.nextBuffer[pi + 3] = nextPos.x;
+                    this.nextBuffer[pi + 4] = nextPos.y;
+                    this.nextBuffer[pi + 5] = nextPos.z;
+
+                    this.sideBuffer[index] = 1;
+                    this.sideBuffer[index + 1] = -1;
+
+                    if (system.worldSpace || particle.parentMatrix) {
+                        this.widthBuffer[index] = current.size;
+                        this.widthBuffer[index + 1] = current.size;
+                    } else {
+                        const objectScale = (Math.abs(scale.x) + Math.abs(scale.y) + Math.abs(scale.z)) / 3;
+                        this.widthBuffer[index] = current.size * objectScale;
+                        this.widthBuffer[index + 1] = current.size * objectScale;
+                    }
+
+                    const ui = index * 2;
+                    this.uvBuffer[ui] = (i / particle.previous.length + col) * tileWidth;
+                    this.uvBuffer[ui + 1] = (vTileCount - row - 1) * tileHeight;
+                    this.uvBuffer[ui + 2] = (i / particle.previous.length + col) * tileWidth;
+                    this.uvBuffer[ui + 3] = (vTileCount - row) * tileHeight;
+
+                    const cci = index * 4;
+                    this.colorBuffer[cci] = current.color.x;
+                    this.colorBuffer[cci + 1] = current.color.y;
+                    this.colorBuffer[cci + 2] = current.color.z;
+                    this.colorBuffer[cci + 3] = current.color.w;
+                    this.colorBuffer[cci + 4] = current.color.x;
+                    this.colorBuffer[cci + 5] = current.color.y;
+                    this.colorBuffer[cci + 6] = current.color.z;
+                    this.colorBuffer[cci + 7] = current.color.w;
+
+                    if (i + 1 < particle.previous.length) {
+                        this.indexBuffer[triangles * 3] = index;
+                        this.indexBuffer[triangles * 3 + 1] = index + 1;
+                        this.indexBuffer[triangles * 3 + 2] = index + 2;
+                        triangles++;
+                        this.indexBuffer[triangles * 3] = index + 2;
+                        this.indexBuffer[triangles * 3 + 1] = index + 1;
+                        this.indexBuffer[triangles * 3 + 2] = index + 3;
+                        triangles++;
+                    }
+
+                    previous = current;
+                    current = next;
+                    if (!curIter.done) {
+                        curIter = iter.next();
+                        if (curIter.value !== undefined) {
+                            next = curIter.value as RecordState;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (index > 0 && triangles > 0) {
+            this.mesh.updateVerticesData(VertexBuffer.PositionKind, this.positionBuffer);
+            this.mesh.updateVerticesData(VertexBuffer.UVKind, this.uvBuffer);
+            this.mesh.updateIndices(Array.from(this.indexBuffer.subarray(0, triangles * 3)));
+            this.previousVB.update(this.previousBuffer);
+            this.nextVB.update(this.nextBuffer);
+            this.sideVB.update(this.sideBuffer);
+            this.widthVB.update(this.widthBuffer);
+
+            const colorVB = this.mesh.getVertexBuffer(VertexBuffer.ColorKind);
+            if (colorVB) colorVB.update(this.colorBuffer);
+
+            this.mesh.setEnabled(true);
+            if (this.mesh.subMeshes && this.mesh.subMeshes.length > 0) {
+                const meshBoundingInfo = this.mesh.getBoundingInfo();
+                for (const subMesh of this.mesh.subMeshes) {
+                    (subMesh as any)._boundingInfo = meshBoundingInfo;
+                }
+                this.mesh.subMeshes[0].indexCount = triangles * 3;
+                this.mesh.subMeshes[0].verticesCount = index;
+            }
+        } else {
+            this.mesh.setEnabled(false);
+        }
+    }
+
+    dispose(): void {
+        if (this.mesh.material) {
+            this.mesh.material.dispose();
+        }
+        super.dispose();
+    }
+}

package/src/VFXBatch.ts

@@ -0,0 +1,102 @@
+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 {IParticleSystem} from 'quarks.core';
+import {VFXBatchSettings} from './BatchedRenderer';
+
+export enum RenderMode {
+    BillBoard = 0,
+    StretchedBillBoard = 1,
+    Mesh = 2,
+    Trail = 3,
+    HorizontalBillBoard = 4,
+    VerticalBillBoard = 5,
+}
+
+export interface StoredBatchSettings {
+    instancingGeometry: Float32Array;
+    instancingIndices: Uint32Array | Uint16Array;
+    instancingUVs?: Float32Array;
+    instancingNormals?: Float32Array;
+    renderMode: RenderMode;
+    renderOrder: number;
+    uTileCount: number;
+    vTileCount: number;
+    blendTiles: boolean;
+    softParticles: boolean;
+    softNearFade: number;
+    softFarFade: number;
+    materialBlendMode: number;
+    materialTransparent: boolean;
+    materialDepthTest: boolean;
+    materialDepthWrite: boolean;
+    materialAlphaTest: number;
+    texture: any;
+    layerMask: number;
+}
+
+export abstract class VFXBatch {
+    mesh: Mesh;
+    systems: Set<IParticleSystem>;
+    settings: StoredBatchSettings;
+    protected maxParticles: number;
+    protected scene: Scene;
+
+    protected constructor(settings: VFXBatchSettings, scene: Scene) {
+        this.scene = scene;
+        this.maxParticles = 1000;
+        this.systems = new Set<IParticleSystem>();
+        this.settings = {
+            instancingGeometry: settings.instancingGeometry,
+            instancingIndices: settings.instancingIndices,
+            instancingUVs: settings.instancingUVs,
+            instancingNormals: settings.instancingNormals,
+            renderMode: settings.renderMode,
+            renderOrder: settings.renderOrder,
+            uTileCount: settings.uTileCount,
+            vTileCount: settings.vTileCount,
+            blendTiles: settings.blendTiles,
+            softParticles: settings.softParticles,
+            softNearFade: settings.softNearFade,
+            softFarFade: settings.softFarFade,
+            materialBlendMode: settings.materialBlendMode,
+            materialTransparent: settings.materialTransparent,
+            materialDepthTest: settings.materialDepthTest,
+            materialDepthWrite: settings.materialDepthWrite,
+            materialAlphaTest: settings.materialAlphaTest,
+            texture: settings.texture,
+            layerMask: settings.layerMask,
+        };
+        this.mesh = new Mesh('vfxBatch', scene);
+        this.mesh.alwaysSelectAsActiveMesh = true;
+    }
+
+    addSystem(system: IParticleSystem) {
+        this.systems.add(system);
+    }
+
+    removeSystem(system: IParticleSystem) {
+        this.systems.delete(system);
+    }
+
+    getVisibleSystems(): IParticleSystem[] {
+        return Array.from(this.systems).filter((system) => system.emitter.visible);
+    }
+
+    applyDepthTexture(depthTexture: BaseTexture | null): void {
+        const material = this.mesh.material;
+        if (material && material instanceof ShaderMaterial) {
+            material.setTexture('depthTexture', depthTexture);
+        }
+    }
+
+    abstract setupBuffers(): void;
+    abstract expandBuffers(target: number): void;
+    abstract rebuildMaterial(): void;
+    abstract update(): void;
+
+    dispose(): void {
+        this.mesh.dispose();
+    }
+}

package/src/index.ts

@@ -0,0 +1,54 @@
+import {loadPlugin} from 'quarks.core';
+import {MeshSurfaceEmitterPlugin} from './MeshSurfaceEmitter';
+import {registerShaderChunks} from './shaders';
+
+export {BatchedRenderer} from './BatchedRenderer';
+export type {VFXBatchSettings} from './BatchedRenderer';
+export {BatchedParticleRenderer} from './BatchedParticleRenderer';
+export {VFXBatch, RenderMode} from './VFXBatch';
+export type {StoredBatchSettings} from './VFXBatch';
+export {SpriteBatch} from './SpriteBatch';
+export {TrailBatch} from './TrailBatch';
+export {ParticleSystem} from './ParticleSystem';
+export type {ParticleSystemParameters, BurstParameters} from './ParticleSystem';
+export {ParticleEmitter} from './ParticleEmitter';
+export {QuarksUtil} from './QuarksUtil';
+export {QuarksLoader} from './QuarksLoader';
+export type {QuarksLoaderOptions} from './QuarksLoader';
+export {QuarksPrefab} from './QuarksPrefab';
+export {MeshSurfaceEmitter, MeshSurfaceEmitterPlugin} from './MeshSurfaceEmitter';
+export * from './shaders/';
+export * from './materials/';
+export * from 'quarks.core';
+
+
+// Re-export quarks.core types (interfaces - type-only)
+export type {
+    IParticleSystem,
+    IParticle,
+    Particle,
+    EmissionState,
+    RendererEmitterSettings,
+    TrailSettings,
+    StretchedBillBoardSettings,
+    BillBoardSettings,
+    MeshSettings,
+    IEmitter,
+    ParticleSystemEvent,
+    ParticleSystemEventType,
+    SerializationOptions,
+    Behavior,
+    EmitterShape,
+    ValueGenerator,
+    FunctionValueGenerator,
+    ColorGenerator,
+    FunctionColorGenerator,
+    RotationGenerator,
+    Vector3Generator,
+} from 'quarks.core';
+
+registerShaderChunks();
+loadPlugin(MeshSurfaceEmitterPlugin);
+// remove this line if you have pro license
+console.log('%c Particle system powered by babylon.quarks. https://quarks.art/', 'font-size: 14px; font-weight: bold;');
+

package/src/materials/ParticleMaterials.ts

@@ -0,0 +1,23 @@
+import {Scene} from '@babylonjs/core/scene';
+import {PBRMaterial} from '@babylonjs/core/Materials/PBR/pbrMaterial';
+import {StandardMaterial} from '@babylonjs/core/Materials/standardMaterial';
+
+export type BabylonParticleMaterialParameters = Record<string, any>;
+
+export class ParticleMeshStandardMaterial extends StandardMaterial {
+    readonly isParticleMeshStandardMaterial = true;
+
+    constructor(name: string, scene?: Scene, parameters: BabylonParticleMaterialParameters = {}) {
+        super(name, scene);
+        Object.assign(this, parameters);
+    }
+}
+
+export class ParticleMeshPhysicsMaterial extends PBRMaterial {
+    readonly isParticleMeshPhysicsMaterial = true;
+
+    constructor(name: string, scene?: Scene, parameters: BabylonParticleMaterialParameters = {}) {
+        super(name, scene);
+        Object.assign(this, parameters);
+    }
+}

package/src/materials/index.ts

@@ -0,0 +1 @@
+export * from './ParticleMaterials';

package/src/shaders/chunks/index.ts

@@ -0,0 +1 @@
+export * from './register-shader-chunks';

package/src/shaders/chunks/register-shader-chunks.ts

@@ -0,0 +1,32 @@
+import softFragment from './soft_fragment.glsl';
+import softParsFragment from './soft_pars_fragment.glsl';
+import softParsVertex from './soft_pars_vertex.glsl';
+import softVertex from './soft_vertex.glsl';
+import tileFragment from './tile_fragment.glsl';
+import tileParsFragment from './tile_pars_fragment.glsl';
+import tileParsVertex from './tile_pars_vertex.glsl';
+import tileVertex from './tile_vertex.glsl';
+
+const shaderChunks: Record<string, string> = {};
+let registered = false;
+
+export function registerShaderChunks(): void {
+    if (registered) return;
+    shaderChunks.tile_pars_vertex = tileParsVertex;
+    shaderChunks.tile_vertex = tileVertex;
+    shaderChunks.tile_pars_fragment = tileParsFragment;
+    shaderChunks.tile_fragment = tileFragment;
+    shaderChunks.soft_pars_vertex = softParsVertex;
+    shaderChunks.soft_vertex = softVertex;
+    shaderChunks.soft_pars_fragment = softParsFragment;
+    shaderChunks.soft_fragment = softFragment;
+    registered = true;
+}
+
+export function getShaderChunk(chunkName: string): string | undefined {
+    return shaderChunks[chunkName];
+}
+
+export function getRegisteredShaderChunks(): Readonly<Record<string, string>> {
+    return shaderChunks;
+}

package/src/shaders/chunks/soft_fragment.glsl.ts

@@ -0,0 +1,13 @@
+export default /* glsl */ `
+#ifdef SOFT_PARTICLES
+
+    vec2 p2 = projPosition.xy / projPosition.w;
+    p2 = 0.5 * p2 + 0.5;
+
+    float readDepth = texture2D(depthTexture, p2.xy).r;
+    float viewDepth = linearize_depth(readDepth);
+    float softParticlesFade = saturate(SOFT_INV_FADE_DISTANCE * ((viewDepth - SOFT_NEAR_FADE) - linearDepth));
+
+    gl_FragColor *= softParticlesFade;
+#endif
+`;

package/src/shaders/chunks/soft_pars_fragment.glsl.ts

@@ -0,0 +1,20 @@
+export default /* glsl */ `
+#ifdef SOFT_PARTICLES
+    uniform sampler2D depthTexture;
+    uniform vec4 projParams;
+    uniform vec2 softParams;
+
+    varying vec4 projPosition;
+    varying float linearDepth;
+
+    #define SOFT_NEAR_FADE softParams.x
+    #define SOFT_INV_FADE_DISTANCE softParams.y
+
+    #define zNear projParams.x
+    #define zFar projParams.y
+
+    float linearize_depth(float d) {
+        return (zFar * zNear) / (zFar - d * (zFar - zNear));
+    }
+#endif
+`;

package/src/shaders/chunks/soft_pars_vertex.glsl.ts

@@ -0,0 +1,6 @@
+export default /* glsl */ `
+#ifdef SOFT_PARTICLES
+    varying vec4 projPosition;
+    varying float linearDepth;
+#endif
+`;

package/src/shaders/chunks/soft_vertex.glsl.ts

@@ -0,0 +1,6 @@
+export default /* glsl */ `
+#ifdef SOFT_PARTICLES
+    projPosition = gl_Position;
+    linearDepth = -mvPosition.z;
+#endif
+`;

package/src/shaders/chunks/tile_fragment.glsl.ts

@@ -0,0 +1,9 @@
+export default /* glsl */ `
+#ifdef USE_MAP
+    vec4 texelColor = texture2D(map, vUv);
+    #ifdef TILE_BLEND
+        texelColor = mix(texelColor, texture2D(map, vUvNext), vUvBlend);
+    #endif
+    diffuseColor *= texelColor;
+#endif
+`;

package/src/shaders/chunks/tile_pars_fragment.glsl.ts

@@ -0,0 +1,9 @@
+export default /* glsl */ `
+#if defined(USE_UV)
+    varying vec2 vUv;
+    #ifdef TILE_BLEND
+        varying vec2 vUvNext;
+        varying float vUvBlend;
+    #endif
+#endif
+`;

package/src/shaders/chunks/tile_pars_vertex.glsl.ts

@@ -0,0 +1,28 @@
+export default /* glsl */ `
+#ifdef UV_TILE
+    attribute float uvTile;
+    uniform vec2 tileCount;
+
+    mat3 makeTileTransform(float tileIndex) {
+        float col = mod(tileIndex, tileCount.x);
+        float row = (tileCount.y - floor(tileIndex / tileCount.x) - 1.0);
+        return mat3(
+            1.0 / tileCount.x, 0.0, 0.0,
+            0.0, 1.0 / tileCount.y, 0.0,
+            col / tileCount.x, row / tileCount.y, 1.0
+        );
+    }
+#else
+    mat3 makeTileTransform(float tileIndex) {
+        return mat3(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
+    }
+#endif
+
+#if defined(USE_UV)
+    varying vec2 vUv;
+    #ifdef TILE_BLEND
+        varying vec2 vUvNext;
+        varying float vUvBlend;
+    #endif
+#endif
+`;