babylon.quarks 0.26.0 → 0.27.0

package/src/batchKey.ts

@@ -0,0 +1,237 @@
+import {Constants} from '@babylonjs/core/Engines/constants';
+import type {Vector3} from 'quarks.core';
+import type {VFXBatchSettings} from './BatchedRenderer';
+import {DEFAULT_SOFT_FAR_FADE, validSoftFade, validTileCount} from './system/normalize';
+import {
+    normalizeErosion,
+    normalizeGradientMap,
+    normalizeMapUV,
+    normalizeMeshRim,
+    normalizeUVDistortion,
+    readsUV1,
+    RenderMode,
+    StoredBatchSettings,
+    TextureUV,
+} from './VFXBatch';
+
+// What decides whether two systems draw from one batch.
+//
+// A batch is one draw call with one material, so its systems share everything the material
+// holds. That falls into two groups, as a Unity material's shader keywords and texture slots
+// against its MaterialPropertyBlock values, or an Unreal material against its dynamic
+// instance's parameters:
+//
+// - the shader key: the render mode, the geometry, the textures, the blend and depth state,
+//   and which effects are compiled in. A change here needs a new material;
+// - the live parameters: the numbers the effects run on, such as a soft fade distance, an
+//   erosion edge width or a rim colour. They are uniforms, so a change here is written to the
+//   material in place.
+//
+// Each render mode reads only part of the settings, so before two settings are compared they
+// are reduced to a canonical form in which every field the mode ignores is at its default. Two
+// billboards that differ only in a mesh rim then share a batch.
+
+/** Geometry a trail batch's settings hold, since a trail draws its own strip. */
+const NO_GEOMETRY = new Float32Array(0);
+const NO_INDICES = new Uint16Array(0);
+
+/** Whether `renderMode` draws camera-facing quads that take a pivot and screen-size limits. */
+export function takesPivotAndSizeLimits(renderMode: RenderMode): boolean {
+    return (
+        renderMode === RenderMode.BillBoard ||
+        renderMode === RenderMode.StretchedBillBoard ||
+        renderMode === RenderMode.VerticalBillBoard ||
+        renderMode === RenderMode.HorizontalBillBoard
+    );
+}
+
+/** Whether the settings draw a flipbook: more than one cell in either direction. */
+export function tilesSheet(settings: {uTileCount: number; vTileCount: number}): boolean {
+    return settings.uTileCount > 1 || settings.vTileCount > 1;
+}
+
+/** Whether the settings put a screen-size limit on the particles. */
+export function hasSizeLimits(settings: {minParticleSize: number; maxParticleSize: number}): boolean {
+    return settings.minParticleSize > 0 || settings.maxParticleSize !== Infinity;
+}
+
+/**
+ * A batch's copy of a system's settings: every optional field defaulted, and every field the
+ * render mode ignores at its default, so that systems that draw the same share a batch whatever
+ * their unused settings say. See {@link batchSettingsEqual}.
+ */
+export function storedBatchSettings(settings: VFXBatchSettings): StoredBatchSettings {
+    const renderMode = settings.renderMode;
+    const isMesh = renderMode === RenderMode.Mesh;
+    const isTrail = renderMode === RenderMode.Trail;
+    const quad = takesPivotAndSizeLimits(renderMode);
+    const softParticles = settings.softParticles;
+    const transparent = settings.materialTransparent;
+    const pivot = settings.pivot;
+    const mapUV = normalizeMapUV(settings.mapUV);
+    const uvDistortion = normalizeUVDistortion(settings.uvDistortion);
+    const gradientMap = normalizeGradientMap(settings.gradientMap);
+    const erosion = normalizeErosion(settings.erosion);
+    const uTileCount = validTileCount(settings.uTileCount);
+    const vTileCount = validTileCount(settings.vTileCount);
+    const stored: StoredBatchSettings = {
+        renderMode,
+        // A trail draws its own strip and reads none of the instanced geometry.
+        instancingGeometry: isTrail ? NO_GEOMETRY : settings.instancingGeometry,
+        instancingIndices: isTrail ? NO_INDICES : settings.instancingIndices,
+        instancingUVs: isTrail ? undefined : settings.instancingUVs,
+        // Normals, and the second UV set when a texture reads it, only reach mesh particles.
+        instancingUVs2: isMesh && readsUV1({mapUV, uvDistortion, erosion}) ? settings.instancingUVs2 : undefined,
+        instancingNormals: isMesh ? settings.instancingNormals : undefined,
+        renderOrder: settings.renderOrder,
+        uTileCount,
+        vTileCount,
+        // A trail cuts its cell on the CPU; a 1×1 sheet has no second cell to blend into.
+        blendTiles: !isTrail && settings.blendTiles && tilesSheet({uTileCount, vTileCount}),
+        softParticles,
+        softNearFade: softParticles ? validSoftFade(settings.softNearFade, 0) : 0,
+        softFarFade: softParticles ? validSoftFade(settings.softFarFade, DEFAULT_SOFT_FAR_FADE) : 0,
+        // An opaque batch draws with blending off, whatever mode it would blend with.
+        materialBlendMode: transparent ? settings.materialBlendMode : Constants.ALPHA_DISABLE,
+        materialTransparent: transparent,
+        materialDepthTest: settings.materialDepthTest,
+        materialDepthWrite: settings.materialDepthWrite,
+        materialAlphaTest: settings.materialAlphaTest > 0 ? settings.materialAlphaTest : 0,
+        texture: settings.texture,
+        reflectionTexture: isMesh ? (settings.reflectionTexture ?? null) : null,
+        reflectionLevel: isMesh ? (settings.reflectionLevel ?? 1) : 1,
+        reflectionAtlas: isMesh ? (settings.reflectionAtlas ?? null) : null,
+        layerMask: settings.layerMask,
+        renderingGroupId: settings.renderingGroupId ?? 0,
+        applyFog: settings.applyFog ?? true,
+        pivot: quad && pivot && (pivot.x !== 0 || pivot.y !== 0 || pivot.z !== 0) ? pivot.clone() : undefined,
+        sortMode: settings.sortMode ?? 'none',
+        minParticleSize: quad ? Math.max(0, settings.minParticleSize ?? 0) : 0,
+        maxParticleSize: quad ? positiveOrUnlimited(settings.maxParticleSize) : Infinity,
+        lighting: isMesh ? (settings.lighting ?? 'fixed') : 'fixed',
+        rim: isMesh ? normalizeMeshRim(settings.rim) : undefined,
+        mapUV,
+        uvDistortion,
+        gradientMap,
+        erosion,
+    };
+    return stored;
+}
+
+/** `size` when it limits something, else no limit. */
+function positiveOrUnlimited(size: number | undefined): number {
+    return size !== undefined && size > 0 ? size : Infinity;
+}
+
+/**
+ * Whether two canonical settings compile to the same material: the same render mode, geometry,
+ * textures, blend and depth state, and the same effects. Batches with equal shader keys differ
+ * only in {@link liveParamsEqual | live parameters}.
+ */
+export function shaderKeyEqual(a: StoredBatchSettings, b: StoredBatchSettings): boolean {
+    return (
+        a.renderMode === b.renderMode &&
+        a.instancingGeometry === b.instancingGeometry &&
+        a.instancingIndices === b.instancingIndices &&
+        a.instancingUVs === b.instancingUVs &&
+        a.instancingUVs2 === b.instancingUVs2 &&
+        a.instancingNormals === b.instancingNormals &&
+        a.texture === b.texture &&
+        a.reflectionTexture === b.reflectionTexture &&
+        a.reflectionAtlas === b.reflectionAtlas &&
+        a.lighting === b.lighting &&
+        a.rim?.mode === b.rim?.mode &&
+        a.uTileCount === b.uTileCount &&
+        a.vTileCount === b.vTileCount &&
+        a.blendTiles === b.blendTiles &&
+        a.softParticles === b.softParticles &&
+        a.materialBlendMode === b.materialBlendMode &&
+        a.materialTransparent === b.materialTransparent &&
+        a.materialDepthTest === b.materialDepthTest &&
+        a.materialDepthWrite === b.materialDepthWrite &&
+        a.materialAlphaTest > 0 === b.materialAlphaTest > 0 &&
+        a.layerMask === b.layerMask &&
+        a.renderingGroupId === b.renderingGroupId &&
+        a.renderOrder === b.renderOrder &&
+        a.applyFog === b.applyFog &&
+        a.sortMode === b.sortMode &&
+        !a.pivot === !b.pivot &&
+        hasSizeLimits(a) === hasSizeLimits(b) &&
+        a.mapUV?.channel === b.mapUV?.channel &&
+        a.uvDistortion?.map === b.uvDistortion?.map &&
+        a.uvDistortion?.mapUV.channel === b.uvDistortion?.mapUV.channel &&
+        !a.gradientMap === !b.gradientMap &&
+        a.gradientMap?.ramp === b.gradientMap?.ramp &&
+        !a.erosion === !b.erosion &&
+        a.erosion?.mask === b.erosion?.mask &&
+        a.erosion?.maskUV.channel === b.erosion?.maskUV.channel
+    );
+}
+
+/**
+ * Whether two canonical settings with the same shader key set the material's uniforms to the
+ * same values: the fade distances, alpha cutoff, pivot, size limits, reflection level, rim
+ * colour, each effect's parameters and each texture's layout.
+ */
+export function liveParamsEqual(a: StoredBatchSettings, b: StoredBatchSettings): boolean {
+    return (
+        a.softNearFade === b.softNearFade &&
+        a.softFarFade === b.softFarFade &&
+        a.materialAlphaTest === b.materialAlphaTest &&
+        a.reflectionLevel === b.reflectionLevel &&
+        pivotEqual(a.pivot, b.pivot) &&
+        a.minParticleSize === b.minParticleSize &&
+        a.maxParticleSize === b.maxParticleSize &&
+        rimParamsEqual(a.rim, b.rim) &&
+        uvLayoutEqual(a.mapUV, b.mapUV) &&
+        a.uvDistortion?.strength === b.uvDistortion?.strength &&
+        uvLayoutEqual(a.uvDistortion?.mapUV, b.uvDistortion?.mapUV) &&
+        a.gradientMap?.channel === b.gradientMap?.channel &&
+        a.erosion?.softness === b.erosion?.softness &&
+        a.erosion?.edgeWidth === b.erosion?.edgeWidth &&
+        colorEqual(a.erosion?.edgeColor, b.erosion?.edgeColor) &&
+        uvLayoutEqual(a.erosion?.maskUV, b.erosion?.maskUV)
+    );
+}
+
+/** Whether two canonical settings draw from one batch: the same shader key and the same live parameters. */
+export function batchSettingsEqual(a: StoredBatchSettings, b: StoredBatchSettings): boolean {
+    return shaderKeyEqual(a, b) && liveParamsEqual(a, b);
+}
+
+/** True when both pivots put the quad in the same place; a missing pivot is zero. */
+function pivotEqual(a: Vector3 | undefined, b: Vector3 | undefined): boolean {
+    return (a?.x ?? 0) === (b?.x ?? 0) && (a?.y ?? 0) === (b?.y ?? 0) && (a?.z ?? 0) === (b?.z ?? 0);
+}
+
+function rimParamsEqual(
+    a: {color: readonly number[]; power: number; strength: number} | undefined,
+    b: {color: readonly number[]; power: number; strength: number} | undefined
+): boolean {
+    if (!a || !b) {
+        return !a === !b;
+    }
+    return a.power === b.power && a.strength === b.strength && colorEqual(a.color, b.color);
+}
+
+function colorEqual(a: readonly number[] | undefined, b: readonly number[] | undefined): boolean {
+    if (!a || !b) {
+        return !a === !b;
+    }
+    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+}
+
+/** Whether two layouts tile, offset and scroll the texture the same; the channel is part of the shader key. */
+function uvLayoutEqual(a: TextureUV | undefined, b: TextureUV | undefined): boolean {
+    if (!a || !b) {
+        return !a === !b;
+    }
+    return (
+        a.tiling[0] === b.tiling[0] &&
+        a.tiling[1] === b.tiling[1] &&
+        a.offset[0] === b.offset[0] &&
+        a.offset[1] === b.offset[1] &&
+        a.scroll[0] === b.scroll[0] &&
+        a.scroll[1] === b.scroll[1]
+    );
+}

package/src/effectResources.ts

@@ -0,0 +1,79 @@
+import type {Material} from '@babylonjs/core/Materials/material';
+import type {BaseTexture} from '@babylonjs/core/Materials/Textures/baseTexture';
+import type {TransformNode} from '@babylonjs/core/Meshes/transformNode';
+import type {Node} from '@babylonjs/core/node';
+
+/** What an effect root owns: the textures it holds a count on, and the materials made for it alone. */
+interface EffectResources {
+    textures: Set<BaseTexture>;
+    materials: Material[];
+}
+
+const owned = new WeakMap<Node, EffectResources>();
+/** How many effect roots hold each texture. */
+const holders = new WeakMap<BaseTexture, number>();
+
+/**
+ * Records that `root` uses `textures` and owns `materials`. They are freed when the root is
+ * disposed, however that happens: {@link disposeEffect}, `root.dispose()`, a parent's dispose or
+ * the scene's.
+ */
+export function retainEffectResources(
+    root: TransformNode,
+    textures: Iterable<BaseTexture>,
+    materials: Material[]
+): void {
+    if (owned.has(root)) {
+        return;
+    }
+    const resources: EffectResources = {textures: new Set(textures), materials};
+    for (const texture of resources.textures) {
+        holders.set(texture, (holders.get(texture) ?? 0) + 1);
+    }
+    owned.set(root, resources);
+    root.onDisposeObservable.addOnce(() => releaseEffectResources(root));
+}
+
+/**
+ * Gives `copy` a hold on the textures the effect `source` belongs to holds, as a copy of the
+ * effect, or of a node in it, draws with them too.
+ */
+export function shareEffectResources(source: TransformNode, copy: TransformNode): void {
+    for (let node: Node | null = source; node !== null; node = node.parent) {
+        const resources = owned.get(node);
+        if (resources !== undefined) {
+            retainEffectResources(copy, resources.textures, []);
+            return;
+        }
+    }
+}
+
+function releaseEffectResources(root: Node): void {
+    const resources = owned.get(root);
+    if (resources === undefined) {
+        return;
+    }
+    owned.delete(root);
+    for (const material of resources.materials) {
+        material.dispose();
+    }
+    for (const texture of resources.textures) {
+        const count = (holders.get(texture) ?? 1) - 1;
+        if (count > 0) {
+            holders.set(texture, count);
+        } else {
+            holders.delete(texture);
+            texture.dispose();
+        }
+    }
+}
+
+/**
+ * Disposes an effect root and its nodes and systems, the materials made for it, and each texture it
+ * holds once no other effect root holds it. A root nothing was recorded for is only disposed.
+ */
+export function disposeEffect(root: TransformNode): void {
+    root.dispose();
+    // A root disposed earlier, before its hold was recorded, still lets go.
+    releaseEffectResources(root);
+}

package/src/envAtlas.ts

@@ -2,8 +2,18 @@ import {BaseTexture} from '@babylonjs/core/Materials/Textures/baseTexture';
 import {Texture} from '@babylonjs/core/Materials/Textures/texture';
 import {Scene} from '@babylonjs/core/scene';
 
-const atlasByCube = new WeakMap<BaseTexture, Texture>();
-const pendingByCube = new WeakMap<BaseTexture, Promise<Texture | null>>();
+/**
+ * Atlases by cube, then by the scene they were built for: a texture belongs to one scene and one
+ * engine, so a second scene (an editor preview, a second canvas) gets an atlas of its own.
+ */
+const atlasesByCube = new WeakMap<BaseTexture, Map<Scene, Texture>>();
+const pendingByCube = new WeakMap<BaseTexture, Map<Scene, Promise<Texture | null>>>();
+/** Atlases this module built, which it disposes; an atlas given to {@link cacheEnvAtlas} stays the caller's. */
+const builtAtlases = new WeakSet<Texture>();
+/** Atlases whose dispose this module already listens to. */
+const watchedAtlases = new WeakSet<Texture>();
+/** Cubes whose dispose this module already listens to. */
+const watchedCubes = new WeakSet<BaseTexture>();
 
 /** Reads the six face URLs from a Babylon CubeTexture (px py pz nx ny nz). */
 export function cubeFaceUrls(reflection: BaseTexture | null | undefined): string[] | null {
@@ -15,14 +25,85 @@ export function cubeFaceUrls(reflection: BaseTexture | null | undefined): string
     return files?.length === 6 ? files.slice() : null;
 }
 
-/** Returns a previously built atlas for this cube, if any. */
-export function getCachedEnvAtlas(cube: BaseTexture): Texture | null {
-    return atlasByCube.get(cube) ?? null;
+/** The scene a texture belongs to, or null for a disposed texture or one with no scene. */
+function sceneOf(texture: BaseTexture): Scene | null {
+    return (texture as {getScene?: () => Scene | null}).getScene?.() ?? null;
 }
 
-/** Stores an atlas for a cube source (tests / prebuilt atlases). */
+/**
+ * Returns the atlas already built or cached for this cube in `scene`, if any.
+ *
+ * @param cube - The cube texture the atlas was made from.
+ * @param scene - The scene the atlas must belong to. Defaults to the cube's own scene.
+ */
+export function getCachedEnvAtlas(cube: BaseTexture, scene: Scene | null = sceneOf(cube)): Texture | null {
+    return (scene && atlasesByCube.get(cube)?.get(scene)) || null;
+}
+
+/**
+ * Stores a prebuilt atlas for a cube in the atlas's scene, so systems that use the cube in that
+ * scene take it instead of building one. The atlas stays the caller's: quarks never disposes it,
+ * and drops it from the cache when it, or the cube, is disposed.
+ *
+ * @param cube - The cube texture the atlas stands in for.
+ * @param atlas - A 3×2 atlas in the layout of {@link createEnvAtlasFromFaceUrls}.
+ */
 export function cacheEnvAtlas(cube: BaseTexture, atlas: Texture): void {
-    atlasByCube.set(cube, atlas);
+    const scene = sceneOf(atlas) ?? sceneOf(cube);
+    if (scene) {
+        store(cube, scene, atlas);
+    } else {
+        console.warn('[babylon.quarks] cacheEnvAtlas: neither the atlas nor the cube has a scene; not cached');
+    }
+}
+
+/**
+ * Drops the atlases made for `cube` from the cache and disposes the ones quarks built. Runs by
+ * itself when the cube is disposed; call it when an environment is swapped out but the cube is
+ * kept. Systems that use the cube build a new atlas the next time their material is resolved.
+ *
+ * @param cube - The cube texture whose atlases to drop.
+ * @param scene - Only the atlas for this scene. Defaults to every scene.
+ */
+export function disposeEnvAtlas(cube: BaseTexture, scene?: Scene): void {
+    const atlases = atlasesByCube.get(cube);
+    if (!atlases) {
+        return;
+    }
+    for (const [atlasScene, atlas] of [...atlases]) {
+        if (scene && atlasScene !== scene) {
+            continue;
+        }
+        atlases.delete(atlasScene);
+        if (builtAtlases.has(atlas)) {
+            atlas.dispose();
+        }
+    }
+}
+
+function store(cube: BaseTexture, scene: Scene, atlas: Texture): void {
+    let atlases = atlasesByCube.get(cube);
+    if (!atlases) {
+        atlases = new Map();
+        atlasesByCube.set(cube, atlases);
+    }
+    atlases.set(scene, atlas);
+    // A scene disposes its textures, so this also lets go of a disposed scene.
+    if (!watchedAtlases.has(atlas) && atlas.onDisposeObservable) {
+        watchedAtlases.add(atlas);
+        atlas.onDisposeObservable.addOnce(() => {
+            if (atlasesByCube.get(cube)?.get(scene) === atlas) {
+                atlasesByCube.get(cube)!.delete(scene);
+            }
+        });
+    }
+    if (!watchedCubes.has(cube) && cube.onDisposeObservable) {
+        watchedCubes.add(cube);
+        cube.onDisposeObservable.addOnce(() => {
+            watchedCubes.delete(cube);
+            disposeEnvAtlas(cube);
+        });
+    }
 }
 
 /**
@@ -63,23 +144,30 @@ export const envAtlasBuilder = {
 };
 
 /**
- * Ensures a 3×2 env atlas exists for a CubeTexture. Returns a cached atlas
- * synchronously when available; otherwise starts (or joins) an async build and
- * invokes onReady when the atlas is usable.
+ * Ensures a 3×2 env atlas exists for a CubeTexture in `scene`. Returns a cached atlas
+ * synchronously when available; otherwise starts (or joins) an async build and invokes onReady
+ * when the atlas is usable. A cube disposed before its build finishes gets no atlas.
  */
 export function ensureEnvAtlasFromCube(
     cube: BaseTexture,
     scene: Scene,
     onReady: (atlas: Texture) => void
 ): Texture | null {
-    const cached = atlasByCube.get(cube);
+    const cached = getCachedEnvAtlas(cube, scene);
     if (cached) {
         onReady(cached);
         return cached;
     }
 
+    let pendingByScene = pendingByCube.get(cube);
+    if (!pendingByScene) {
+        pendingByScene = new Map();
+        pendingByCube.set(cube, pendingByScene);
+    }
+    const pendings = pendingByScene;
+
     const kick = () => {
-        const existingPending = pendingByCube.get(cube);
+        const existingPending = pendings.get(scene);
         if (existingPending) {
             existingPending.then((atlas) => {
                 if (atlas) {
@@ -94,20 +182,34 @@ export function ensureEnvAtlasFromCube(
             return;
         }
 
+        let cubeDisposed = false;
+        // Removed once the build settles, so it does not keep the scene and onReady alive.
+        const cubeObserver = cube.onDisposeObservable?.addOnce(() => (cubeDisposed = true));
+        const settle = () => {
+            pendings.delete(scene);
+            if (cubeObserver) {
+                cube.onDisposeObservable.remove(cubeObserver);
+            }
+        };
         const pending = envAtlasBuilder
             .createFromFaceUrls(urls, scene)
             .then((atlas) => {
-                atlasByCube.set(cube, atlas);
-                pendingByCube.delete(cube);
+                settle();
+                if (cubeDisposed || scene.isDisposed) {
+                    atlas.dispose();
+                    return null;
+                }
+                builtAtlases.add(atlas);
+                store(cube, scene, atlas);
                 onReady(atlas);
                 return atlas;
             })
             .catch((err) => {
-                pendingByCube.delete(cube);
+                settle();
                 console.warn('[babylon.quarks] Failed to build env atlas from cubemap faces', err);
                 return null;
             });
-        pendingByCube.set(cube, pending);
+        pendings.set(scene, pending);
     };
 
     if (cube.isReady()) {
@@ -121,7 +223,7 @@ export function ensureEnvAtlasFromCube(
         }
     }
 
-    return atlasByCube.get(cube) ?? null;
+    return getCachedEnvAtlas(cube, scene);
 }
 
 /** Loads one image URL as an HTMLImageElement. */

package/src/index.ts

@@ -1,9 +1,7 @@
 import {loadPlugin} from 'quarks.core';
 import {MeshSurfaceEmitterPlugin} from './MeshSurfaceEmitter';
-import {registerShaderChunks} from './shaders';
 
 export * from 'quarks.core';
-export {BatchedParticleRenderer} from './BatchedParticleRenderer';
 export {BatchedRenderer} from './BatchedRenderer';
 export type {AdaptivePerformanceOptions, AdaptivePerformanceState, VFXBatchSettings} from './BatchedRenderer';
 export {EffectPool} from './EffectPool';
@@ -12,11 +10,12 @@ export {
     cacheEnvAtlas,
     createEnvAtlasFromFaceUrls,
     cubeFaceUrls,
+    disposeEnvAtlas,
     ensureEnvAtlasFromCube,
     getCachedEnvAtlas,
 } from './envAtlas';
-export * from './materials/';
 export {MeshSurfaceEmitter, MeshSurfaceEmitterPlugin} from './MeshSurfaceEmitter';
+export {quarksNodeId} from './nodeId';
 export {ParticleEmitter} from './ParticleEmitter';
 export {ParticleSystem} from './ParticleSystem';
 export type {
@@ -29,22 +28,47 @@ export type {
     ParticleSystemParameters,
     ScalingMode,
 } from './ParticleSystem';
-export {QuarksLoader} from './QuarksLoader';
+export {QuarksFormatError, QuarksLoader} from './QuarksLoader';
 export type {
     QuarksBatchLoadOptions,
     QuarksJSONLoadEntry,
     QuarksLoaderOptions,
+    QuarksLoadOptions,
     QuarksResourceKind,
     QuarksResourceResolver,
 } from './QuarksLoader';
 export {QuarksPrefab} from './QuarksPrefab';
 export type {AnimationData, QuarksTimelineClip} from './QuarksPrefab';
+export {QUARKS_FORMAT_VERSION, serializeEffect} from './QuarksSerializer';
+export type {
+    QuarksEffectJSON,
+    QuarksGeometryJSON,
+    QuarksImageJSON,
+    QuarksNodeJSON,
+    QuarksTextureJSON,
+    SerializeEffectOptions,
+} from './QuarksSerializer';
 export {QuarksUtil} from './QuarksUtil';
-export * from './shaders/';
-export {SpriteBatch} from './SpriteBatch';
-export {TrailBatch} from './TrailBatch';
+export {shaderProgram} from './shaderProgram';
+export type {ShaderContext, ShaderDepth, ShaderProgram, ShaderSettings} from './shaderProgram';
+export type {ShaderSources} from './shaders/shaderLanguageSupport';
+export {shaderVariants} from './shaderVariants';
+export type {ShaderVariant} from './shaderVariants';
+export {decodeSoftDepth, softDepthParams} from './softDepth';
+export type {DepthTextureOptions, SoftDepthEncoding} from './softDepth';
+export {textureSourceUrl} from './textureSource';
+export {
+    MAX_TRAIL_TESSELLATION,
+    trailCurveTension,
+    trailLifetime,
+    trailMinVertexDistance,
+    trailTessellation,
+    trailTextureMode,
+    trailTextureScale,
+} from './trailSettings';
 export {
     defaultMeshLighting,
+    EROSION_DEFAULT_SOFTNESS,
     erosionEqual,
     GRADIENT_MAP_WEIGHTS,
     gradientMapEqual,
@@ -60,6 +84,7 @@ export {
     RenderMode,
     textureUVEqual,
     textureUVToJSON,
+    UV_DISTORTION_DEFAULT_STRENGTH,
     UV_DISTORTION_DEFAULT_UV,
     uvDistortionEqual,
     VFXBatch,
@@ -80,30 +105,4 @@ export type {
     UVChannel,
 } from './VFXBatch';
 
-// Re-export quarks.core types (interfaces - type-only)
-export type {
-    Behavior,
-    BillBoardSettings,
-    ColorGenerator,
-    EmissionState,
-    EmitterShape,
-    FunctionColorGenerator,
-    FunctionValueGenerator,
-    IEmitter,
-    IParticle,
-    IParticleSystem,
-    MeshSettings,
-    Particle,
-    ParticleSystemEvent,
-    ParticleSystemEventType,
-    RendererEmitterSettings,
-    RotationGenerator,
-    SerializationOptions,
-    StretchedBillBoardSettings,
-    TrailSettings,
-    ValueGenerator,
-    Vector3Generator,
-} from 'quarks.core';
-
-registerShaderChunks();
 loadPlugin(MeshSurfaceEmitterPlugin);

package/src/nodeId.ts

@@ -0,0 +1,13 @@
+import {RandomGUID} from '@babylonjs/core/Misc/guid';
+
+/**
+ * The id an effect file knows a node by: the uuid it was loaded under, or, for a node made in code,
+ * a GUID given to it the first time it is asked for and kept from then on. Every link written into
+ * a file (a sub emitter's target, a mesh surface shape's mesh, a prefab animation's target) and
+ * every node's own `uuid` use this, so an effect loaded, saved and loaded again keeps its links,
+ * and a node made in code never takes the id of one loaded from a file.
+ */
+export function quarksNodeId(node: object): string {
+    const ided = node as {_quarksUUID?: string};
+    return (ided._quarksUUID ??= RandomGUID());
+}