babylon.quarks 0.17.0

package/dist/types/shaders/trail_vert.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\nattribute vec3 position;\nattribute vec3 previous;\nattribute vec3 next;\nattribute float side;\nattribute float width;\nattribute vec2 uv;\nattribute vec4 color;\n\nuniform mat4 view;\nuniform mat4 projection;\nuniform float lineWidth;\nuniform vec2 resolution;\nuniform float sizeAttenuation;\n\nvarying vec2 vUV;\nvarying vec4 vColor;\n\nvec2 fix(vec4 i, float aspect) {\n    vec2 res = i.xy / i.w;\n    res.x *= aspect;\n    return res;\n}\n\nvoid main() {\n    float aspect = resolution.x / resolution.y;\n    vec4 finalPosition = projection * view * vec4(position, 1.0);\n    vec4 prevPos = projection * view * vec4(previous, 1.0);\n    vec4 nextPos = projection * view * vec4(next, 1.0);\n\n    vec2 currentP = fix(finalPosition, aspect);\n    vec2 prevP = fix(prevPos, aspect);\n    vec2 nextP = fix(nextPos, aspect);\n\n    float w = lineWidth * width;\n    vec2 dir;\n    if (distance(nextP, currentP) < 0.0001) {\n        dir = normalize(currentP - prevP);\n    } else if (distance(prevP, currentP) < 0.0001) {\n        dir = normalize(nextP - currentP);\n    } else {\n        vec2 dir1 = normalize(currentP - prevP);\n        vec2 dir2 = normalize(nextP - currentP);\n        dir = normalize(dir1 + dir2);\n    }\n    vec4 normal = vec4(-dir.y, dir.x, 0.0, 1.0);\n    normal.xy *= 0.5 * w;\n    normal *= projection;\n    if (sizeAttenuation == 0.0) {\n        normal.xy *= finalPosition.w;\n        normal.xy /= (vec4(resolution, 0.0, 1.0) * projection).xy;\n    }\n    finalPosition.xy += normal.xy * side;\n    gl_Position = finalPosition;\n    vUV = uv;\n    vColor = color;\n}\n";
+export default _default;

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "babylon.quarks",
+  "version": "0.17.0",
+  "description": "A High-Performance Particle System for Babylon.js",
+  "type": "module",
+  "types": "./dist/types/index.d.ts",
+  "main": "./dist/babylon.quarks.cjs",
+  "module": "./dist/babylon.quarks.esm.js",
+  "exports": {
+    ".": {
+      "import": "./dist/babylon.quarks.esm.js",
+      "require": "./dist/babylon.quarks.cjs",
+      "types": "./dist/types/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "LICENSE"
+  ],
+  "scripts": {
+    "clean": "rimraf dist",
+    "build:types": "tsc --emitDeclarationOnly",
+    "build:js": "cross-env NODE_ENV=production rollup -c",
+    "build": "npm run clean && npm run build:types && npm run build:js",
+    "test": "jest",
+    "prettier": "prettier --write --ignore-unknown **/*.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Soullnik/babylon.quarks-standalone.git"
+  },
+  "keywords": [
+    "particle",
+    "library",
+    "3d",
+    "game",
+    "performance",
+    "babylonjs",
+    "vfx"
+  ],
+  "author": "soullnik <soullnik96@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Soullnik/babylon.quarks-standalone/issues"
+  },
+  "homepage": "https://github.com/Soullnik/babylon.quarks-standalone#readme",
+  "peerDependencies": {
+    "@babylonjs/core": ">=9.0.0"
+  },
+  "dependencies": {
+    "quarks.core": "^0.17.0"
+  },
+  "devDependencies": {
+    "@babylonjs/core": "^9.0.0",
+    "@types/jest": "^30.0.0"
+  }
+}

package/src/BatchedParticleRenderer.ts

@@ -0,0 +1,3 @@
+import {BatchedRenderer} from './BatchedRenderer';
+
+export const BatchedParticleRenderer = BatchedRenderer;

package/src/BatchedRenderer.ts

@@ -0,0 +1,135 @@
+import {TransformNode} from '@babylonjs/core/Meshes/transformNode';
+import {Scene} from '@babylonjs/core/scene';
+import {Texture} from '@babylonjs/core/Materials/Textures/texture';
+import {BaseTexture} from '@babylonjs/core/Materials/Textures/baseTexture';
+import {IParticleSystem} from 'quarks.core';
+import {VFXBatch, RenderMode, StoredBatchSettings} from './VFXBatch';
+import {SpriteBatch} from './SpriteBatch';
+import {TrailBatch} from './TrailBatch';
+import {ParticleSystem} from './ParticleSystem';
+
+export interface VFXBatchSettings {
+    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: Texture | null;
+    layerMask: number;
+}
+
+export class BatchedRenderer extends TransformNode {
+    batches: Array<VFXBatch> = [];
+    systemToBatchIndex: Map<IParticleSystem, number> = new Map<IParticleSystem, number>();
+    depthTexture: BaseTexture | null = null;
+
+    constructor(name: string, scene: Scene) {
+        super(name, scene);
+    }
+
+    private static equals(a: StoredBatchSettings, b: VFXBatchSettings): boolean {
+        return (
+            a.materialBlendMode === b.materialBlendMode &&
+            a.materialTransparent === b.materialTransparent &&
+            a.materialDepthTest === b.materialDepthTest &&
+            a.materialDepthWrite === b.materialDepthWrite &&
+            a.materialAlphaTest === b.materialAlphaTest &&
+            a.texture === b.texture &&
+            a.renderMode === b.renderMode &&
+            a.blendTiles === b.blendTiles &&
+            a.softParticles === b.softParticles &&
+            a.softFarFade === b.softFarFade &&
+            a.softNearFade === b.softNearFade &&
+            a.uTileCount === b.uTileCount &&
+            a.vTileCount === b.vTileCount &&
+            a.instancingGeometry === b.instancingGeometry &&
+            a.renderOrder === b.renderOrder &&
+            a.layerMask === b.layerMask
+        );
+    }
+
+    addSystem(system: IParticleSystem) {
+        (system as unknown as ParticleSystem)._renderer = this;
+        const settings = (system as unknown as ParticleSystem).getRendererSettings();
+        for (let i = 0; i < this.batches.length; i++) {
+            if (BatchedRenderer.equals(this.batches[i].settings, settings)) {
+                this.batches[i].addSystem(system);
+                this.systemToBatchIndex.set(system, i);
+                return;
+            }
+        }
+        let batch: VFXBatch;
+        const scene = this.getScene();
+        switch (settings.renderMode) {
+            case RenderMode.Trail:
+                batch = new TrailBatch(settings, scene);
+                break;
+            case RenderMode.Mesh:
+            case RenderMode.BillBoard:
+            case RenderMode.VerticalBillBoard:
+            case RenderMode.HorizontalBillBoard:
+            case RenderMode.StretchedBillBoard:
+                batch = new SpriteBatch(settings, scene);
+                break;
+            default:
+                throw new Error(`Unsupported render mode: ${settings.renderMode}`);
+        }
+        batch.mesh.parent = this;
+        if (this.depthTexture) {
+            batch.applyDepthTexture(this.depthTexture);
+        }
+        batch.addSystem(system);
+        this.batches.push(batch);
+        this.systemToBatchIndex.set(system, this.batches.length - 1);
+    }
+
+    deleteSystem(system: IParticleSystem) {
+        const batchIndex = this.systemToBatchIndex.get(system);
+        if (batchIndex !== undefined) {
+            this.batches[batchIndex].removeSystem(system);
+            this.systemToBatchIndex.delete(system);
+        }
+    }
+
+    updateSystem(system: IParticleSystem) {
+        this.deleteSystem(system);
+        this.addSystem(system);
+    }
+
+    setDepthTexture(depthTexture: BaseTexture | null) {
+        this.depthTexture = depthTexture;
+        for (const batch of this.batches) {
+            batch.applyDepthTexture(depthTexture);
+        }
+    }
+
+    update(delta: number) {
+        this.systemToBatchIndex.forEach((_value, ps) => {
+            (ps as any).update(delta);
+        });
+        for (let i = 0; i < this.batches.length; i++) {
+            this.batches[i].update();
+        }
+    }
+
+    dispose(): void {
+        for (const batch of this.batches) {
+            batch.dispose();
+        }
+        this.batches = [];
+        this.systemToBatchIndex.clear();
+        super.dispose();
+    }
+}

package/src/MeshSurfaceEmitter.ts

@@ -0,0 +1,137 @@
+import {Mesh} from '@babylonjs/core/Meshes/mesh';
+import {VertexBuffer} from '@babylonjs/core/Buffers/buffer';
+import {
+    Particle,
+    EmitterShape,
+    ShapeJSON,
+    IParticleSystem,
+    Vector3,
+    Plugin,
+} from 'quarks.core';
+
+export class MeshSurfaceEmitter implements EmitterShape {
+    type = 'mesh_surface';
+
+    private _triangleIndexToArea: number[] = [];
+    private _mesh?: Mesh;
+    private _positions?: Float32Array;
+    private _indices?: Uint32Array | Int32Array;
+    private _meshReferenceId?: string;
+
+    get mesh() {
+        return this._mesh;
+    }
+
+    set mesh(mesh: Mesh | undefined) {
+        this._mesh = mesh;
+        if (!mesh) return;
+
+        const positions = mesh.getVerticesData(VertexBuffer.PositionKind);
+        const indices = mesh.getIndices();
+        if (!positions || !indices) return;
+
+        this._positions = new Float32Array(positions);
+        this._indices = new Int32Array(indices);
+
+        this._triangleIndexToArea.length = 0;
+        let area = 0;
+        const triCount = indices.length / 3;
+        this._triangleIndexToArea.push(0);
+
+        const a = new Vector3();
+        const b = new Vector3();
+        const c = new Vector3();
+
+        for (let i = 0; i < triCount; i++) {
+            const i0 = indices[i * 3];
+            const i1 = indices[i * 3 + 1];
+            const i2 = indices[i * 3 + 2];
+
+            a.set(positions[i0 * 3], positions[i0 * 3 + 1], positions[i0 * 3 + 2]);
+            b.set(positions[i1 * 3], positions[i1 * 3 + 1], positions[i1 * 3 + 2]);
+            c.set(positions[i2 * 3], positions[i2 * 3 + 1], positions[i2 * 3 + 2]);
+
+            b.sub(a);
+            c.sub(a);
+            const cross = new Vector3();
+            cross.crossVectors(b, c);
+            area += cross.length() * 0.5;
+            this._triangleIndexToArea.push(area);
+        }
+    }
+
+    constructor(mesh?: Mesh, meshReferenceId?: string) {
+        this._meshReferenceId = meshReferenceId;
+        if (mesh) this.mesh = mesh;
+    }
+
+    initialize(p: Particle) {
+        if (!this._positions || !this._indices) {
+            p.position.set(0, 0, 0);
+            p.velocity.set(0, 0, 1).multiplyScalar(p.startSpeed);
+            return;
+        }
+
+        const triCount = this._triangleIndexToArea.length - 1;
+        let left = 0, right = triCount;
+        const target = Math.random() * this._triangleIndexToArea[triCount];
+
+        while (left + 1 < right) {
+            const mid = Math.floor((left + right) / 2);
+            if (target < this._triangleIndexToArea[mid]) {
+                right = mid;
+            } else {
+                left = mid;
+            }
+        }
+
+        let u1 = Math.random();
+        let u2 = Math.random();
+        if (u1 + u2 > 1) {
+            u1 = 1 - u1;
+            u2 = 1 - u2;
+        }
+
+        const idx0 = this._indices[left * 3];
+        const idx1 = this._indices[left * 3 + 1];
+        const idx2 = this._indices[left * 3 + 2];
+
+        const ax = this._positions[idx0 * 3], ay = this._positions[idx0 * 3 + 1], az = this._positions[idx0 * 3 + 2];
+        const bx = this._positions[idx1 * 3] - ax, by = this._positions[idx1 * 3 + 1] - ay, bz = this._positions[idx1 * 3 + 2] - az;
+        const cx = this._positions[idx2 * 3] - ax, cy = this._positions[idx2 * 3 + 1] - ay, cz = this._positions[idx2 * 3 + 2] - az;
+
+        p.position.set(ax + bx * u1 + cx * u2, ay + by * u1 + cy * u2, az + bz * u1 + cz * u2);
+
+        const nx = by * cz - bz * cy;
+        const ny = bz * cx - bx * cz;
+        const nz = bx * cy - by * cx;
+        const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+        p.velocity.set(nx / len, ny / len, nz / len).multiplyScalar(p.startSpeed);
+    }
+
+    toJSON(): ShapeJSON {
+        return {type: 'mesh_surface', mesh: this._mesh ? (this._mesh as any).uniqueId?.toString() : this._meshReferenceId ?? ''};
+    }
+
+    static fromJSON(json: any): MeshSurfaceEmitter {
+        return new MeshSurfaceEmitter(undefined, json?.mesh);
+    }
+
+    clone(): EmitterShape {
+        return new MeshSurfaceEmitter(this._mesh, this._meshReferenceId);
+    }
+
+    update(_system: IParticleSystem, _delta: number): void {}
+}
+
+export const MeshSurfaceEmitterPlugin: Plugin = {
+    id: 'babylon.quarks',
+    initialize: () => {},
+    emitterShapes: [{
+        type: 'mesh_surface',
+        params: [['mesh', ['mesh']]],
+        constructor: MeshSurfaceEmitter,
+        loadJSON: (json: any) => MeshSurfaceEmitter.fromJSON(json),
+    }],
+    behaviors: [],
+};

package/src/ParticleEmitter.ts

@@ -0,0 +1,86 @@
+import {TransformNode} from '@babylonjs/core/Meshes/transformNode';
+import {Scene} from '@babylonjs/core/scene';
+import {Matrix4, IParticleSystem, SerializationOptions} from 'quarks.core';
+
+export class ParticleEmitter extends TransformNode {
+    system: IParticleSystem;
+    private _matrixWorld: Matrix4 = new Matrix4();
+
+    get matrixWorld(): Matrix4 {
+        const m = this.getWorldMatrix();
+        const e = this._matrixWorld.elements;
+        e[0] = m.m[0]; e[1] = m.m[1]; e[2] = m.m[2]; e[3] = m.m[3];
+        e[4] = m.m[4]; e[5] = m.m[5]; e[6] = m.m[6]; e[7] = m.m[7];
+        e[8] = m.m[8]; e[9] = m.m[9]; e[10] = m.m[10]; e[11] = m.m[11];
+        e[12] = m.m[12]; e[13] = m.m[13]; e[14] = m.m[14]; e[15] = m.m[15];
+        return this._matrixWorld;
+    }
+
+    get visible(): boolean {
+        return this.isEnabled();
+    }
+
+    set visible(value: boolean) {
+        this.setEnabled(value);
+    }
+
+    get uuid(): string {
+        return this.uniqueId.toString();
+    }
+
+    constructor(system: IParticleSystem, scene?: Scene) {
+        super('particleEmitter', scene || undefined);
+        this.system = system;
+    }
+
+    dispose(): void {
+        super.dispose();
+    }
+
+    extractFromCache(cache: any): any[] {
+        const values: any[] = [];
+        for (const key in cache) {
+            const data = cache[key];
+            if (data && typeof data === 'object') {
+                delete data.metadata;
+            }
+            values.push(data);
+        }
+        return values;
+    }
+
+    clone(name?: string): ParticleEmitter {
+        const clonedSystem = this.system.clone();
+        const clonedEmitter = clonedSystem.emitter as ParticleEmitter;
+        clonedEmitter.name = name ?? this.name;
+        clonedEmitter.position.copyFrom(this.position);
+        clonedEmitter.rotation.copyFrom(this.rotation);
+        clonedEmitter.scaling.copyFrom(this.scaling);
+        if (this.rotationQuaternion) {
+            clonedEmitter.rotationQuaternion = this.rotationQuaternion.clone();
+        }
+        clonedEmitter.setEnabled(this.isEnabled());
+        return clonedEmitter;
+    }
+
+    toJSON(meta?: any, options: SerializationOptions = {}): any {
+        return {
+            uuid: (this as any)._quarksUUID ?? this.uniqueId.toString(),
+            type: 'ParticleEmitter',
+            name: this.name,
+            position: [this.position.x, this.position.y, this.position.z],
+            rotation: [this.rotation.x, this.rotation.y, this.rotation.z],
+            quaternion: this.rotationQuaternion
+                ? [
+                    this.rotationQuaternion.x,
+                    this.rotationQuaternion.y,
+                    this.rotationQuaternion.z,
+                    this.rotationQuaternion.w,
+                ]
+                : undefined,
+            scale: [this.scaling.x, this.scaling.y, this.scaling.z],
+            visible: this.isEnabled(),
+            ps: this.system.toJSON(meta, options),
+        };
+    }
+}