p5 2.2.3 → 2.3.0-rc.0

package/dist/webgpu/shaders/color.js

@@ -119,7 +119,7 @@ ${uniforms}
 @fragment
 fn main(input: FragmentInput) -> @location(0) vec4<f32> {
   HOOK_beforeFragment();
-  var outColor = HOOK_getFinalColor(input.vColor);
+  var outColor = HOOK_getFinalColor(input.vColor, input.vVertTexCoord);
   outColor = vec4<f32>(outColor.rgb * outColor.a, outColor.a);
   HOOK_afterFragment();
   return outColor;

package/dist/webgpu/shaders/compute.js

@@ -0,0 +1,32 @@
+const baseComputeShader = `
+struct ComputeUniforms {
+  uTotalCount: vec3<i32>,
+  uPhysicalCount: vec3<i32>,
+}
+@group(0) @binding(0) var<uniform> uniforms: ComputeUniforms;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(
+  @builtin(global_invocation_id) globalId: vec3<u32>,
+  @builtin(local_invocation_id) localId: vec3<u32>,
+  @builtin(workgroup_id) workgroupId: vec3<u32>,
+  @builtin(local_invocation_index) localIndex: u32
+) {
+  let totalIterations = u32(uniforms.uTotalCount.x) * u32(uniforms.uTotalCount.y) * u32(uniforms.uTotalCount.z);
+  let physicalId = globalId.x + globalId.y * (u32(uniforms.uPhysicalCount.x)) + globalId.z * (u32(uniforms.uPhysicalCount.x) * u32(uniforms.uPhysicalCount.y));
+
+  if (physicalId >= totalIterations) {
+    return;
+  }
+
+  var index = vec3<i32>(0);
+  index.x = i32(physicalId % u32(uniforms.uTotalCount.x));
+  let remainingY = physicalId / u32(uniforms.uTotalCount.x);
+  index.y = i32(remainingY % u32(uniforms.uTotalCount.y));
+  index.z = i32(remainingY / u32(uniforms.uTotalCount.y));
+
+  HOOK_iteration(index);
+}
+`;
+
+export { baseComputeShader };

package/dist/webgpu/shaders/functions/randomComputeWGSL.js

@@ -0,0 +1,31 @@
+// _p5_hash: "Hash without Sine" by Dave Hoskins (https://www.shadertoy.com/view/4djSRW)
+// Mixing constants: R₂ sequence by Martin Roberts (https://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/)
+//   α₁ = 1/φ₂ = 0.7548776662 (plastic constant reciprocal)
+//   α₂ = 1/φ₂² = 0.5698402910
+//   1/φ = 0.6180339887 (golden ratio conjugate)
+//
+// Compute shader version: invocationId is passed in from main via @builtin(global_invocation_id).
+
+var randomComputeWGSL = `
+var<private> _p5_randomCallIndex: i32 = 0;
+
+fn _p5_hash(p: vec3<f32>) -> f32 {
+  var p3 = fract(p * vec3<f32>(0.1031, 0.1030, 0.0973));
+  p3 = p3 + dot(p3, p3.yxz + 33.33);
+  return fract((p3.x + p3.y) * p3.z);
+}
+
+fn random(seed: f32, invocationId: vec3<u32>) -> f32 {
+  let id = vec3<f32>(invocationId);
+  let callIndex = f32(_p5_randomCallIndex);
+  _p5_randomCallIndex = _p5_randomCallIndex + 1;
+  let s = fract(seed * 0.7548776662);
+  return _p5_hash(vec3<f32>(
+    id.x + s,
+    id.y + callIndex * 0.5698402910,
+    id.z + s + callIndex * 0.6180339887
+  ));
+}
+`;
+
+export { randomComputeWGSL as default };

package/dist/webgpu/shaders/functions/randomVertWGSL.js

@@ -0,0 +1,30 @@
+// _p5_hash: "Hash without Sine" by Dave Hoskins (https://www.shadertoy.com/view/4djSRW)
+// Mixing constants: R₂ sequence by Martin Roberts (https://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/)
+//   α₁ = 1/φ₂ = 0.7548776662 (plastic constant reciprocal)
+//   α₂ = 1/φ₂² = 0.5698402910
+//   1/φ = 0.6180339887 (golden ratio conjugate)
+//
+// Vertex shader version: vertexId is passed in from main via @builtin(vertex_index).
+
+var randomVertWGSL = `
+var<private> _p5_randomCallIndex: i32 = 0;
+
+fn _p5_hash(p: vec3<f32>) -> f32 {
+  var p3 = fract(p * vec3<f32>(0.1031, 0.1030, 0.0973));
+  p3 = p3 + dot(p3, p3.yxz + 33.33);
+  return fract((p3.x + p3.y) * p3.z);
+}
+
+fn random(seed: f32, vertexId: f32) -> f32 {
+  let callIndex = f32(_p5_randomCallIndex);
+  _p5_randomCallIndex = _p5_randomCallIndex + 1;
+  let s = fract(seed * 0.7548776662);
+  return _p5_hash(vec3<f32>(
+    vertexId + s,
+    vertexId * 0.5698402910 + callIndex * 0.6180339887,
+    s + callIndex * 0.7548776662
+  ));
+}
+`;
+
+export { randomVertWGSL as default };

package/dist/webgpu/shaders/functions/randomWGSL.js

@@ -0,0 +1,30 @@
+// _p5_hash: "Hash without Sine" by Dave Hoskins (https://www.shadertoy.com/view/4djSRW)
+// Mixing constants: R₂ sequence by Martin Roberts (https://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/)
+//   α₁ = 1/φ₂ = 0.7548776662 (plastic constant reciprocal)
+//   α₂ = 1/φ₂² = 0.5698402910
+//   1/φ = 0.6180339887 (golden ratio conjugate)
+//
+// Fragment shader version: pixelCoord is passed in from main via @builtin(position).
+
+var randomWGSL = `
+var<private> _p5_randomCallIndex: i32 = 0;
+
+fn _p5_hash(p: vec3<f32>) -> f32 {
+  var p3 = fract(p * vec3<f32>(0.1031, 0.1030, 0.0973));
+  p3 = p3 + dot(p3, p3.yxz + 33.33);
+  return fract((p3.x + p3.y) * p3.z);
+}
+
+fn random(seed: f32, pixelCoord: vec2<f32>) -> f32 {
+  let callIndex = f32(_p5_randomCallIndex);
+  _p5_randomCallIndex = _p5_randomCallIndex + 1;
+  let s = fract(seed * 0.7548776662);
+  return _p5_hash(vec3<f32>(
+    pixelCoord.x + s,
+    pixelCoord.y + callIndex * 0.5698402910,
+    s + callIndex * 0.6180339887
+  ));
+}
+`;
+
+export { randomWGSL as default };

package/dist/webgpu/shaders/line.js

@@ -362,7 +362,7 @@ fn main(input: StrokeFragmentInput) -> @location(0) vec4<f32> {
       discard;
     }
   }
-  var col = HOOK_getFinalColor(inputs.color);
+  var col = HOOK_getFinalColor(inputs.color, vec2<f32>(0.0, 0.0));
   col = vec4<f32>(col.rgb, 1.0) * col.a;
   HOOK_afterFragment();
   return vec4<f32>(col);

package/dist/webgpu/shaders/material.js

@@ -416,9 +416,9 @@ fn main(input: FragmentInput) -> @location(0) vec4<f32> {
     inputs.emissiveMaterial
   );
 
-  var outColor = HOOK_getFinalColor(
-    HOOK_combineColors(components)
-  );
+   var outColor = HOOK_getFinalColor(
+     HOOK_combineColors(components), input.vTexCoord
+   );
   outColor = vec4<f32>(outColor.rgb * outColor.a, outColor.a);
   HOOK_afterFragment();
   return outColor;

package/dist/webgpu/strands_wgslBackend.js

@@ -1,7 +1,11 @@
-import { BaseType, DataType, NodeTypeToName, NodeType, OpCode, OpCodeToSymbol, isStructType, StatementType, BlockType } from '../strands/ir_types.js';
+import noiseWGSL from './shaders/functions/noise3DWGSL.js';
+import randomWGSL from './shaders/functions/randomWGSL.js';
+import randomVertWGSL from './shaders/functions/randomVertWGSL.js';
+import randomComputeWGSL from './shaders/functions/randomComputeWGSL.js';
+import { INSTANCE_ID_VARYING_NAME, BaseType, DataType, NodeTypeToName, NodeType, OpCode, OpCodeToSymbol, isStructType, StatementType, BlockType } from '../strands/ir_types.js';
 import { getNodeDataFromID, extractNodeTypeInfo } from '../strands/ir_dag.js';
 import { internalError } from '../strands/strands_FES.js';
-import { v as variableNode, c as createStrandsNode, f as functionCallNode } from '../ir_builders-Cd6rU9Vm.js';
+import { v as variableNode, c as createStrandsNode, s as scalarLiteralNode, f as functionCallNode } from '../ir_builders-C2ebb6Lu.js';
 import '../strands/ir_cfg.js';
 import '../strands/strands_builtins.js';
 
@@ -206,10 +210,10 @@ const wgslBackend = {
     // Add texture and sampler bindings for sampler2D uniforms to both vertex and fragment declarations
     if (!strandsContext.renderer || !strandsContext.baseShader) return;
 
-    // Get the next available binding index from the renderer
     let bindingIndex = strandsContext.renderer.getNextBindingIndex({
-      vert: strandsContext.baseShader.vertSrc(),
-      frag: strandsContext.baseShader.fragSrc(),
+      vert: strandsContext.baseShader._vertSrc,
+      frag: strandsContext.baseShader._fragSrc,
+      compute: strandsContext.baseShader._computeSrc,
     });
 
     for (const {name, typeInfo} of strandsContext.uniforms) {
@@ -226,6 +230,38 @@ const wgslBackend = {
       }
     }
   },
+  addStorageBufferBindingsToDeclarations(strandsContext) {
+    if (!strandsContext.renderer || !strandsContext.baseShader) return;
+
+    const isComputeShader = strandsContext.baseShader.shaderType === 'compute';
+    let bindingIndex = strandsContext.renderer.getNextBindingIndex({
+      vert: strandsContext.baseShader._vertSrc,
+      frag: strandsContext.baseShader._fragSrc,
+      compute: strandsContext.baseShader._computeSrc,
+    });
+
+    for (const {name, typeInfo} of strandsContext.uniforms) {
+      if (typeInfo.baseType === 'storage') {
+        const accessMode = isComputeShader ? 'read_write' : 'read';
+        let declaration;
+        if (typeInfo.schema) {
+          const structTypeName = `${name}Element`;
+          declaration = `struct ${structTypeName} ${typeInfo.schema.structBody}\n@group(0) @binding(${bindingIndex}) var<storage, ${accessMode}> ${name}: array<${structTypeName}>;`;
+        } else {
+          declaration = `@group(0) @binding(${bindingIndex}) var<storage, ${accessMode}> ${name}: array<f32>;`;
+        }
+
+        if (isComputeShader) {
+          strandsContext.computeDeclarations.add(declaration);
+        } else {
+          strandsContext.vertexDeclarations.add(declaration);
+          strandsContext.fragmentDeclarations.add(declaration);
+        }
+
+        bindingIndex += 1;
+      }
+    }
+  },
   getTypeName(baseType, dimension) {
     const primitiveTypeName = TypeNames[baseType + dimension];
     if (!primitiveTypeName) {
@@ -233,6 +269,19 @@ const wgslBackend = {
     }
     return primitiveTypeName;
   },
+  getNoiseShaderSnippet() {
+    return noiseWGSL;
+  },
+  getRandomFragmentShaderSnippet() {
+    return randomWGSL;
+  },
+  getRandomVertexShaderSnippet() {
+    return randomVertWGSL;
+  },
+  getRandomComputeShaderSnippet() {
+    return randomComputeWGSL;
+  },
+
   generateHookUniformKey(name, typeInfo) {
     // For sampler2D types, we don't add them to the uniform struct,
     // but we still need them in the shader's hooks object so that
@@ -240,6 +289,11 @@ const wgslBackend = {
     if (typeInfo.baseType === 'sampler2D') {
       return `${name}: sampler2D`; // Signal that this should not be added to uniform struct
     }
+    // For storage buffers, we don't add them to the uniform struct
+    // Instead, they become separate storage buffer bindings
+    if (typeInfo.baseType === 'storage') {
+      return null; // Signal that this should not be added to uniform struct
+    }
     return `${name}: ${this.getTypeName(typeInfo.baseType, typeInfo.dimension)}`;
   },
   generateVaryingVariable(varName, typeInfo) {
@@ -266,9 +320,13 @@ const wgslBackend = {
       // Generate just a semicolon (unless suppressed)
       generationContext.write(semicolon);
     } else if (node.statementType === StatementType.EARLY_RETURN) {
-      const exprNodeID = node.dependsOn[0];
-      const expr = this.generateExpression(generationContext, dag, exprNodeID);
-      generationContext.write(`return ${expr}${semicolon}`);
+      if (node.dependsOn && node.dependsOn.length > 0) {
+        const exprNodeID = node.dependsOn[0];
+        const expr = this.generateExpression(generationContext, dag, exprNodeID);
+        generationContext.write(`return ${expr}${semicolon}`);
+      } else {
+        generationContext.write(`return${semicolon}`);
+      }
     }
   },
   generateAssignment(generationContext, dag, nodeID) {
@@ -280,6 +338,17 @@ const wgslBackend = {
     const targetNode = getNodeDataFromID(dag, targetNodeID);
     const semicolon = generationContext.suppressSemicolon ? '' : ';';
 
+    // Check if target is an array access (storage buffer assignment)
+    if (targetNode.opCode === OpCode.Binary.ARRAY_ACCESS) {
+      const [bufferID, indexID] = targetNode.dependsOn;
+      const bufferExpr = this.generateExpression(generationContext, dag, bufferID);
+      const indexExpr = this.generateExpression(generationContext, dag, indexID);
+      const sourceExpr = this.generateExpression(generationContext, dag, sourceNodeID);
+      const fieldSuffix = targetNode.identifier ? `.${targetNode.identifier}` : '';
+      generationContext.write(`${bufferExpr}[i32(${indexExpr})]${fieldSuffix} = ${sourceExpr}${semicolon}`);
+      return;
+    }
+
     // Check if target is a swizzle assignment
     if (targetNode.opCode === OpCode.Unary.SWIZZLE) {
       const parentID = targetNode.dependsOn[0];
@@ -337,6 +406,10 @@ const wgslBackend = {
     return `var ${tmp}: ${typeName} = ${expr};`;
   },
   generateReturnStatement(strandsContext, generationContext, rootNodeID, returnType) {
+    if (!returnType) {
+      generationContext.write('return;');
+      return;
+    }
     const dag = strandsContext.dag;
     const rootNode = getNodeDataFromID(dag, rootNodeID);
     if (isStructType(returnType)) {
@@ -377,9 +450,15 @@ const wgslBackend = {
         }
       }
 
-      // Check if this is a uniform variable (but not a texture)
+      // Detect instanceID usage in fragment context and rewrite to varying name
+      if (node.identifier === this.instanceIdReference() && generationContext.shaderContext === 'fragment') {
+        generationContext.strandsContext._instanceIDUsedInFragment = true;
+        return INSTANCE_ID_VARYING_NAME;
+      }
+
+      // Check if this is a uniform variable (but not a texture or storage buffer)
       const uniform = generationContext.strandsContext?.uniforms?.find(uniform => uniform.name === node.identifier);
-      if (uniform && uniform.typeInfo.baseType !== 'sampler2D') {
+      if (uniform && uniform.typeInfo.baseType !== 'sampler2D' && uniform.typeInfo.baseType !== 'storage') {
         return `hooks.${node.identifier}`;
       }
 
@@ -398,6 +477,13 @@ const wgslBackend = {
         const deps = node.dependsOn.map((dep) => this.generateExpression(generationContext, dag, dep));
         return `${T}(${deps.join(', ')})`;
       }
+      if (node.opCode === OpCode.Nary.TERNARY) {
+        const [condID, trueID, falseID] = node.dependsOn;
+        const cond = this.generateExpression(generationContext, dag, condID);
+        const trueExpr = this.generateExpression(generationContext, dag, trueID);
+        const falseExpr = this.generateExpression(generationContext, dag, falseID);
+        return `select(${falseExpr}, ${trueExpr}, ${cond})`;
+      }
       if (node.opCode === OpCode.Nary.FUNCTION_CALL) {
         // Convert mod() function calls to % operator in WGSL
         if (node.identifier === 'mod' && node.dependsOn.length === 2) {
@@ -419,6 +505,18 @@ const wgslBackend = {
         }
 
         const functionArgs = node.dependsOn.map(arg =>this.generateExpression(generationContext, dag, arg));
+
+        if (node.identifier === 'random') {
+          const ctx = generationContext.shaderContext;
+          if (ctx === 'fragment') {
+            functionArgs.push('_p5FragPos.xy');
+          } else if (ctx === 'vertex') {
+            functionArgs.push('f32(_p5VertexId)');
+          } else if (ctx === 'compute') {
+            functionArgs.push('_p5GlobalId');
+          }
+        }
+
         return `${node.identifier}(${functionArgs.join(', ')})`;
       }
       if (node.opCode === OpCode.Binary.MEMBER_ACCESS) {
@@ -432,6 +530,13 @@ const wgslBackend = {
         const parentExpr = this.generateExpression(generationContext, dag, parentID);
         return `${parentExpr}.${node.swizzle}`;
       }
+      if (node.opCode === OpCode.Binary.ARRAY_ACCESS) {
+        const [bufferID, indexID] = node.dependsOn;
+        const bufferExpr = this.generateExpression(generationContext, dag, bufferID);
+        const indexExpr = this.generateExpression(generationContext, dag, indexID);
+        const fieldSuffix = node.identifier ? `.${node.identifier}` : '';
+        return `${bufferExpr}[i32(${indexExpr})]${fieldSuffix}`;
+      }
       if (node.dependsOn.length === 2) {
         const [lID, rID] = node.dependsOn;
         const left  = this.generateExpression(generationContext, dag, lID);
@@ -505,12 +610,25 @@ const wgslBackend = {
     const samplerVariable = variableNode(strandsContext, { baseType: BaseType.SAMPLER, dimension: 1 }, samplerIdentifier);
     const samplerNode = createStrandsNode(samplerVariable.id, samplerVariable.dimension, strandsContext);
 
-    // Create the augmented args: [texture, sampler, coords]
-    const augmentedArgs = [textureArg, samplerNode, coordsArg];
-
-    const { id, dimension } = functionCallNode(strandsContext, 'textureSample', augmentedArgs, {
+    // Create a LOD literal node (0.0) so we can use textureSampleLevel instead
+    // of textureSample. textureSample doesn't let you use uniform values in control
+    // flow, whereas textureSampleLevel does. While we don't have mipmaps, we don't
+    // miss out.
+    // TODO: if we *do* add mipmap support, update this logic -- we'd need to hoist
+    // the texture lookup out of the control flow.
+    const lodLiteral = scalarLiteralNode(
+      strandsContext,
+      { dimension: 1, baseType: BaseType.FLOAT },
+      0.0
+    );
+    const lodNode = createStrandsNode(lodLiteral.id, lodLiteral.dimension, strandsContext);
+
+    // Create the augmented args: [texture, sampler, coords, lod]
+    const augmentedArgs = [textureArg, samplerNode, coordsArg, lodNode];
+
+    const { id, dimension } = functionCallNode(strandsContext, 'textureSampleLevel', augmentedArgs, {
       overloads: [{
-        params: [DataType.sampler2D, DataType.sampler, DataType.float2],
+        params: [DataType.sampler2D, DataType.sampler, DataType.float2, DataType.float1],
         returnType: DataType.float4
       }]
     });
@@ -520,6 +638,10 @@ const wgslBackend = {
   instanceIdReference() {
     return 'instanceID';
   },
+
+  generateInstanceIDVarying() {
+    return { name: INSTANCE_ID_VARYING_NAME, declaration: `${INSTANCE_ID_VARYING_NAME}: i32`, source: 'i32(instanceID)', interpolation: 'flat' };
+  },
 };
 
 export { wgslBackend };