p5 2.3.0 → 2.3.1-rc.1

package/dist/strands/strands_api.js

@@ -1,4 +1,4 @@
-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-C8mrXj5z.js';
+import { u as unaryOpNode, c as createStrandsNode, S as StrandsNode, p as primitiveConstructorNode, v as variableNode, a as structInstanceNode, b as structConstructorNode, d as binaryOpNode, e as statementNode, f as functionCallNode } from '../ir_builders-CMXkjMoV.js';
 import { OperatorTable, StatementType, NodeType, DataType, BaseType, BlockType, isStructType, structType, HOOK_PARAM_PREFIX } from './ir_types.js';
 import { strandsBuiltinFunctions } from './strands_builtins.js';
 import { StrandsConditional } from './strands_conditionals.js';
@@ -6,7 +6,7 @@ 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';
+import { userError, dimensionMismatchError } from './strands_FES.js';
 import './strands_phi_utils.js';
 
 const BUILTIN_GLOBAL_SPECS = {
@@ -89,19 +89,116 @@ function installBuiltinGlobalAccessors(strandsContext) {
 
   for (const name of Object.keys(BUILTIN_GLOBAL_SPECS)) {
     const spec = BUILTIN_GLOBAL_SPECS[name];
-    Object.defineProperty(window, name, {
-      get: () => {
+    const backingKey = `_strands_${name}`;
+
+    // Define on window for global mode only
+    const inst = getRuntimeP5Instance();
+    if (inst?._isGlobal) {
+      Object.defineProperty(window, name, {
+        get: () => {
+          if (strandsContext.active) {
+            return getBuiltinGlobalNode(strandsContext, name);
+          }
+          const inst = getRuntimeP5Instance();
+          return spec.get(inst);
+        },
+        configurable: true,
+      });
+    }
+
+    // Capture original descriptor (held in closure for the getter to delegate to)
+    const originalProtoDesc = Object.getOwnPropertyDescriptor(strandsContext.p5.prototype, name);
+
+    // Define on p5.prototype for instance mode
+    Object.defineProperty(strandsContext.p5.prototype, name, {
+      get: function() {
         if (strandsContext.active) {
           return getBuiltinGlobalNode(strandsContext, name);
         }
-        const inst = getRuntimeP5Instance();
-          return spec.get(inst);
+        // If our setter stored a value on this instance, return it
+        if (Object.prototype.hasOwnProperty.call(this, backingKey)) {
+          return this[backingKey];
+        }
+        // Delegate to original getter (e.g. width -> this._renderer?.width)
+        if (originalProtoDesc?.get) {
+          return originalProtoDesc.get.call(this);
+        }
+        // Fall back to original value for data properties (like mouseX)
+        return originalProtoDesc?.value;
       },
+      set: function(val) {
+        this[backingKey] = val;
+      },
+      configurable: true,
     });
+
+    // Define on p5.Graphics.prototype for graphics mode
+    const GraphicsProto = strandsContext.p5?.Graphics?.prototype;
+    if (GraphicsProto) {
+      const originalDesc = Object.getOwnPropertyDescriptor(GraphicsProto, name);
+
+      Object.defineProperty(GraphicsProto, name, {
+        get: function() {
+          if (strandsContext.active) {
+            return getBuiltinGlobalNode(strandsContext, name);
+          }
+          // Delegate to original getter if it exists (class-level getters like width, deltaTime)
+          if (originalDesc?.get) {
+            return originalDesc.get.call(this);
+          }
+          return this[backingKey];
+        },
+        set: function(val) {
+          if (originalDesc?.set) {
+            originalDesc.set.call(this, val);
+          } else {
+            this[backingKey] = val;
+          }
+        },
+        configurable: true,
+      });
+    }
   }
   strandsContext._builtinGlobalsAccessorsInstalled = true;
 }
 
+function installInstanceIndexAccessor(strandsContext) {
+  if (strandsContext._instanceIndexAccessorInstalled) return;
+
+  const getRuntimeP5Instance = () => strandsContext.renderer?._pInst || strandsContext.p5?.instance;
+
+  const instanceIndexGetter = function() {
+    if (strandsContext.active) {
+      const node = variableNode(strandsContext, { baseType: BaseType.INT, dimension: 1 }, strandsContext.backend.instanceIdReference());
+      return createStrandsNode(node.id, node.dimension, strandsContext);
+    }
+    return undefined;
+  };
+
+  const inst = getRuntimeP5Instance();
+  if (inst?._isGlobal) {
+    Object.defineProperty(window, 'instanceIndex', {
+      get: instanceIndexGetter,
+      configurable: true,
+    });
+  }
+
+  Object.defineProperty(strandsContext.p5.prototype, 'instanceIndex', {
+    get: instanceIndexGetter,
+    configurable: true,
+  });
+
+  const GraphicsProto = strandsContext.p5?.Graphics?.prototype;
+  if (GraphicsProto) {
+    Object.defineProperty(GraphicsProto, 'instanceIndex', {
+      get: instanceIndexGetter,
+      configurable: true,
+    });
+  }
+
+  strandsContext._instanceIndexAccessorInstalled = true;
+}
+
 //////////////////////////////////////////////
 // Prototype mirroring helpers
 //////////////////////////////////////////////
@@ -275,7 +372,7 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
   const originalLerp = fn.lerp;
   augmentFn(fn, p5, 'lerp', function (...args) {
     if (strandsContext.active) {
-      return fn.mix(...args);
+      return this.mix(...args);
     } else {
       return originalLerp.apply(this, args);
     }
@@ -298,6 +395,139 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
     return result;
   });
 
+  const originalColor = fn.color;
+  augmentFn(fn, p5, 'color', function (...args) {
+    if (!strandsContext.active) {
+      return originalColor.apply(this, args);
+    }
+    // Reuse p5's parser - handles hex strings, rgb(), CSS named colors, numerics
+    const c = originalColor.apply(this, args);
+    // _getRGBA() returns [r, g, b, a] normalized to 0-1
+    const rgba = c._getRGBA();
+    const { id, dimension } = primitiveConstructorNode(
+      strandsContext,
+      { baseType: BaseType.FLOAT, dimension: null },
+      rgba
+    );
+    return createStrandsNode(id, dimension, strandsContext);
+  });
+  const originalLerpColor = fn.lerpColor;
+  augmentFn(fn, p5, 'lerpColor', function (...args) {
+    if (!strandsContext.active) {
+      return originalLerpColor.apply(this, args);
+    }
+    // In strands, colors are vec4s - lerpColor maps directly to GLSL mix()
+    return this.mix(...args);
+  });
+  // Component accessors: extract scalar channels from a vec4 color
+  const originalRed = fn.red;
+  augmentFn(fn, p5, 'red', function (...args) {
+    if (!strandsContext.active) {
+      return originalRed.apply(this, args);
+    }
+    return p5.strandsNode(args[0]).x;
+  });
+
+  const originalGreen = fn.green;
+  augmentFn(fn, p5, 'green', function (...args) {
+    if (!strandsContext.active) {
+      return originalGreen.apply(this, args);
+    }
+    return p5.strandsNode(args[0]).y;
+  });
+
+  const originalBlue = fn.blue;
+  augmentFn(fn, p5, 'blue', function (...args) {
+    if (!strandsContext.active) {
+      return originalBlue.apply(this, args);
+    }
+    return p5.strandsNode(args[0]).z;
+  });
+
+  const originalAlpha = fn.alpha;
+  augmentFn(fn, p5, 'alpha', function (...args) {
+    if (!strandsContext.active) {
+      return originalAlpha.apply(this, args);
+    }
+    return p5.strandsNode(args[0]).w;
+  });
+
+  // RGB to HSB conversion based on:
+  // https://en.wikipedia.org/wiki/HSL_and_HSV#From_RGB
+  // Using mix/step to avoid branching, via the compact form from:
+  // http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl
+  const _rgb2hsb = (instance, colorNode) => {
+  const r = colorNode.x;
+  const g = colorNode.y;
+  const b = colorNode.z;
+  const K = instance.vec4(0, -1/3, 2/3, -1);
+  const p = instance.mix(
+    instance.vec4(b, g, K.w, K.z),
+    instance.vec4(g, b, K.x, K.y),
+    instance.step(b, g)
+  );
+  const q = instance.mix(
+    instance.vec4(p.x, p.y, p.w, r),
+    instance.vec4(r, p.y, p.z, p.x),
+    instance.step(p.x, r)
+  );
+  const d = q.x.sub(instance.min(q.w, q.y));
+  const e = p5.strandsNode(1e-10);
+  const h = instance.abs(q.z.add(q.w.sub(q.y).div(d.mult(6).add(e))));
+  const s = d.div(q.x.add(e));
+  return instance.vec3(h, s, q.x);
+};
+
+const _rgb2hsl = (instance, colorNode) => {
+  const r = colorNode.x;
+  const g = colorNode.y;
+  const b = colorNode.z;
+  const maxC = instance.max(r, instance.max(g, b));
+  const minC = instance.min(r, instance.min(g, b));
+  const l = maxC.add(minC).div(2);
+  const d = maxC.sub(minC);
+  const e = p5.strandsNode(1e-10);
+  const s = instance.mix(
+    p5.strandsNode(0),
+    d.div(p5.strandsNode(1).sub(instance.abs(l.mult(2).sub(1)))),
+    instance.step(e, d)
+  );
+  const h_rg = instance.mod(g.sub(b).div(d.add(e)), p5.strandsNode(6)).div(6);
+  const h_gb = b.sub(r).div(d.add(e)).add(2).div(6);
+  const h_br = r.sub(g).div(d.add(e)).add(4).div(6);
+  const isR = instance.step(maxC.sub(e), r).mult(instance.step(r.sub(e), maxC));
+  const isG = instance.step(maxC.sub(e), g).mult(instance.step(g.sub(e), maxC));
+  const h = instance.mix(instance.mix(h_br, h_gb, isG), h_rg, isR);
+  return instance.vec3(h, s, l);
+};
+  const originalHue = fn.hue;
+  augmentFn(fn, p5, 'hue', function (...args) {
+    if (!strandsContext.active) return originalHue.apply(this, args);
+    const colorNode = p5.strandsNode(args[0]);
+    return _rgb2hsl(this, this.vec3(colorNode.x, colorNode.y, colorNode.z)).x;
+  });
+
+  const originalSaturation = fn.saturation;
+  augmentFn(fn, p5, 'saturation', function (...args) {
+    if (!strandsContext.active) return originalSaturation.apply(this, args);
+    const colorNode = p5.strandsNode(args[0]);
+    return _rgb2hsl(this, this.vec3(colorNode.x, colorNode.y, colorNode.z)).y;
+  });
+
+  const originalBrightness = fn.brightness;
+  augmentFn(fn, p5, 'brightness', function (...args) {
+    if (!strandsContext.active) return originalBrightness.apply(this, args);
+    const colorNode = p5.strandsNode(args[0]);
+    return _rgb2hsb(this, this.vec3(colorNode.x, colorNode.y, colorNode.z)).z;
+  });
+
+  const originalLightness = fn.lightness;
+  augmentFn(fn, p5, 'lightness', function (...args) {
+    if (!strandsContext.active) return originalLightness.apply(this, args);
+    const colorNode = p5.strandsNode(args[0]);
+    return _rgb2hsl(this, this.vec3(colorNode.x, colorNode.y, colorNode.z)).z;
+  });
+
   augmentFn(fn, p5, 'getTexture', function (...rawArgs) {
     if (strandsContext.active) {
       const { id, dimension } = strandsContext.backend.createGetTextureCall(strandsContext, rawArgs);
@@ -323,6 +553,7 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
   const originalNoise = fn.noise;
   const originalNoiseDetail = fn.noiseDetail;
   const originalRandom = fn.random;
+  const originalRandomGaussian=fn.randomGaussian;
   const originalRandomSeed = fn.randomSeed;
   const originalMillis = fn.millis;
 
@@ -466,6 +697,20 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
     }
   });
 
+   augmentFn(fn, p5, 'randomGaussian', function(...args){
+      if(!strandsContext.active){
+        return originalRandomGaussian.apply(this, args);
+      }
+      const mean = args.length >= 1 ? args[0] : 0;
+      const stdDev = args.length >= 2 ? args[1] : 1;
+
+      const u1 = this.max(this.random(), 1e-6);
+      const u2 = this.random();
+      const z = this.sqrt(this.log(u1).mult(-2)).mult(this.cos(u2.mult(2*Math.PI)));
+
+      return z.mult(stdDev).add(mean);
+    });
+
   augmentFn(fn, p5, 'millis', function (...args) {
     if (!strandsContext.active) {
       return originalMillis.apply(this, args);
@@ -657,6 +902,17 @@ function createHookArguments(strandsContext, parameters){
             return createStrandsNode(propNode.id, propNode.dimension, strandsContext, onRebind);
           },
           set(val) {
+            const valDim = val?.isStrandsNode
+              ? val.dimension
+              : (Array.isArray(val) ? val.length : 1);
+            if( valDim !== propertyType.dataType.dimension && valDim !== 1){
+              dimensionMismatchError(
+                propertyType.dataType.dimension,
+                valDim,
+                `${param.name}.${propertyType.name}`
+              );
+            }
+
             const oldDependsOn = dag.dependsOn[structNode.id];
             const newDependsOn = [...oldDependsOn];
             let newValueID;
@@ -734,6 +990,7 @@ function enforceReturnTypeMatch(strandsContext, expectedType, returned, hookName
 }
 function createShaderHooksFunctions(strandsContext, fn, shader) {
   installBuiltinGlobalAccessors(strandsContext);
+  installInstanceIndexAccessor(strandsContext);
 
   // Add shader context to hooks before spreading
   const vertexHooksWithContext = Object.fromEntries(
@@ -766,6 +1023,54 @@ function createShaderHooksFunctions(strandsContext, fn, shader) {
     hook.set = function(result) {
       hook._result = result;
     };
+    hook._active = false;
+
+    const numStructArgs = hookType.parameters.filter(
+      param => param.type && param.type.properties
+    ).length;
+    let argIdx = -1;
+    if (numStructArgs === 1) {
+      argIdx = hookType.parameters.findIndex(
+        param => param.type && param.type.properties
+      );
+    }
+    if (argIdx >= 0) {
+      const structParam = hookType.parameters[argIdx];
+      if (structParam.type.properties) {
+        const nameMatch = /^get([A-Z0-9]\w*)$/.exec(hookType.name);
+        const displayName = nameMatch
+          ? nameMatch[1][0].toLowerCase() + nameMatch[1].slice(1)
+          : hookType.name;
+        for (const prop of structParam.type.properties) {
+          const key = prop.name;
+          Object.defineProperty(hook, key, {
+            get() {
+              if (!this._active) {
+                userError(
+                  'scope error',
+                  `It looks like you're trying to access "${displayName}.${key}" outside of its begin()/end() block.\n\n` +
+                  `Properties of ${displayName} are only available between ` +
+                  `${displayName}.begin() and ${displayName}.end().\n\n` +
+                  `To share data between hooks, use sharedVec3() or sharedFloat() ` +
+                  `to pass values between them.`
+                );
+              }
+              return this._args[this._argIdx][key];
+            },
+            set(val) {
+              if (!this._active) {
+                userError(
+                  'scope error',
+                  `It looks like you're trying to set "${displayName}.${key}" outside of its begin()/end() block.`
+                );
+              }
+              this._args[this._argIdx][key] = val;
+            },
+            enumerable: true,
+          });
+        }
+      }
+    }
 
     let entryBlockID;
     function setupHook() {
@@ -774,25 +1079,14 @@ function createShaderHooksFunctions(strandsContext, fn, shader) {
       addEdge(cfg, cfg.currentBlock, entryBlockID);
       pushBlock(cfg, entryBlockID);
       const args = createHookArguments(strandsContext, hookType.parameters);
-      const numStructArgs = hookType.parameters.filter(param => param.type.properties).length;
-      let argIdx = -1;
-      if (numStructArgs === 1) {
-        argIdx = hookType.parameters.findIndex(param => param.type.properties);
-      }
+      hook._active = true;
+      hook._args = args;
+      hook._argIdx = argIdx;
       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];
-              },
-              set(val) {
-                args[argIdx][key] = val;
-              },
-              enumerable: true,
-            });
           }
           if (hookType.returnType?.typeName === hookType.parameters[argIdx].type.typeName) {
             hook.set(args[argIdx]);
@@ -805,6 +1099,7 @@ function createShaderHooksFunctions(strandsContext, fn, shader) {
       return args;
     }
     function finishHook() {
+      hook._active = false;
       const userReturned = hook._result;
       strandsContext.activeHook = undefined;
 

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-C8mrXj5z.js';
+import { c as createStrandsNode } from '../ir_builders-CMXkjMoV.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-C8mrXj5z.js';
+import { c as createStrandsNode, p as primitiveConstructorNode } from '../ir_builders-CMXkjMoV.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-C8mrXj5z.js';
+export { S as StrandsNode, c as createStrandsNode } from '../ir_builders-CMXkjMoV.js';
 import './ir_types.js';
 import './ir_dag.js';
 import './ir_cfg.js';

package/dist/strands/strands_ternary.js

@@ -1,7 +1,7 @@
 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-C8mrXj5z.js';
+import { c as createStrandsNode } from '../ir_builders-CMXkjMoV.js';
 import { userError } from './strands_FES.js';
 import './strands_builtins.js';
 

package/dist/{strands_glslBackend-D6G3UyCs.js → strands_glslBackend-DMhOnoGl.js}

@@ -1,7 +1,7 @@
 import { INSTANCE_ID_VARYING_NAME, NodeTypeToName, NodeType, OpCode, BaseType, OpCodeToSymbol, isStructType, StatementType, HOOK_PARAM_PREFIX, DataType, BlockType } from './strands/ir_types.js';
 import { getNodeDataFromID, extractNodeTypeInfo } from './strands/ir_dag.js';
 import { internalError } from './strands/strands_FES.js';
-import { f as functionCallNode } from './ir_builders-C8mrXj5z.js';
+import { f as functionCallNode } from './ir_builders-CMXkjMoV.js';
 
 var noiseGLSL = "// Based on https://github.com/stegu/webgl-noise/blob/22434e04d7753f7e949e8d724ab3da2864c17a0f/src/noise3D.glsl\n// MIT licensed, adapted for p5.strands\n\nvec3 mod289(vec3 x) {\n  return x - floor(x * (1.0 / 289.0)) * 289.0;\n}\n\nvec4 mod289(vec4 x) {\n  return x - floor(x * (1.0 / 289.0)) * 289.0;\n}\n\nvec4 permute(vec4 x) {\n  return mod289(((x*34.0)+10.0)*x);\n}\n\nvec4 taylorInvSqrt(vec4 r)\n{\n  return 1.79284291400159 - 0.85373472095314 * r;\n}\n\nfloat baseNoise(vec3 v)\n{\n  const vec2  C = vec2(1.0/6.0, 1.0/3.0) ;\n  const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);\n\n  // First corner\n  vec3 i  = floor(v + dot(v, C.yyy) );\n  vec3 x0 =   v - i + dot(i, C.xxx) ;\n\n  // Other corners\n  vec3 g = step(x0.yzx, x0.xyz);\n  vec3 l = 1.0 - g;\n  vec3 i1 = min( g.xyz, l.zxy );\n  vec3 i2 = max( g.xyz, l.zxy );\n\n  //   x0 = x0 - 0.0 + 0.0 * C.xxx;\n  //   x1 = x0 - i1  + 1.0 * C.xxx;\n  //   x2 = x0 - i2  + 2.0 * C.xxx;\n  //   x3 = x0 - 1.0 + 3.0 * C.xxx;\n  vec3 x1 = x0 - i1 + C.xxx;\n  vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y\n  vec3 x3 = x0 - D.yyy;      // -1.0+3.0*C.x = -0.5 = -D.y\n\n  // Permutations\n  i = mod289(i);\n  vec4 p = permute( permute( permute(\n          i.z + vec4(0.0, i1.z, i2.z, 1.0 ))\n        + i.y + vec4(0.0, i1.y, i2.y, 1.0 ))\n      + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));\n\n  // Gradients: 7x7 points over a square, mapped onto an octahedron.\n  // The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)\n  float n_ = 0.142857142857; // 1.0/7.0\n  vec3  ns = n_ * D.wyz - D.xzx;\n\n  vec4 j = p - 49.0 * floor(p * ns.z * ns.z);  //  mod(p,7*7)\n\n  vec4 x_ = floor(j * ns.z);\n  vec4 y_ = floor(j - 7.0 * x_ );    // mod(j,N)\n\n  vec4 x = x_ *ns.x + ns.yyyy;\n  vec4 y = y_ *ns.x + ns.yyyy;\n  vec4 h = 1.0 - abs(x) - abs(y);\n\n  vec4 b0 = vec4( x.xy, y.xy );\n  vec4 b1 = vec4( x.zw, y.zw );\n\n  //vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;\n  //vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;\n  vec4 s0 = floor(b0)*2.0 + 1.0;\n  vec4 s1 = floor(b1)*2.0 + 1.0;\n  vec4 sh = -step(h, vec4(0.0));\n\n  vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;\n  vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;\n\n  vec3 p0 = vec3(a0.xy,h.x);\n  vec3 p1 = vec3(a0.zw,h.y);\n  vec3 p2 = vec3(a1.xy,h.z);\n  vec3 p3 = vec3(a1.zw,h.w);\n\n  //Normalise gradients\n  vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));\n  p0 *= norm.x;\n  p1 *= norm.y;\n  p2 *= norm.z;\n  p3 *= norm.w;\n\n  // Mix final noise value\n  vec4 m = max(0.5 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);\n  m = m * m;\n  return 105.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1),\n        dot(p2,x2), dot(p3,x3) ) );\n}\n\nfloat noise(vec3 st, int octaves, float ampFalloff) {\n  float result = 0.0;\n  float amplitude = 1.0;\n  float frequency = 1.0;\n\n  for (int i = 0; i < 8; i++) {\n    if (i >= octaves) break;\n    result += amplitude * baseNoise(st * frequency);\n    frequency *= 2.0;\n    amplitude *= ampFalloff;\n  }\n  return (result + 1.0) * 0.5;\n}\n";
 
@@ -253,7 +253,7 @@ const glslBackend = {
     }
     const dag = strandsContext.dag;
     const rootNode = getNodeDataFromID(dag, rootNodeID);
-    if (isStructType(returnType)) {
+    if (isStructType(returnType) && rootNode.identifier) {
       const structTypeInfo = returnType;
       for (let i = 0; i < structTypeInfo.properties.length; i++) {
         const prop = structTypeInfo.properties[i];

package/dist/type/index.js

@@ -1,10 +1,10 @@
 import textCore from './textCore.js';
 import font from './p5.Font.js';
-import '../p5.Renderer-XOvhEbJn.js';
-import '../creating_reading-DLkHH80h.js';
+import '../p5.Renderer-op0Y1WO6.js';
+import '../creating_reading-YUSK33h8.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
-import '../constants-Dv6ZqA6s.js';
+import '../constants-Bx3_xAam.js';
 import '../image/filters.js';
 import '../math/p5.Vector.js';
 import '../shape/custom_shapes.js';

package/dist/type/p5.Font.js

@@ -1,12 +1,12 @@
 import { textCoreConstants } from './textCore.js';
-import { t as CENTER, aa as RIGHT, s as RADIUS } from '../constants-Dv6ZqA6s.js';
+import { t as CENTER, aa as RIGHT, s as RADIUS } from '../constants-Bx3_xAam.js';
 import { UnicodeRange } from '@japont/unicode-range';
 import { unicodeRanges } from './unicodeRanges.js';
 import { Vector } from '../math/p5.Vector.js';
 import Typr from './lib/Typr.js';
 import { createFromCommands } from '@davepagurek/bezier-path';
-import '../p5.Renderer-XOvhEbJn.js';
-import '../creating_reading-DLkHH80h.js';
+import '../p5.Renderer-op0Y1WO6.js';
+import '../creating_reading-YUSK33h8.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
 import '../image/filters.js';
@@ -266,7 +266,7 @@ class Font {
    * coordinates of the bounding box's bottom-left corner. See
    * <a href="#/p5/textAlign">textAlign()</a> for more ways to align text.
    *
-   * The fourth parameter, `options`, is also optional. `font.textToPoints()`
+   * The fourth parameter, `options`, is also optional. `font.textToContours()`
    * expects an object with the following properties:
    *
    * `sampleFactor` is the ratio of the text's path length to the number of
@@ -349,6 +349,15 @@ class Font {
    *
    * The generated model (a Geometry object) can be manipulated further—rotated, scaled,
    * or styled with shaders—to create engaging, interactive visual art.
+   * 
+   * The `options` parameter is also optional. `font.textToModel()` expects an object 
+   * with the following properties:
+   * 
+   * `extrude` is the depth to extrude the text. It defaults to 0. A value of 0 produces
+   * flat text; higher values create thicker, 3D models.
+   * 
+   * `sampleFactor` is a factor controlling the level of detail for the text contours.
+   * It defaults to 1. Higher values result in smoother curves.
    *
    * @param {String} str The text string to convert into a 3D model.
    * @param {Number} x The x-coordinate for the starting position of the text.

package/dist/type/textCore.js

@@ -1,8 +1,8 @@
-import { R as Renderer } from '../p5.Renderer-XOvhEbJn.js';
-import '../creating_reading-DLkHH80h.js';
+import { R as Renderer } from '../p5.Renderer-op0Y1WO6.js';
+import '../creating_reading-YUSK33h8.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
-import '../constants-Dv6ZqA6s.js';
+import '../constants-Bx3_xAam.js';
 import '../image/filters.js';
 import '../math/p5.Vector.js';
 import '../shape/custom_shapes.js';

package/dist/webgl/3d_primitives.js

@@ -1,17 +1,17 @@
-import '../constants-Dv6ZqA6s.js';
-export { p as default } from '../rendering-C5lX6zKm.js';
+import '../constants-Bx3_xAam.js';
+export { p as default } from '../rendering-SZ71KIDM.js';
 import '../math/p5.Vector.js';
 import './p5.Geometry.js';
 import '../math/p5.Matrix.js';
 import '../math/Matrices/Matrix.js';
-import '../creating_reading-DLkHH80h.js';
+import '../creating_reading-YUSK33h8.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
 import '../strands/ir_types.js';
 import '../dom/p5.Element.js';
 import '../dom/p5.File.js';
 import '../io/p5.XML.js';
-import '../p5.Renderer-XOvhEbJn.js';
+import '../p5.Renderer-op0Y1WO6.js';
 import '../image/filters.js';
 import '../shape/custom_shapes.js';
 import '../core/States.js';

package/dist/webgl/GeometryBuilder.js

@@ -1,4 +1,4 @@
-import { T as TRIANGLE_STRIP, Y as QUAD_STRIP, X as TRIANGLE_FAN, c as TRIANGLES } from '../constants-Dv6ZqA6s.js';
+import { T as TRIANGLE_STRIP, Y as QUAD_STRIP, X as TRIANGLE_FAN, c as TRIANGLES } from '../constants-Bx3_xAam.js';
 import '../math/p5.Matrix.js';
 import { Geometry } from './p5.Geometry.js';
 import { Matrix } from '../math/Matrices/Matrix.js';

package/dist/webgl/ShapeBuilder.js

@@ -1,4 +1,4 @@
-import { z as PATH, V as QUADS, Y as QUAD_STRIP, T as TRIANGLE_STRIP, c as TRIANGLES, ae as IMAGE, Q as LINES, X as TRIANGLE_FAN } from '../constants-Dv6ZqA6s.js';
+import { z as PATH, V as QUADS, Y as QUAD_STRIP, T as TRIANGLE_STRIP, c as TRIANGLES, ae as IMAGE, Q as LINES, X as TRIANGLE_FAN } from '../constants-Bx3_xAam.js';
 import { Geometry } from './p5.Geometry.js';
 import libtess from 'libtess';
 import { Vector } from '../math/p5.Vector.js';

package/dist/webgl/enums.js

@@ -1,4 +1,4 @@
-import { am as constants } from '../constants-Dv6ZqA6s.js';
+import { am as constants } from '../constants-Bx3_xAam.js';
 
 function getStrokeDefs(shaderConstant) {
   const STROKE_CAP_ENUM = {};

package/dist/webgl/index.js

@@ -1,4 +1,4 @@
-import { r as renderer3D, p as primitives3D, a as light, m as material, c as camera, b as framebuffer, t as texture } from '../rendering-C5lX6zKm.js';
+import { r as renderer3D, p as primitives3D, a as light, m as material, c as camera, b as framebuffer, t as texture } from '../rendering-SZ71KIDM.js';
 import interaction from './interaction.js';
 import loading from './loading.js';
 import text from './text.js';
@@ -8,15 +8,15 @@ import matrix from '../math/p5.Matrix.js';
 import geometry from './p5.Geometry.js';
 import dataArray from './p5.DataArray.js';
 import rendererGL from './p5.RendererGL.js';
-import '../constants-Dv6ZqA6s.js';
-import '../creating_reading-DLkHH80h.js';
+import '../constants-Bx3_xAam.js';
+import '../creating_reading-YUSK33h8.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
 import '../strands/ir_types.js';
 import '../dom/p5.Element.js';
 import '../dom/p5.File.js';
 import '../io/p5.XML.js';
-import '../p5.Renderer-XOvhEbJn.js';
+import '../p5.Renderer-op0Y1WO6.js';
 import '../image/filters.js';
 import '../math/p5.Vector.js';
 import '../shape/custom_shapes.js';
@@ -51,10 +51,10 @@ import '../type/unicodeRanges.js';
 import '../type/lib/Typr.js';
 import 'pako';
 import '@davepagurek/bezier-path';
-import '../strands_glslBackend-D6G3UyCs.js';
+import '../strands_glslBackend-DMhOnoGl.js';
 import '../strands/ir_dag.js';
 import '../strands/strands_FES.js';
-import '../ir_builders-C8mrXj5z.js';
+import '../ir_builders-CMXkjMoV.js';
 import '../strands/ir_cfg.js';
 import '../strands/strands_builtins.js';
 import './shaderHookUtils.js';

package/dist/webgl/interaction.js

@@ -1,4 +1,4 @@
-import { a5 as GRID, a6 as AXES } from '../constants-Dv6ZqA6s.js';
+import { a5 as GRID, a6 as AXES } from '../constants-Bx3_xAam.js';
 import { Vector } from '../math/p5.Vector.js';
 
 /**