babylon.quarks 0.17.4 → 0.17.7

package/src/shaders/particle_vert.glsl.ts

@@ -1,85 +1,85 @@
-export default /* glsl */ `
-// Per-vertex attributes
-attribute vec3 position;
-attribute vec2 uv;
-
-// Per-instance attributes
-attribute vec3 offset;
-attribute vec4 color;
-attribute vec3 size;
-attribute float rotation;
-attribute float uvTile;
-
-// Uniforms
-uniform mat4 world;
-uniform mat4 view;
-uniform mat4 projection;
-uniform mat4 worldViewProjection;
-
-#ifdef UV_TILE
-uniform float tileCountX;
-uniform float tileCountY;
-#endif
-
-// Varyings
-varying vec2 vUV;
-varying vec4 vColor;
-#ifdef TILE_BLEND
-varying vec2 vUV2;
-varying float vTileBlend;
-#endif
-#ifdef SOFT_PARTICLES
-varying vec4 projPosition;
-varying float linearDepth;
-#endif
-
-void main() {
-    float c = cos(rotation);
-    float s = sin(rotation);
-
-    vec2 alignedPosition = position.xy * size.xy;
-    vec2 rotatedPosition;
-    rotatedPosition.x = c * alignedPosition.x - s * alignedPosition.y;
-    rotatedPosition.y = s * alignedPosition.x + c * alignedPosition.y;
-
-#ifdef HORIZONTAL
-    vec4 mvPosition = world * vec4(offset, 1.0);
-    mvPosition.x += rotatedPosition.x;
-    mvPosition.z -= rotatedPosition.y;
-    mvPosition = view * mvPosition;
-#elif defined(VERTICAL)
-    vec4 mvPosition = world * vec4(offset, 1.0);
-    mvPosition.y += rotatedPosition.y;
-    mvPosition = view * mvPosition;
-    mvPosition.x += rotatedPosition.x;
-#else
-    vec4 mvPosition = view * world * vec4(offset, 1.0);
-    mvPosition.xy += rotatedPosition;
-#endif
-
-    gl_Position = projection * mvPosition;
-#ifdef SOFT_PARTICLES
-    projPosition = gl_Position;
-    linearDepth = -mvPosition.z;
-#endif
-
-    #ifdef UV_TILE
-        vec2 tc = vec2(tileCountX, tileCountY);
-        float baseTile = floor(uvTile);
-        float tileU = mod(baseTile, tc.x) / tc.x;
-        float tileV = 1.0 - floor(baseTile / tc.x) / tc.y - 1.0 / tc.y;
-        vUV = uv / tc + vec2(tileU, tileV);
-        #ifdef TILE_BLEND
-            float nextTile = ceil(uvTile);
-            float nextU = mod(nextTile, tc.x) / tc.x;
-            float nextV = 1.0 - floor(nextTile / tc.x) / tc.y - 1.0 / tc.y;
-            vUV2 = uv / tc + vec2(nextU, nextV);
-            vTileBlend = fract(uvTile);
-        #endif
-    #else
-        vUV = uv;
-    #endif
-
-    vColor = color;
-}
-`;
+export default /* glsl */ `
+// Per-vertex attributes
+attribute vec3 position;
+attribute vec2 uv;
+
+// Per-instance attributes
+attribute vec3 offset;
+attribute vec4 color;
+attribute vec3 size;
+attribute float rotation;
+attribute float uvTile;
+
+// Uniforms
+uniform mat4 world;
+uniform mat4 view;
+uniform mat4 projection;
+uniform mat4 worldViewProjection;
+
+#ifdef UV_TILE
+uniform float tileCountX;
+uniform float tileCountY;
+#endif
+
+// Varyings
+varying vec2 vUV;
+varying vec4 vColor;
+#ifdef TILE_BLEND
+varying vec2 vUV2;
+varying float vTileBlend;
+#endif
+#ifdef SOFT_PARTICLES
+varying vec4 projPosition;
+varying float linearDepth;
+#endif
+
+void main() {
+    float c = cos(rotation);
+    float s = sin(rotation);
+
+    vec2 alignedPosition = position.xy * size.xy;
+    vec2 rotatedPosition;
+    rotatedPosition.x = c * alignedPosition.x - s * alignedPosition.y;
+    rotatedPosition.y = s * alignedPosition.x + c * alignedPosition.y;
+
+#ifdef HORIZONTAL
+    vec4 mvPosition = world * vec4(offset, 1.0);
+    mvPosition.x += rotatedPosition.x;
+    mvPosition.z -= rotatedPosition.y;
+    mvPosition = view * mvPosition;
+#elif defined(VERTICAL)
+    vec4 mvPosition = world * vec4(offset, 1.0);
+    mvPosition.y += rotatedPosition.y;
+    mvPosition = view * mvPosition;
+    mvPosition.x += rotatedPosition.x;
+#else
+    vec4 mvPosition = view * world * vec4(offset, 1.0);
+    mvPosition.xy += rotatedPosition;
+#endif
+
+    gl_Position = projection * mvPosition;
+#ifdef SOFT_PARTICLES
+    projPosition = gl_Position;
+    linearDepth = -mvPosition.z;
+#endif
+
+    #ifdef UV_TILE
+        vec2 tc = vec2(tileCountX, tileCountY);
+        float baseTile = floor(uvTile);
+        float tileU = mod(baseTile, tc.x) / tc.x;
+        float tileV = 1.0 - floor(baseTile / tc.x) / tc.y - 1.0 / tc.y;
+        vUV = uv / tc + vec2(tileU, tileV);
+        #ifdef TILE_BLEND
+            float nextTile = ceil(uvTile);
+            float nextU = mod(nextTile, tc.x) / tc.x;
+            float nextV = 1.0 - floor(nextTile / tc.x) / tc.y - 1.0 / tc.y;
+            vUV2 = uv / tc + vec2(nextU, nextV);
+            vTileBlend = fract(uvTile);
+        #endif
+    #else
+        vUV = uv;
+    #endif
+
+    vColor = color;
+}
+`;

package/src/shaders/stretched_bb_particle_vert.glsl.ts

@@ -1,74 +1,76 @@
-export default /* glsl */ `
-// Per-vertex attributes
-attribute vec3 position;
-attribute vec2 uv;
-
-// Per-instance attributes
-attribute vec3 offset;
-attribute vec4 color;
-attribute vec3 size;
-attribute float rotation;
-attribute float uvTile;
-attribute vec4 velocity;
-
-// Uniforms
-uniform mat4 world;
-uniform mat4 view;
-uniform mat4 projection;
-uniform float speedFactor;
-
-#ifdef UV_TILE
-uniform float tileCountX;
-uniform float tileCountY;
-#endif
-
-// Varyings
-varying vec2 vUV;
-varying vec4 vColor;
-#ifdef TILE_BLEND
-varying vec2 vUV2;
-varying float vTileBlend;
-#endif
-#ifdef SOFT_PARTICLES
-varying vec4 projPosition;
-varying float linearDepth;
-#endif
-
-void main() {
-    float lengthFactor = velocity.w;
-    float avgSize = (size.x + size.y) * 0.5;
-    vec4 mvPosition = view * world * vec4(offset, 1.0);
-    vec3 viewVelocity = mat3(view * world) * velocity.xyz;
-    float vlength = length(viewVelocity);
-    if (vlength < 0.0001) {
-        vlength = 0.0001;
-        viewVelocity = vec3(0.0, 0.0, 1.0);
-    }
-    mvPosition.xyz += position.y * normalize(cross(mvPosition.xyz, viewVelocity)) * avgSize;
-    mvPosition.xyz -= (position.x + 0.5) * viewVelocity * (1.0 + lengthFactor / vlength) * avgSize;
-    gl_Position = projection * mvPosition;
-#ifdef SOFT_PARTICLES
-    projPosition = gl_Position;
-    linearDepth = -mvPosition.z;
-#endif
-
-    #ifdef UV_TILE
-        vec2 tc = vec2(tileCountX, tileCountY);
-        float baseTile = floor(uvTile);
-        float tileU = mod(baseTile, tc.x) / tc.x;
-        float tileV = 1.0 - floor(baseTile / tc.x) / tc.y - 1.0 / tc.y;
-        vUV = uv / tc + vec2(tileU, tileV);
-        #ifdef TILE_BLEND
-            float nextTile = ceil(uvTile);
-            float nextU = mod(nextTile, tc.x) / tc.x;
-            float nextV = 1.0 - floor(nextTile / tc.x) / tc.y - 1.0 / tc.y;
-            vUV2 = uv / tc + vec2(nextU, nextV);
-            vTileBlend = fract(uvTile);
-        #endif
-    #else
-        vUV = uv;
-    #endif
-
-    vColor = color;
-}
-`;
+export default /* glsl */ `
+// Per-vertex attributes
+attribute vec3 position;
+attribute vec2 uv;
+
+// Per-instance attributes
+attribute vec3 offset;
+attribute vec4 color;
+attribute vec3 size;
+attribute float rotation;
+attribute float uvTile;
+attribute vec4 velocity;
+
+// Uniforms
+uniform mat4 world;
+uniform mat4 view;
+uniform mat4 projection;
+uniform float speedFactor;
+
+#ifdef UV_TILE
+uniform float tileCountX;
+uniform float tileCountY;
+#endif
+
+// Varyings
+varying vec2 vUV;
+varying vec4 vColor;
+#ifdef TILE_BLEND
+varying vec2 vUV2;
+varying float vTileBlend;
+#endif
+#ifdef SOFT_PARTICLES
+varying vec4 projPosition;
+varying float linearDepth;
+#endif
+
+void main() {
+    float lengthFactor = velocity.w;
+    float avgSize = (size.x + size.y) * 0.5;
+    vec4 mvPosition = view * world * vec4(offset, 1.0);
+    vec3 viewVelocity = mat3(view * world) * velocity.xyz;
+    float vlength = length(viewVelocity);
+    // Stretch direction is the velocity direction; only a genuinely motionless particle has none.
+    // Deriving it via normalize keeps the stretch aligned even when the speed contribution is ~0
+    // (e.g. speedFactor 0), instead of collapsing the whole burst onto a fixed screen axis.
+    vec3 vdir = vlength > 0.000001 ? viewVelocity / vlength : vec3(0.0, 0.0, 1.0);
+    mvPosition.xyz += position.y * normalize(cross(mvPosition.xyz, vdir)) * avgSize;
+    // Equivalent to viewVelocity * (1.0 + lengthFactor / vlength) for moving particles, but the
+    // size-based term (vdir * lengthFactor) survives when the velocity contribution vanishes.
+    mvPosition.xyz -= (position.x + 0.5) * (viewVelocity + vdir * lengthFactor) * avgSize;
+    gl_Position = projection * mvPosition;
+#ifdef SOFT_PARTICLES
+    projPosition = gl_Position;
+    linearDepth = -mvPosition.z;
+#endif
+
+    #ifdef UV_TILE
+        vec2 tc = vec2(tileCountX, tileCountY);
+        float baseTile = floor(uvTile);
+        float tileU = mod(baseTile, tc.x) / tc.x;
+        float tileV = 1.0 - floor(baseTile / tc.x) / tc.y - 1.0 / tc.y;
+        vUV = uv / tc + vec2(tileU, tileV);
+        #ifdef TILE_BLEND
+            float nextTile = ceil(uvTile);
+            float nextU = mod(nextTile, tc.x) / tc.x;
+            float nextV = 1.0 - floor(nextTile / tc.x) / tc.y - 1.0 / tc.y;
+            vUV2 = uv / tc + vec2(nextU, nextV);
+            vTileBlend = fract(uvTile);
+        #endif
+    #else
+        vUV = uv;
+    #endif
+
+    vColor = color;
+}
+`;

package/src/shaders/trail_frag.glsl.ts

@@ -1,21 +1,21 @@
-export default /* glsl */ `
-varying vec2 vUV;
-varying vec4 vColor;
-
-#ifdef USE_MAP
-uniform sampler2D map;
-#endif
-
-void main() {
-    vec4 baseColor = vColor;
-
-#ifdef USE_MAP
-    vec4 texColor = texture2D(map, vUV);
-    baseColor *= texColor;
-#endif
-
-    if (baseColor.a < 0.01) discard;
-
-    gl_FragColor = baseColor;
-}
-`;
+export default /* glsl */ `
+varying vec2 vUV;
+varying vec4 vColor;
+
+#ifdef USE_MAP
+uniform sampler2D map;
+#endif
+
+void main() {
+    vec4 baseColor = vColor;
+
+#ifdef USE_MAP
+    vec4 texColor = texture2D(map, vUV);
+    baseColor *= texColor;
+#endif
+
+    if (baseColor.a < 0.01) discard;
+
+    gl_FragColor = baseColor;
+}
+`;

package/src/shaders/trail_vert.glsl.ts

@@ -1,58 +1,58 @@
-export default /* glsl */ `
-attribute vec3 position;
-attribute vec3 previous;
-attribute vec3 next;
-attribute float side;
-attribute float width;
-attribute vec2 uv;
-attribute vec4 color;
-
-uniform mat4 view;
-uniform mat4 projection;
-uniform float lineWidth;
-uniform vec2 resolution;
-uniform float sizeAttenuation;
-
-varying vec2 vUV;
-varying vec4 vColor;
-
-vec2 fix(vec4 i, float aspect) {
-    vec2 res = i.xy / i.w;
-    res.x *= aspect;
-    return res;
-}
-
-void main() {
-    float aspect = resolution.x / resolution.y;
-    vec4 finalPosition = projection * view * vec4(position, 1.0);
-    vec4 prevPos = projection * view * vec4(previous, 1.0);
-    vec4 nextPos = projection * view * vec4(next, 1.0);
-
-    vec2 currentP = fix(finalPosition, aspect);
-    vec2 prevP = fix(prevPos, aspect);
-    vec2 nextP = fix(nextPos, aspect);
-
-    float w = lineWidth * width;
-    vec2 dir;
-    if (distance(nextP, currentP) < 0.0001) {
-        dir = normalize(currentP - prevP);
-    } else if (distance(prevP, currentP) < 0.0001) {
-        dir = normalize(nextP - currentP);
-    } else {
-        vec2 dir1 = normalize(currentP - prevP);
-        vec2 dir2 = normalize(nextP - currentP);
-        dir = normalize(dir1 + dir2);
-    }
-    vec4 normal = vec4(-dir.y, dir.x, 0.0, 1.0);
-    normal.xy *= 0.5 * w;
-    normal *= projection;
-    if (sizeAttenuation == 0.0) {
-        normal.xy *= finalPosition.w;
-        normal.xy /= (vec4(resolution, 0.0, 1.0) * projection).xy;
-    }
-    finalPosition.xy += normal.xy * side;
-    gl_Position = finalPosition;
-    vUV = uv;
-    vColor = color;
-}
-`;
+export default /* glsl */ `
+attribute vec3 position;
+attribute vec3 previous;
+attribute vec3 next;
+attribute float side;
+attribute float width;
+attribute vec2 uv;
+attribute vec4 color;
+
+uniform mat4 view;
+uniform mat4 projection;
+uniform float lineWidth;
+uniform vec2 resolution;
+uniform float sizeAttenuation;
+
+varying vec2 vUV;
+varying vec4 vColor;
+
+vec2 fix(vec4 i, float aspect) {
+    vec2 res = i.xy / i.w;
+    res.x *= aspect;
+    return res;
+}
+
+void main() {
+    float aspect = resolution.x / resolution.y;
+    vec4 finalPosition = projection * view * vec4(position, 1.0);
+    vec4 prevPos = projection * view * vec4(previous, 1.0);
+    vec4 nextPos = projection * view * vec4(next, 1.0);
+
+    vec2 currentP = fix(finalPosition, aspect);
+    vec2 prevP = fix(prevPos, aspect);
+    vec2 nextP = fix(nextPos, aspect);
+
+    float w = lineWidth * width;
+    vec2 dir;
+    if (distance(nextP, currentP) < 0.0001) {
+        dir = normalize(currentP - prevP);
+    } else if (distance(prevP, currentP) < 0.0001) {
+        dir = normalize(nextP - currentP);
+    } else {
+        vec2 dir1 = normalize(currentP - prevP);
+        vec2 dir2 = normalize(nextP - currentP);
+        dir = normalize(dir1 + dir2);
+    }
+    vec4 normal = vec4(-dir.y, dir.x, 0.0, 1.0);
+    normal.xy *= 0.5 * w;
+    normal *= projection;
+    if (sizeAttenuation == 0.0) {
+        normal.xy *= finalPosition.w;
+        normal.xy /= (vec4(resolution, 0.0, 1.0) * projection).xy;
+    }
+    finalPosition.xy += normal.xy * side;
+    gl_Position = finalPosition;
+    vUV = uv;
+    vColor = color;
+}
+`;

package/dist/types/BatchedParticleRenderer.d.ts

@@ -1,2 +0,0 @@
-import { BatchedRenderer } from './BatchedRenderer';
-export declare const BatchedParticleRenderer: typeof BatchedRenderer;

package/dist/types/BatchedRenderer.d.ts

@@ -1,59 +0,0 @@
-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 } from './VFXBatch';
-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 interface AdaptivePerformanceOptions {
-    targetFrameMs: number;
-    minQuality: number;
-    maxQuality: number;
-    decreaseStep: number;
-    increaseStep: number;
-}
-export interface AdaptivePerformanceState extends AdaptivePerformanceOptions {
-    enabled: boolean;
-    currentQuality: number;
-    lastFrameCpuMs: number;
-}
-export declare class BatchedRenderer extends TransformNode {
-    batches: Array<VFXBatch>;
-    systemToBatchIndex: Map<IParticleSystem, number>;
-    depthTexture: BaseTexture | null;
-    private adaptivePerformanceState;
-    private lastAppliedQuality;
-    constructor(name: string, scene: Scene);
-    private static clamp;
-    private static equals;
-    addSystem(system: IParticleSystem): void;
-    deleteSystem(system: IParticleSystem): void;
-    updateSystem(system: IParticleSystem): void;
-    setDepthTexture(depthTexture: BaseTexture | null): void;
-    configureAdaptivePerformance(options?: Partial<AdaptivePerformanceOptions>): void;
-    disableAdaptivePerformance(resetQuality?: boolean): void;
-    getAdaptivePerformanceState(): AdaptivePerformanceState;
-    private applyAdaptiveQuality;
-    update(delta: number): void;
-    dispose(): void;
-}

package/dist/types/MeshSurfaceEmitter.d.ts

@@ -1,19 +0,0 @@
-import { Mesh } from '@babylonjs/core/Meshes/mesh';
-import { Particle, EmitterShape, ShapeJSON, IParticleSystem, Plugin } from 'quarks.core';
-export declare class MeshSurfaceEmitter implements EmitterShape {
-    type: string;
-    private _triangleIndexToArea;
-    private _mesh?;
-    private _positions?;
-    private _indices?;
-    private _meshReferenceId?;
-    get mesh(): Mesh | undefined;
-    set mesh(mesh: Mesh | undefined);
-    constructor(mesh?: Mesh, meshReferenceId?: string);
-    initialize(p: Particle): void;
-    toJSON(): ShapeJSON;
-    static fromJSON(json: any): MeshSurfaceEmitter;
-    clone(): EmitterShape;
-    update(_system: IParticleSystem, _delta: number): void;
-}
-export declare const MeshSurfaceEmitterPlugin: Plugin;

package/dist/types/ParticleEmitter.d.ts

@@ -1,16 +0,0 @@
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-import { Scene } from '@babylonjs/core/scene';
-import { Matrix4, IParticleSystem, SerializationOptions } from 'quarks.core';
-export declare class ParticleEmitter extends TransformNode {
-    system: IParticleSystem;
-    private _matrixWorld;
-    get matrixWorld(): Matrix4;
-    get visible(): boolean;
-    set visible(value: boolean);
-    get uuid(): string;
-    constructor(system: IParticleSystem, scene?: Scene);
-    dispose(): void;
-    extractFromCache(cache: any): any[];
-    clone(name?: string): ParticleEmitter;
-    toJSON(meta?: any, options?: SerializationOptions): any;
-}