p5 2.3.0 → 2.3.1-rc.2

package/dist/{ir_builders-C8mrXj5z.js → ir_builders-CMXkjMoV.js}

@@ -1,6 +1,6 @@
 import { getNodeDataFromID, createNodeData, getOrCreateNode, extractNodeTypeInfo, propagateTypeToAssignOnUse } from './strands/ir_dag.js';
 import { recordInBasicBlock } from './strands/ir_cfg.js';
-import { userError, internalError } from './strands/strands_FES.js';
+import { dimensionMismatchError, userError, internalError } from './strands/strands_FES.js';
 import { BaseType, NodeType, OpCode, typeEquals, BasePriority, DataType, OpCodeToSymbol, booleanOpCode } from './strands/ir_types.js';
 import { strandsBuiltinFunctions } from './strands/strands_builtins.js';
 
@@ -58,6 +58,16 @@ class StrandsNode {
 
     // For varying variables, we need both assignment generation AND a way to reference by identifier
     if (this._originalIdentifier) {
+      const valueDim = value?.isStrandsNode
+        ? value.dimension
+        : (Array.isArray(value) ? value.length : 1);
+      if (valueDim !== this._originalDimension && valueDim !== 1){
+        dimensionMismatchError(
+          this._originalDimension,
+          valueDim,
+          this._originalIdentifier
+        );
+      }
       // Create a variable node for the target (the varying variable)
       const { id: targetVarID } = variableNode(
         this.strandsContext,
@@ -110,6 +120,16 @@ class StrandsNode {
 
     // For varying variables, create swizzle assignment
     if (this._originalIdentifier) {
+      const valueDim = value?.isStrandsNode
+        ? value.dimension
+        : (Array.isArray(value) ? value.length : 1);
+      if (valueDim !== swizzlePattern.length && valueDim !== 1){
+        dimensionMismatchError(
+          swizzlePattern.length,
+          valueDim,
+          `${this._originalIdentifier}.${swizzlePattern}`
+        );
+      }
       // Create a variable node for the target with swizzle
       const { id: targetVarID } = variableNode(
         this.strandsContext,
@@ -560,38 +580,24 @@ function castToFloat(strandsContext, dep) {
   return createStrandsNode(id, dimension, strandsContext);
 }
 
-function structConstructorNode(strandsContext, structTypeInfo, rawUserArgs) {
+function structConstructorNode(strandsContext, structTypeInfo, dependsOn) {
   const { cfg, dag } = strandsContext;
-  const { identifer, properties } = structTypeInfo;
+  const { properties } = structTypeInfo;
 
-  if (!(rawUserArgs.length === properties.length)) {
+  if (dependsOn.length !== properties.length) {
     userError('type error',
-      `You've tried to construct a ${structTypeInfo.typeName} struct with ${rawUserArgs.length} properties, but it expects ${properties.length} properties.\n` +
+      `You've tried to construct a ${structTypeInfo.typeName} struct with ${dependsOn.length} properties, but it expects ${properties.length} properties.\n` +
       `The properties it expects are:\n` +
-      `${properties.map(prop => prop.name + ' ' + prop.DataType.baseType + prop.DataType.dimension)}`
+      `${properties.map(prop => `${prop.name}: ${prop.dataType.baseType}${prop.dataType.dimension}`).join(', ')}`
     );
   }
 
-  const dependsOn = [];
-  for (let i = 0; i < properties.length; i++) {
-    const expectedProperty = properties[i];
-    const { originalNodeID, mappedDependencies } = mapPrimitiveDepsToIDs(strandsContext, expectedProperty.dataType, rawUserArgs[i]);
-    if (originalNodeID) {
-      dependsOn.push(originalNodeID);
-    }
-    else {
-      dependsOn.push(
-        constructTypeFromIDs(strandsContext, expectedProperty.dataType, mappedDependencies)
-      );
-    }
-  }
-
   const nodeData = createNodeData({
     nodeType: NodeType.OPERATION,
     opCode: OpCode.Nary.CONSTRUCTOR,
     dimension: properties.length,
-    baseType: structTypeInfo.typeName ,
-    dependsOn
+    baseType: structTypeInfo.typeName,
+    dependsOn,
   });
   const id = getOrCreateNode(dag, nodeData);
   recordInBasicBlock(cfg, cfg.currentBlock, id);
@@ -788,7 +794,11 @@ function swizzleTrap(id, dimension, strandsContext, onRebind) {
             scalars.push(createStrandsNode(id, dimension, strandsContext));
           }
         } else {
-          userError('type error', `Swizzle assignment: RHS vector does not match LHS vector (need ${chars.length}, got ${value.dimension}).`);
+          dimensionMismatchError(
+            chars.length,
+            value.dimension,
+            `${target._originalIdentifier || 'value'}.${property}`
+          );
         }
       } else if (Array.isArray(value)) {
         const flat = value.flat(Infinity);
@@ -1018,4 +1028,4 @@ function arrayAssignmentNode(strandsContext, bufferNode, indexNode, valueNode) {
   return { id: assignmentID };
 }
 
-export { StrandsNode as S, statementNode as a, binaryOpNode as b, createStrandsNode as c, structInstanceNode as d, structConstructorNode as e, functionCallNode as f, constructTypeFromIDs as g, castToFloat as h, swizzleNode as i, swizzleTrap as j, arrayAccessNode as k, createStructArrayElementProxy as l, memberAccessNode as m, arrayAssignmentNode as n, primitiveConstructorNode as p, scalarLiteralNode as s, unaryOpNode as u, variableNode as v };
+export { StrandsNode as S, structInstanceNode as a, structConstructorNode as b, createStrandsNode as c, binaryOpNode as d, statementNode as e, functionCallNode as f, constructTypeFromIDs as g, castToFloat as h, swizzleNode as i, swizzleTrap as j, arrayAccessNode as k, createStructArrayElementProxy as l, memberAccessNode as m, arrayAssignmentNode as n, primitiveConstructorNode as p, scalarLiteralNode as s, unaryOpNode as u, variableNode as v };

package/dist/{main-BR2ALC_6.js → main-CAqj0AHr.js}

@@ -1,20 +1,18 @@
-import { P as P2D, ad as WEBGL, B as BLEND, an as _DEFAULT_FILL, ao as _DEFAULT_STROKE, u as ROUND, b as REMOVE, S as SUBTRACT, D as DARKEST, L as LIGHTEST, ap as DIFFERENCE, M as MULTIPLY, E as EXCLUSION, a as SCREEN, R as REPLACE, aq as OVERLAY, ar as HARD_LIGHT, as as SOFT_LIGHT, at as DODGE, au as BURN, A as ADD, o as TWO_PI, v as SQUARE, w as PROJECT, x as BEVEL, y as MITER, aa as RIGHT, t as CENTER, av as LEFT, aw as BOTTOM, ax as BASELINE, ay as TOP, az as VERSION, am as constants } from './constants-Dv6ZqA6s.js';
+import { P as P2D, ad as WEBGL, B as BLEND, an as _DEFAULT_FILL, ao as _DEFAULT_STROKE, u as ROUND, b as REMOVE, S as SUBTRACT, D as DARKEST, L as LIGHTEST, ap as DIFFERENCE, M as MULTIPLY, E as EXCLUSION, a as SCREEN, R as REPLACE, aq as OVERLAY, ar as HARD_LIGHT, as as SOFT_LIGHT, at as DODGE, au as BURN, A as ADD, v as SQUARE, w as PROJECT, x as BEVEL, y as MITER, aa as RIGHT, t as CENTER, av as LEFT, aw as BOTTOM, ax as BASELINE, ay as TOP, az as VERSION, am as constants } from './constants-DkQDfqzw.js';
 import transform from './core/transform.js';
 import structure from './core/structure.js';
 import environment from './core/environment.js';
-import { G as Graphics, k as rendering, n as graphics } from './rendering-C5lX6zKm.js';
-import { R as Renderer, I as Image, r as renderer } from './p5.Renderer-XOvhEbJn.js';
+import { G as Graphics, k as rendering, n as graphics } from './rendering-BowMW0pZ.js';
+import { R as Renderer, I as Image, r as renderer } from './p5.Renderer-Bf-YLpi6.js';
 import { Element } from './dom/p5.Element.js';
 import { MediaElement } from './dom/p5.MediaElement.js';
-import { b as RGBHDR } from './creating_reading-DLkHH80h.js';
+import { b as RGBP3 } from './creating_reading-Dyt2y-6S.js';
 import FilterRenderer2D from './image/filterRenderer2D.js';
 import './math/p5.Matrix.js';
 import { PrimitiveToPath2DConverter } from './shape/custom_shapes.js';
 import { DefaultFill, textCoreConstants } from './type/textCore.js';
 import { Matrix } from './math/Matrices/Matrix.js';
 
-const styleEmpty = 'rgba(0,0,0,0)';
-
 class Renderer2D extends Renderer {
   constructor(pInst, w, h, isMainCanvas, elt, attributes = {}) {
     super(pInst, w, h, isMainCanvas);
@@ -69,7 +67,7 @@ class Renderer2D extends Renderer {
     // Get and store drawing context
     this.drawingContext = this.canvas.getContext('2d', attributes);
     if(attributes.colorSpace === 'display-p3'){
-      this.states.colorMode = RGBHDR;
+      this.states.colorMode = RGBP3;
     }
     this.scale(this._pixelDensity, this._pixelDensity);
 
@@ -446,10 +444,12 @@ class Renderer2D extends Renderer {
     ctx.save();
     ctx.clearRect(0, 0, img.canvas.width, img.canvas.height);
 
+    const tint = this.states.tint._getRGBA([255, 255, 255, 255]);
+
     if (
-      this.states.tint[0] < 255 ||
-      this.states.tint[1] < 255 ||
-      this.states.tint[2] < 255
+      tint[0] < 255 ||
+      tint[1] < 255 ||
+      tint[2] < 255
     ) {
       // Color tint: we need to use the multiply blend mode to change the colors.
       // However, the canvas implementation of this destroys the alpha channel of
@@ -472,16 +472,16 @@ class Renderer2D extends Renderer {
 
       // Apply color tint
       ctx.globalCompositeOperation = 'multiply';
-      ctx.fillStyle = `rgb(${this.states.tint.slice(0, 3).join(', ')})`;
+      ctx.fillStyle = `rgb(${tint.slice(0, 3).join(', ')})`;
       ctx.fillRect(0, 0, img.canvas.width, img.canvas.height);
 
       // Replace the alpha channel with the original alpha * the alpha tint
       ctx.globalCompositeOperation = 'destination-in';
-      ctx.globalAlpha = this.states.tint[3] / 255;
+      ctx.globalAlpha = tint[3] / 255;
       ctx.drawImage(img.canvas, 0, 0);
     } else {
       // If we only need to change the alpha, we can skip all the extra work!
-      ctx.globalAlpha = this.states.tint[3] / 255;
+      ctx.globalAlpha = tint[3] / 255;
       ctx.drawImage(img.canvas, 0, 0);
     }
 
@@ -707,96 +707,32 @@ class Renderer2D extends Renderer {
   }
 
   line(x1, y1, x2, y2) {
-    const ctx = this.drawingContext;
-    if (!this.states.strokeColor) {
-      return this;
-    } else if (this._getStroke() === styleEmpty) {
-      return this;
-    }
-    if (this._clipping) {
-      const tempPath = new Path2D();
-      tempPath.moveTo(x1, y1);
-      tempPath.lineTo(x2, y2);
-      const currentTransform = this.drawingContext.getTransform();
-      const clipBaseTransform = this._clipBaseTransform.inverse();
-      const relativeTransform = clipBaseTransform.multiply(currentTransform);
-      this.clipPath.addPath(tempPath, relativeTransform);
-      return this;
-    }
-    ctx.beginPath();
-    ctx.moveTo(x1, y1);
-    ctx.lineTo(x2, y2);
-    ctx.stroke();
+    const shape = new p5.Shape({ position: new p5.Vector(0, 0) });
+    shape.beginShape();
+    shape.line(x1, y1, x2, y2);
+    shape.endShape();
+    this.drawShape(shape);
 
     return this;
   }
 
   point(x, y) {
-    const ctx = this.drawingContext;
-    if (!this.states.strokeColor) {
-      return this;
-    } else if (this._getStroke() === styleEmpty) {
-      return this;
-    }
-    const s = this._getStroke();
-    const f = this._getFill();
-    if (this._clipping) {
-      const tempPath = new Path2D();
-      const drawingContextWidth = this.drawingContext.lineWidth;
-      tempPath.arc(x, y, drawingContextWidth / 2, 0, TWO_PI);
-      const currentTransform = this.drawingContext.getTransform();
-      const clipBaseTransform = this._clipBaseTransform.inverse();
-      const relativeTransform = clipBaseTransform.multiply(currentTransform);
-      this.clipPath.addPath(tempPath, relativeTransform);
-      return this;
-    }
-    this._setFill(s);
-    ctx.beginPath();
-    ctx.arc(x, y, ctx.lineWidth / 2, 0, TWO_PI, false);
-    ctx.fill();
-    this._setFill(f);
+    const shape = new p5.Shape({ position: new p5.Vector(0, 0) });
+    shape.beginShape();
+    shape.point(x, y);
+    shape.endShape();
+    this.drawShape(shape);
 
     return this;
   }
 
   quad(x1, y1, x2, y2, x3, y3, x4, y4) {
-    const ctx = this.drawingContext;
-    const doFill = !!this.states.fillColor,
-      doStroke = this.states.strokeColor;
-    if (doFill && !doStroke) {
-      if (this._getFill() === styleEmpty) {
-        return this;
-      }
-    } else if (!doFill && doStroke) {
-      if (this._getStroke() === styleEmpty) {
-        return this;
-      }
-    }
-    if (this._clipping) {
-      const tempPath = new Path2D();
-      tempPath.moveTo(x1, y1);
-      tempPath.lineTo(x2, y2);
-      tempPath.lineTo(x3, y3);
-      tempPath.lineTo(x4, y4);
-      tempPath.closePath();
-      const currentTransform = this.drawingContext.getTransform();
-      const clipBaseTransform = this._clipBaseTransform.inverse();
-      const relativeTransform = clipBaseTransform.multiply(currentTransform);
-      this.clipPath.addPath(tempPath, relativeTransform);
-      return this;
-    }
-    ctx.beginPath();
-    ctx.moveTo(x1, y1);
-    ctx.lineTo(x2, y2);
-    ctx.lineTo(x3, y3);
-    ctx.lineTo(x4, y4);
-    ctx.closePath();
-    if (doFill) {
-      ctx.fill();
-    }
-    if (doStroke) {
-      ctx.stroke();
-    }
+    const shape = new p5.Shape({ position: new p5.Vector(0, 0) });
+    shape.beginShape();
+    shape.quad(x1, y1, x2, y2, x3, y3, x4, y4);
+    shape.endShape();
+    this.drawShape(shape);
+
     return this;
   }
 
@@ -809,134 +745,29 @@ class Renderer2D extends Renderer {
     let tr = args[5];
     let br = args[6];
     let bl = args[7];
-    const ctx = this.drawingContext;
-    const doFill = !!this.states.fillColor,
-      doStroke = this.states.strokeColor;
-    if (doFill && !doStroke) {
-      if (this._getFill() === styleEmpty) {
-        return this;
-      }
-    } else if (!doFill && doStroke) {
-      if (this._getStroke() === styleEmpty) {
-        return this;
-      }
-    }
-    if (this._clipping) {
-      const tempPath = new Path2D();
-      if (typeof tl === 'undefined') {
-        tempPath.rect(x, y, w, h);
-      } else {
-        tempPath.roundRect(x, y, w, h, [tl, tr, br, bl]);
-      }
-      const currentTransform = this.drawingContext.getTransform();
-      const clipBaseTransform = this._clipBaseTransform.inverse();
-      const relativeTransform = clipBaseTransform.multiply(currentTransform);
-      this.clipPath.addPath(tempPath, relativeTransform);
-      return this;
-    }
-    ctx.beginPath();
-    if (typeof tl === 'undefined') {
-      // No rounded corners
-      ctx.rect(x, y, w, h);
-    } else {
-      // At least one rounded corner
-      // Set defaults when not specified
-      if (typeof tr === 'undefined') {
-        tr = tl;
-      }
-      if (typeof br === 'undefined') {
-        br = tr;
-      }
-      if (typeof bl === 'undefined') {
-        bl = br;
-      }
 
-      // corner rounding must always be positive
-      const absW = Math.abs(w);
-      const absH = Math.abs(h);
-      const hw = absW / 2;
-      const hh = absH / 2;
-
-      // Clip radii
-      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 shape = new p5.Shape({ position: new p5.Vector(0, 0) });
+    shape.beginShape();
+    shape.rectPrimitive(x, y, w, h, tl, tr, br, bl);
+    shape.endShape();
+    this.drawShape(shape);
 
-      ctx.roundRect(x, y, w, h, [tl, tr, br, bl]);
-    }
-    if (doFill) {
-      ctx.fill();
-    }
-    if (doStroke) {
-      ctx.stroke();
-    }
     return this;
   }
 
-
   triangle(args) {
-    const ctx = this.drawingContext;
-    const doFill = !!this.states.fillColor,
-      doStroke = this.states.strokeColor;
     const x1 = args[0],
       y1 = args[1];
     const x2 = args[2],
       y2 = args[3];
     const x3 = args[4],
       y3 = args[5];
-    if (doFill && !doStroke) {
-      if (this._getFill() === styleEmpty) {
-        return this;
-      }
-    } else if (!doFill && doStroke) {
-      if (this._getStroke() === styleEmpty) {
-        return this;
-      }
-    }
-    if (this._clipping) {
-      const tempPath = new Path2D();
-      tempPath.moveTo(x1, y1);
-      tempPath.lineTo(x2, y2);
-      tempPath.lineTo(x3, y3);
-      tempPath.closePath();
-      const currentTransform = this.drawingContext.getTransform();
-      const clipBaseTransform = this._clipBaseTransform.inverse();
-      const relativeTransform = clipBaseTransform.multiply(currentTransform);
-      this.clipPath.addPath(tempPath, relativeTransform);
-      return this;
-    }
-    ctx.beginPath();
-    ctx.moveTo(x1, y1);
-    ctx.lineTo(x2, y2);
-    ctx.lineTo(x3, y3);
-    ctx.closePath();
-    if (doFill) {
-      ctx.fill();
-    }
-    if (doStroke) {
-      ctx.stroke();
-    }
+
+    const shape = new p5.Shape({ position: new p5.Vector(0, 0) });
+    shape.beginShape();
+    shape.triangle(x1, y1, x2, y2, x3, y3);
+    shape.endShape();
+    this.drawShape(shape);
 
     return this;
   }
@@ -1207,7 +1038,7 @@ function renderer2D(p5, fn){
    */
   p5.Renderer2D = Renderer2D;
   p5.renderers[P2D] = Renderer2D;
-  p5.renderers['p2d-hdr'] = new Proxy(Renderer2D, {
+  p5.renderers['p2d-p3'] = new Proxy(Renderer2D, {
     construct(target, [pInst, w, h, isMainCanvas, elt]){
       return new target(pInst, w, h, isMainCanvas, elt, { colorSpace: 'display-p3' });
     }

package/dist/math/Matrices/Matrix.js

@@ -1,6 +1,6 @@
 import { Vector } from '../p5.Vector.js';
 import { MatrixInterface } from './MatrixInterface.js';
-import '../../constants-Dv6ZqA6s.js';
+import '../../constants-DkQDfqzw.js';
 
 /**
  * @module Math

package/dist/math/Matrices/MatrixNumjs.js

@@ -1,7 +1,7 @@
 import nj from '@d4c/numjs/build/module/numjs.min.js';
 import { Vector } from '../p5.Vector.js';
 import { MatrixInterface } from './MatrixInterface.js';
-import '../../constants-Dv6ZqA6s.js';
+import '../../constants-DkQDfqzw.js';
 
 let isMatrixArray = x => Array.isArray(x);
 if (typeof Float32Array !== 'undefined') {