@woosh/meep-engine 3.58.0 → 3.60.0

package/src/shade/renderer/particles/graph/ParticleNodeRegistry.d.ts

@@ -16,8 +16,8 @@ export function particle_node_descriptions(): ParticleNodeDescription[];
 export function get_particle_node_description(name: string): ParticleNodeDescription;
 /**
  * Standard particle-node library, expressed as {@link ParticleNodeDescription}s in a
- * {@link NodeRegistry}. Nodes are value-producing operations (constants, builtins, attribute reads,
- * math, curves, random) or sinks (attribute writes, kill).
+ * {@link NodeRegistry}. Nodes are value-producing operations (constants, builtins, particle field
+ * reads, math, curves, random) or sinks (particle field writes, kill).
  *
  * These lower to the same opcodes the JS reference + WGSL interpreter agree on, so any effect
  * authored here is executable and testable end-to-end on the CPU before it ever hits the GPU.
@@ -36,8 +36,8 @@ export function get_particle_node_description(name: string): ParticleNodeDescrip
  * A type may also say what a value *means* — {@link PARTICLE_TYPE_COLOR} is four lanes that are a
  * colour — and the rules below never ask. They compare `components` and take the widest, so a
  * colour is accepted wherever a `vec4` is, produces whatever a `vec4` would, and survives the
- * arithmetic in between. The two places a colour enters a graph are the `color` node and an
- * attribute the effect's layout has tagged as one.
+ * arithmetic in between. The two places a colour enters a graph are the `color` node and a field
+ * the effect's layout has tagged as one.
  */
 /**
  * The declared type of every port in the library: a value goes here.

package/src/shade/renderer/particles/graph/ParticleNodeRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleNodeRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/ParticleNodeRegistry.js"],"names":[],"mappings":"AA2rBA;;;;;;;GAOG;AACH,8CAFa,uBAAuB,EAAE,CAIrC;AAED;;;;;GAKG;AACH,oDAJW,MAAM,GACJ,uBAAuB,CAWnC;AAtrBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;;GASG;AACH,kCAFU,QAAQ,CAE2C;AAE7D;;;GAGG;AACH,wCAFU,MAAM,CAE+B;AAE/C;;GAEG;AACH,qCAFU,YAAY,CAEmC;wCAhEjB,8BAA8B;yBAZ7C,oDAAoD;6BAFhD,wDAAwD"}
+{"version":3,"file":"ParticleNodeRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/ParticleNodeRegistry.js"],"names":[],"mappings":"AA8tBA;;;;;;;GAOG;AACH,8CAFa,uBAAuB,EAAE,CAIrC;AAED;;;;;GAKG;AACH,oDAJW,MAAM,GACJ,uBAAuB,CAWnC;AAvtBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;;GASG;AACH,kCAFU,QAAQ,CAE2C;AAE7D;;;GAGG;AACH,wCAFU,MAAM,CAE+B;AAE/C;;GAEG;AACH,qCAFU,YAAY,CAEmC;wCAhEjB,8BAA8B;yBAd7C,oDAAoD;6BAFhD,wDAAwD"}

package/src/shade/renderer/particles/graph/ParticleNodeRegistry.js

@@ -6,6 +6,8 @@ import {
     VM_BUILTIN_COMPONENTS,
     VM_OP,
     VM_SWIZZLE_BROADCAST,
+    vm_builtin_emitter_field,
+    vm_builtin_global_field,
     vm_immediate,
     vm_register,
 } from "../isa/ParticleVMISA.js";
@@ -31,8 +33,8 @@ import {
 
 /**
  * Standard particle-node library, expressed as {@link ParticleNodeDescription}s in a
- * {@link NodeRegistry}. Nodes are value-producing operations (constants, builtins, attribute reads,
- * math, curves, random) or sinks (attribute writes, kill).
+ * {@link NodeRegistry}. Nodes are value-producing operations (constants, builtins, particle field
+ * reads, math, curves, random) or sinks (particle field writes, kill).
  *
  * These lower to the same opcodes the JS reference + WGSL interpreter agree on, so any effect
  * authored here is executable and testable end-to-end on the CPU before it ever hits the GPU.
@@ -51,8 +53,8 @@ import {
  * A type may also say what a value *means* — {@link PARTICLE_TYPE_COLOR} is four lanes that are a
  * colour — and the rules below never ask. They compare `components` and take the widest, so a
  * colour is accepted wherever a `vec4` is, produces whatever a `vec4` would, and survives the
- * arithmetic in between. The two places a colour enters a graph are the `color` node and an
- * attribute the effect's layout has tagged as one.
+ * arithmetic in between. The two places a colour enters a graph are the `color` node and a field
+ * the effect's layout has tagged as one.
  */
 
 /**
@@ -301,7 +303,7 @@ const REDUCTION = {
 
 /**
  * An op that has to see the whole vector to compute any lane of it: a `normalize` feeding a
- * one-component attribute still divides by the length of the whole vector rather than by the
+ * one-component particle field still divides by the length of the whole vector rather than by the
  * length of its first lane. Its type is its input's; only the width it runs at differs from the
  * element-wise default.
  */
@@ -368,32 +370,33 @@ function pattern_span(pattern) {
 }
 
 /**
- * The attribute a node names, as a type; `null` where there is no layout to look in or the name is
- * not in it — which the validator reports in its own words.
+ * The field a node names in `layout`, as a type; `null` where there is no layout to look in or the
+ * name is not in it — which the validator reports in its own words. The same rule types particle,
+ * emitter and global fields, each looked up in its own layout.
  *
- * An attribute the layout has tagged (`color`, say) is that type rather than the plain shape, which
- * is how a colour reaches a graph without a node saying so. The tag has to be the shape the
- * attribute actually is: three words tagged `color` is a mistake, and reading them as a four-lane
- * colour would be a second one, so the shape wins and the tag is ignored.
+ * A field the layout has tagged (`color`, say) is that type rather than the plain shape, which is
+ * how a colour reaches a graph without a node saying so. The tag has to be the shape the field
+ * actually is: three words tagged `color` is a mistake, and reading them as a four-lane colour would
+ * be a second one, so the shape wins and the tag is ignored.
  *
  * @param {object} parameters
- * @param {ParticleLayout|undefined} layout
+ * @param {ParticleLayout|undefined} layout the particle, emitter or global layout
  * @returns {ParticleValueType|null}
  */
-function attribute_type(parameters, layout) {
+function particle_field_type(parameters, layout) {
     if (layout === undefined || !layout.has(parameters.name)) {
         return null;
     }
 
-    const attribute = layout.get(parameters.name);
+    const particle_field = layout.get(parameters.name);
 
-    const semantic = particle_semantic_type(attribute.type);
+    const semantic = particle_semantic_type(particle_field.type);
 
-    if (semantic !== null && semantic.components === attribute.components) {
+    if (semantic !== null && semantic.components === particle_field.components) {
         return semantic;
     }
 
-    return particle_value_type(attribute.components);
+    return particle_value_type(particle_field.components);
 }
 
 /**
@@ -416,7 +419,7 @@ function scalar_operand(source_types) {
 
 // --- sources ---
 // A source has a type of its own, and it is as wide as that: a literal is as wide as it was
-// written, a builtin as wide as the host fills it, an attribute as wide as the layout says. A
+// written, a builtin as wide as the host fills it, a particle field as wide as the layout says. A
 // consumer wanting more lanes than that is a conversion the compiler makes after the value is
 // produced — except where a source can fill lanes for free, which it then does.
 source("const", parameters => particle_value_type_or_null(literal_of(parameters).length), emit_literal, {
@@ -427,23 +430,23 @@ source(
     parameters => particle_value_type_or_null(VM_BUILTIN_COMPONENTS[parameters.id]),
     (s, c) => s.loadBuiltin(c.out, c.parameters.id, c.width)
 );
-source("attribute", attribute_type, (s, c) => {
+source("particleField", particle_field_type, (s, c) => {
     const a = c.layout.get(c.parameters.name);
 
-    s.loadAttr(c.out, a.offset, a.components, c.width);
+    s.loadParticleField(c.out, a.offset, a.components, c.width);
 });
 // One uniform draw in `[0, 1)` per lane, as many lanes as the node says. Shaped distributions are
 // compositions over it rather than modes of it — see ./particle_graph_distributions.js.
 source("random", parameters => particle_value_type_or_null(parameters.components), (s, c) => s.random(c.out, c.width));
 
 // --- sinks ---
-// A store is exactly as wide as the attribute it writes, and that is how it reads its input.
-sink("setAttribute", ["value"], (s, c) => {
+// A store is exactly as wide as the particle field it writes, and that is how it reads its input.
+sink("setParticleField", ["value"], (s, c) => {
     const a = c.layout.get(c.parameters.name);
 
-    s.storeAttr(c.in("value"), a.offset, a.components);
+    s.storeParticleField(c.in("value"), a.offset, a.components);
 }, {
-    infer_types: ({ parameters, layout }) => ({ output: null, inputs: { value: attribute_type(parameters, layout) } }),
+    infer_types: ({ parameters, layout }) => ({ output: null, inputs: { value: particle_field_type(parameters, layout) } }),
     operation_width: ({ parameters, layout }) => layout.get(parameters.name).components,
 });
 sink("kill", ["condition"], (s, c) => s.kill(c.in("condition")), {
@@ -697,6 +700,38 @@ define("wind", ["position"], (s, c) => s.emit(VM_OP.SAMPLE_WIND, c.out, c.in("po
     operation_width: () => 3,
 });
 
+// --- emitter fields ---
+// One of the members the effect declares for every emitter, read from the emitter's own block: an
+// emitter field is to the emitter what a particle field is to the particle, and as wide as the
+// emitter layout says. A builtin is the same thing with the engine as the declarer, so it is read
+// through the same instruction.
+define("emitterField", [], (s, c) => {
+    const field = c.emitter_layout.get(c.parameters.name);
+
+    s.loadBuiltin(c.out, vm_builtin_emitter_field(field.offset), c.width);
+}, {
+    infer_types: ({ parameters, emitter_layout }) => ({
+        output: particle_field_type(parameters, emitter_layout),
+        inputs: {},
+    }),
+});
+
+// --- global fields ---
+// One of the system's static members, by name. The effect declares the globals it reads; the
+// program carries them as imports, in the order it first reads them, and is linked to the system's
+// layout when it is placed. So the id here is an import index, not an offset.
+define("globalField", [], (s, c) => {
+    const field = c.global_layout.get(c.parameters.name);
+    const index = c.asm.global_import(field.name, field.components);
+
+    s.loadBuiltin(c.out, vm_builtin_global_field(index), c.width);
+}, {
+    infer_types: ({ parameters, global_layout }) => ({
+        output: particle_field_type(parameters, global_layout),
+        inputs: {},
+    }),
+});
+
 /**
  * Every node type in the library, in declaration order.
  *

package/src/shade/renderer/particles/graph/ParticleValueType.d.ts

@@ -1,7 +1,7 @@
 /**
  * The semantic type of this name, or `null` for a name that is not one.
  *
- * How a tag written somewhere else — an attribute in a
+ * How a tag written somewhere else — a particle field in a
  * {@link ../layout/ParticleLayout.js ParticleLayout}, most of all — becomes a type. An unknown name
  * is not an error here: the caller knows the shape regardless, and falling back to it leaves an
  * effect that names a semantic this build has never heard of working as the plain vector it is.
@@ -93,8 +93,8 @@ export function particle_type_conversion(from: ParticleValueType, to: ParticleVa
  * and silently. A vector read narrower keeps its leading lanes; read wider, the missing lanes read
  * zero. Both of those are how the four-lane register file always behaved, so a graph written before
  * types compiles to the same lanes it did — but each is now a warning naming the lanes concerned,
- * because a `vec4` literal feeding a three-component attribute is either a mistake or a literal
- * that ought to be a `vec3`.
+ * because a `vec4` literal feeding a three-component particle field is either a mistake or a
+ * literal that ought to be a `vec3`.
  *
  * Types of the same width never convert, whatever they mean, so nothing is said about a colour
  * meeting a `vec4`. A view still draws the two in their own colours, which is worth seeing — it is