Merge branch 'dev-2.0' into fix/mouse-blur-reset

Author: avinxshKD

docs/parameterData.json

@@ -751,14 +751,18 @@ function environment(p5, fn, lifecycles){
   };
 
   Object.defineProperty(fn, 'width', {
+    configurable: true,
+    enumerable: true,
     get(){
-      return this._renderer.width;
+      return this._renderer?.width;
     }
   });
 
   Object.defineProperty(fn, 'height', {
+    configurable: true,
+    enumerable: true,
     get(){
-      return this._renderer.height;
+      return this._renderer?.height;
     }
   });
 

src/core/environment.js

@@ -573,15 +573,19 @@ function validateParams(p5, fn, lifecycles) {
 
   fn._validate = validate; // TEMP: For unit tests
 
-  p5.decorateHelper(
-    /^(?!_).+$/,
-    function(target, { name }){
-      return function(...args){
-        if (!p5.disableFriendlyErrors && !p5.disableParameterValidator) {
-          validate(name, args);
-        }
-        return target.apply(this, args);
-      };
+  p5.registerDecorator(
+    ({ path }) => {
+      return path.startsWith('p5.prototype');
+    },
+    function(target, { kind, name }){
+      if(kind === 'method'){
+        return function(...args){
+          if (!p5.disableFriendlyErrors && !p5.disableParameterValidator) {
+            validate(name, args);
+          }
+          return target.apply(this, args);
+        };
+      }
     }
   );
 

src/core/friendly_errors/param_validator.js

@@ -50,30 +50,7 @@ class p5 {
   constructor(sketch, node) {
     // Apply addon defined decorations
     if(p5.decorations.size > 0){
-      for (const [patternArray, decoration] of p5.decorations) {
-        for(const member in p5.prototype) {
-          // Member must be a function
-          if (typeof p5.prototype[member] !== 'function') continue;
-
-          if (!patternArray.some(pattern => {
-            if (typeof pattern === 'string') {
-              return pattern === member;
-            } else if (pattern instanceof RegExp) {
-              return pattern.test(member);
-            }
-          })) continue;
-
-          p5.prototype[member] = decoration(p5.prototype[member], {
-            kind: 'method',
-            name: member,
-            access: {},
-            static: false,
-            private: false,
-            addInitializer(initializer){}
-          });
-        }
-      }
-
+      decorateClass(p5, p5.decorations);
       p5.decorations.clear();
     }
 
@@ -165,11 +142,11 @@ class p5 {
   }
 
   get pixels(){
-    return this._renderer.pixels;
+    return this._renderer?.pixels;
   }
 
   get drawingContext(){
-    return this._renderer.drawingContext;
+    return this._renderer?.drawingContext;
   }
 
   static _registeredAddons = new Set();
@@ -193,10 +170,20 @@ class p5 {
   }
 
   static decorations = new Map();
-  static decorateHelper(pattern, decoration){
-    let patternArray = pattern;
-    if (!Array.isArray(pattern)) patternArray = [pattern];
-    p5.decorations.set(patternArray, decoration);
+  static registerDecorator(pattern, decoration){
+    if(typeof pattern === 'string'){
+      const patternStr = pattern;
+      pattern = ({ path }) => patternStr === path;
+    }else if(
+      Array.isArray(pattern) &&
+      pattern.every(value => typeof value === 'string')
+    ){
+      const patternArray = pattern;
+      pattern = ({ path }) => patternArray.includes(path);
+    }else if(typeof pattern !== 'function'){
+      throw new Error('Decorator matching pattern must be a function, a string, or an array of strings');
+    }
+    p5.decorations.set(pattern, decoration);
   }
 
   #customActions = {};
@@ -437,6 +424,11 @@ class p5 {
   }
 }
 
+// Attach constants to p5 prototype
+for (const k in constants) {
+  p5.prototype[k] = constants[k];
+}
+
 // Global helper function for binding properties to window in global mode
 function createBindGlobal(instance) {
   return function bindGlobal(property) {
@@ -527,9 +519,107 @@ function createBindGlobal(instance) {
   };
 }
 
-// Attach constants to p5 prototype
-for (const k in constants) {
-  p5.prototype[k] = constants[k];
+// Generic function to decorate classes
+function decorateClass(Target, decorations, path){
+  path ??= Target.name;
+  // Static properties
+  for(const key in Target){
+    if(!key.startsWith('_')){
+      for (const [pattern, decorator] of decorations) {
+        if(pattern({ path: `${path}.${key}` })){
+          // Check if method or accessor
+          if(typeof Target[key] === 'function'){
+            const result = decorator(Target[key], {
+              kind: 'method',
+              name: key,
+              static: true
+            });
+            if(result){
+              Object.defineProperty(Target, key, {
+                enumerable: true,
+                writable: true,
+                value: result
+              });
+            }
+          }else{
+            const result = decorator(undefined, {
+              kind: 'field',
+              name: key,
+              static: true
+            });
+            if(result && typeof result === 'function'){
+              Target[key] = result(Target[key]);
+            }
+          }
+        }
+      }
+
+      if(typeof Target[key] === 'function' && Target[key].prototype){
+        decorateClass(Target[key], decorations, `${path}.${key}`);
+      }
+    }
+  }
+
+  // Member properties
+  for(const member of Object.getOwnPropertyNames(Target.prototype)){
+    if(member !== 'constructor' && !member.startsWith('_')){
+      for (const [pattern, decorator] of decorations) {
+        if(pattern({ path: `${path}.prototype.${member}` })){
+          // Check if method or accessor
+          if(typeof Target.prototype[member] === 'function'){
+            const result = decorator(Target.prototype[member], {
+              kind: 'method',
+              name: member,
+              static: false
+            });
+            if(result) {
+              Object.defineProperty(Target.prototype, member, {
+                enumerable: true,
+                writable: true,
+                value: result
+              });
+            }
+          }else{
+            const descriptor = Object.getOwnPropertyDescriptor(
+              Target.prototype,
+              member
+            );
+            if(descriptor.hasOwnProperty('value')){
+              const result = decorator(undefined, {
+                kind: 'field',
+                name: member,
+                static: false
+              });
+              Object.defineProperty(Target.prototype, member, {
+                enumerable: true,
+                writable: true,
+                value: result && typeof result === 'function' ?
+                  result(Target.prototype[member]) :
+                  Target.prototype[member]
+              });
+            }else{
+              const { get, set } = descriptor;
+              const getterResult = decorator(get, {
+                kind: 'getter',
+                name: member,
+                static: false
+              });
+              const setterResult = decorator(set, {
+                kind: 'setter',
+                name: member,
+                static: false
+              });
+              Object.defineProperty(Target.prototype, member, {
+                enumerable: true,
+                get: getterResult ?? get,
+                set: setterResult ?? set
+              });
+            }
+          }
+        }
+      }
+    }
+  }
 }
 
 import transform from './transform';

src/core/main.js

@@ -72,7 +72,14 @@ class Renderer {
     this._pInst = pInst;
     this._isMainCanvas = isMainCanvas;
     this.pixels = [];
-    this._pixelDensity = Math.ceil(window.devicePixelRatio) || 1;
+
+    if (isMainCanvas) {
+      this._pixelDensity = Math.ceil(window.devicePixelRatio) || 1;
+    } else {
+      
+      const parentDensity = pInst._pInst?._renderer?._pixelDensity;
+      this._pixelDensity = parentDensity || Math.ceil(window.devicePixelRatio) || 1;
+    }
 
     this.width = w;
     this.height = h;

src/core/p5.Renderer.js

@@ -1,7 +1,7 @@
 import * as DAG from './ir_dag'
 import * as CFG from './ir_cfg'
 import * as FES from './strands_FES'
-import { NodeType, OpCode, BaseType, DataType, BasePriority, OpCodeToSymbol, typeEquals, } from './ir_types';
+import { NodeType, OpCode, BaseType, DataType, BasePriority, OpCodeToSymbol, typeEquals, booleanOpCode } from './ir_types';
 import { createStrandsNode, StrandsNode } from './strands_node';
 import { strandsBuiltinFunctions } from './strands_builtins';
 
@@ -50,12 +50,22 @@ export function unaryOpNode(strandsContext, nodeOrValue, opCode) {
     node = createStrandsNode(id, dimension, strandsContext);
   }
   dependsOn = [node.id];
+
+  const typeInfo = {
+    baseType: dag.baseTypes[node.id],
+    dimension: node.dimension
+  };
+  if (booleanOpCode[opCode]) {
+    typeInfo.baseType = BaseType.BOOL;
+    typeInfo.dimension = 1;
+  }
+
   const nodeData = DAG.createNodeData({
     nodeType: NodeType.OPERATION,
     opCode,
     dependsOn,
-    baseType: dag.baseTypes[node.id],
-    dimension: node.dimension
+    baseType: typeInfo.baseType,
+    dimension: typeInfo.dimension
   })
   const id = DAG.getOrCreateNode(dag, nodeData);
   CFG.recordInBasicBlock(cfg, cfg.currentBlock, id);
@@ -137,6 +147,11 @@ export function binaryOpNode(strandsContext, leftStrandsNode, rightArg, opCode)
     }
   }
 
+  if (booleanOpCode[opCode]) {
+    cast.toType.baseType = BaseType.BOOL;
+    cast.toType.dimension = 1;
+  }
+
   const nodeData = DAG.createNodeData({
     nodeType: NodeType.OPERATION,
     opCode,
@@ -224,6 +239,17 @@ function mapPrimitiveDepsToIDs(strandsContext, typeInfo, dependsOn) {
       calculatedDimensions += dimension;
       continue;
     }
+    else if (typeof dep === 'boolean') {
+      // Handle boolean literals - convert to bool type
+      const { id, dimension } = scalarLiteralNode(strandsContext, { dimension: 1, baseType: BaseType.BOOL }, dep);
+      mappedDependencies.push(id);
+      calculatedDimensions += dimension;
+      // Update baseType to BOOL if it was inferred
+      if (baseType !== BaseType.BOOL) {
+        baseType = BaseType.BOOL;
+      }
+      continue;
+    }
     else {
       FES.userError('type error', `You've tried to construct a scalar or vector type with a non-numeric value: ${dep}`);
     }
@@ -274,7 +300,12 @@ export function primitiveConstructorNode(strandsContext, typeInfo, dependsOn) {
   const { mappedDependencies, inferredTypeInfo } = mapPrimitiveDepsToIDs(strandsContext, typeInfo, dependsOn);
 
   const finalType = {
-    baseType: typeInfo.baseType,
+    // We might have inferred a non numeric type. Currently this is
+    // just used for booleans. Maybe this needs to be something more robust
+    // if we ever want to support inference of e.g. int vectors?
+    baseType: inferredTypeInfo.baseType === BaseType.BOOL
+      ? BaseType.BOOL
+      : typeInfo.baseType,
     dimension: inferredTypeInfo.dimension
   };