babylon.quarks-editor 0.17.7 → 0.17.8

package/src/core/loadEffect.ts

@@ -1,102 +1,102 @@
-import {ParticleEmitter, QuarksLoader, QuarksUtil} from 'babylon.quarks';
-import type {BatchedRenderer, ParticleSystem} from 'babylon.quarks';
-import type {Scene} from '@babylonjs/core/scene';
-import {TransformNode} from '@babylonjs/core/Meshes/transformNode';
-import type {Node} from '@babylonjs/core/node';
-
-/** `ParticleEmitter`'s constructor default (see babylon.quarks/src/ParticleEmitter.ts) — the
- * name every emitter gets when the source JSON didn't give it one of its own. */
-const DEFAULT_EMITTER_NAME = 'particleEmitter';
-
-function hasMeaningfulName(node: TransformNode): boolean {
-    return !!node.name && node.name !== DEFAULT_EMITTER_NAME;
-}
-
-function groupChildren(node: TransformNode): TransformNode[] {
-    return node.getChildren().filter((c): c is TransformNode => c instanceof TransformNode);
-}
-
-/** Reparents `only` onto `parent`, transferring the outgoing node's name if `only` doesn't
- * already have a meaningful one of its own, then disposes the now-empty wrapper. World
- * transform is preserved via `setParent`. */
-function collapseInto(wrapper: TransformNode, only: TransformNode, parent: Node | null): void {
-    if (!hasMeaningfulName(only) && hasMeaningfulName(wrapper)) {
-        only.name = wrapper.name;
-    }
-    only.setParent(parent);
-    wrapper.dispose(true, false);
-}
-
-/**
- * Collapses redundant organizational groups left over by importers — Unity's
- * one-GameObject-per-component convention turns every visual layer into its own Group, so a
- * single particle system becomes "Sparks" > unnamed emitter, and a component quarks doesn't
- * understand (e.g. a Light) becomes an empty Group with nothing under it. Recurses
- * bottom-up so nested wrapper chains collapse all the way down. The tree root itself is
- * handled separately by `promoteIfSingleChildRoot`, since collapsing it means returning a
- * different node as the effect's root.
- */
-function flattenRedundantGroups(node: TransformNode): void {
-    for (const child of node.getChildren()) {
-        if (child instanceof TransformNode) {
-            flattenRedundantGroups(child);
-        }
-    }
-    if (node instanceof ParticleEmitter || !node.parent) {
-        return;
-    }
-    const children = groupChildren(node);
-    if (children.length === 0) {
-        node.dispose(true, false);
-        return;
-    }
-    if (children.length !== 1) {
-        return;
-    }
-    const only = children[0];
-    if (only instanceof ParticleEmitter && only.getChildren().length > 0) {
-        return;
-    }
-    collapseInto(node, only, node.parent);
-}
-
-/** If the tree root itself only ever wraps a single child (after `flattenRedundantGroups`
- * has settled everything below it), that wrapper adds a tree level with nothing to organize —
- * promote the child to be the new root instead. Loops in case that child is, in turn, also a
- * single-child wrapper. */
-function promoteIfSingleChildRoot(root: TransformNode): TransformNode {
-    let current = root;
-    while (!(current instanceof ParticleEmitter)) {
-        const children = groupChildren(current);
-        if (children.length !== 1) {
-            break;
-        }
-        const only = children[0];
-        const parent = current.parent;
-        collapseInto(current, only, parent);
-        current = only;
-    }
-    return current;
-}
-
-/** Parses a Quarks JSON export, registers all systems with the renderer and starts playback. */
-export function loadEffectFromJson(
-    scene: Scene,
-    renderer: BatchedRenderer,
-    json: unknown,
-    baseUrl = ''
-): {root: TransformNode; systems: ParticleSystem[]} {
-    const loader = new QuarksLoader(scene, {baseUrl});
-    let root = loader.parse(json as never, baseUrl);
-    flattenRedundantGroups(root);
-    root = promoteIfSingleChildRoot(root);
-    const systems: ParticleSystem[] = [];
-    QuarksUtil.runOnAllParticleEmitters(root, (emitter: ParticleEmitter) => {
-        const system = emitter.system as ParticleSystem;
-        renderer.addSystem(system);
-        systems.push(system);
-    });
-    QuarksUtil.restart(root);
-    QuarksUtil.play(root);
-    return {root, systems};
-}
+import {ParticleEmitter, QuarksLoader, QuarksUtil} from 'babylon.quarks';
+import type {BatchedRenderer, ParticleSystem} from 'babylon.quarks';
+import type {Scene} from '@babylonjs/core/scene';
+import {TransformNode} from '@babylonjs/core/Meshes/transformNode';
+import type {Node} from '@babylonjs/core/node';
+
+/** `ParticleEmitter`'s constructor default (see babylon.quarks/src/ParticleEmitter.ts) — the
+ * name every emitter gets when the source JSON didn't give it one of its own. */
+const DEFAULT_EMITTER_NAME = 'particleEmitter';
+
+function hasMeaningfulName(node: TransformNode): boolean {
+    return !!node.name && node.name !== DEFAULT_EMITTER_NAME;
+}
+
+function groupChildren(node: TransformNode): TransformNode[] {
+    return node.getChildren().filter((c): c is TransformNode => c instanceof TransformNode);
+}
+
+/** Reparents `only` onto `parent`, transferring the outgoing node's name if `only` doesn't
+ * already have a meaningful one of its own, then disposes the now-empty wrapper. World
+ * transform is preserved via `setParent`. */
+function collapseInto(wrapper: TransformNode, only: TransformNode, parent: Node | null): void {
+    if (!hasMeaningfulName(only) && hasMeaningfulName(wrapper)) {
+        only.name = wrapper.name;
+    }
+    only.setParent(parent);
+    wrapper.dispose(true, false);
+}
+
+/**
+ * Collapses redundant organizational groups left over by importers — Unity's
+ * one-GameObject-per-component convention turns every visual layer into its own Group, so a
+ * single particle system becomes "Sparks" > unnamed emitter, and a component quarks doesn't
+ * understand (e.g. a Light) becomes an empty Group with nothing under it. Recurses
+ * bottom-up so nested wrapper chains collapse all the way down. The tree root itself is
+ * handled separately by `promoteIfSingleChildRoot`, since collapsing it means returning a
+ * different node as the effect's root.
+ */
+function flattenRedundantGroups(node: TransformNode): void {
+    for (const child of node.getChildren()) {
+        if (child instanceof TransformNode) {
+            flattenRedundantGroups(child);
+        }
+    }
+    if (node instanceof ParticleEmitter || !node.parent) {
+        return;
+    }
+    const children = groupChildren(node);
+    if (children.length === 0) {
+        node.dispose(true, false);
+        return;
+    }
+    if (children.length !== 1) {
+        return;
+    }
+    const only = children[0];
+    if (only instanceof ParticleEmitter && only.getChildren().length > 0) {
+        return;
+    }
+    collapseInto(node, only, node.parent);
+}
+
+/** If the tree root itself only ever wraps a single child (after `flattenRedundantGroups`
+ * has settled everything below it), that wrapper adds a tree level with nothing to organize —
+ * promote the child to be the new root instead. Loops in case that child is, in turn, also a
+ * single-child wrapper. */
+function promoteIfSingleChildRoot(root: TransformNode): TransformNode {
+    let current = root;
+    while (!(current instanceof ParticleEmitter)) {
+        const children = groupChildren(current);
+        if (children.length !== 1) {
+            break;
+        }
+        const only = children[0];
+        const parent = current.parent;
+        collapseInto(current, only, parent);
+        current = only;
+    }
+    return current;
+}
+
+/** Parses a Quarks JSON export, registers all systems with the renderer and starts playback. */
+export function loadEffectFromJson(
+    scene: Scene,
+    renderer: BatchedRenderer,
+    json: unknown,
+    baseUrl = ''
+): {root: TransformNode; systems: ParticleSystem[]} {
+    const loader = new QuarksLoader(scene, {baseUrl});
+    let root = loader.parse(json as never, baseUrl);
+    flattenRedundantGroups(root);
+    root = promoteIfSingleChildRoot(root);
+    const systems: ParticleSystem[] = [];
+    QuarksUtil.runOnAllParticleEmitters(root, (emitter: ParticleEmitter) => {
+        const system = emitter.system as ParticleSystem;
+        renderer.addSystem(system);
+        systems.push(system);
+    });
+    QuarksUtil.restart(root);
+    QuarksUtil.play(root);
+    return {root, systems};
+}

package/src/core/scrub.ts

@@ -1,28 +1,28 @@
-import type {BatchedRenderer} from 'babylon.quarks';
-import type {EffectBinding} from './binding';
-
-const WIDE_STEP_THRESHOLD = 8;
-
-/**
- * Approximate timeline scrub: replays every system from t=0 up to `time` using the existing
- * simulation loop. Not frame-exact (spawn/burst randomization is unseeded), but reuses
- * `EffectBinding.restart()` and `BatchedRenderer.update()` verbatim — no new engine primitive.
- *
- * `ParticleSystem.update()` clamps its own `delta` to 0.1s per call, so a single big step
- * can't reach `time` directly; must step through in small increments instead.
- */
-export function scrubTo(binding: EffectBinding, renderer: BatchedRenderer, time: number): void {
-    binding.restart();
-    if (time <= 0) {
-        return;
-    }
-    const fixedStep = time > WIDE_STEP_THRESHOLD ? 1 / 30 : 1 / 60;
-    const steps = Math.floor(time / fixedStep);
-    for (let i = 0; i < steps; i++) {
-        renderer.update(fixedStep);
-    }
-    const remainder = time - steps * fixedStep;
-    if (remainder > 0) {
-        renderer.update(remainder);
-    }
-}
+import type {BatchedRenderer} from 'babylon.quarks';
+import type {EffectBinding} from './binding';
+
+const WIDE_STEP_THRESHOLD = 8;
+
+/**
+ * Approximate timeline scrub: replays every system from t=0 up to `time` using the existing
+ * simulation loop. Not frame-exact (spawn/burst randomization is unseeded), but reuses
+ * `EffectBinding.restart()` and `BatchedRenderer.update()` verbatim — no new engine primitive.
+ *
+ * `ParticleSystem.update()` clamps its own `delta` to 0.1s per call, so a single big step
+ * can't reach `time` directly; must step through in small increments instead.
+ */
+export function scrubTo(binding: EffectBinding, renderer: BatchedRenderer, time: number): void {
+    binding.restart();
+    if (time <= 0) {
+        return;
+    }
+    const fixedStep = time > WIDE_STEP_THRESHOLD ? 1 / 30 : 1 / 60;
+    const steps = Math.floor(time / fixedStep);
+    for (let i = 0; i < steps; i++) {
+        renderer.update(fixedStep);
+    }
+    const remainder = time - steps * fixedStep;
+    if (remainder > 0) {
+        renderer.update(remainder);
+    }
+}

package/src/core/shapes.ts

@@ -1,133 +1,133 @@
-import {
-    CircleEmitter,
-    ConeEmitter,
-    DonutEmitter,
-    GridEmitter,
-    HemisphereEmitter,
-    MeshSurfaceEmitter,
-    PointEmitter,
-    RectangleEmitter,
-    SphereEmitter,
-} from 'babylon.quarks';
-import type {EmitterShape} from 'babylon.quarks';
-import {EmitterMode} from 'babylon.quarks';
-import type {Mesh} from '@babylonjs/core/Meshes/mesh';
-
-export type ShapeType = 'point' | 'sphere' | 'hemisphere' | 'cone' | 'circle' | 'donut' | 'rectangle' | 'grid' | 'mesh_surface';
-
-export const SHAPE_TYPES: Array<{value: ShapeType; label: string}> = [
-    {value: 'cone', label: 'Cone'},
-    {value: 'sphere', label: 'Sphere'},
-    {value: 'hemisphere', label: 'Hemisphere'},
-    {value: 'circle', label: 'Circle'},
-    {value: 'donut', label: 'Donut'},
-    {value: 'rectangle', label: 'Rectangle'},
-    {value: 'grid', label: 'Grid'},
-    {value: 'mesh_surface', label: 'Mesh surface'},
-    {value: 'point', label: 'Point'},
-];
-
-export interface ShapeParams {
-    radius: number;
-    arc: number;
-    thickness: number;
-    angle: number;
-    donutRadius: number;
-    width: number;
-    height: number;
-    mode: EmitterMode;
-    spread: number;
-    column: number;
-    row: number;
-    mesh?: Mesh;
-}
-
-export const DEFAULT_SHAPE_PARAMS: ShapeParams = {
-    radius: 0.3,
-    arc: Math.PI * 2,
-    thickness: 1,
-    angle: 0.5,
-    donutRadius: 0.1,
-    width: 1,
-    height: 1,
-    mode: EmitterMode.Random,
-    spread: 0,
-    column: 10,
-    row: 10,
-    mesh: undefined,
-};
-
-export function getShapeType(shape: EmitterShape): ShapeType {
-    const type = (shape as {type?: string}).type ?? 'point';
-    return (SHAPE_TYPES.some((s) => s.value === type) ? type : 'point') as ShapeType;
-}
-
-export function readShapeParams(shape: EmitterShape): ShapeParams {
-    const anyShape = shape as unknown as {[key: string]: unknown};
-    const num = (key: string, fallback: number) => (typeof anyShape[key] === 'number' ? (anyShape[key] as number) : fallback);
-    return {
-        radius: num('radius', DEFAULT_SHAPE_PARAMS.radius),
-        mode: num('mode', DEFAULT_SHAPE_PARAMS.mode) as EmitterMode,
-        spread: num('spread', DEFAULT_SHAPE_PARAMS.spread),
-        arc: num('arc', DEFAULT_SHAPE_PARAMS.arc),
-        thickness: num('thickness', DEFAULT_SHAPE_PARAMS.thickness),
-        angle: num('angle', DEFAULT_SHAPE_PARAMS.angle),
-        donutRadius: num('donutRadius', DEFAULT_SHAPE_PARAMS.donutRadius),
-        width: num('width', DEFAULT_SHAPE_PARAMS.width),
-        height: num('height', DEFAULT_SHAPE_PARAMS.height),
-        column: num('column', DEFAULT_SHAPE_PARAMS.column),
-        row: num('row', DEFAULT_SHAPE_PARAMS.row),
-        mesh: anyShape.mesh as Mesh | undefined,
-    };
-}
-
-/** Which parameters are relevant per shape type (drives the UI). `mesh_surface`'s mesh
- * reference isn't a NumberField, so it's handled separately by the Shape module. */
-export const SHAPE_PARAM_KEYS: {[K in ShapeType]: Array<keyof ShapeParams>} = {
-    point: [],
-    sphere: ['radius', 'arc', 'thickness'],
-    hemisphere: ['radius', 'arc', 'thickness'],
-    cone: ['radius', 'arc', 'thickness', 'angle'],
-    circle: ['radius', 'arc', 'thickness'],
-    donut: ['radius', 'arc', 'thickness', 'donutRadius'],
-    rectangle: ['width', 'height'],
-    grid: ['width', 'height', 'column', 'row'],
-    mesh_surface: [],
-};
-
-export function createShape(type: ShapeType, params: ShapeParams): EmitterShape {
-    switch (type) {
-        case 'point':
-            return new PointEmitter();
-        case 'sphere':
-            return new SphereEmitter({radius: params.radius, arc: params.arc, thickness: params.thickness, mode: params.mode, spread: params.spread});
-        case 'hemisphere':
-            return new HemisphereEmitter({radius: params.radius, arc: params.arc, thickness: params.thickness, mode: params.mode, spread: params.spread});
-        case 'cone':
-            return new ConeEmitter({
-                radius: params.radius,
-                arc: params.arc,
-                thickness: params.thickness,
-                angle: params.angle,
-                mode: params.mode,
-                spread: params.spread,
-            });
-        case 'circle':
-            return new CircleEmitter({radius: params.radius, arc: params.arc, thickness: params.thickness, mode: params.mode, spread: params.spread});
-        case 'donut':
-            return new DonutEmitter({
-                radius: params.radius,
-                arc: params.arc,
-                thickness: params.thickness,
-                donutRadius: params.donutRadius,
-                mode: params.mode,
-                spread: params.spread,
-            });
-        case 'rectangle':
-            return new RectangleEmitter({width: params.width, height: params.height, mode: params.mode, spread: params.spread});
-        case 'grid':
-            return new GridEmitter({width: params.width, height: params.height, column: params.column, row: params.row});
-        case 'mesh_surface':
-            return new MeshSurfaceEmitter(params.mesh);
-    }
-}
+import {
+    CircleEmitter,
+    ConeEmitter,
+    DonutEmitter,
+    GridEmitter,
+    HemisphereEmitter,
+    MeshSurfaceEmitter,
+    PointEmitter,
+    RectangleEmitter,
+    SphereEmitter,
+} from 'babylon.quarks';
+import type {EmitterShape} from 'babylon.quarks';
+import {EmitterMode} from 'babylon.quarks';
+import type {Mesh} from '@babylonjs/core/Meshes/mesh';
+
+export type ShapeType = 'point' | 'sphere' | 'hemisphere' | 'cone' | 'circle' | 'donut' | 'rectangle' | 'grid' | 'mesh_surface';
+
+export const SHAPE_TYPES: Array<{value: ShapeType; label: string}> = [
+    {value: 'cone', label: 'Cone'},
+    {value: 'sphere', label: 'Sphere'},
+    {value: 'hemisphere', label: 'Hemisphere'},
+    {value: 'circle', label: 'Circle'},
+    {value: 'donut', label: 'Donut'},
+    {value: 'rectangle', label: 'Rectangle'},
+    {value: 'grid', label: 'Grid'},
+    {value: 'mesh_surface', label: 'Mesh surface'},
+    {value: 'point', label: 'Point'},
+];
+
+export interface ShapeParams {
+    radius: number;
+    arc: number;
+    thickness: number;
+    angle: number;
+    donutRadius: number;
+    width: number;
+    height: number;
+    mode: EmitterMode;
+    spread: number;
+    column: number;
+    row: number;
+    mesh?: Mesh;
+}
+
+export const DEFAULT_SHAPE_PARAMS: ShapeParams = {
+    radius: 0.3,
+    arc: Math.PI * 2,
+    thickness: 1,
+    angle: 0.5,
+    donutRadius: 0.1,
+    width: 1,
+    height: 1,
+    mode: EmitterMode.Random,
+    spread: 0,
+    column: 10,
+    row: 10,
+    mesh: undefined,
+};
+
+export function getShapeType(shape: EmitterShape): ShapeType {
+    const type = (shape as {type?: string}).type ?? 'point';
+    return (SHAPE_TYPES.some((s) => s.value === type) ? type : 'point') as ShapeType;
+}
+
+export function readShapeParams(shape: EmitterShape): ShapeParams {
+    const anyShape = shape as unknown as {[key: string]: unknown};
+    const num = (key: string, fallback: number) => (typeof anyShape[key] === 'number' ? (anyShape[key] as number) : fallback);
+    return {
+        radius: num('radius', DEFAULT_SHAPE_PARAMS.radius),
+        mode: num('mode', DEFAULT_SHAPE_PARAMS.mode) as EmitterMode,
+        spread: num('spread', DEFAULT_SHAPE_PARAMS.spread),
+        arc: num('arc', DEFAULT_SHAPE_PARAMS.arc),
+        thickness: num('thickness', DEFAULT_SHAPE_PARAMS.thickness),
+        angle: num('angle', DEFAULT_SHAPE_PARAMS.angle),
+        donutRadius: num('donutRadius', DEFAULT_SHAPE_PARAMS.donutRadius),
+        width: num('width', DEFAULT_SHAPE_PARAMS.width),
+        height: num('height', DEFAULT_SHAPE_PARAMS.height),
+        column: num('column', DEFAULT_SHAPE_PARAMS.column),
+        row: num('row', DEFAULT_SHAPE_PARAMS.row),
+        mesh: anyShape.mesh as Mesh | undefined,
+    };
+}
+
+/** Which parameters are relevant per shape type (drives the UI). `mesh_surface`'s mesh
+ * reference isn't a NumberField, so it's handled separately by the Shape module. */
+export const SHAPE_PARAM_KEYS: {[K in ShapeType]: Array<keyof ShapeParams>} = {
+    point: [],
+    sphere: ['radius', 'arc', 'thickness'],
+    hemisphere: ['radius', 'arc', 'thickness'],
+    cone: ['radius', 'arc', 'thickness', 'angle'],
+    circle: ['radius', 'arc', 'thickness'],
+    donut: ['radius', 'arc', 'thickness', 'donutRadius'],
+    rectangle: ['width', 'height'],
+    grid: ['width', 'height', 'column', 'row'],
+    mesh_surface: [],
+};
+
+export function createShape(type: ShapeType, params: ShapeParams): EmitterShape {
+    switch (type) {
+        case 'point':
+            return new PointEmitter();
+        case 'sphere':
+            return new SphereEmitter({radius: params.radius, arc: params.arc, thickness: params.thickness, mode: params.mode, spread: params.spread});
+        case 'hemisphere':
+            return new HemisphereEmitter({radius: params.radius, arc: params.arc, thickness: params.thickness, mode: params.mode, spread: params.spread});
+        case 'cone':
+            return new ConeEmitter({
+                radius: params.radius,
+                arc: params.arc,
+                thickness: params.thickness,
+                angle: params.angle,
+                mode: params.mode,
+                spread: params.spread,
+            });
+        case 'circle':
+            return new CircleEmitter({radius: params.radius, arc: params.arc, thickness: params.thickness, mode: params.mode, spread: params.spread});
+        case 'donut':
+            return new DonutEmitter({
+                radius: params.radius,
+                arc: params.arc,
+                thickness: params.thickness,
+                donutRadius: params.donutRadius,
+                mode: params.mode,
+                spread: params.spread,
+            });
+        case 'rectangle':
+            return new RectangleEmitter({width: params.width, height: params.height, mode: params.mode, spread: params.spread});
+        case 'grid':
+            return new GridEmitter({width: params.width, height: params.height, column: params.column, row: params.row});
+        case 'mesh_surface':
+            return new MeshSurfaceEmitter(params.mesh);
+    }
+}