p5 2.2.3 → 2.3.0-rc.0

package/dist/strands/strands_api.js

@@ -1,8 +1,9 @@
-import { u as unaryOpNode, c as createStrandsNode, S as StrandsNode, p as primitiveConstructorNode, v as variableNode, b as binaryOpNode, s as statementNode, f as functionCallNode, a as structInstanceNode, d as structConstructorNode } from '../ir_builders-Cd6rU9Vm.js';
+import { u as unaryOpNode, c as createStrandsNode, S as StrandsNode, p as primitiveConstructorNode, v as variableNode, b as binaryOpNode, a as statementNode, f as functionCallNode, d as structInstanceNode, e as structConstructorNode } from '../ir_builders-C2ebb6Lu.js';
 import { OperatorTable, StatementType, NodeType, DataType, BaseType, BlockType, isStructType, structType } from './ir_types.js';
 import { strandsBuiltinFunctions } from './strands_builtins.js';
 import { StrandsConditional } from './strands_conditionals.js';
 import { StrandsFor } from './strands_for.js';
+import { buildTernary } from './strands_ternary.js';
 import { createBasicBlock, addEdge, pushBlock, recordInBasicBlock, popBlock } from './ir_cfg.js';
 import { createNodeData, getOrCreateNode, getNodeDataFromID } from './ir_dag.js';
 import { userError } from './strands_FES.js';
@@ -181,6 +182,10 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
     return new StrandsFor(strandsContext, initialCb, conditionCb, updateCb, bodyCb, initialVars).build();
   };
   augmentFn(fn, p5, 'strandsFor', p5.strandsFor);
+  p5.strandsTernary = function(condition, ifTrue, ifFalse) {
+    return buildTernary(strandsContext, condition, ifTrue, ifFalse);
+  };
+  augmentFn(fn, p5, 'strandsTernary', p5.strandsTernary);
   p5.strandsEarlyReturn = function(value) {
     const { dag, cfg } = strandsContext;
 
@@ -201,7 +206,7 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
     const nodeData = createNodeData({
       nodeType: NodeType.STATEMENT,
       statementType: StatementType.EARLY_RETURN,
-      dependsOn: [valueNode.id]
+      dependsOn: value !== undefined ? [valueNode.id] : []
     });
     const earlyReturnID = getOrCreateNode(dag, nodeData);
     recordInBasicBlock(cfg, cfg.currentBlock, earlyReturnID);
@@ -266,6 +271,33 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
     }
   }
 
+  // Alias lerp to GLSL mix in strands context
+  const originalLerp = fn.lerp;
+  augmentFn(fn, p5, 'lerp', function (...args) {
+    if (strandsContext.active) {
+      return fn.mix(...args);
+    } else {
+      return originalLerp.apply(this, args);
+    }
+  });
+
+  const originalMap = fn.map;
+  augmentFn(fn, p5, 'map', function (...args) {
+    if (!strandsContext.active) {
+      return originalMap.apply(this, args);
+    }
+    const [n, start1, stop1, start2, stop2, withinBounds] = args;
+    const nNode = p5.strandsNode(n);
+    const start1Node = p5.strandsNode(start1);
+    const stop1Node = p5.strandsNode(stop1);
+    const t = nNode.sub(start1Node).div(stop1Node.sub(start1Node));
+    const result = this.mix(start2, stop2, t);
+    if (withinBounds) {
+      return this.clamp(result, this.min(start2, stop2), this.max(start2, stop2));
+    }
+    return result;
+  });
+
   augmentFn(fn, p5, 'getTexture', function (...rawArgs) {
     if (strandsContext.active) {
       const { id, dimension } = strandsContext.backend.createGetTextureCall(strandsContext, rawArgs);
@@ -290,6 +322,8 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
   // Add noise function with backend-agnostic implementation
   const originalNoise = fn.noise;
   const originalNoiseDetail = fn.noiseDetail;
+  const originalRandom = fn.random;
+  const originalRandomSeed = fn.randomSeed;
   const originalMillis = fn.millis;
 
   strandsContext._noiseOctaves = null;
@@ -309,9 +343,10 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
       return originalNoise.apply(this, args); // fallback to regular p5.js noise
     }
     // Get noise shader snippet from the current renderer
-    const noiseSnippet = this._renderer.getNoiseShaderSnippet();
+    const noiseSnippet = strandsContext.backend.getNoiseShaderSnippet();
     strandsContext.vertexDeclarations.add(noiseSnippet);
     strandsContext.fragmentDeclarations.add(noiseSnippet);
+    strandsContext.computeDeclarations.add(noiseSnippet);
 
     // Make each input into a strands node so that we can check their dimensions
     const strandsArgs = args.flat().map(arg => p5.strandsNode(arg));
@@ -353,6 +388,84 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
     return createStrandsNode(id, dimension, strandsContext);
   });
 
+  strandsContext._randomSeed = null;
+
+  augmentFn(fn, p5, 'randomSeed', function (seed) {
+    if (!strandsContext.active) {
+      return originalRandomSeed.apply(this, arguments);
+    }
+    strandsContext._randomSeed = seed;
+  });
+
+  augmentFn(fn, p5, 'random', function (...args) {
+    if (!strandsContext.active) {
+      return originalRandom.apply(this, args);
+    }
+
+    const randomVertSnippet = strandsContext.backend.getRandomVertexShaderSnippet();
+    const randomFragSnippet = strandsContext.backend.getRandomFragmentShaderSnippet();
+
+    strandsContext.vertexDeclarations.add(randomVertSnippet);
+    strandsContext.fragmentDeclarations.add(randomFragSnippet);
+
+    if (strandsContext.backend.getRandomComputeShaderSnippet) {
+      const randomComputeSnippet = strandsContext.backend.getRandomComputeShaderSnippet();
+      strandsContext.computeDeclarations.add(randomComputeSnippet);
+    }
+
+    let seedNode;
+    if (strandsContext._randomSeed !== null && strandsContext._randomSeed.isStrandsNode) {
+      seedNode = strandsContext._randomSeed;
+    } else {
+      const userSeed = strandsContext._randomSeed;
+      seedNode = getOrCreateUniformNode(
+        strandsContext,
+        '_p5_randomSeed',
+        DataType.float1,
+        userSeed !== null
+          ? () => userSeed
+          : () => performance.now(),
+      );
+    }
+
+    // The shader-side random() owns a private per-invocation counter, so a
+    // single AST node still produces distinct values across runtime loop
+    // iterations. We just pass the seed.
+    const nodeArgs = [seedNode];
+    const randomOverloads = [{
+      params: [DataType.float1],
+      returnType: DataType.float1,
+    }];
+
+    if (args.length === 0) {
+      const { id, dimension } = functionCallNode(strandsContext, 'random', nodeArgs, {
+        overloads: randomOverloads,
+      });
+      return createStrandsNode(id, dimension, strandsContext);
+    } else if (args.length === 1) {
+      // random(max) → [0, max)
+      const rawNode = functionCallNode(strandsContext, 'random', nodeArgs, {
+        overloads: randomOverloads,
+      });
+      const rawStrandsNode = createStrandsNode(rawNode.id, rawNode.dimension, strandsContext);
+      return rawStrandsNode.mult(p5.strandsNode(args[0]));
+    } else if (args.length === 2) {
+      // random(min, max) → [min, max)
+      const rawNode = functionCallNode(strandsContext, 'random', nodeArgs, {
+        overloads: randomOverloads,
+      });
+      const rawStrandsNode = createStrandsNode(rawNode.id, rawNode.dimension, strandsContext);
+      const minNode = p5.strandsNode(args[0]);
+      const maxNode = p5.strandsNode(args[1]);
+      // min + raw * (max - min)
+      return rawStrandsNode.mult(maxNode.sub(minNode)).add(minNode);
+    } else {
+      p5._friendlyError(
+        `It looks like you've called random() with ${args.length} arguments. In strands, random() supports 0, 1, or 2 numeric arguments.`
+      );
+    }
+  });
+
   augmentFn(fn, p5, 'millis', function (...args) {
     if (!strandsContext.active) {
       return originalMillis.apply(this, args);
@@ -464,6 +577,53 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
       }
     });
   }
+
+  // Storage buffer uniform function for compute shaders
+  fn.uniformStorage = function(name, bufferOrSchema) {
+    let schema = null;
+    let defaultValue = null;
+
+    // If it's a function, evaluate it immediately to infer schema,
+    // then store the function so it gets called each frame.
+    let value = bufferOrSchema;
+    if (typeof bufferOrSchema === 'function') {
+      value = bufferOrSchema();
+      if (value?._schema) {
+        defaultValue = bufferOrSchema;
+      }
+    }
+
+    if (value?._schema) {
+      // Struct storage buffer with pre-computed schema
+      schema = value._schema;
+      if (defaultValue === null) defaultValue = value;
+    } else if (value && typeof value === 'object' && !value._isStorageBuffer) {
+      // Plain object schema template -- only used to infer struct layout, not as a default value
+      schema = strandsContext.renderer?._inferStructSchema(value) ?? null;
+    } else if (value?._isStorageBuffer) {
+      defaultValue = bufferOrSchema;
+    }
+
+    const { id, dimension } = variableNode(
+      strandsContext,
+      { baseType: 'storage', dimension: 1 },
+      name
+    );
+    strandsContext.uniforms.push({
+      name,
+      typeInfo: { baseType: 'storage', dimension: 1, schema },
+      defaultValue,
+    });
+
+    // Create StrandsNode with _originalIdentifier set (like varying variables)
+    // This enables proper assignment node creation and ordering preservation
+    const node = createStrandsNode(id, dimension, strandsContext);
+    node._originalIdentifier = name;
+    node._originalBaseType = 'storage';
+    node._originalDimension = 1;
+    node._schema = schema;
+    return node;
+  };
 }
 //////////////////////////////////////////////
 // Per-Hook functions
@@ -582,10 +742,14 @@ function createShaderHooksFunctions(strandsContext, fn, shader) {
   const fragmentHooksWithContext = Object.fromEntries(
     Object.entries(shader.hooks.fragment).map(([name, hook]) => [name, { ...hook, shaderContext: 'fragment' }])
   );
+  const computeHooksWithContext = Object.fromEntries(
+    Object.entries(shader.hooks.compute).map(([name, hook]) => [name, { ...hook, shaderContext: 'compute' }])
+  );
 
   const availableHooks = {
     ...vertexHooksWithContext,
     ...fragmentHooksWithContext,
+    ...computeHooksWithContext,
   };
   const hookTypes = Object.keys(availableHooks).map(name => shader.hookTypes(name));
 
@@ -615,9 +779,11 @@ function createShaderHooksFunctions(strandsContext, fn, shader) {
       if (numStructArgs === 1) {
         argIdx = hookType.parameters.findIndex(param => param.type.properties);
       }
+      hook._properties = [];
       for (let i = 0; i < args.length; i++) {
         if (i === argIdx) {
           for (const key of args[argIdx].structProperties || []) {
+            hook._properties.push(key);
             Object.defineProperty(hook, key, {
               get() {
                 return args[argIdx][key];
@@ -632,6 +798,7 @@ function createShaderHooksFunctions(strandsContext, fn, shader) {
             hook.set(args[argIdx]);
           }
         } else {
+          hook._properties.push(hookType.parameters[i].name);
           hook[hookType.parameters[i].name] = args[i];
         }
       }
@@ -702,17 +869,21 @@ function createShaderHooksFunctions(strandsContext, fn, shader) {
             return newStruct.id;
           }
         }
+        else if (!expectedReturnType.dataType || expectedReturnType.typeName?.trim() === 'void') {
+          return null;
+        }
         else /*if(isNativeType(expectedReturnType.typeName))*/ {
-          if (!expectedReturnType.dataType) {
-            throw new Error(`Missing dataType for return type ${expectedReturnType.typeName}`);
-          }
           const expectedTypeInfo = expectedReturnType.dataType;
           return enforceReturnTypeMatch(strandsContext, expectedTypeInfo, retNode, hookType.name);
         }
       };
       for (const { valueNode, earlyReturnID } of hook.earlyReturns) {
         const id = handleRetVal(valueNode);
-        dag.dependsOn[earlyReturnID] = [id];
+        if (id !== null) {
+          dag.dependsOn[earlyReturnID] = [id];
+        } else {
+          dag.dependsOn[earlyReturnID] = [];
+        }
       }
       rootNodeID = userReturned ? handleRetVal(userReturned) : undefined;
       const fullHookName = `${hookType.returnType.typeName} ${hookType.name}`;
@@ -721,7 +892,7 @@ function createShaderHooksFunctions(strandsContext, fn, shader) {
         hookType,
         entryBlockID,
         rootNodeID,
-        shaderContext: hookInfo?.shaderContext, // 'vertex' or 'fragment'
+        shaderContext: hookInfo?.shaderContext, // 'vertex', 'fragment', or 'compute'
       });
       popBlock(cfg);
     }    hook.begin = setupHook;

package/dist/strands/strands_codegen.js

@@ -7,18 +7,26 @@ function generateShaderCode(strandsContext) {
     cfg,
     backend,
     vertexDeclarations,
-    fragmentDeclarations
+    fragmentDeclarations,
+    computeDeclarations
   } = strandsContext;
 
   const hooksObj = {
     uniforms: {},
+    storageUniforms: {},
     varyingVariables: [],
   };
 
   for (const {name, typeInfo, defaultValue} of strandsContext.uniforms) {
-    const key = backend.generateHookUniformKey(name, typeInfo);
-    if (key !== null) {
-      hooksObj.uniforms[key] = defaultValue;
+    if (typeInfo.baseType === 'storage') {
+      if (defaultValue !== null && defaultValue !== undefined) {
+        hooksObj.storageUniforms[name] = defaultValue;
+      }
+    } else {
+      const key = backend.generateHookUniformKey(name, typeInfo);
+      if (key !== null) {
+        hooksObj.uniforms[key] = defaultValue;
+      }
     }
   }
 
@@ -27,6 +35,11 @@ function generateShaderCode(strandsContext) {
     backend.addTextureBindingsToDeclarations(strandsContext);
   }
 
+  // Add storage buffer bindings to declarations for WebGPU backend
+  if (backend.addStorageBufferBindingsToDeclarations) {
+    backend.addStorageBufferBindingsToDeclarations(strandsContext);
+  }
+
   for (const { hookType, rootNodeID, entryBlockID, shaderContext } of strandsContext.hooks) {
     const generationContext = {
       indent: 1,
@@ -51,14 +64,13 @@ function generateShaderCode(strandsContext) {
     let returnType;
     if (hookType.returnType.properties) {
       returnType = structType(hookType.returnType);
+    } else if (!hookType.returnType.dataType || hookType.returnType.typeName?.trim() === 'void') {
+      returnType = null;
     } else {
-      if (!hookType.returnType.dataType) {
-        throw new Error(`Missing dataType for return type ${hookType.returnType.typeName}`);
-      }
       returnType = hookType.returnType.dataType;
     }
 
-    if (rootNodeID) {
+    if (rootNodeID !== undefined) {
       backend.generateReturnStatement(strandsContext, generationContext, rootNodeID, returnType);
     }
     hooksObj[`${hookType.returnType.typeName} ${hookType.name}`] = [firstLine, ...generationContext.codeLines, '}'].join('\n');
@@ -81,8 +93,14 @@ function generateShaderCode(strandsContext) {
     }
   }
 
+  // Register instanceID varying if used in a fragment hook
+  if (strandsContext._instanceIDUsedInFragment) {
+    hooksObj.instanceIDVarying = backend.generateInstanceIDVarying();
+  }
+
   hooksObj.vertexDeclarations = [...vertexDeclarations].join('\n');
   hooksObj.fragmentDeclarations = [...fragmentDeclarations].join('\n');
+  hooksObj.computeDeclarations = [...computeDeclarations].join('\n');
 
   return hooksObj;
 }

package/dist/strands/strands_conditionals.js

@@ -1,7 +1,7 @@
 import { createBasicBlock, addEdge, pushBlock, popBlock, pushBlockForModification, recordInBasicBlock } from './ir_cfg.js';
 import { getOrCreateNode } from './ir_dag.js';
 import { BlockType, NodeType } from './ir_types.js';
-import { c as createStrandsNode } from '../ir_builders-Cd6rU9Vm.js';
+import { c as createStrandsNode } from '../ir_builders-C2ebb6Lu.js';
 import { createPhiNode } from './strands_phi_utils.js';
 import './strands_FES.js';
 import './strands_builtins.js';

package/dist/strands/strands_for.js

@@ -1,7 +1,7 @@
 import { createBasicBlock, addEdge, pushBlock, popBlock, pushBlockForModification, recordInBasicBlock } from './ir_cfg.js';
 import { getNodeDataFromID, createNodeData, getOrCreateNode } from './ir_dag.js';
 import { BlockType, NodeType, StatementType, OpCode, BaseType } from './ir_types.js';
-import { c as createStrandsNode, p as primitiveConstructorNode } from '../ir_builders-Cd6rU9Vm.js';
+import { c as createStrandsNode, p as primitiveConstructorNode } from '../ir_builders-C2ebb6Lu.js';
 import { createPhiNode } from './strands_phi_utils.js';
 import './strands_FES.js';
 import './strands_builtins.js';

package/dist/strands/strands_node.js

@@ -1,4 +1,4 @@
-export { S as StrandsNode, c as createStrandsNode } from '../ir_builders-Cd6rU9Vm.js';
+export { S as StrandsNode, c as createStrandsNode } from '../ir_builders-C2ebb6Lu.js';
 import './ir_types.js';
 import './ir_dag.js';
 import './ir_cfg.js';

package/dist/strands/strands_ternary.js

@@ -0,0 +1,56 @@
+import { extractNodeTypeInfo, propagateTypeToAssignOnUse, createNodeData, getOrCreateNode } from './ir_dag.js';
+import { recordInBasicBlock } from './ir_cfg.js';
+import { BaseType, OpCode, NodeType } from './ir_types.js';
+import { c as createStrandsNode } from '../ir_builders-C2ebb6Lu.js';
+import { userError } from './strands_FES.js';
+import './strands_builtins.js';
+
+function buildTernary(strandsContext, condition, ifTrue, ifFalse) {
+  const { dag, cfg, p5 } = strandsContext;
+
+  // Ensure all inputs are StrandsNodes
+  const condNode = condition?.isStrandsNode ? condition : p5.strandsNode(condition);
+  const trueNode = ifTrue?.isStrandsNode ? ifTrue : p5.strandsNode(ifTrue);
+  const falseNode = ifFalse?.isStrandsNode ? ifFalse : p5.strandsNode(ifFalse);
+
+  // Get type info for both nodes
+  let trueType = extractNodeTypeInfo(dag, trueNode.id);
+  let falseType = extractNodeTypeInfo(dag, falseNode.id);
+
+  // Propagate type from the known branch to any ASSIGN_ON_USE branch
+  if (trueType.baseType === BaseType.ASSIGN_ON_USE && falseType.baseType !== BaseType.ASSIGN_ON_USE) {
+    propagateTypeToAssignOnUse(dag, trueNode.id, falseType.baseType, falseType.dimension);
+    trueType = extractNodeTypeInfo(dag, trueNode.id);
+  } else if (falseType.baseType === BaseType.ASSIGN_ON_USE && trueType.baseType !== BaseType.ASSIGN_ON_USE) {
+    propagateTypeToAssignOnUse(dag, falseNode.id, trueType.baseType, trueType.dimension);
+    falseType = extractNodeTypeInfo(dag, falseNode.id);
+  }
+
+  // After ASSIGN_ON_USE propagation, if both types are known, they must match
+  if (
+    trueType.baseType !== BaseType.ASSIGN_ON_USE &&
+    falseType.baseType !== BaseType.ASSIGN_ON_USE &&
+    (trueType.baseType !== falseType.baseType || trueType.dimension !== falseType.dimension)
+  ) {
+    userError('type error',
+      'The true and false branches of a ternary expression must have the same type. ' +
+      `Right now, the true branch is a ${trueType.baseType}${trueType.dimension}, and the false branch is a ${falseType.baseType}${falseType.dimension}.`
+    );
+  }
+
+  const resultType = trueType;
+
+  const nodeData = createNodeData({
+    nodeType: NodeType.OPERATION,
+    opCode: OpCode.Nary.TERNARY,
+    dependsOn: [condNode.id, trueNode.id, falseNode.id],
+    baseType: resultType.baseType,
+    dimension: resultType.dimension,
+  });
+
+  const id = getOrCreateNode(dag, nodeData);
+  recordInBasicBlock(cfg, cfg.currentBlock, id);
+  return createStrandsNode(id, resultType.dimension, strandsContext);
+}
+
+export { buildTernary };