babylon.quarks 0.17.0

package/dist/types/BatchedRenderer.d.ts

@@ -0,0 +1,40 @@
+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 declare class BatchedRenderer extends TransformNode {
+    batches: Array<VFXBatch>;
+    systemToBatchIndex: Map<IParticleSystem, number>;
+    depthTexture: BaseTexture | null;
+    constructor(name: string, scene: Scene);
+    private static equals;
+    addSystem(system: IParticleSystem): void;
+    deleteSystem(system: IParticleSystem): void;
+    updateSystem(system: IParticleSystem): void;
+    setDepthTexture(depthTexture: BaseTexture | null): void;
+    update(delta: number): void;
+    dispose(): void;
+}

package/dist/types/MeshSurfaceEmitter.d.ts

@@ -0,0 +1,19 @@
+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

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

package/dist/types/ParticleSystem.d.ts

@@ -0,0 +1,226 @@
+import { Scene } from '@babylonjs/core/scene';
+import { Texture } from '@babylonjs/core/Materials/Textures/texture';
+import { ColorGenerator, FunctionColorGenerator, FunctionJSON, FunctionValueGenerator, ValueGenerator, Behavior, Particle, EmitterShape, RendererEmitterSettings, RotationGenerator, IParticleSystem, EmissionState, SerializationOptions, Matrix4, Vector3Generator, ParticleSystemEvent, ParticleSystemEventType } from 'quarks.core';
+import { ParticleEmitter } from './ParticleEmitter';
+import { RenderMode } from './VFXBatch';
+import { BatchedRenderer, VFXBatchSettings } from './BatchedRenderer';
+export interface BurstParameters {
+    time: number;
+    count: ValueGenerator | FunctionValueGenerator;
+    cycle: number;
+    interval: number;
+    probability: number;
+}
+export interface ParticleSystemParameters {
+    autoDestroy?: boolean;
+    looping?: boolean;
+    prewarm?: boolean;
+    duration?: number;
+    shape?: EmitterShape;
+    startLife?: ValueGenerator | FunctionValueGenerator;
+    startSpeed?: ValueGenerator | FunctionValueGenerator;
+    startRotation?: ValueGenerator | FunctionValueGenerator | RotationGenerator;
+    startSize?: ValueGenerator | FunctionValueGenerator | Vector3Generator;
+    startLength?: ValueGenerator | FunctionValueGenerator;
+    startColor?: ColorGenerator | FunctionColorGenerator;
+    emissionOverTime?: ValueGenerator | FunctionValueGenerator;
+    emissionOverDistance?: ValueGenerator | FunctionValueGenerator;
+    emissionBursts?: Array<BurstParameters>;
+    onlyUsedByOther?: boolean;
+    behaviors?: Array<Behavior>;
+    instancingGeometry?: Float32Array;
+    instancingIndices?: Uint32Array | Uint16Array;
+    instancingUVs?: Float32Array;
+    instancingNormals?: Float32Array;
+    renderMode?: RenderMode;
+    rendererEmitterSettings?: RendererEmitterSettings;
+    speedFactor?: number;
+    material?: any;
+    texture?: Texture | null;
+    startTileIndex?: ValueGenerator;
+    uTileCount?: number;
+    vTileCount?: number;
+    blendTiles?: boolean;
+    softParticles?: boolean;
+    softFarFade?: number;
+    softNearFade?: number;
+    renderOrder?: number;
+    worldSpace?: boolean;
+    blendMode?: number;
+    transparent?: boolean;
+    depthTest?: boolean;
+    depthWrite?: boolean;
+    alphaTest?: number;
+    layerMask?: number;
+    scene?: Scene;
+}
+export interface BurstParametersJSON {
+    time: number;
+    count: FunctionJSON | number;
+    cycle: number;
+    interval: number;
+    probability: number;
+}
+export interface ParticleSystemJSONParameters {
+    version: string;
+    autoDestroy: boolean;
+    looping: boolean;
+    prewarm: boolean;
+    duration: number;
+    shape: any;
+    startLife: FunctionJSON;
+    startSpeed: FunctionJSON;
+    startRotation: FunctionJSON;
+    startSize: FunctionJSON;
+    startColor: FunctionJSON;
+    emissionOverTime: FunctionJSON;
+    emissionOverDistance: FunctionJSON;
+    emissionBursts?: Array<BurstParametersJSON>;
+    onlyUsedByOther: boolean;
+    rendererEmitterSettings: RendererEmitterSettings;
+    instancingGeometry?: any;
+    renderMode: number;
+    renderOrder?: number;
+    speedFactor?: number;
+    texture?: string;
+    material?: string;
+    layers?: number;
+    startTileIndex: FunctionJSON | number;
+    uTileCount: number;
+    vTileCount: number;
+    blendTiles?: boolean;
+    softParticles?: boolean;
+    softFarFade?: number;
+    softNearFade?: number;
+    blending?: number;
+    transparent?: boolean;
+    depthTest?: boolean;
+    depthWrite?: boolean;
+    alphaTest?: number;
+    behaviors: Array<any>;
+    worldSpace: boolean;
+}
+export interface BabylonMetaData {
+    textures: {
+        [uuid: string]: Texture | null;
+    };
+    materials: {
+        [uuid: string]: any;
+    };
+    geometries: {
+        [uuid: string]: any;
+    };
+    images?: {
+        [uuid: string]: any;
+    };
+    shapes?: {
+        [uuid: string]: any;
+    };
+    skeletons?: {
+        [uuid: string]: any;
+    };
+    animations?: {
+        [uuid: string]: any;
+    };
+    nodes?: {
+        [uuid: string]: any;
+    };
+}
+export declare class ParticleSystem implements IParticleSystem {
+    private static serializationCounter;
+    autoDestroy: boolean;
+    prewarm: boolean;
+    looping: boolean;
+    duration: number;
+    startLife: ValueGenerator | FunctionValueGenerator;
+    startSpeed: ValueGenerator | FunctionValueGenerator;
+    startRotation: ValueGenerator | FunctionValueGenerator | RotationGenerator;
+    startSize: ValueGenerator | FunctionValueGenerator | Vector3Generator;
+    startColor: ColorGenerator | FunctionColorGenerator;
+    startTileIndex: ValueGenerator;
+    rendererEmitterSettings: RendererEmitterSettings;
+    emissionOverTime: ValueGenerator | FunctionValueGenerator;
+    emissionOverDistance: ValueGenerator | FunctionValueGenerator;
+    emissionBursts: Array<BurstParameters>;
+    onlyUsedByOther: boolean;
+    worldSpace: boolean;
+    particleNum: number;
+    paused: boolean;
+    particles: Array<Particle>;
+    emitterShape: EmitterShape;
+    emitter: ParticleEmitter;
+    rendererSettings: VFXBatchSettings;
+    neededToUpdateRender: boolean;
+    behaviors: Array<Behavior>;
+    emissionState: EmissionState;
+    private prewarmed;
+    private emitEnded;
+    private markForDestroy;
+    private temp;
+    private normalMatrix;
+    private memory;
+    private listeners;
+    private readonly layerMaskProxy;
+    private materialRef;
+    /** @internal **/
+    _renderer?: BatchedRenderer;
+    set time(time: number);
+    get time(): number;
+    get layers(): {
+        mask: number;
+    };
+    get texture(): Texture | null;
+    set texture(texture: Texture | null);
+    get material(): any;
+    set material(material: any);
+    get uTileCount(): number;
+    set uTileCount(u: number);
+    get vTileCount(): number;
+    set vTileCount(v: number);
+    get blendTiles(): boolean;
+    set blendTiles(v: boolean);
+    get softParticles(): boolean;
+    set softParticles(v: boolean);
+    get softNearFade(): number;
+    set softNearFade(v: number);
+    get softFarFade(): number;
+    set softFarFade(v: number);
+    get instancingGeometry(): Float32Array;
+    set instancingGeometry(geometry: Float32Array);
+    get blending(): number;
+    set blending(blending: number);
+    get renderMode(): RenderMode;
+    set renderMode(renderMode: RenderMode);
+    get renderOrder(): number;
+    set renderOrder(renderOrder: number);
+    constructor(parameters: ParticleSystemParameters);
+    private applyMaterialSettings;
+    pause(): void;
+    play(): void;
+    stop(): void;
+    private spawn;
+    endEmit(): void;
+    dispose(): void;
+    restart(): void;
+    private firstTimeUpdate;
+    /** @internal */
+    update(delta: number): void;
+    emit(delta: number, emissionState: EmissionState, emitterMatrix: Matrix4): void;
+    toJSON(metaData?: BabylonMetaData | string, _options?: SerializationOptions): ParticleSystemJSONParameters;
+    static fromJSON(json: ParticleSystemJSONParameters, meta: BabylonMetaData, dependencies?: {
+        [uuid: string]: Behavior;
+    }, scene?: Scene): ParticleSystem;
+    private static nextSerializationId;
+    private static createFallbackNormals;
+    private toRendererSettingsJSON;
+    private ensureGeometryMeta;
+    private ensureMaterialMeta;
+    private static resolveGeometryData;
+    addBehavior(behavior: Behavior): void;
+    getRendererSettings(): VFXBatchSettings;
+    addEventListener(event: ParticleSystemEventType, callback: (event: ParticleSystemEvent) => void): void;
+    removeAllEventListeners(event: ParticleSystemEventType): void;
+    removeEventListener(event: ParticleSystemEventType, callback: (event: ParticleSystemEvent) => void): void;
+    private fire;
+    clone(): ParticleSystem;
+}

package/dist/types/QuarksLoader.d.ts

@@ -0,0 +1,28 @@
+import { Scene } from '@babylonjs/core/scene';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+export interface QuarksLoaderOptions {
+    baseUrl?: string;
+}
+export declare class QuarksLoader {
+    private scene;
+    private options;
+    constructor(scene: Scene, options?: QuarksLoaderOptions);
+    load(url: string): Promise<TransformNode>;
+    parse(json: any, baseUrl?: string): TransformNode;
+    private parseGeometries;
+    private parseSphereGeometry;
+    private parseBufferGeometry;
+    private extractInterleavedAttribute;
+    private int32ArrayToFloat32;
+    private parseImages;
+    private parseTextures;
+    private mapWrapMode;
+    private parseMaterials;
+    private getGeometry;
+    private getMaterial;
+    private createPlaceholderNode;
+    private createMeshNode;
+    private parseObject;
+    private parseParticleSystem;
+    private linkReferences;
+}

package/dist/types/QuarksPrefab.d.ts

@@ -0,0 +1,48 @@
+import { IAnimationData, IPrefab } from 'quarks.core';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { Scene } from '@babylonjs/core/scene';
+import { ParticleEmitter } from './ParticleEmitter';
+import { BatchedRenderer } from './BatchedRenderer';
+interface QuarksTimelineClip {
+    uuid?: string;
+    duration?: number;
+    play?: () => void;
+    pause?: () => void;
+    stop?: () => void;
+    setTime?: (time: number) => void;
+}
+interface AnimationData extends IAnimationData {
+    type: 'three' | 'ps';
+    target: TransformNode;
+    loop: boolean;
+    clip?: QuarksTimelineClip;
+    clipUUID?: string;
+}
+export declare class QuarksPrefab extends TransformNode implements IPrefab {
+    type: string;
+    animationData: Array<AnimationData>;
+    isPlaying: boolean;
+    currentTime: number;
+    timeScale: number;
+    duration: number;
+    private _lastUpdateTimeMs;
+    private _batchedRenderer?;
+    private _tempAnimationJSON;
+    constructor(name?: string, scene?: Scene);
+    registerBatchedRenderer(renderer: BatchedRenderer): void;
+    addParticleSystemAnimation(emitter: ParticleEmitter, startTime?: number, duration?: number, loop?: boolean): AnimationData;
+    addThreeAnimation(target: TransformNode, clip?: QuarksTimelineClip, startTime?: number, duration?: number, loop?: boolean, clipUUID?: string): AnimationData;
+    removeAnimation(index: number): void;
+    play(): void;
+    pause(): void;
+    stop(): void;
+    update(forceDelta?: number): void;
+    setTime(time: number): void;
+    getDuration(): number;
+    resolveReferences(root: TransformNode): void;
+    toJSON(): any;
+    static fromJSON(json: any, scene?: Scene): QuarksPrefab;
+    private resolveTimelineClip;
+    private updateDuration;
+}
+export {};

package/dist/types/QuarksUtil.d.ts

@@ -0,0 +1,14 @@
+import { Node } from '@babylonjs/core/node';
+import { ParticleEmitter } from './ParticleEmitter';
+import { BatchedRenderer } from './BatchedRenderer';
+export declare class QuarksUtil {
+    static runOnAllParticleEmitters(root: Node, callback: (emitter: ParticleEmitter) => void): void;
+    static addToBatchRenderer(root: Node, batchRenderer: BatchedRenderer): void;
+    static play(root: Node): void;
+    static stop(root: Node): void;
+    static pause(root: Node): void;
+    static restart(root: Node): void;
+    static setAutoDestroy(root: Node, autoDestroy: boolean): void;
+    static endEmit(root: Node): void;
+    private static traverseNode;
+}

package/dist/types/SpriteBatch.d.ts

@@ -0,0 +1,32 @@
+import { Scene } from '@babylonjs/core/scene';
+import { VFXBatch } from './VFXBatch';
+import { VFXBatchSettings } from './BatchedRenderer';
+export declare class SpriteBatch extends VFXBatch {
+    private offsetBuffer;
+    private rotationBuffer;
+    private sizeBuffer;
+    private colorBuffer;
+    private uvTileBuffer;
+    private velocityBuffer?;
+    private offsetVB;
+    private rotationVB;
+    private sizeVB;
+    private colorVB;
+    private uvTileVB;
+    private velocityVB?;
+    constructor(settings: VFXBatchSettings, scene: Scene);
+    setupBuffers(): void;
+    private buildExpandableBuffers;
+    expandBuffers(target: number): void;
+    rebuildMaterial(): void;
+    private vector_;
+    private vector2_;
+    private vector3_;
+    private quaternion_;
+    private quaternion2_;
+    private quaternion3_;
+    private rotationMat_;
+    private rotationMat2_;
+    update(): void;
+    dispose(): void;
+}

package/dist/types/TrailBatch.d.ts

@@ -0,0 +1,27 @@
+import { Scene } from '@babylonjs/core/scene';
+import { VFXBatch } from './VFXBatch';
+import { VFXBatchSettings } from './BatchedRenderer';
+export declare class TrailBatch extends VFXBatch {
+    private positionBuffer;
+    private previousBuffer;
+    private nextBuffer;
+    private uvBuffer;
+    private sideBuffer;
+    private widthBuffer;
+    private colorBuffer;
+    private indexBuffer;
+    private previousVB;
+    private nextVB;
+    private sideVB;
+    private widthVB;
+    constructor(settings: VFXBatchSettings, scene: Scene);
+    setupBuffers(): void;
+    expandBuffers(target: number): void;
+    rebuildMaterial(): void;
+    private vector_;
+    private vector2_;
+    private vector3_;
+    private quaternion_;
+    update(): void;
+    dispose(): void;
+}

package/dist/types/VFXBatch.d.ts

@@ -0,0 +1,51 @@
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { Scene } from '@babylonjs/core/scene';
+import { BaseTexture } from '@babylonjs/core/Materials/Textures/baseTexture';
+import { IParticleSystem } from 'quarks.core';
+import { VFXBatchSettings } from './BatchedRenderer';
+export declare 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 declare abstract class VFXBatch {
+    mesh: Mesh;
+    systems: Set<IParticleSystem>;
+    settings: StoredBatchSettings;
+    protected maxParticles: number;
+    protected scene: Scene;
+    protected constructor(settings: VFXBatchSettings, scene: Scene);
+    addSystem(system: IParticleSystem): void;
+    removeSystem(system: IParticleSystem): void;
+    getVisibleSystems(): IParticleSystem[];
+    applyDepthTexture(depthTexture: BaseTexture | null): void;
+    abstract setupBuffers(): void;
+    abstract expandBuffers(target: number): void;
+    abstract rebuildMaterial(): void;
+    abstract update(): void;
+    dispose(): void;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,19 @@
+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';
+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';

package/dist/types/materials/ParticleMaterials.d.ts

@@ -0,0 +1,12 @@
+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 declare class ParticleMeshStandardMaterial extends StandardMaterial {
+    readonly isParticleMeshStandardMaterial = true;
+    constructor(name: string, scene?: Scene, parameters?: BabylonParticleMaterialParameters);
+}
+export declare class ParticleMeshPhysicsMaterial extends PBRMaterial {
+    readonly isParticleMeshPhysicsMaterial = true;
+    constructor(name: string, scene?: Scene, parameters?: BabylonParticleMaterialParameters);
+}

package/dist/types/materials/index.d.ts

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

package/dist/types/shaders/chunks/index.d.ts

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

package/dist/types/shaders/chunks/register-shader-chunks.d.ts

@@ -0,0 +1,3 @@
+export declare function registerShaderChunks(): void;
+export declare function getShaderChunk(chunkName: string): string | undefined;
+export declare function getRegisteredShaderChunks(): Readonly<Record<string, string>>;

package/dist/types/shaders/chunks/soft_fragment.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n#ifdef SOFT_PARTICLES\n\n    vec2 p2 = projPosition.xy / projPosition.w;\n    p2 = 0.5 * p2 + 0.5;\n\n    float readDepth = texture2D(depthTexture, p2.xy).r;\n    float viewDepth = linearize_depth(readDepth);\n    float softParticlesFade = saturate(SOFT_INV_FADE_DISTANCE * ((viewDepth - SOFT_NEAR_FADE) - linearDepth));\n\n    gl_FragColor *= softParticlesFade;\n#endif\n";
+export default _default;

package/dist/types/shaders/chunks/soft_pars_fragment.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n#ifdef SOFT_PARTICLES\n    uniform sampler2D depthTexture;\n    uniform vec4 projParams;\n    uniform vec2 softParams;\n\n    varying vec4 projPosition;\n    varying float linearDepth;\n\n    #define SOFT_NEAR_FADE softParams.x\n    #define SOFT_INV_FADE_DISTANCE softParams.y\n\n    #define zNear projParams.x\n    #define zFar projParams.y\n\n    float linearize_depth(float d) {\n        return (zFar * zNear) / (zFar - d * (zFar - zNear));\n    }\n#endif\n";
+export default _default;

package/dist/types/shaders/chunks/soft_pars_vertex.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n#ifdef SOFT_PARTICLES\n    varying vec4 projPosition;\n    varying float linearDepth;\n#endif\n";
+export default _default;

package/dist/types/shaders/chunks/soft_vertex.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n#ifdef SOFT_PARTICLES\n    projPosition = gl_Position;\n    linearDepth = -mvPosition.z;\n#endif\n";
+export default _default;

package/dist/types/shaders/chunks/tile_fragment.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n#ifdef USE_MAP\n    vec4 texelColor = texture2D(map, vUv);\n    #ifdef TILE_BLEND\n        texelColor = mix(texelColor, texture2D(map, vUvNext), vUvBlend);\n    #endif\n    diffuseColor *= texelColor;\n#endif\n";
+export default _default;

package/dist/types/shaders/chunks/tile_pars_fragment.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n#if defined(USE_UV)\n    varying vec2 vUv;\n    #ifdef TILE_BLEND\n        varying vec2 vUvNext;\n        varying float vUvBlend;\n    #endif\n#endif\n";
+export default _default;

package/dist/types/shaders/chunks/tile_pars_vertex.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n#ifdef UV_TILE\n    attribute float uvTile;\n    uniform vec2 tileCount;\n\n    mat3 makeTileTransform(float tileIndex) {\n        float col = mod(tileIndex, tileCount.x);\n        float row = (tileCount.y - floor(tileIndex / tileCount.x) - 1.0);\n        return mat3(\n            1.0 / tileCount.x, 0.0, 0.0,\n            0.0, 1.0 / tileCount.y, 0.0,\n            col / tileCount.x, row / tileCount.y, 1.0\n        );\n    }\n#else\n    mat3 makeTileTransform(float tileIndex) {\n        return mat3(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);\n    }\n#endif\n\n#if defined(USE_UV)\n    varying vec2 vUv;\n    #ifdef TILE_BLEND\n        varying vec2 vUvNext;\n        varying float vUvBlend;\n    #endif\n#endif\n";
+export default _default;

package/dist/types/shaders/chunks/tile_vertex.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n#ifdef UV_TILE\n    mat3 tileTransform = makeTileTransform(floor(uvTile));\n    #ifdef TILE_BLEND\n        mat3 nextTileTransform = makeTileTransform(ceil(uvTile));\n        vUvBlend = fract(uvTile);\n    #endif\n#else\n    mat3 tileTransform = makeTileTransform(0.0);\n#endif\n\n#if defined(USE_UV)\n    vUv = (tileTransform * vec3(uv, 1.0)).xy;\n    #if defined(TILE_BLEND) && defined(UV_TILE)\n        vUvNext = (nextTileTransform * vec3(uv, 1.0)).xy;\n    #endif\n#endif\n";
+export default _default;

package/dist/types/shaders/index.d.ts

@@ -0,0 +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 particlePhysicsFragShader } from './particle_physics_frag.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';

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

@@ -0,0 +1,2 @@
+declare const _default: "\nattribute vec3 position;\nattribute vec2 uv;\nattribute vec3 normal;\nattribute vec3 offset;\nattribute vec4 color;\nattribute vec3 size;\nattribute vec4 rotation;\nattribute float uvTile;\n\nuniform mat4 world;\nuniform mat4 view;\nuniform mat4 projection;\n\n#ifdef UV_TILE\nuniform float tileCountX;\nuniform float tileCountY;\n#endif\n\nvarying vec2 vUV;\nvarying vec4 vColor;\nvarying vec3 vNormal;\nvarying vec3 vWorldPos;\n\n#ifdef SOFT_PARTICLES\nvarying vec4 projPosition;\nvarying float linearDepth;\n#endif\n\nvec3 applyQuaternion(vec3 v, vec4 q) {\n    vec3 qVec = q.xyz;\n    float qW = q.w;\n    vec3 t = 2.0 * cross(qVec, v);\n    return v + qW * t + cross(qVec, t);\n}\n\nvoid main() {\n    vec3 scaledPosition = position * size;\n    vec3 rotatedPosition = applyQuaternion(scaledPosition, rotation);\n    vec3 rotatedNormal = normalize(applyQuaternion(normal, rotation));\n    vec3 localPos = rotatedPosition + offset;\n\n    vec4 worldPos = world * vec4(localPos, 1.0);\n    vec4 viewPos = view * worldPos;\n    gl_Position = projection * viewPos;\n\n    vWorldPos = worldPos.xyz;\n    vNormal = normalize((world * vec4(rotatedNormal, 0.0)).xyz);\n\n#ifdef SOFT_PARTICLES\n    projPosition = gl_Position;\n    linearDepth = -viewPos.z;\n#endif\n\n#ifdef UV_TILE\n    vec2 tc = vec2(tileCountX, tileCountY);\n    float tileU = mod(uvTile, tc.x) / tc.x;\n    float tileV = 1.0 - floor(uvTile / tc.x) / tc.y - 1.0 / tc.y;\n    vUV = uv / tc + vec2(tileU, tileV);\n#else\n    vUV = uv;\n#endif\n\n    vColor = color;\n}\n";
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: "\n// Per-vertex attributes\nattribute vec3 position;\nattribute vec2 uv;\n\n// Per-instance attributes\nattribute vec3 offset;\nattribute vec4 color;\nattribute vec3 size;\nattribute vec4 rotation;\nattribute float uvTile;\n\n// Uniforms\nuniform mat4 worldViewProjection;\n\n#ifdef UV_TILE\nuniform float tileCountX;\nuniform float tileCountY;\n#endif\n\n// Varyings\nvarying vec2 vUV;\nvarying vec4 vColor;\n\nvec3 applyQuaternion(vec3 v, vec4 q) {\n    vec3 qVec = q.xyz;\n    float qW = q.w;\n    vec3 t = 2.0 * cross(qVec, v);\n    return v + qW * t + cross(qVec, t);\n}\n\nvoid main() {\n    vec3 rotatedPosition = applyQuaternion(position * size, rotation);\n    vec3 worldPos = rotatedPosition + offset;\n\n    gl_Position = worldViewProjection * vec4(worldPos, 1.0);\n\n    #ifdef UV_TILE\n        vec2 tc = vec2(tileCountX, tileCountY);\n        float baseTile = floor(uvTile);\n        float tileU = mod(baseTile, tc.x) / tc.x;\n        float tileV = 1.0 - floor(baseTile / tc.x) / tc.y - 1.0 / tc.y;\n        vUV = uv / tc + vec2(tileU, tileV);\n    #else\n        vUV = uv;\n    #endif\n\n    vColor = color;\n}\n";
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: "\nvarying vec2 vUV;\nvarying vec4 vColor;\n\n#ifdef TILE_BLEND\nvarying vec2 vUV2;\nvarying float vTileBlend;\n#endif\n\n#ifdef USE_MAP\nuniform sampler2D map;\n#endif\n\n#ifdef SOFT_PARTICLES\nuniform sampler2D depthTexture;\nuniform vec2 softParams;\nuniform vec4 projParams;\nvarying vec4 projPosition;\nvarying float linearDepth;\n#endif\n\n#ifdef USE_ALPHATEST\nuniform float alphaTest;\n#endif\n\nvoid main() {\n    vec4 baseColor = vColor;\n\n#ifdef USE_MAP\n    vec4 texColor = texture2D(map, vUV);\n    #ifdef TILE_BLEND\n        vec4 texColor2 = texture2D(map, vUV2);\n        texColor = mix(texColor, texColor2, vTileBlend);\n    #endif\n    baseColor *= texColor;\n#endif\n\n#ifdef USE_COLOR_AS_ALPHA\n    baseColor.a *= (baseColor.r + baseColor.g + baseColor.b) / 3.0;\n#endif\n\n#ifdef USE_ALPHATEST\n    if (baseColor.a < alphaTest) discard;\n#else\n    if (baseColor.a < 0.01) discard;\n#endif\n\n    gl_FragColor = baseColor;\n\n#ifdef SOFT_PARTICLES\n    vec2 p2 = projPosition.xy / projPosition.w;\n    p2 = 0.5 * p2 + 0.5;\n    float readDepth = texture2D(depthTexture, p2.xy).r;\n    float zNear = projParams.x;\n    float zFar = projParams.y;\n    float viewDepth = (zFar * zNear) / (zFar - readDepth * (zFar - zNear));\n    float fade = clamp(softParams.y * ((viewDepth - softParams.x) - linearDepth), 0.0, 1.0);\n    gl_FragColor *= fade;\n#endif\n}\n";
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: "\nvarying vec2 vUV;\nvarying vec4 vColor;\nvarying vec3 vNormal;\n\nuniform vec3 lightDirection;\nuniform vec3 lightColor;\nuniform vec3 ambientColor;\n\n#ifdef TILE_BLEND\nvarying vec2 vUV2;\nvarying float vTileBlend;\n#endif\n\n#ifdef USE_MAP\nuniform sampler2D map;\n#endif\n\n#ifdef SOFT_PARTICLES\nuniform sampler2D depthTexture;\nuniform vec2 softParams;\nuniform vec4 projParams;\nvarying vec4 projPosition;\nvarying float linearDepth;\n#endif\n\n#ifdef USE_ALPHATEST\nuniform float alphaTest;\n#endif\n\nvoid main() {\n    vec4 baseColor = vColor;\n\n#ifdef USE_MAP\n    vec4 texColor = texture2D(map, vUV);\n    #ifdef TILE_BLEND\n        vec4 texColor2 = texture2D(map, vUV2);\n        texColor = mix(texColor, texColor2, vTileBlend);\n    #endif\n    baseColor *= texColor;\n#endif\n\n#ifdef USE_ALPHATEST\n    if (baseColor.a < alphaTest) discard;\n#else\n    if (baseColor.a < 0.01) discard;\n#endif\n\n    vec3 N = normalize(vNormal);\n    vec3 L = normalize(-lightDirection);\n    float NdotL = max(dot(N, L), 0.0);\n    vec3 litColor = ambientColor + lightColor * NdotL;\n\n    gl_FragColor = vec4(baseColor.rgb * litColor, baseColor.a);\n\n#ifdef SOFT_PARTICLES\n    vec2 p2 = projPosition.xy / projPosition.w;\n    p2 = 0.5 * p2 + 0.5;\n    float readDepth = texture2D(depthTexture, p2.xy).r;\n    float zNear = projParams.x;\n    float zFar = projParams.y;\n    float viewDepth = (zFar * zNear) / (zFar - readDepth * (zFar - zNear));\n    float fade = clamp(softParams.y * ((viewDepth - softParams.x) - linearDepth), 0.0, 1.0);\n    gl_FragColor *= fade;\n#endif\n}\n";
+export default _default;

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

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

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

@@ -0,0 +1,2 @@
+declare const _default: "\n// Per-vertex attributes\nattribute vec3 position;\nattribute vec2 uv;\n\n// Per-instance attributes\nattribute vec3 offset;\nattribute vec4 color;\nattribute vec3 size;\nattribute float rotation;\nattribute float uvTile;\nattribute vec4 velocity;\n\n// Uniforms\nuniform mat4 world;\nuniform mat4 view;\nuniform mat4 projection;\nuniform float speedFactor;\n\n#ifdef UV_TILE\nuniform float tileCountX;\nuniform float tileCountY;\n#endif\n\n// Varyings\nvarying vec2 vUV;\nvarying vec4 vColor;\n#ifdef TILE_BLEND\nvarying vec2 vUV2;\nvarying float vTileBlend;\n#endif\n#ifdef SOFT_PARTICLES\nvarying vec4 projPosition;\nvarying float linearDepth;\n#endif\n\nvoid main() {\n    float lengthFactor = velocity.w;\n    float avgSize = (size.x + size.y) * 0.5;\n    vec4 mvPosition = view * world * vec4(offset, 1.0);\n    vec3 viewVelocity = mat3(view * world) * velocity.xyz;\n    float vlength = length(viewVelocity);\n    if (vlength < 0.0001) {\n        vlength = 0.0001;\n        viewVelocity = vec3(0.0, 0.0, 1.0);\n    }\n    mvPosition.xyz += position.y * normalize(cross(mvPosition.xyz, viewVelocity)) * avgSize;\n    mvPosition.xyz -= (position.x + 0.5) * viewVelocity * (1.0 + lengthFactor / vlength) * avgSize;\n    gl_Position = projection * mvPosition;\n#ifdef SOFT_PARTICLES\n    projPosition = gl_Position;\n    linearDepth = -mvPosition.z;\n#endif\n\n    #ifdef UV_TILE\n        vec2 tc = vec2(tileCountX, tileCountY);\n        float baseTile = floor(uvTile);\n        float tileU = mod(baseTile, tc.x) / tc.x;\n        float tileV = 1.0 - floor(baseTile / tc.x) / tc.y - 1.0 / tc.y;\n        vUV = uv / tc + vec2(tileU, tileV);\n        #ifdef TILE_BLEND\n            float nextTile = ceil(uvTile);\n            float nextU = mod(nextTile, tc.x) / tc.x;\n            float nextV = 1.0 - floor(nextTile / tc.x) / tc.y - 1.0 / tc.y;\n            vUV2 = uv / tc + vec2(nextU, nextV);\n            vTileBlend = fract(uvTile);\n        #endif\n    #else\n        vUV = uv;\n    #endif\n\n    vColor = color;\n}\n";
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: "\nvarying vec2 vUV;\nvarying vec4 vColor;\n\n#ifdef USE_MAP\nuniform sampler2D map;\n#endif\n\nvoid main() {\n    vec4 baseColor = vColor;\n\n#ifdef USE_MAP\n    vec4 texColor = texture2D(map, vUV);\n    baseColor *= texColor;\n#endif\n\n    if (baseColor.a < 0.01) discard;\n\n    gl_FragColor = baseColor;\n}\n";
+export default _default;