p5 2.2.2-rc.0 → 2.2.2-rc.2

package/lib/p5.js

@@ -1,4 +1,4 @@
-/*! p5.js v2.2.2-rc.0 February 18, 2026 */
+/*! p5.js v2.2.2-rc.2 February 21, 2026 */
 var p5 = (function () {
   'use strict';
 
@@ -15,7 +15,7 @@ var p5 = (function () {
    * @property {String} VERSION
    * @final
    */
-  const VERSION = '2.2.2-rc.0';
+  const VERSION = '2.2.2-rc.2';
 
   // GRAPHICS RENDERER
   /**
@@ -12614,11 +12614,11 @@ var p5 = (function () {
      * values. 0 is equal to the first color, 0.1 is very near the first color,
      * 0.5 is halfway between the two colors, and so on. Negative numbers are set
      * to 0. Numbers greater than 1 are set to 1. This differs from the behavior of
-     * <a href="#/lerp">lerp</a>. It's necessary because numbers outside of the
+     * <a href="#/p5/lerp">lerp</a>. It's necessary because numbers outside of the
      * interval [0, 1] will produce strange and unexpected colors.
      *
      * The way that colors are interpolated depends on the current
-     * <a href="#/colorMode">colorMode()</a>.
+     * <a href="#/p5/colorMode">colorMode()</a>.
      *
      * @method lerpColor
      * @param  {p5.Color} c1  interpolate from this color.
@@ -132385,32 +132385,45 @@ var p5 = (function () {
     return strandsContext._builtinGlobals
   }
 
-  function getBuiltinGlobalNode(strandsContext, name) {
-    const spec = BUILTIN_GLOBAL_SPECS[name];
-    if (!spec) return null
-
+  function getOrCreateUniformNode(strandsContext, uniformName, typeInfo, defaultValueFn) {
     const cache = _getBuiltinGlobalsCache(strandsContext);
-    const uniformName = `_p5_global_${name}`;
+
     const cached = cache.nodes.get(uniformName);
-    if (cached) return cached
+    if (cached) return cached;
 
     if (!cache.uniformsAdded.has(uniformName)) {
       cache.uniformsAdded.add(uniformName);
       strandsContext.uniforms.push({
         name: uniformName,
-        typeInfo: spec.typeInfo,
-        defaultValue: () => {
-          const p5Instance = strandsContext.renderer?._pInst || strandsContext.p5?.instance;
-          return p5Instance ? spec.get(p5Instance) : undefined
-        },
+        typeInfo,
+        defaultValue: defaultValueFn,
       });
     }
 
-    const { id, dimension } = variableNode(strandsContext, spec.typeInfo, uniformName);
+    const { id, dimension } = variableNode(strandsContext, typeInfo, uniformName);
     const node = createStrandsNode(id, dimension, strandsContext);
-    node._originalBuiltinName = name;
     cache.nodes.set(uniformName, node);
-    return node
+    return node;
+  }
+
+  function getBuiltinGlobalNode(strandsContext, name) {
+    const spec = BUILTIN_GLOBAL_SPECS[name];
+    if (!spec) return null;
+
+    const uniformName = `_p5_global_${name}`;
+    const instance = strandsContext.renderer?._pInst || strandsContext.p5?.instance;
+
+    const node = getOrCreateUniformNode(
+      strandsContext,
+      uniformName,
+      spec.typeInfo,
+      () => {
+        return instance ? spec.get(instance) : undefined;
+      }
+    );
+
+    node._originalBuiltinName = name;
+    return node;
   }
 
   function installBuiltinGlobalAccessors(strandsContext) {
@@ -132573,6 +132586,7 @@ var p5 = (function () {
     // Add noise function with backend-agnostic implementation
     const originalNoise = fn.noise;
     const originalNoiseDetail = fn.noiseDetail;
+    const originalMillis = fn.millis;
 
     strandsContext._noiseOctaves = null;
     strandsContext._noiseAmpFalloff = null;
@@ -132635,6 +132649,21 @@ var p5 = (function () {
       return createStrandsNode(id, dimension, strandsContext);
     };
 
+    fn.millis = function (...args) {
+      if (!strandsContext.active) {
+        return originalMillis.apply(this, args);
+      }
+      const instance = strandsContext.renderer?._pInst || strandsContext.p5?.instance;
+      return getOrCreateUniformNode(
+        strandsContext,
+        '_p5_global_millis',
+        DataType.float1,
+        () => {
+          return instance ? instance.millis() : undefined;
+        }
+      );
+    };
+
     // Next is type constructors and uniform functions.
     // For some of them, we have aliases so that you can write either a more human-readable
     // variant or also one more directly translated from GLSL, or to be more compatible with