babylon.quarks 0.17.4 → 0.17.7

package/src/VFXBatch.ts

@@ -1,108 +1,108 @@
-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[] {
-        const visibleSystems: IParticleSystem[] = [];
-        for (const system of this.systems) {
-            if (system.emitter.visible) {
-                visibleSystems.push(system);
-            }
-        }
-        return visibleSystems;
-    }
-
-    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();
-    }
-}
+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[] {
+        const visibleSystems: IParticleSystem[] = [];
+        for (const system of this.systems) {
+            if (system.emitter.visible) {
+                visibleSystems.push(system);
+            }
+        }
+        return visibleSystems;
+    }
+
+    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/geometryUtil.ts

@@ -1,15 +1,15 @@
-/** Sequential 0..N-1 indices for non-indexed triangle-list BufferGeometry (Three.js drawArrays). */
-export function ensureTriangleIndices(
-    positions: Float32Array,
-    indices?: Uint32Array | Uint16Array
-): Uint32Array | Uint16Array {
-    if (indices && indices.length > 0) {
-        return indices;
-    }
-    const vertexCount = positions.length / 3;
-    const out = new Uint32Array(vertexCount);
-    for (let i = 0; i < vertexCount; i++) {
-        out[i] = i;
-    }
-    return out;
-}
+/** Sequential 0..N-1 indices for non-indexed triangle-list BufferGeometry (Three.js drawArrays). */
+export function ensureTriangleIndices(
+    positions: Float32Array,
+    indices?: Uint32Array | Uint16Array
+): Uint32Array | Uint16Array {
+    if (indices && indices.length > 0) {
+        return indices;
+    }
+    const vertexCount = positions.length / 3;
+    const out = new Uint32Array(vertexCount);
+    for (let i = 0; i < vertexCount; i++) {
+        out[i] = i;
+    }
+    return out;
+}

package/src/index.ts

@@ -1,52 +1,59 @@
-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);
-
+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 {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,
+    BurstParametersJSON,
+    ParticleSystemJSONParameters,
+    BabylonMetaData,
+} 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 * 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);
+

package/src/materials/ParticleMaterials.ts

@@ -1,23 +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);
-    }
-}
+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

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

package/src/shaders/chunks/index.ts

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

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

@@ -1,32 +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;
-}
+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

@@ -1,13 +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
-`;
+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

@@ -1,20 +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
-`;
+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

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

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

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

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

@@ -1,9 +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
-`;
+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

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