babylon.quarks-editor 0.17.7 → 0.17.8

package/package.json

@@ -1,63 +1,68 @@
-{
-  "name": "babylon.quarks-editor",
-  "version": "0.17.7",
-  "description": "Shuriken-style effect editor for babylon.quarks: headless edit-model core + React module-stack UI",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    },
-    "./react": {
-      "import": "./dist/react/index.js",
-      "types": "./dist/react/index.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "src",
-    "LICENSE",
-    "README.md",
-    "CHANGELOG.md"
-  ],
-  "scripts": {
-    "clean": "rimraf dist",
-    "build": "npm run clean && tsc -p tsconfig.json"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Soullnik/babylon.quarks-standalone.git"
-  },
-  "keywords": [
-    "babylonjs",
-    "particles",
-    "vfx",
-    "editor",
-    "react",
-    "quarks"
-  ],
-  "author": "soullnik <soullnik96@gmail.com>",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/Soullnik/babylon.quarks-standalone/issues"
-  },
-  "homepage": "https://github.com/Soullnik/babylon.quarks-standalone#readme",
-  "peerDependencies": {
-    "@babylonjs/core": ">=9.0.0",
-    "@babylonjs/materials": ">=9.0.0",
-    "babylon.quarks": ">=0.17.0",
-    "react": ">=18",
-    "react-dom": ">=18"
-  },
-  "devDependencies": {
-    "@babylonjs/materials": "9.6.2",
-    "@types/react": "^19.0.0",
-    "react": "^19.0.0",
-    "rimraf": "^6.0.0",
-    "typescript": "^5.9.3",
-    "react-dom": "^19.0.0",
-    "@types/react-dom": "^19.0.0"
-  }
-}
+{
+  "name": "babylon.quarks-editor",
+  "version": "0.17.8",
+  "description": "Shuriken-style effect editor for babylon.quarks: headless edit-model core + React module-stack UI",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./react": {
+      "import": "./dist/react/index.js",
+      "types": "./dist/react/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "npm run clean && tsc -p tsconfig.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Soullnik/babylon.quarks-standalone.git"
+  },
+  "keywords": [
+    "babylonjs",
+    "babylon.js",
+    "particles",
+    "particle-system",
+    "particle-editor",
+    "vfx",
+    "vfx-editor",
+    "shuriken",
+    "editor",
+    "react",
+    "quarks"
+  ],
+  "author": "soullnik <soullnik96@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Soullnik/babylon.quarks-standalone/issues"
+  },
+  "homepage": "https://github.com/Soullnik/babylon.quarks-standalone#readme",
+  "peerDependencies": {
+    "@babylonjs/core": ">=9.0.0",
+    "@babylonjs/materials": ">=9.0.0",
+    "babylon.quarks": ">=0.17.0",
+    "react": ">=18",
+    "react-dom": ">=18"
+  },
+  "devDependencies": {
+    "@babylonjs/materials": "9.6.2",
+    "@types/react": "^19.0.0",
+    "react": "^19.0.0",
+    "rimraf": "^6.0.0",
+    "typescript": "^5.9.3",
+    "react-dom": "^19.0.0",
+    "@types/react-dom": "^19.0.0"
+  }
+}

package/src/core/binding.ts

@@ -1,105 +1,105 @@
-import type {ParticleSystem} from 'babylon.quarks';
-import type {TransformNode} from '@babylonjs/core/Meshes/transformNode';
-import {buildEffectTree, serializeEffectTree} from './effectTree';
-import type {EffectTreeNode} from './effectTree';
-
-export type EditorListener = () => void;
-
-/**
- * Headless edit-model over a live ParticleSystem: mutate through apply() so every
- * change notifies subscribers (React UI, save indicators, hosts like BabylonJS Editor).
- */
-export class EffectBinding {
-    /** Not `readonly` — `promoteToMain` reassigns this when the current main system is removed. */
-    system: ParticleSystem;
-    /** Systems spawned by sub-emitter behaviors; serialized as children of the root emitter. */
-    readonly subSystems: ParticleSystem[] = [];
-    /** Loaded scene root of the whole effect (Group tree); defaults to the system's emitter. */
-    readonly root: TransformNode;
-    /** Invoked before any mutation — used by EffectHistory to capture undo snapshots. */
-    onBeforeChange?: () => void;
-    private listeners = new Set<EditorListener>();
-    private revision = 0;
-
-    constructor(system: ParticleSystem, subSystems: ParticleSystem[] = [], root?: TransformNode) {
-        this.system = system;
-        this.subSystems.push(...subSystems);
-        this.root = root ?? system.emitter;
-    }
-
-    /** Editor hierarchy tree (groups + emitters) rooted at this effect's scene root. */
-    getTree(): EffectTreeNode {
-        return buildEffectTree(this.root);
-    }
-
-    subscribe(listener: EditorListener): () => void {
-        this.listeners.add(listener);
-        return () => this.listeners.delete(listener);
-    }
-
-    /** Monotonic change counter, usable as a React external-store snapshot. */
-    getRevision(): number {
-        return this.revision;
-    }
-
-    apply(mutate: (system: ParticleSystem) => void): void {
-        this.onBeforeChange?.();
-        mutate(this.system);
-        this.notify();
-    }
-
-    addSubSystem(sub: ParticleSystem): void {
-        this.subSystems.push(sub);
-        this.notify();
-    }
-
-    removeSubSystem(sub: ParticleSystem): void {
-        const index = this.subSystems.indexOf(sub);
-        if (index >= 0) {
-            this.subSystems.splice(index, 1);
-        }
-        this.notify();
-    }
-
-    /**
-     * Swaps which system is "main" — used when the current `system` is about to be removed
-     * but other top-level systems remain. Being "main" vs. a sub-system is otherwise
-     * meaningless to the effect itself (both play/restart/export the same way); it only
-     * exists so there's always a designated fallback system to select.
-     */
-    promoteToMain(next: ParticleSystem): void {
-        const index = this.subSystems.indexOf(next);
-        if (index < 0) {
-            return;
-        }
-        this.subSystems.splice(index, 1, this.system);
-        this.system = next;
-        this.notify();
-    }
-
-    private notify(): void {
-        this.revision++;
-        for (const listener of this.listeners) {
-            listener();
-        }
-    }
-
-    restart(): void {
-        // Replay every independent system; sub-emitter targets (onlyUsedByOther) are only
-        // reset — their parents re-drive them, so playing them directly would double-emit.
-        for (const system of [this.system, ...this.subSystems]) {
-            system.restart();
-            if (!system.onlyUsedByOther) {
-                system.play();
-            }
-        }
-    }
-
-    /**
-     * Serializes the effect into the Quarks JSON envelope understood by QuarksLoader,
-     * preserving the loaded group/emitter hierarchy.
-     */
-    exportJSON(name = 'effect'): string {
-        return serializeEffectTree(this.root, name);
-    }
-}
+import type {ParticleSystem} from 'babylon.quarks';
+import type {TransformNode} from '@babylonjs/core/Meshes/transformNode';
+import {buildEffectTree, serializeEffectTree} from './effectTree';
+import type {EffectTreeNode} from './effectTree';
+
+export type EditorListener = () => void;
+
+/**
+ * Headless edit-model over a live ParticleSystem: mutate through apply() so every
+ * change notifies subscribers (React UI, save indicators, hosts like BabylonJS Editor).
+ */
+export class EffectBinding {
+    /** Not `readonly` — `promoteToMain` reassigns this when the current main system is removed. */
+    system: ParticleSystem;
+    /** Systems spawned by sub-emitter behaviors; serialized as children of the root emitter. */
+    readonly subSystems: ParticleSystem[] = [];
+    /** Loaded scene root of the whole effect (Group tree); defaults to the system's emitter. */
+    readonly root: TransformNode;
+    /** Invoked before any mutation — used by EffectHistory to capture undo snapshots. */
+    onBeforeChange?: () => void;
+    private listeners = new Set<EditorListener>();
+    private revision = 0;
+
+    constructor(system: ParticleSystem, subSystems: ParticleSystem[] = [], root?: TransformNode) {
+        this.system = system;
+        this.subSystems.push(...subSystems);
+        this.root = root ?? system.emitter;
+    }
+
+    /** Editor hierarchy tree (groups + emitters) rooted at this effect's scene root. */
+    getTree(): EffectTreeNode {
+        return buildEffectTree(this.root);
+    }
+
+    subscribe(listener: EditorListener): () => void {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+
+    /** Monotonic change counter, usable as a React external-store snapshot. */
+    getRevision(): number {
+        return this.revision;
+    }
+
+    apply(mutate: (system: ParticleSystem) => void): void {
+        this.onBeforeChange?.();
+        mutate(this.system);
+        this.notify();
+    }
+
+    addSubSystem(sub: ParticleSystem): void {
+        this.subSystems.push(sub);
+        this.notify();
+    }
+
+    removeSubSystem(sub: ParticleSystem): void {
+        const index = this.subSystems.indexOf(sub);
+        if (index >= 0) {
+            this.subSystems.splice(index, 1);
+        }
+        this.notify();
+    }
+
+    /**
+     * Swaps which system is "main" — used when the current `system` is about to be removed
+     * but other top-level systems remain. Being "main" vs. a sub-system is otherwise
+     * meaningless to the effect itself (both play/restart/export the same way); it only
+     * exists so there's always a designated fallback system to select.
+     */
+    promoteToMain(next: ParticleSystem): void {
+        const index = this.subSystems.indexOf(next);
+        if (index < 0) {
+            return;
+        }
+        this.subSystems.splice(index, 1, this.system);
+        this.system = next;
+        this.notify();
+    }
+
+    private notify(): void {
+        this.revision++;
+        for (const listener of this.listeners) {
+            listener();
+        }
+    }
+
+    restart(): void {
+        // Replay every independent system; sub-emitter targets (onlyUsedByOther) are only
+        // reset — their parents re-drive them, so playing them directly would double-emit.
+        for (const system of [this.system, ...this.subSystems]) {
+            system.restart();
+            if (!system.onlyUsedByOther) {
+                system.play();
+            }
+        }
+    }
+
+    /**
+     * Serializes the effect into the Quarks JSON envelope understood by QuarksLoader,
+     * preserving the loaded group/emitter hierarchy.
+     */
+    exportJSON(name = 'effect'): string {
+        return serializeEffectTree(this.root, name);
+    }
+}

package/src/core/collision.ts

@@ -1,40 +1,40 @@
-import {Vector3, getPhysicsResolver, setPhysicsResolver} from 'babylon.quarks';
-
-/**
- * A horizontal ground plane collider. quarks.core's ApplyCollision behavior delegates to a
- * host-provided `PhysicsResolver` (a global singleton) and ships no collider primitive of its
- * own, so the editor supplies this — the common "particles bounce off the floor" case.
- *
- * `resolve` returns true and fills the surface normal when the point is at or below the plane,
- * which is exactly what ApplyCollision.update reflects the velocity against.
- */
-export class GroundPlaneResolver {
-    constructor(public y = 0) {}
-
-    resolve(position: Vector3, normal: Vector3): boolean {
-        if (position.y <= this.y) {
-            normal.set(0, 1, 0);
-            return true;
-        }
-        return false;
-    }
-}
-
-/**
- * Registers (once) a shared ground-plane resolver so ApplyCollision behaviors — whether added
- * in the inspector or deserialized from imported JSON — have something to collide against.
- * Idempotent: an already-registered resolver is left untouched and returned.
- */
-export function ensureGroundResolver(): GroundPlaneResolver {
-    const existing = getPhysicsResolver();
-    if (existing instanceof GroundPlaneResolver) {
-        return existing;
-    }
-    if (existing) {
-        // A host registered its own resolver; don't clobber it, but we can't tweak its floor.
-        return existing as GroundPlaneResolver;
-    }
-    const resolver = new GroundPlaneResolver(0);
-    setPhysicsResolver(resolver);
-    return resolver;
-}
+import {Vector3, getPhysicsResolver, setPhysicsResolver} from 'babylon.quarks';
+
+/**
+ * A horizontal ground plane collider. quarks.core's ApplyCollision behavior delegates to a
+ * host-provided `PhysicsResolver` (a global singleton) and ships no collider primitive of its
+ * own, so the editor supplies this — the common "particles bounce off the floor" case.
+ *
+ * `resolve` returns true and fills the surface normal when the point is at or below the plane,
+ * which is exactly what ApplyCollision.update reflects the velocity against.
+ */
+export class GroundPlaneResolver {
+    constructor(public y = 0) {}
+
+    resolve(position: Vector3, normal: Vector3): boolean {
+        if (position.y <= this.y) {
+            normal.set(0, 1, 0);
+            return true;
+        }
+        return false;
+    }
+}
+
+/**
+ * Registers (once) a shared ground-plane resolver so ApplyCollision behaviors — whether added
+ * in the inspector or deserialized from imported JSON — have something to collide against.
+ * Idempotent: an already-registered resolver is left untouched and returned.
+ */
+export function ensureGroundResolver(): GroundPlaneResolver {
+    const existing = getPhysicsResolver();
+    if (existing instanceof GroundPlaneResolver) {
+        return existing;
+    }
+    if (existing) {
+        // A host registered its own resolver; don't clobber it, but we can't tweak its floor.
+        return existing as GroundPlaneResolver;
+    }
+    const resolver = new GroundPlaneResolver(0);
+    setPhysicsResolver(resolver);
+    return resolver;
+}

package/src/core/groups.ts

@@ -1,29 +1,29 @@
-import {TransformNode} from '@babylonjs/core/Meshes/transformNode';
-
-/**
- * Groups the given nodes under a new organizational TransformNode. Each node's world
- * transform is preserved via `setParent` — grouping never moves anything visually, it only
- * changes the hierarchy so the group can be repositioned/organized as one unit afterwards.
- */
-export function groupNodes(nodes: TransformNode[], name = 'Group'): TransformNode {
-    const scene = nodes[0].getScene();
-    const group = new TransformNode(name, scene);
-    group.setParent(nodes[0].parent);
-    for (const node of nodes) {
-        node.setParent(group);
-    }
-    return group;
-}
-
-/**
- * Dissolves a group, reparenting its children onto the group's own parent and disposing the
- * (now childless) group node. World transform of each child is preserved.
- */
-export function ungroupNode(group: TransformNode): void {
-    const parent = group.parent;
-    const children = group.getChildren().filter((c): c is TransformNode => c instanceof TransformNode);
-    for (const child of children) {
-        child.setParent(parent);
-    }
-    group.dispose(true, false);
-}
+import {TransformNode} from '@babylonjs/core/Meshes/transformNode';
+
+/**
+ * Groups the given nodes under a new organizational TransformNode. Each node's world
+ * transform is preserved via `setParent` — grouping never moves anything visually, it only
+ * changes the hierarchy so the group can be repositioned/organized as one unit afterwards.
+ */
+export function groupNodes(nodes: TransformNode[], name = 'Group'): TransformNode {
+    const scene = nodes[0].getScene();
+    const group = new TransformNode(name, scene);
+    group.setParent(nodes[0].parent);
+    for (const node of nodes) {
+        node.setParent(group);
+    }
+    return group;
+}
+
+/**
+ * Dissolves a group, reparenting its children onto the group's own parent and disposing the
+ * (now childless) group node. World transform of each child is preserved.
+ */
+export function ungroupNode(group: TransformNode): void {
+    const parent = group.parent;
+    const children = group.getChildren().filter((c): c is TransformNode => c instanceof TransformNode);
+    for (const child of children) {
+        child.setParent(parent);
+    }
+    group.dispose(true, false);
+}