@woosh/meep-engine 3.58.0 → 3.60.0

package/editor/view/particles/effect/ParticleEmitterInspectorView.js

@@ -12,8 +12,9 @@ import View from "../../../../src/view/View.js";
 
 /**
  * Everything about an effect that is not its simulation: how fast it emits, how its particles are
- * blended and oriented, which per-particle attribute drives which render channel, and the attribute
- * schema those channels can name.
+ * blended and oriented, which particle field drives which render channel, the particle field
+ * schema those channels can name, and the emitter and global fields the effect declares, with
+ * their starting and preview values.
  *
  * There is nothing here for bounds. An emitter has none to declare — the box the culling and
  * occupancy passes use is measured from the live particles on the GPU — so the one bounds-related
@@ -23,17 +24,17 @@ import View from "../../../../src/view/View.js";
  * nothing visible until something says that `position` is what the renderer should place the quad
  * at — so it is a third panel over the same document rather than a section of either.
  *
- * ## Why the attribute schema is here
+ * ## Why the particle field schema is here
  *
- * The layout is the contract between the simulation and the renderer: the VM addresses attributes by
- * the word offsets it assigns, and the emitter record stores those same offsets for the render
- * channels. Editing it is editing that contract, which is why adding one is guarded by
- * {@link ParticleEffectDocument#addAttribute} rather than done by hand, and why removing one unbinds
- * the channels that named it.
+ * The layout is the contract between the simulation and the renderer: the VM addresses particle
+ * fields by the word offsets it assigns, and the emitter record stores those same offsets for the
+ * render channels. Editing it is editing that contract, which is why adding one is guarded by
+ * {@link ParticleEffectDocument#addParticleField} rather than done by hand, and why removing one
+ * unbinds the channels that named it.
  */
 
 /**
- * Emitter fields that are a plain number, and the range a control should hold them to.
+ * Emitter settings that are a plain number, and the range a control should hold them to.
  * @type {Array<{key: string, label: string, min: number, step: number, help: string}>}
  */
 const NUMERIC_FIELDS = [
@@ -80,7 +81,7 @@ export class ParticleEmitterInspectorView extends View {
     /**
      * @type {EmptyView}
      */
-    #attributes;
+    #particle_fields;
 
     /**
      * @type {EmptyView}
@@ -88,11 +89,11 @@ export class ParticleEmitterInspectorView extends View {
     #channels;
 
     /**
-     * The rows listing the attributes. Separate from the section around it so the "add" row below
-     * survives a rebuild with whatever is typed into it.
+     * The rows listing the particle fields. Separate from the section around it so the "add" row
+     * below survives a rebuild with whatever is typed into it.
      * @type {EmptyView}
      */
-    #attribute_rows;
+    #particle_field_rows;
 
     /**
      * The row each render channel picker sits in, by channel name. Held so a mis-sized binding can
@@ -109,16 +110,41 @@ export class ParticleEmitterInspectorView extends View {
     #channel_selects = new Map();
 
     /**
-     * The attribute schema the option lists were last built from.
+     * The particle field schema the option lists were last built from.
      *
-     * Only the attributes decide the *shape* of the channel pickers and the attribute list, and a
-     * change to the effect is far more often something else - a spawn rate, a node parameter. So
-     * they are rebuilt when this changes and left alone otherwise, which is also what keeps a
-     * half-typed attribute name from being swept away by an unrelated edit.
+     * Only the particle fields decide the *shape* of the channel pickers and the particle field
+     * list, and a change to the effect is far more often something else - a spawn rate, a node
+     * parameter. So they are rebuilt when this changes and left alone otherwise, which is also what
+     * keeps a half-typed particle field name from being swept away by an unrelated edit.
      *
      * @type {string}
      */
-    #attributes_signature = "";
+    #particle_fields_signature = "";
+
+    /**
+     * The rows listing the emitter fields, with the value each emitter of the effect starts from.
+     * @type {EmptyView}
+     */
+    #emitter_field_rows;
+
+    /**
+     * The emitter field declarations, values included, the rows were last built from. A value is
+     * committed on `change`, so a rebuild after one never lands under an author's typing.
+     * @type {string}
+     */
+    #emitter_fields_signature = "";
+
+    /**
+     * The rows listing the global fields the effect imports, with the value the preview gives each.
+     * @type {EmptyView}
+     */
+    #global_field_rows;
+
+    /**
+     * The global field imports, values included, the rows were last built from.
+     * @type {string}
+     */
+    #global_fields_signature = "";
 
     /**
      * @param {object} options
@@ -146,14 +172,46 @@ export class ParticleEmitterInspectorView extends View {
 
         this.#buildChannelRows();
 
-        this.#attributes = new EmptyView({ classList: ['section', 'attributes'] });
-        this.#attributes.addChild(new LabelView("attributes", { classList: ['heading'] }));
-        this.addChild(this.#attributes);
+        this.#particle_fields = new EmptyView({ classList: ['section', 'particle-fields'] });
+        this.#particle_fields.addChild(new LabelView("particle fields", { classList: ['heading'] }));
+        this.addChild(this.#particle_fields);
+
+        this.#particle_field_rows = new EmptyView({ classList: ['particle-field-rows'] });
 
-        this.#attribute_rows = new EmptyView({ classList: ['attribute-rows'] });
+        this.#particle_fields.addChild(this.#particle_field_rows);
+        this.#particle_fields.addChild(this.#buildFieldAdder(
+            'add-particle-field',
+            'new particle field',
+            (name, components) => this.effect.addParticleField(name, components)
+        ));
 
-        this.#attributes.addChild(this.#attribute_rows);
-        this.#attributes.addChild(this.#buildAttributeAdder());
+        const emitter_fields = new EmptyView({ classList: ['section', 'emitter-fields'] });
+
+        emitter_fields.addChild(new LabelView("emitter fields", { classList: ['heading'] }));
+        this.addChild(emitter_fields);
+
+        this.#emitter_field_rows = new EmptyView({ classList: ['particle-field-rows'] });
+
+        emitter_fields.addChild(this.#emitter_field_rows);
+        emitter_fields.addChild(this.#buildFieldAdder(
+            'add-emitter-field',
+            'new emitter field',
+            (name, components) => this.effect.addEmitterField(name, components)
+        ));
+
+        const global_fields = new EmptyView({ classList: ['section', 'global-fields'] });
+
+        global_fields.addChild(new LabelView("global fields", { classList: ['heading'] }));
+        this.addChild(global_fields);
+
+        this.#global_field_rows = new EmptyView({ classList: ['particle-field-rows'] });
+
+        global_fields.addChild(this.#global_field_rows);
+        global_fields.addChild(this.#buildFieldAdder(
+            'add-global-field',
+            'imported global field',
+            (name, components) => this.effect.addGlobalField(name, components)
+        ));
 
         this.bindSignal(effect.on.changed, this.refresh, this);
         this.on.linked.add(this.refresh, this);
@@ -164,27 +222,120 @@ export class ParticleEmitterInspectorView extends View {
     /**
      * Re-read everything from the document.
      *
-     * Values are pushed into every control; the option lists and the attribute rows are rebuilt only
-     * when the attributes themselves changed, because that is the only thing their shape follows and
-     * rebuilding them on every edit would sweep away whatever an author was in the middle of.
+     * Values are pushed into every control; the option lists and the field rows are rebuilt only
+     * when the declarations they show changed, because that is the only thing their shape follows
+     * and rebuilding them on every edit would sweep away whatever an author was in the middle of.
      */
     refresh() {
         for (const reader of this.#readers) {
             reader();
         }
 
-        const signature = this.effect.attributes
-            .map(attribute => `${attribute.name}:${attribute.components}`)
+        const signature = this.effect.particle_fields
+            .map(particle_field => `${particle_field.name}:${particle_field.components}`)
             .join(",");
 
-        if (signature !== this.#attributes_signature) {
-            this.#attributes_signature = signature;
+        if (signature !== this.#particle_fields_signature) {
+            this.#particle_fields_signature = signature;
 
             this.#writeChannelOptions();
-            this.#buildAttributes();
+            this.#buildParticleFields();
         }
 
         this.#writeChannelValues();
+
+        const emitter_signature = JSON.stringify(this.effect.emitter_fields);
+
+        if (emitter_signature !== this.#emitter_fields_signature) {
+            this.#emitter_fields_signature = emitter_signature;
+
+            this.#buildDeclaredFields(this.#emitter_field_rows, 'emitter-field', this.effect.emitter_fields, {
+                layout: () => this.effect.buildEmitterLayout(),
+                set_value: (name, value) => this.effect.setEmitterFieldValue(name, value),
+                remove: name => this.effect.removeEmitterField(name),
+            });
+        }
+
+        const global_signature = JSON.stringify(this.effect.global_fields);
+
+        if (global_signature !== this.#global_fields_signature) {
+            this.#global_fields_signature = global_signature;
+
+            this.#buildDeclaredFields(this.#global_field_rows, 'global-field', this.effect.global_fields, {
+                layout: () => this.effect.buildGlobalLayout(),
+                set_value: (name, value) => this.effect.setGlobalFieldValue(name, value),
+                remove: name => this.effect.removeGlobalField(name),
+            });
+        }
+    }
+
+    /**
+     * Declared fields with a value each — emitter fields with the value an emitter starts from,
+     * global fields with the value the preview gives them — one number per component, and the word
+     * each occupies in its layout.
+     *
+     * @param {EmptyView} rows
+     * @param {string} row_class
+     * @param {Array<{name: string, components: number, value: number[]}>} declarations
+     * @param {{layout: function():(import("../../../../src/shade/renderer/particles/layout/ParticleLayout.js").ParticleLayout|null), set_value: function(string, number[]):void, remove: function(string):void}} edits
+     */
+    #buildDeclaredFields(rows, row_class, declarations, edits) {
+        rows.removeAllChildren();
+
+        let layout = null;
+
+        try {
+            layout = edits.layout();
+        } catch (e) {
+            rows.addChild(new LabelView(e.message, { classList: ['problem', 'error'] }));
+        }
+
+        for (const declaration of declarations) {
+            const entry = new EmptyView({ classList: ['particle-field', row_class] });
+
+            const offset = layout === null || !layout.has(declaration.name)
+                ? "?"
+                : String(layout.offsetOf(declaration.name));
+
+            entry.addChild(new LabelView(declaration.name, { classList: ['name'] }));
+            entry.addChild(new LabelView(`w${offset} · ${declaration.components}c`, { classList: ['where'] }));
+
+            for (let i = 0; i < declaration.components; i++) {
+                const input = document.createElement('input');
+
+                input.setAttribute('type', 'number');
+                input.setAttribute('step', 'any');
+                input.classList.add('lane');
+                input.value = String(declaration.value[i] ?? 0);
+
+                input.addEventListener('change', () => {
+                    const parsed = Number.parseFloat(input.value);
+
+                    if (!Number.isFinite(parsed)) {
+                        input.value = String(declaration.value[i] ?? 0);
+                        return;
+                    }
+
+                    const value = Array.from({ length: declaration.components }, (_, lane) => declaration.value[lane] ?? 0);
+
+                    value[i] = parsed;
+
+                    edits.set_value(declaration.name, value);
+                });
+
+                entry.addChild(new EmptyView({ el: input }));
+            }
+
+            const remove = new EmptyView({ classList: ['remove'] });
+
+            remove.addChild(new LabelView("✕"));
+            remove.el.setAttribute('title', `Remove '${declaration.name}'`);
+            remove.el.addEventListener('click', () => edits.remove(declaration.name));
+
+            entry.addChild(remove);
+
+            rows.addChild(entry);
+        }
     }
 
     /**
@@ -271,7 +422,7 @@ export class ParticleEmitterInspectorView extends View {
     }
 
     /**
-     * Re-read the options every picker offers from the effect's attributes.
+     * Re-read the options every picker offers from the effect's particle fields.
      */
     #writeChannelOptions() {
         for (const select of this.#channel_selects.values()) {
@@ -282,11 +433,11 @@ export class ParticleEmitterInspectorView extends View {
 
             const options = [none];
 
-            for (const attribute of this.effect.attributes) {
+            for (const particle_field of this.effect.particle_fields) {
                 const option = document.createElement('option');
 
-                option.value = attribute.name;
-                option.textContent = `${attribute.name} (${attribute.components})`;
+                option.value = particle_field.name;
+                option.textContent = `${particle_field.name} (${particle_field.components})`;
 
                 options.push(option);
             }
@@ -296,43 +447,43 @@ export class ParticleEmitterInspectorView extends View {
     }
 
     /**
-     * Point every picker at what the emitter binds now. A binding naming an attribute that is gone
-     * reads as unbound, which is what the record would carry.
+     * Point every picker at what the emitter binds now. A binding naming a particle field that is
+     * gone reads as unbound, which is what the record would carry.
      */
     #writeChannelValues() {
         for (const [channel, select] of this.#channel_selects) {
             const bound = this.effect.emitter.render[channel];
-            const attribute = this.effect.attributes.find(candidate => candidate.name === bound);
+            const particle_field = this.effect.particle_fields.find(candidate => candidate.name === bound);
 
-            select.value = attribute === undefined ? "" : bound;
+            select.value = particle_field === undefined ? "" : bound;
 
-            this.#markChannelWidth(channel, attribute);
+            this.#markChannelWidth(channel, particle_field);
         }
     }
 
     /**
-     * Mark a channel whose attribute is narrower than the render pass reads.
+     * Mark a channel whose particle field is narrower than the render pass reads.
      *
      * The read is a fixed width — see {@link EMITTER_RENDER_CHANNEL_COMPONENTS} — so a narrow
-     * attribute is not a smaller read, it is a read into whatever the layout packed next. Nothing
-     * downstream objects to it, which is exactly why it is worth saying here.
+     * particle field is not a smaller read, it is a read into whatever the layout packed next.
+     * Nothing downstream objects to it, which is exactly why it is worth saying here.
      *
      * @param {string} channel
-     * @param {{name: string, components: number}|undefined} attribute
+     * @param {{name: string, components: number}|undefined} particle_field
      */
-    #markChannelWidth(channel, attribute) {
+    #markChannelWidth(channel, particle_field) {
         const channel_row = this.#channel_rows.get(channel);
         const wanted = EMITTER_RENDER_CHANNEL_COMPONENTS[channel];
 
-        const mismatched = attribute !== undefined && attribute.components < wanted;
+        const mismatched = particle_field !== undefined && particle_field.components < wanted;
 
         channel_row.setClass('mismatched', mismatched);
 
         if (mismatched) {
             channel_row.el.setAttribute(
                 'title',
-                `The render pass reads ${wanted} words for '${channel}', and '${attribute.name}' is `
-                + `${attribute.components}. The rest comes from whatever the layout packed after it.`
+                `The render pass reads ${wanted} words for '${channel}', and '${particle_field.name}' is `
+                + `${particle_field.components}. The rest comes from whatever the layout packed after it.`
             );
         } else {
             channel_row.el.removeAttribute('title');
@@ -340,51 +491,57 @@ export class ParticleEmitterInspectorView extends View {
     }
 
     /**
-     * The per-particle attribute schema, with the word each occupies — which is what the VM
+     * The particle field schema, with the word each occupies — which is what the VM
      * addresses and what the emitter record stores for a render channel.
      */
-    #buildAttributes() {
-        this.#attribute_rows.removeAllChildren();
+    #buildParticleFields() {
+        this.#particle_field_rows.removeAllChildren();
 
         let layout = null;
 
         try {
             layout = this.effect.buildLayout();
         } catch (e) {
-            this.#attribute_rows.addChild(new LabelView(e.message, { classList: ['problem', 'error'] }));
+            this.#particle_field_rows.addChild(new LabelView(e.message, { classList: ['problem', 'error'] }));
         }
 
-        for (const attribute of this.effect.attributes) {
-            const entry = new EmptyView({ classList: ['attribute'] });
+        for (const particle_field of this.effect.particle_fields) {
+            const entry = new EmptyView({ classList: ['particle-field'] });
 
-            const offset = layout === null || !layout.has(attribute.name)
+            const offset = layout === null || !layout.has(particle_field.name)
                 ? "?"
-                : String(layout.offsetOf(attribute.name));
+                : String(layout.offsetOf(particle_field.name));
 
-            entry.addChild(new LabelView(attribute.name, { classList: ['name'] }));
-            entry.addChild(new LabelView(`w${offset} · ${attribute.components}c`, { classList: ['where'] }));
+            entry.addChild(new LabelView(particle_field.name, { classList: ['name'] }));
+            entry.addChild(new LabelView(`w${offset} · ${particle_field.components}c`, { classList: ['where'] }));
 
             const remove = new EmptyView({ classList: ['remove'] });
 
             remove.addChild(new LabelView("✕"));
-            remove.el.setAttribute('title', `Remove '${attribute.name}'`);
-            remove.el.addEventListener('click', () => this.effect.removeAttribute(attribute.name));
+            remove.el.setAttribute('title', `Remove '${particle_field.name}'`);
+            remove.el.addEventListener('click', () => this.effect.removeParticleField(particle_field.name));
 
             entry.addChild(remove);
 
-            this.#attribute_rows.addChild(entry);
+            this.#particle_field_rows.addChild(entry);
         }
     }
 
     /**
+     * A row that declares a field: a name, a component count, and an "add" that hands both to
+     * `declare` and shows what it throws.
+     *
+     * @param {string} class_name
+     * @param {string} placeholder
+     * @param {function(string, number):void} declare
      * @returns {View}
      */
-    #buildAttributeAdder() {
-        const adder = new EmptyView({ classList: ['add-attribute'] });
+    #buildFieldAdder(class_name, placeholder, declare) {
+        const adder = new EmptyView({ classList: [class_name] });
 
         const name = text_input("");
 
-        name.setAttribute('placeholder', 'new attribute');
+        name.setAttribute('placeholder', placeholder);
 
         const components = document.createElement('select');
 
@@ -415,7 +572,7 @@ export class ParticleEmitterInspectorView extends View {
             }
 
             try {
-                this.effect.addAttribute(candidate, Number.parseInt(components.value, 10));
+                declare(candidate, Number.parseInt(components.value, 10));
 
                 name.value = "";
             } catch (e) {

package/editor/view/particles/effect/ParticleGraphEditorView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleGraphEditorView.d.ts","sourceRoot":"","sources":["../../../../../editor/view/particles/effect/ParticleGraphEditorView.js"],"names":[],"mappings":"AA4LA;IA6FI;;;;;OAKG;IACH;QAJyG,MAAM,EAApG,OAAO,qDAAqD,EAAE,sBAAsB;QAC1D,eAAe;OAsDnD;IAhDG,mBAAuC;IAIvC;;OAEG;IACH,QAFU,OAAO,qDAAqD,EAAE,sBAAsB,CAE1E;IAEpB;;OAEG;IACH,2CAAsC;IA4X1C;;;;;;;;;;;;;;;OAeG;IACH,kBAHa,QAAQ,eAAa,IAAI,CAAC,CAwEtC;IAED;;;;;;;;OAQG;IACH,oBAFa,QAAQ,cAAc,CAAC,CAgCnC;IA+ID;;;;;;;;;;;;;OAaG;IACH,iBAHW,OAAO,qEAAqE,EAAE,iBAAiB,GAC7F,IAAI,CAsDhB;IAED;;;OAGG;IACH,cAFa,IAAI,CAIhB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,IAAI,CAWhB;IAED;;;;OAIG;IACH,cAFa,OAAO,qEAAqE,EAAE,iBAAiB,EAAE,CAI7G;IAED;;;;;;;;;;OAUG;IACH,gBAuCC;IAwBD;;;;;;;OAOG;IACH,wDAHW,MAAM,GACJ,qBAAqB,CAiBjC;IAiED;;;;OAIG;IACH,gBAFa,mBAAmB,CAQ/B;IAED;;OAEG;IACH,eAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,aAFW,MAAM,QAmBhB;IAoGD;;;;;;;;;OASG;IACH,mBAJW,OAAO,qEAAqE,EAAE,iBAAiB,SAC/F,MAAM,GACJ,IAAI,CAqBhB;IAED;;;;;;;;;;;OAWG;IACH,wBAoCC;IAoDD;;;;;OAKG;IACH,qBAHW,MAAM,WACN,MAAM,QA2BhB;IAED;;;;;OAKG;IACH,cAFa,OAAO,6CAA6C,EAAE,uBAAuB,GAAC,IAAI,CAI9F;IAED,eAuBC;;CAgCJ;iBAxgDgB,8BAA8B;gCAvCf,sDAAsD;oCA0ClD,yCAAyC"}
+{"version":3,"file":"ParticleGraphEditorView.d.ts","sourceRoot":"","sources":["../../../../../editor/view/particles/effect/ParticleGraphEditorView.js"],"names":[],"mappings":"AA4LA;IA6FI;;;;;OAKG;IACH;QAJyG,MAAM,EAApG,OAAO,qDAAqD,EAAE,sBAAsB;QAC1D,eAAe;OAsDnD;IAhDG,mBAAuC;IAIvC;;OAEG;IACH,QAFU,OAAO,qDAAqD,EAAE,sBAAsB,CAE1E;IAEpB;;OAEG;IACH,2CAAsC;IAgY1C;;;;;;;;;;;;;;;OAeG;IACH,kBAHa,QAAQ,eAAa,IAAI,CAAC,CAwEtC;IAED;;;;;;;;OAQG;IACH,oBAFa,QAAQ,cAAc,CAAC,CAgCnC;IAwKD;;;;;;;;;;;;;OAaG;IACH,iBAHW,OAAO,qEAAqE,EAAE,iBAAiB,GAC7F,IAAI,CAsDhB;IAED;;;OAGG;IACH,cAFa,IAAI,CAIhB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,IAAI,CAWhB;IAED;;;;OAIG;IACH,cAFa,OAAO,qEAAqE,EAAE,iBAAiB,EAAE,CAI7G;IAED;;;;;;;;;;OAUG;IACH,gBAuCC;IAwBD;;;;;;;OAOG;IACH,wDAHW,MAAM,GACJ,qBAAqB,CAiBjC;IAqED;;;;OAIG;IACH,gBAFa,mBAAmB,CAQ/B;IAED;;OAEG;IACH,eAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,aAFW,MAAM,QAmBhB;IAoGD;;;;;;;;;OASG;IACH,mBAJW,OAAO,qEAAqE,EAAE,iBAAiB,SAC/F,MAAM,GACJ,IAAI,CAqBhB;IAED;;;;;;;;;;;OAWG;IACH,wBAoCC;IAoDD;;;;;OAKG;IACH,qBAHW,MAAM,WACN,MAAM,QA2BhB;IAED;;;;;OAKG;IACH,cAFa,OAAO,6CAA6C,EAAE,uBAAuB,GAAC,IAAI,CAI9F;IAED,eAuBC;;CAgCJ;iBAziDgB,8BAA8B;gCAvCf,sDAAsD;oCA0ClD,yCAAyC"}

package/editor/view/particles/effect/ParticleGraphEditorView.js

@@ -57,8 +57,8 @@ import { ParticleNodeParametersView } from "./ParticleNodeParametersView.js";
  *
  * Built *with* the node-graph editor rather than in it. Everything particle-specific arrives
  * through the seams the base offers — the node library the canvas's add-node menu offers, a
- * parameter-view factory that draws vector, enum, attribute and swizzle controls, the one rule the
- * clipboard needs (a group's boundary blocks are not something there can be a second of), and a
+ * parameter-view factory that draws vector, enum, field and swizzle controls, the one rule
+ * the clipboard needs (a group's boundary blocks are not something there can be a second of), and a
  * problems list fed by the document's own compile. The base is left knowing nothing about particles.
  *
  * ## Adding a node
@@ -135,8 +135,8 @@ const PARTICLE_TYPE_COLORS = new Map([
  * @type {Array<{name: string, types: string[]}>}
  */
 const PALETTE_CATEGORIES = [
-    { name: "sources", types: ["const", "color", "builtin", "attribute", "random"] },
-    { name: "output", types: ["setAttribute", "kill"] },
+    { name: "sources", types: ["const", "color", "builtin", "particleField", "random"] },
+    { name: "output", types: ["setParticleField", "kill"] },
     // The three that are authored data rather than wiring, and are edited as a picture: a gradient
     // strip and a curve plot. Their own heading, because "a colour ramp" is a thing an
     // author goes looking for by name and would not think to look for under `sources`.
@@ -558,7 +558,11 @@ export class ParticleGraphEditorView extends View {
             return {};
         }
 
-        return particle_node_default_parameters(description.name, { layout: this.#layoutOrNothing() });
+        return particle_node_default_parameters(description.name, {
+            layout: this.#layoutOrNothing(),
+            emitter_layout: this.#emitterLayoutOrNothing(),
+            global_layout: this.#globalLayoutOrNothing(),
+        });
     }
 
     /**
@@ -936,7 +940,7 @@ export class ParticleGraphEditorView extends View {
     }
 
     /**
-     * The effect's attribute schema, or nothing when the declarations do not make one.
+     * The effect's particle field schema, or nothing when the declarations do not make one.
      *
      * @returns {import("../../../../src/shade/renderer/particles/layout/ParticleLayout.js").ParticleLayout|undefined}
      */
@@ -944,7 +948,32 @@ export class ParticleGraphEditorView extends View {
         try {
             return this.effect.buildLayout();
         } catch (e) {
-            // a broken attribute schema types the attribute reads as unknown, and nothing else
+            // a broken particle field schema types the particle field reads as unknown, and
+            // nothing else
+            return undefined;
+        }
+    }
+
+    /**
+     * @returns {import("../../../../src/shade/renderer/particles/layout/ParticleLayout.js").ParticleLayout|undefined}
+     */
+    #emitterLayoutOrNothing() {
+        try {
+            return this.effect.buildEmitterLayout() ?? undefined;
+        } catch (e) {
+            // the same for a broken emitter field schema and the emitter field reads
+            return undefined;
+        }
+    }
+
+    /**
+     * @returns {import("../../../../src/shade/renderer/particles/layout/ParticleLayout.js").ParticleLayout|undefined}
+     */
+    #globalLayoutOrNothing() {
+        try {
+            return this.effect.buildGlobalLayout() ?? undefined;
+        } catch (e) {
+            // and for broken global field imports and the global field reads
             return undefined;
         }
     }
@@ -1165,9 +1194,9 @@ export class ParticleGraphEditorView extends View {
         let types = this.#group_types.get(group);
 
         if (types === undefined) {
-            // No layout: a group has no effect and so no attribute schema of its own. A group that
-            // reads an attribute types that read as unknown, which is honest — what it reads depends
-            // on the effect it is placed in.
+            // No layout: a group has no effect and so no particle field schema of its own. A group
+            // that reads a particle field types that read as unknown, which is honest — what it
+            // reads depends on the effect it is placed in.
             types = infer_particle_graph_types(group.graph);
 
             this.#group_types.set(group, types);
@@ -1186,7 +1215,11 @@ export class ParticleGraphEditorView extends View {
         let types = this.#types.get(id);
 
         if (types === undefined) {
-            types = infer_particle_graph_types(this.effect[id], { layout: this.#layoutOrNothing() });
+            types = infer_particle_graph_types(this.effect[id], {
+                layout: this.#layoutOrNothing(),
+                emitter_layout: this.#emitterLayoutOrNothing(),
+                global_layout: this.#globalLayoutOrNothing(),
+            });
 
             this.#types.set(id, types);
         }

package/editor/view/particles/effect/ParticleNodeParametersView.d.ts

@@ -2,7 +2,8 @@ export class ParticleNodeParametersView extends View {
     /**
      * @param {object} options
      * @param {import("../../../particles/effect/ParticleEffectDocument.js").ParticleEffectDocument} options.effect
-     *        the effect document being edited; read for the attribute list, and watched for changes to it
+     *        the effect document being edited; read for its field declarations, and watched for
+     *        changes to them
      * @param {NodeInstance} options.node
      * @param {function(string, *)} options.commit called with a parameter name and its new value
      */

package/editor/view/particles/effect/ParticleNodeParametersView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleNodeParametersView.d.ts","sourceRoot":"","sources":["../../../../../editor/view/particles/effect/ParticleNodeParametersView.js"],"names":[],"mappings":"AAqCA;IAOI;;;;;;OAMG;IACH;QALyG,MAAM,EAApG,OAAO,qDAAqD,EAAE,sBAAsB;QAE9D,IAAI;QACG,MAAM,SAA1B,MAAM;OA6BzB;IAxBG,mBAAuC;IAIvC;;OAEG;IACH,mBAAgB;;CAmavB;iBA3dgB,8BAA8B"}
+{"version":3,"file":"ParticleNodeParametersView.d.ts","sourceRoot":"","sources":["../../../../../editor/view/particles/effect/ParticleNodeParametersView.js"],"names":[],"mappings":"AAsCA;IAOI;;;;;;;OAOG;IACH;QANyG,MAAM,EAApG,OAAO,qDAAqD,EAAE,sBAAsB;QAG9D,IAAI;QACG,MAAM,SAA1B,MAAM;OA6BzB;IAxBG,mBAAuC;IAIvC;;OAEG;IACH,mBAAgB;;CA+bvB;iBAzfgB,8BAA8B"}