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

package/lib/p5.esm.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 */
 /**
  * @module Constants
  * @submodule Constants
@@ -12,7 +12,7 @@ const _PI = Math.PI;
  * @property {String} VERSION
  * @final
  */
-const VERSION = '2.2.2-rc.0';
+const VERSION = '2.2.2-rc.2';
 
 // GRAPHICS RENDERER
 /**
@@ -12611,11 +12611,11 @@ function creatingReading(p5, fn){
    * 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.
@@ -132382,32 +132382,45 @@ function _getBuiltinGlobalsCache(strandsContext) {
   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) {
@@ -132570,6 +132583,7 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
   // 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;
@@ -132632,6 +132646,21 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
     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