p5 2.3.0 → 2.3.1-rc.1

package/dist/{rendering-C5lX6zKm.js → rendering-SZ71KIDM.js}

@@ -1,8 +1,8 @@
-import { n as CORNER, r as CORNERS, t as CENTER, aB as COVER, aC as CONTAIN, aa as RIGHT, aw as BOTTOM, B as BLEND, aD as FILL, ae as IMAGE, C as CLAMP, u as ROUND, Q as LINES, K as POINTS, c as TRIANGLES, ac as BLUR, D as DARKEST, L as LIGHTEST, A as ADD, S as SUBTRACT, a as SCREEN, E as EXCLUSION, R as REPLACE, M as MULTIPLY, b as REMOVE, au as BURN, aq as OVERLAY, ar as HARD_LIGHT, as as SOFT_LIGHT, at as DODGE, d as UNSIGNED_INT, U as UNSIGNED_BYTE, av as LEFT, ax as BASELINE, ay as TOP, aE as SIMPLE, aF as FULL, o as TWO_PI, O as OPEN, a1 as NORMAL, J as CLOSE, a0 as PIE, $ as CHORD, a7 as TEXTURE, P as P2D, g as LINEAR, ab as WEBGL2, N as NEAREST, aG as LINEAR_MIPMAP, f as REPEAT, e as MIRROR, F as FLOAT, ad as WEBGL, H as HALF_FLOAT, W as WEBGPU } from './constants-Dv6ZqA6s.js';
-import { C as Color, c as creatingReading, h as RGBA, R as RGB } from './creating_reading-DLkHH80h.js';
+import { n as CORNER, r as CORNERS, t as CENTER, aB as COVER, aC as CONTAIN, aa as RIGHT, aw as BOTTOM, B as BLEND, aD as FILL, ae as IMAGE, C as CLAMP, u as ROUND, Q as LINES, K as POINTS, c as TRIANGLES, ac as BLUR, D as DARKEST, L as LIGHTEST, A as ADD, S as SUBTRACT, a as SCREEN, E as EXCLUSION, R as REPLACE, M as MULTIPLY, b as REMOVE, au as BURN, aq as OVERLAY, ar as HARD_LIGHT, as as SOFT_LIGHT, at as DODGE, d as UNSIGNED_INT, U as UNSIGNED_BYTE, av as LEFT, ax as BASELINE, ay as TOP, aE as SIMPLE, aF as FULL, o as TWO_PI, O as OPEN, a1 as NORMAL, J as CLOSE, a0 as PIE, $ as CHORD, a7 as TEXTURE, P as P2D, g as LINEAR, ab as WEBGL2, N as NEAREST, aG as LINEAR_MIPMAP, f as REPEAT, e as MIRROR, F as FLOAT, ad as WEBGL, H as HALF_FLOAT, W as WEBGPU } from './constants-Bx3_xAam.js';
+import { C as Color, c as creatingReading, h as RGBA, R as RGB } from './creating_reading-YUSK33h8.js';
 import './strands/ir_types.js';
 import { Element } from './dom/p5.Element.js';
-import { R as Renderer, I as Image } from './p5.Renderer-XOvhEbJn.js';
+import { R as Renderer, I as Image$1 } from './p5.Renderer-op0Y1WO6.js';
 import { MediaElement } from './dom/p5.MediaElement.js';
 import primitives from './shape/2d_primitives.js';
 import attributes from './shape/attributes.js';
@@ -2973,8 +2973,19 @@ function loadingDisplaying(p5, fn){
 
       } else {
         // Non-GIF Section
-        const blob = new Blob([data]);
-        const img = await createImageBitmap(blob);
+        const img = await new Promise((resolve, reject) => {
+          const img = new Image();
+          const blob = new Blob([data], { type: contentType });
+          const url = URL.createObjectURL(blob);
+
+          img.onerror = e => reject(e);
+          img.onload = () => {
+            URL.revokeObjectURL(url);
+            resolve(img);
+          };
+
+          img.src = url;
+        });
 
         pImg.width = pImg.canvas.width = img.width;
         pImg.height = pImg.canvas.height = img.height;
@@ -9594,7 +9605,11 @@ class Renderer3D extends Renderer {
     // the next time a shader is used. However, the texture() function
     // works differently and is global p5 state. If the p5 state has
     // been cleared, we also need to clear the value in uSampler to match.
-    fillShader.setUniform("uSampler", this.states._tex || empty);
+    this._settingFillUniforms = true;
+    if (this.states._tex || !fillShader._userSetSampler) {
+      fillShader.setUniform("uSampler", this.states._tex || empty);
+    }
+    this._settingFillUniforms = false;
     fillShader.setUniform(
       "uTint",
       this.states.tint?._getRGBA([255, 255, 255, 255]) ?? [255, 255, 255, 255]
@@ -9717,7 +9732,7 @@ class Renderer3D extends Renderer {
   _getEmptyTexture() {
     if (!this._emptyTexture) {
       // a plain white texture RGBA, full alpha, single pixel.
-      const im = new Image(1, 1);
+      const im = new Image$1(1, 1);
       im.set(0, 0, 255);
       this._emptyTexture = new Texture(this, im);
     }
@@ -17172,7 +17187,7 @@ function material(p5, fn) {
    *   // Replace alpha in the color with dithering by
    *   // randomly setting pixel colors to 0 based on opacity
    *   let a = 1;
-   *   if (noise(pixelInputs.position.xy) > pixelInputs.color.a) {
+   *   if (random() > pixelInputs.color.a) {
    *     a = 0;
    *   }
    *   pixelInputs.color.a = a;
@@ -19621,7 +19636,7 @@ class Texture {
   _detectSourceType() {
     const obj = this.src;
     this.isFramebufferTexture = obj instanceof FramebufferTexture;
-    this.isSrcP5Image = obj instanceof Image;
+    this.isSrcP5Image = obj instanceof Image$1;
     this.isSrcP5Graphics = obj instanceof Graphics;
     this.isSrcP5Renderer = obj instanceof Renderer;
     this.isImageData = typeof ImageData !== 'undefined' && obj instanceof ImageData;

package/dist/shape/2d_primitives.js

@@ -1,4 +1,4 @@
-import { n as CORNER, o as TWO_PI, p as HALF_PI, q as PI } from '../constants-Dv6ZqA6s.js';
+import { n as CORNER, o as TWO_PI, p as HALF_PI, q as PI } from '../constants-Bx3_xAam.js';
 import canvas from '../core/helpers.js';
 
 /**

package/dist/shape/attributes.js

@@ -1,4 +1,4 @@
-import { n as CORNER, r as CORNERS, s as RADIUS, t as CENTER, u as ROUND, v as SQUARE, w as PROJECT, x as BEVEL, y as MITER } from '../constants-Dv6ZqA6s.js';
+import { n as CORNER, r as CORNERS, s as RADIUS, t as CENTER, u as ROUND, v as SQUARE, w as PROJECT, x as BEVEL, y as MITER } from '../constants-Bx3_xAam.js';
 
 /**
  * @module Shape
@@ -514,8 +514,9 @@ function attributes(p5, fn){
    * Sets the width of the stroke used for points, lines, and the outlines of
    * shapes.
    *
-   * Note: `strokeWeight()` is affected by transformations, especially calls to
-   * <a href="#/p5/scale">scale()</a>.
+   * Note: In 2D mode, `strokeWeight()` is affected by transformations,
+   * especially calls to <a href="#/p5/scale">scale()</a>. It isn't affected by
+   * transformations in WebGL and WebGPU modes.
    * 
    * Calling `strokeWeight()` without an argument returns the current stroke weight as a number.
    *

package/dist/shape/custom_shapes.js

@@ -1,6 +1,6 @@
-import { C as Color } from '../creating_reading-DLkHH80h.js';
+import { C as Color } from '../creating_reading-YUSK33h8.js';
 import { Vector } from '../math/p5.Vector.js';
-import { I as INCLUDE, z as PATH, G as EMPTY_PATH, O as OPEN, J as CLOSE, K as POINTS, Q as LINES, c as TRIANGLES, V as QUADS, X as TRIANGLE_FAN, T as TRIANGLE_STRIP, Y as QUAD_STRIP, Z as EXCLUDE, _ as JOIN, $ as CHORD, a0 as PIE } from '../constants-Dv6ZqA6s.js';
+import { I as INCLUDE, z as PATH, G as EMPTY_PATH, O as OPEN, J as CLOSE, K as POINTS, Q as LINES, c as TRIANGLES, V as QUADS, X as TRIANGLE_FAN, T as TRIANGLE_STRIP, Y as QUAD_STRIP, Z as EXCLUDE, _ as JOIN, $ as CHORD, a0 as PIE } from '../constants-Bx3_xAam.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
 
@@ -545,6 +545,47 @@ class EllipsePrimitive extends ShapePrimitive {
   }
 }
 
+class RectPrimitive extends ShapePrimitive {
+  #x;
+  #y;
+  #w;
+  #h;
+  #tl;
+  #tr;
+  #br;
+  #bl;
+  #vertexCapacity = 1;
+
+  constructor(startVertex, x, y, w, h, tl, tr, br, bl) {
+    super(startVertex);
+    this.#x = x;
+    this.#y = y;
+    this.#w = w;
+    this.#h = h;
+    this.#tl = tl;
+    this.#tr = tr;
+    this.#br = br;
+    this.#bl = bl;
+  }
+
+  get x() { return this.#x; }
+  get y() { return this.#y; }
+  get w() { return this.#w; }
+  get h() { return this.#h; }
+  get tl() { return this.#tl; }
+  get tr() { return this.#tr; }
+  get br() { return this.#br; }
+  get bl() { return this.#bl; }
+
+  get vertexCapacity() {
+    return this.#vertexCapacity;
+  }
+
+  accept(visitor) {
+    visitor.visitRectPrimitive(this);
+  }
+}
+
 // ---- TESSELLATION PRIMITIVES ----
 
 class TriangleFan extends ShapePrimitive {
@@ -1027,6 +1068,42 @@ class Shape {
     return primitive.addToShape(this);
   }
 
+  rectPrimitive(x, y, w, h, tl, tr, br, bl) {
+    const startVertex = this.#createVertex(new Vector(x, y));
+    const primitive = new RectPrimitive(startVertex, x, y, w, h, tl, tr, br, bl);
+    return primitive.addToShape(this);
+  }
+
+  point(x, y) {
+    const v0 = this.#createVertex(new Vector(x, y));
+    const primitive = new Point(v0);
+    return primitive.addToShape(this);
+  }
+
+  line(x1, y1, x2, y2) {
+    const v0 = this.#createVertex(new Vector(x1, y1));
+    const v1 = this.#createVertex(new Vector(x2, y2));
+    const primitive = new Line(v0, v1);
+    return primitive.addToShape(this);
+  }
+
+  triangle(x1, y1, x2, y2, x3, y3) {
+    const v0 = this.#createVertex(new Vector(x1, y1));
+    const v1 = this.#createVertex(new Vector(x2, y2));
+    const v2 = this.#createVertex(new Vector(x3, y3));
+    const primitive = new Triangle(v0, v1, v2);
+    return primitive.addToShape(this);
+  }
+
+  quad(x1, y1, x2, y2, x3, y3, x4, y4) {
+    const v0 = this.#createVertex(new Vector(x1, y1));
+    const v1 = this.#createVertex(new Vector(x2, y2));
+    const v2 = this.#createVertex(new Vector(x3, y3));
+    const v3 = this.#createVertex(new Vector(x4, y4));
+    const primitive = new Quad(v0, v1, v2, v3);
+    return primitive.addToShape(this);
+  }
+
   beginContour(shapeKind = PATH) {
     if (this.at(-1)?.kind === EMPTY_PATH) {
       this.contours.pop();
@@ -1131,6 +1208,9 @@ class PrimitiveVisitor {
   visitEllipsePrimitive(ellipse) {
     throw new Error('Method visitEllipsePrimitive() has not been implemented.');
   }
+  visitRectPrimitive(rect) {
+    throw new Error('Method visitRectPrimitive() has not been implemented.');
+  }
 
   // isolated primitives
   visitPoint(point) {
@@ -1334,6 +1414,62 @@ class PrimitiveToPath2DConverter extends PrimitiveVisitor {
     this.path.moveTo(centerX + radiusX, centerY);
     this.path.ellipse(centerX, centerY, radiusX, radiusY, 0, 0, 2 * Math.PI);
   }
+  visitRectPrimitive(rect) {
+    const x = rect.x;
+    const y = rect.y;
+    const w = rect.w;
+    const h = rect.h;
+    let tl = rect.tl;
+    let tr = rect.tr;
+    let br = rect.br;
+    let bl = rect.bl;
+
+    if (typeof tl === 'undefined') {
+      this.path.rect(x, y, w, h);
+    } else {
+      if (typeof tr === 'undefined') {
+        tr = tl;
+      }
+      if (typeof br === 'undefined') {
+        br = tr;
+      }
+      if (typeof bl === 'undefined') {
+        bl = br;
+      }
+
+      const absW = Math.abs(w);
+      const absH = Math.abs(h);
+      const hw = absW / 2;
+      const hh = absH / 2;
+
+      if (absW < 2 * tl) {
+        tl = hw;
+      }
+      if (absH < 2 * tl) {
+        tl = hh;
+      }
+      if (absW < 2 * tr) {
+        tr = hw;
+      }
+      if (absH < 2 * tr) {
+        tr = hh;
+      }
+      if (absW < 2 * br) {
+        br = hw;
+      }
+      if (absH < 2 * br) {
+        br = hh;
+      }
+      if (absW < 2 * bl) {
+        bl = hw;
+      }
+      if (absH < 2 * bl) {
+        bl = hh;
+      }
+
+      this.path.roundRect(x, y, w, h, [tl, tr, br, bl]);
+    }
+  }
   visitQuadStrip(quadStrip) {
     for (let i = 0; i < quadStrip.vertices.length - 3; i += 2) {
       const v0 = quadStrip.vertices[i];
@@ -1530,6 +1666,72 @@ class PrimitiveToVerticesConverter extends PrimitiveVisitor {
       verts.push(new Vertex(vertexProps));
     }
 
+    this.contours.push(verts);
+  }
+  visitRectPrimitive(rect) {
+    const x = rect.x;
+    const y = rect.y;
+    const w = rect.w;
+    const h = rect.h;
+    let tl = rect.tl;
+    let tr = rect.tr;
+    let br = rect.br;
+    let bl = rect.bl;
+
+    const startVertex = rect.vertices[0];
+    const getVertexProps = (px, py) => {
+      const props = {};
+      for (const [key, value] of Object.entries(startVertex)) {
+        if (key === 'position') continue;
+        props[key] = value;
+      }
+      props.position = new Vector(px, py);
+      return new Vertex(props);
+    };
+
+    const verts = [];
+    if (typeof tl === 'undefined') {
+      verts.push(getVertexProps(x, y));
+      verts.push(getVertexProps(x + w, y));
+      verts.push(getVertexProps(x + w, y + h));
+      verts.push(getVertexProps(x, y + h));
+      verts.push(getVertexProps(x, y));
+    } else {
+      if (typeof tr === 'undefined') tr = tl;
+      if (typeof br === 'undefined') br = tr;
+      if (typeof bl === 'undefined') bl = br;
+
+      const absW = Math.abs(w);
+      const absH = Math.abs(h);
+      const hw = absW / 2;
+      const hh = absH / 2;
+
+      if (absW < 2 * tl) tl = hw;
+      if (absH < 2 * tl) tl = hh;
+      if (absW < 2 * tr) tr = hw;
+      if (absH < 2 * tr) tr = hh;
+      if (absW < 2 * br) br = hw;
+      if (absH < 2 * br) br = hh;
+      if (absW < 2 * bl) bl = hw;
+      if (absH < 2 * bl) bl = hh;
+
+      const addCornerArc = (cx, cy, rx, ry, startAngle, endAngle) => {
+        const perimeter = Math.PI / 2 * (rx + ry) / 2;
+        const numPoints = Math.max(1, Math.ceil(this.curveDetail * perimeter));
+        for (let i = 0; i <= numPoints; i++) {
+          const angle = startAngle + (endAngle - startAngle) * (i / numPoints);
+          verts.push(getVertexProps(cx + rx * Math.cos(angle), cy + ry * Math.sin(angle)));
+        }
+      };
+
+      addCornerArc(x + tl, y + tl, tl, tl, Math.PI, 1.5 * Math.PI);
+      addCornerArc(x + w - tr, y + tr, tr, tr, 1.5 * Math.PI, 2 * Math.PI);
+      addCornerArc(x + w - br, y + h - br, br, br, 0, 0.5 * Math.PI);
+      addCornerArc(x + bl, y + h - bl, bl, bl, 0.5 * Math.PI, Math.PI);
+
+      verts.push(verts[0]);
+    }
+
     this.contours.push(verts);
   }
 }
@@ -3039,4 +3241,4 @@ if (typeof p5 !== 'undefined') {
   customShapes(p5, p5.prototype);
 }
 
-export { Anchor, ArcPrimitive, BezierSegment, Contour, EllipsePrimitive, Line, LineSegment, Point, PointAtLengthGetter, PrimitiveToPath2DConverter, PrimitiveToVerticesConverter, PrimitiveVisitor, Quad, QuadStrip, Segment, Shape, ShapePrimitive, SplineSegment, Triangle, TriangleFan, TriangleStrip, Vertex, customShapes as default };
+export { Anchor, ArcPrimitive, BezierSegment, Contour, EllipsePrimitive, Line, LineSegment, Point, PointAtLengthGetter, PrimitiveToPath2DConverter, PrimitiveToVerticesConverter, PrimitiveVisitor, Quad, QuadStrip, RectPrimitive, Segment, Shape, ShapePrimitive, SplineSegment, Triangle, TriangleFan, TriangleStrip, Vertex, customShapes as default };

package/dist/shape/index.js

@@ -3,9 +3,9 @@ import attributes from './attributes.js';
 import curves from './curves.js';
 import vertex from './vertex.js';
 import customShapes from './custom_shapes.js';
-import '../constants-Dv6ZqA6s.js';
+import '../constants-Bx3_xAam.js';
 import '../core/helpers.js';
-import '../creating_reading-DLkHH80h.js';
+import '../creating_reading-YUSK33h8.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
 import '../math/p5.Vector.js';

package/dist/strands/ir_builders.js

@@ -2,5 +2,5 @@ import './ir_dag.js';
 import './ir_cfg.js';
 import './strands_FES.js';
 import './ir_types.js';
-export { k as arrayAccessNode, n as arrayAssignmentNode, b as binaryOpNode, h as castToFloat, g as constructTypeFromIDs, l as createStructArrayElementProxy, f as functionCallNode, m as memberAccessNode, p as primitiveConstructorNode, s as scalarLiteralNode, a as statementNode, e as structConstructorNode, d as structInstanceNode, i as swizzleNode, j as swizzleTrap, u as unaryOpNode, v as variableNode } from '../ir_builders-C8mrXj5z.js';
+export { k as arrayAccessNode, n as arrayAssignmentNode, d as binaryOpNode, h as castToFloat, g as constructTypeFromIDs, l as createStructArrayElementProxy, f as functionCallNode, m as memberAccessNode, p as primitiveConstructorNode, s as scalarLiteralNode, e as statementNode, b as structConstructorNode, a as structInstanceNode, i as swizzleNode, j as swizzleTrap, u as unaryOpNode, v as variableNode } from '../ir_builders-CMXkjMoV.js';
 import './strands_builtins.js';

package/dist/strands/p5.strands.js

@@ -8,7 +8,7 @@ import 'acorn';
 import 'acorn-walk';
 import 'escodegen';
 import './strands_FES.js';
-import '../ir_builders-C8mrXj5z.js';
+import '../ir_builders-CMXkjMoV.js';
 import './strands_builtins.js';
 import './strands_conditionals.js';
 import './strands_phi_utils.js';
@@ -338,18 +338,20 @@ if (typeof p5 !== "undefined") {
  */
 
 /**
- * @method instanceID
+ * @property instanceIndex
  * @beta
  * @description
  * Returns the index of the current instance when drawing multiple copies of a
  * shape with <a href="#/p5/model">`model(count)`</a>. The first instance has an
- * ID of `0`, the second has `1`, and so on.
+ * index of `0`, the second has `1`, and so on.
  *
  * This lets each copy of a shape behave differently. For example, you can use
- * the ID to place instances at different positions, give them different colors,
+ * the index to place instances at different positions, give them different colors,
  * or animate them at different speeds.
  *
- * `instanceID()` can only be used inside a p5.strands shader callback.
+ * `instanceIndex` can only be used inside a p5.strands shader callback.
+ *
+ * (Note: `instanceID()` is also available as a function for compatibility.)
  *
  * ```js example
  * let instancesShader;
@@ -372,7 +374,7 @@ if (typeof p5 !== "undefined") {
  *   // Spread spheres evenly across the canvas based on their index
  *   let spacing = width / count;
  *   worldInputs.position.x +=
- *     (instanceID() - (count - 1) / 2) * spacing;
+ *     (instanceIndex - (count - 1) / 2) * spacing;
  *   worldInputs.end();
  * }
  *
@@ -386,7 +388,7 @@ if (typeof p5 !== "undefined") {
  * }
  * ```
  *
- * If you are using WebGPU mode, a common pattern is to use `instanceID()` to look up data made with
+ * If you are using WebGPU mode, a common pattern is to use `instanceIndex` to look up data made with
  * <a href="#/p5/createStorage">`createStorage()`</a>.
  * This lets you give each instance different properties.
  *
@@ -429,7 +431,7 @@ if (typeof p5 !== "undefined") {
  *   let itemColor = sharedVec4();
  *
  *   worldInputs.begin();
- *   let item = data[instanceID()];
+ *   let item = data[instanceIndex];
  *   itemColor = item.color;
  *   worldInputs.position += item.position;
  *   worldInputs.end();
@@ -451,7 +453,22 @@ if (typeof p5 !== "undefined") {
  * This can be paired with <a href="#/p5/buildComputeShader">`buildComputeShader`</a>
  * to update the data being read.
  *
- * @webgpu
+ * @type {*}
+ */
+
+/**
+ * @method instanceID
+ * @beta
+ * @deprecated Use <a href="#/p5/instanceIndex">`instanceIndex`</a> instead.
+ * @description
+ * A function alias for <a href="#/p5/instanceIndex">`instanceIndex`</a>, kept for compatibility.
+ * Prefer using <a href="#/p5/instanceIndex">`instanceIndex`</a> directly as a value instead.
+ *
+ * Returns the index of the current instance when drawing multiple copies of a
+ * shape with <a href="#/p5/model">`model(count)`</a>.
+ *
+ * `instanceID()` can only be used inside a p5.strands shader callback.
+ *
  * @returns {*} The index of the current instance.
  */
 

package/dist/strands/strands_FES.js

@@ -8,4 +8,11 @@ function userError(errorType, errorMessage) {
     throw new Error(prefixedMessage);
 }
 
-export { internalError, userError };
+function dimensionMismatchError(declaredDim,actualDim,varName){
+    userError(
+        'dimension mismatch',
+    `Cannot assign a value of dimension ${actualDim} to \`${varName}\`, which expects dimension ${declaredDim}.`
+    );
+}
+
+export { dimensionMismatchError, internalError, userError };