Sep 18, 2025 · Jun 24, 2025 · Jun 27, 2025 · Jul 1, 2025 · Jul 5, 2025 · Jul 7, 2025
diff --git a/preview/global/sketch.js b/preview/global/sketch.js
 function callback() {

  getFinalColor((col) => {
    let x = vec3(1);
    return vec3(1).div(ivec3(1, 2, 4).mult(ivec3(2.0, 2, 3)));
    let x = vec4(1);
    // return 1;
    return vec4(1).div(ivec4(1).mult(ivec4(2.0, 3.0, 2, 3)));
  });
 }

diff --git a/src/strands/builder.js b/src/strands/builder.js
  return id;
 }

 export function createUnaryOpNode(strandsContext, strandsNode, opCode) {
  const { dag, cfg } = strandsContext;
  const nodeData = DAG.createNodeData({
    nodeType: NodeType.OPERATION,
    opCode,
    dependsOn: strandsNode.id,
    baseType: dag.baseTypes[strandsNode.id],
    dimension: dag.dimensions[strandsNode.id],
  })
  CFG.recordInBasicBlock(cfg, cfg.currentBlock, id);
  return id;
 }

 export function createStatementNode(strandsContext, type) {
  return -99;
 }
diff --git a/src/strands/code_generation.js b/src/strands/code_generation.js
 import { WEBGL } from '../core/constants';
 import { glslBackend } from './GLSL_backend';
 import {dfsPostOrder, dfsReversePostOrder,NodeType } from './utils';
 import { NodeType } from './utils';
 import { extractTypeInfo } from './builder';
 import { sortCFG } from './control_flow_graph';
 import { sortDAG } from './directed_acyclic_graph';

 let globalTempCounter = 0;
 let backend;

  for (const { hookType, entryBlockID, rootNodeID} of strandsContext.hooks) {
    const { cfg, dag } = strandsContext;
    const dagSorted =dfsPostOrder(dag.dependsOn, rootNodeID);
    const cfgSorted =dfsReversePostOrder(cfg.outgoingEdges, entryBlockID);
    const dagSorted =sortDAG(dag.dependsOn, rootNodeID);
    const cfgSorted =sortCFG(cfg.outgoingEdges, entryBlockID);

    const generationContext = {
      ...generateTopLevelDeclarations(strandsContext, dagSorted),
diff --git a/src/strands/control_flow_graph.js b/src/strands/control_flow_graph.js
  const block = getBlockDataFromID(graph, id);
  block.blockType = BlockTypeToName[block.blockType];
  console.log(block);
 }

 export function sortCFG(adjacencyList, start) {
  const visited = new Set();
  const postOrder = [];

  function dfs(v) {
    if (visited.has(v)) {
      return;
    }
    visited.add(v);
    for (let w of adjacencyList[v].sort((a, b) => b-a) || []) {
      dfs(w);
    }
    postOrder.push(v);
  }

  dfs(start);
  return postOrder.reverse();
 }
diff --git a/src/strands/directed_acyclic_graph.js b/src/strands/directed_acyclic_graph.js
 import { NodeTypeRequiredFields, NodeTypeToName, TypeInfo } from './utils';
 import { NodeTypeRequiredFields, NodeTypeToName } from './utils';
 import * as FES from './strands_FES';

 /////////////////////////////////
  if (missingFields.length > 0) {
    FES.internalError(`Missing fields ${missingFields.join(', ')} for a node type '${NodeTypeToName[nodeType]}'.`);
  }
 }

 export function sortDAG(adjacencyList, start) {
  const visited = new Set();
  const postOrder = [];

  function dfs(v) {
    if (visited.has(v)) {
      return;
    }
    visited.add(v);
    for (let w of adjacencyList[v]) {
      dfs(w);
    }
    postOrder.push(v);
  }

  dfs(start);
  return postOrder;
 }
diff --git a/src/strands/p5.strands.js b/src/strands/p5.strands.js
 import { createDirectedAcyclicGraph } from './directed_acyclic_graph'
 import { createControlFlowGraph, createBasicBlock, pushBlock, popBlock } from './control_flow_graph';
 import { generateShaderCode } from './code_generation';
 import { initGlobalStrandsAPI,initShaderHooksFunctions } from './user_API';
 import { initGlobalStrandsAPI,createShaderHooksFunctions } from './user_API';

 function strands(p5, fn) {
  //////////////////////////////////////////////
      // Reset the context object every time modify is called;
      const backend = WEBGL;
      initStrandsContext(strandsContext, backend);
 initShaderHooksFunctions(strandsContext, fn, this);
 createShaderHooksFunctions(strandsContext, fn, this);

      // 1. Transpile from strands DSL to JS
      let strandsCallback;
diff --git a/src/strands/user_API.js b/src/strands/user_API.js
  createVariableNode,
  createStatementNode,
  createTypeConstructorNode,
  createUnaryOpNode,
 } from './builder'
 import { OperatorTable,SymbolToOpCode,BlockType, TypeInfo, BaseType, TypeInfoFromGLSLName } from './utils'
 import { OperatorTable, BlockType, TypeInfo, BaseType, TypeInfoFromGLSLName } from './utils'
 import { strandsShaderFunctions } from './shader_functions'
 import { StrandsConditional } from './strands_conditionals'
 import * as CFG from './control_flow_graph'
 export function initGlobalStrandsAPI(p5, fn, strandsContext) {
  // We augment the strands node with operations programatically
  // this means methods like .add, .sub, etc can be chained
  for (const { name,symbol, arity } of OperatorTable) {
  for (const { name,arity, opCode, symbol } of OperatorTable) {
    if (arity === 'binary') {
      StrandsNode.prototype[name] = function (...right) {
        const id = createBinaryOpNode(strandsContext, this, right,SymbolToOpCode[symbol]);
        const id = createBinaryOpNode(strandsContext, this, right,opCode);
        return new StrandsNode(id);
      };
    }
 //if (arity === 'unary') {
 //   StrandsNode.prototype[name] = function () {
 //const id =createUnaryExpressionNode(this, SymbolToOpCode[symbol]);
 //    return new StrandsNode(id);
 //   };
 //}
    if (arity === 'unary') {
  fn[name] = function (strandsNode) {
        const id =createUnaryOpNode(strandsContext, strandsNode, opCode);
        return new StrandsNode(id);
  }
    }
  }

  //////////////////////////////////////////////
 //////////////////////////////////////////////
 // Per-Hook functions
 //////////////////////////////////////////////
 const structTypes = ['Vertex', ]

 function createHookArguments(strandsContext, parameters){
  const structTypes = ['Vertex', ]
  const args = [];

  for (const param of parameters) {
    const paramType = param.type;
    if(structTypes.includes(paramType.typeName)) {
      const propertiesNodes = paramType.properties.map(
        (prop) => [prop.name, createVariableNode(strandsContext, TypeInfoFromGLSLName[prop.dataType], prop.name)]
      );
      const argObject = Object.fromEntries(propertiesNodes);
      const propertyEntries = paramType.properties.map((prop) => {
        const typeInfo = TypeInfoFromGLSLName[prop.dataType];
        const variableNode = createVariableNode(strandsContext, typeInfo, prop.name);
        return [prop.name, variableNode];
      });
      const argObject = Object.fromEntries(propertyEntries);
      args.push(argObject);
    } else {
      const typeInfo = TypeInfoFromGLSLName[paramType.typeName];
  return args;
 }

 export functioninitShaderHooksFunctions(strandsContext, fn, shader) {
 export functioncreateShaderHooksFunctions(strandsContext, fn, shader) {
  const availableHooks = {
    ...shader.hooks.vertex,
    ...shader.hooks.fragment,
  }
  const hookTypes = Object.keys(availableHooks).map(name => shader.hookTypes(name));
  const { cfg } = strandsContext;
  const { cfg, dag } = strandsContext;

  for (const hookType of hookTypes) {
    window[hookType.name] = function(hookUserCallback) {
      const entryBlockID = CFG.createBasicBlock(cfg, BlockType.FUNCTION);
      CFG.addEdge(cfg, cfg.currentBlock, entryBlockID);
      CFG.pushBlock(cfg, entryBlockID);

      const args = createHookArguments(strandsContext, hookType.parameters);
      const rootNodeID = hookUserCallback(args).id;
      const returned = hookUserCallback(args);
      let returnedNode;

      const expectedReturnType = hookType.returnType;
      if(structTypes.includes(expectedReturnType.typeName)) {

      }
      else {
        // In this case we are expecting a native shader type, probably vec4 or vec3.
        const expected = TypeInfoFromGLSLName[expectedReturnType.typeName];
        // User may have returned a raw value like [1,1,1,1] or 25.
        if (!(returned instanceof StrandsNode)) {
          const id = createTypeConstructorNode(strandsContext, { baseType: BaseType.DEFER, dimension: null }, returned);
          returnedNode = new StrandsNode(id);
        }
        else {
          returnedNode = returned;
        }

        const received = {
          baseType: dag.baseTypes[returnedNode.id],
          dimension: dag.dimensions[returnedNode.id],
        }
        if (received.dimension !== expected.dimension) {
          if (received.dimension !== 1) {
            FES.userError('type error', `You have returned a vector with ${received.dimension} components in ${hookType.name} when a ${expected.baseType + expected.dimension} was expected!`);
          }
          else {
            const newID = createTypeConstructorNode(strandsContext, expected, returnedNode);
            returnedNode = new StrandsNode(newID);
          }
        }
        else if (received.baseType !== expected.baseType) {
            const newID = createTypeConstructorNode(strandsContext, expected, returnedNode);
            returnedNode = new StrandsNode(newID);
        }
      }

      strandsContext.hooks.push({
        hookType,
        entryBlockID,
        rootNodeID,
        rootNodeID: returnedNode.id,
      });
      CFG.popBlock(cfg);
    }
diff --git a/src/strands/utils.js b/src/strands/utils.js
 };

 export const OperatorTable = [
  { arity: "unary", name: "not", symbol: "!",opcode: OpCode.Unary.LOGICAL_NOT },
  { arity: "unary", name: "neg", symbol: "-",opcode: OpCode.Unary.NEGATE },
  { arity: "unary", name: "plus", symbol: "+",opcode: OpCode.Unary.PLUS },
  { arity: "binary", name: "add", symbol: "+",opcode: OpCode.Binary.ADD },
  { arity: "binary", name: "sub", symbol: "-",opcode: OpCode.Binary.SUBTRACT },
  { arity: "binary", name: "mult", symbol: "*",opcode: OpCode.Binary.MULTIPLY },
  { arity: "binary", name: "div", symbol: "/",opcode: OpCode.Binary.DIVIDE },
  { arity: "binary", name: "mod", symbol: "%",opcode: OpCode.Binary.MODULO },
  { arity: "binary", name: "equalTo", symbol: "==",opcode: OpCode.Binary.EQUAL },
  { arity: "binary", name: "notEqual", symbol: "!=",opcode: OpCode.Binary.NOT_EQUAL },
  { arity: "binary", name: "greaterThan", symbol: ">",opcode: OpCode.Binary.GREATER_THAN },
  { arity: "binary", name: "greaterEqual", symbol: ">=",opcode: OpCode.Binary.GREATER_EQUAL },
  { arity: "binary", name: "lessThan", symbol: "<",opcode: OpCode.Binary.LESS_THAN },
  { arity: "binary", name: "lessEqual", symbol: "<=",opcode: OpCode.Binary.LESS_EQUAL },
  { arity: "binary", name: "and", symbol: "&&",opcode: OpCode.Binary.LOGICAL_AND },
  { arity: "binary", name: "or", symbol: "||",opcode: OpCode.Binary.LOGICAL_OR },
  { arity: "unary", name: "not", symbol: "!",opCode: OpCode.Unary.LOGICAL_NOT },
  { arity: "unary", name: "neg", symbol: "-",opCode: OpCode.Unary.NEGATE },
  { arity: "unary", name: "plus", symbol: "+",opCode: OpCode.Unary.PLUS },
  { arity: "binary", name: "add", symbol: "+",opCode: OpCode.Binary.ADD },
  { arity: "binary", name: "sub", symbol: "-",opCode: OpCode.Binary.SUBTRACT },
  { arity: "binary", name: "mult", symbol: "*",opCode: OpCode.Binary.MULTIPLY },
  { arity: "binary", name: "div", symbol: "/",opCode: OpCode.Binary.DIVIDE },
  { arity: "binary", name: "mod", symbol: "%",opCode: OpCode.Binary.MODULO },
  { arity: "binary", name: "equalTo", symbol: "==",opCode: OpCode.Binary.EQUAL },
  { arity: "binary", name: "notEqual", symbol: "!=",opCode: OpCode.Binary.NOT_EQUAL },
  { arity: "binary", name: "greaterThan", symbol: ">",opCode: OpCode.Binary.GREATER_THAN },
  { arity: "binary", name: "greaterEqual", symbol: ">=",opCode: OpCode.Binary.GREATER_EQUAL },
  { arity: "binary", name: "lessThan", symbol: "<",opCode: OpCode.Binary.LESS_THAN },
  { arity: "binary", name: "lessEqual", symbol: "<=",opCode: OpCode.Binary.LESS_EQUAL },
  { arity: "binary", name: "and", symbol: "&&",opCode: OpCode.Binary.LOGICAL_AND },
  { arity: "binary", name: "or", symbol: "||",opCode: OpCode.Binary.LOGICAL_OR },
 ];

 export const ConstantFolding = {

 export const SymbolToOpCode = {};
 export const OpCodeToSymbol = {};
 export const OpCodeArgs = {};
 export const OpCodeToOperation = {};

 for (const { arity, symbol, opcode } of OperatorTable) {
  SymbolToOpCode[symbol] = opcode;
  OpCodeToSymbol[opcode] = symbol;
  OpCodeArgs[opcode] = args;
 for (const { symbol, opCode } of OperatorTable) {
  SymbolToOpCode[symbol] = opCode;
  OpCodeToSymbol[opCode] = symbol;
 }

 export const BlockType = {
  FOR: 7,
  MERGE: 8,
  DEFAULT: 9,

 }

 export const BlockTypeToName = Object.fromEntries(
  Object.entries(BlockType).map(([key, val]) => [val, key])
 );

 ////////////////////////////
 // Type Checking helpers
 ////////////////////////////
 export function arrayToFloatType(array) {
  let type = false;
  if (array.length === 1) {
    type = `FLOAT`;
  } else if (array.length >= 2 && array.length <= 4) {
    type = `VEC${array.length}`;
  } else {
    throw new Error('Tried to construct a float / vector with and empty array, or more than 4 components!')
  }
 }

 ////////////////////////////
 // Graph utils
 ////////////////////////////
 export function dfsPostOrder(adjacencyList, start) {
  const visited = new Set();
  const postOrder = [];

  function dfs(v) {
    if (visited.has(v)) {
      return;
    }
    visited.add(v);
    for (let w of adjacencyList[v]) {
      dfs(w);
    }
    postOrder.push(v);
  }

  dfs(start);
  return postOrder;
 }

 export function dfsReversePostOrder(adjacencyList, start) {
  const visited = new Set();
  const postOrder = [];

  function dfs(v) {
    if (visited.has(v)) {
      return;
    }
    visited.add(v);
    for (let w of adjacencyList[v].sort((a, b) => b-a) || []) {
      dfs(w);
    }
    postOrder.push(v);
  }

  dfs(start);
  return postOrder.reverse();
 }
 );
Original file line number	Diff line number	Diff line change
Expand Up		@@ -3,8 +3,9 @@ p5.disableFriendlyErrors = true;
		function callback() {

		getFinalColor((col) => {
		let x = vec3(1);
		return vec3(1).div(ivec3(1, 2, 4).mult(ivec3(2.0, 2, 3)));
		let x = vec4(1);
		// return 1;
		return vec4(1).div(ivec4(1).mult(ivec4(2.0, 3.0, 2, 3)));
		});
		}

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -196,6 +196,19 @@ export function createFunctionCallNode(strandsContext, identifier, overrides, de
		return id;
		}

		export function createUnaryOpNode(strandsContext, strandsNode, opCode) {
		const { dag, cfg } = strandsContext;
		const nodeData = DAG.createNodeData({
		nodeType: NodeType.OPERATION,
		opCode,
		dependsOn: strandsNode.id,
		baseType: dag.baseTypes[strandsNode.id],
		dimension: dag.dimensions[strandsNode.id],
		})
		CFG.recordInBasicBlock(cfg, cfg.currentBlock, id);
		return id;
		}

		export function createStatementNode(strandsContext, type) {
		return -99;
		}
Original file line number	Diff line number	Diff line change
		@@ -1,7 +1,9 @@
		import { WEBGL } from '../core/constants';
		import { glslBackend } from './GLSL_backend';
		import {dfsPostOrder, dfsReversePostOrder,NodeType } from './utils';
		import { NodeType } from './utils';
		import { extractTypeInfo } from './builder';
		import { sortCFG } from './control_flow_graph';
		import { sortDAG } from './directed_acyclic_graph';

		let globalTempCounter = 0;
		let backend;
Expand DownExpand Up		@@ -41,8 +43,8 @@ export function generateShaderCode(strandsContext) {

		for (const { hookType, entryBlockID, rootNodeID} of strandsContext.hooks) {
		const { cfg, dag } = strandsContext;
		const dagSorted =dfsPostOrder(dag.dependsOn, rootNodeID);
		const cfgSorted =dfsReversePostOrder(cfg.outgoingEdges, entryBlockID);
		const dagSorted =sortDAG(dag.dependsOn, rootNodeID);
		const cfgSorted =sortCFG(cfg.outgoingEdges, entryBlockID);

		const generationContext = {
		...generateTopLevelDeclarations(strandsContext, dagSorted),
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -59,4 +59,23 @@ export function printBlockData(graph, id) {
		const block = getBlockDataFromID(graph, id);
		block.blockType = BlockTypeToName[block.blockType];
		console.log(block);
		}

		export function sortCFG(adjacencyList, start) {
		const visited = new Set();
		const postOrder = [];

		function dfs(v) {
		if (visited.has(v)) {
		return;
		}
		visited.add(v);
		for (let w of adjacencyList[v].sort((a, b) => b-a) \|\| []) {
		dfs(w);
		}
		postOrder.push(v);
		}

		dfs(start);
		return postOrder.reverse();
		}
Original file line number	Diff line number	Diff line change
		@@ -1,4 +1,4 @@
		import { NodeTypeRequiredFields, NodeTypeToName, TypeInfo } from './utils';
		import { NodeTypeRequiredFields, NodeTypeToName } from './utils';
		import * as FES from './strands_FES';

		/////////////////////////////////
Expand DownExpand Up		@@ -113,4 +113,23 @@ function validateNode(node){
		if (missingFields.length > 0) {
		FES.internalError(`Missing fields ${missingFields.join(', ')} for a node type '${NodeTypeToName[nodeType]}'.`);
		}
		}

		export function sortDAG(adjacencyList, start) {
		const visited = new Set();
		const postOrder = [];

		function dfs(v) {
		if (visited.has(v)) {
		return;
		}
		visited.add(v);
		for (let w of adjacencyList[v]) {
		dfs(w);
		}
		postOrder.push(v);
		}

		dfs(start);
		return postOrder;
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -12,7 +12,7 @@ import { BlockType } from './utils';
		import { createDirectedAcyclicGraph } from './directed_acyclic_graph'
		import { createControlFlowGraph, createBasicBlock, pushBlock, popBlock } from './control_flow_graph';
		import { generateShaderCode } from './code_generation';
		import { initGlobalStrandsAPI,initShaderHooksFunctions } from './user_API';
		import { initGlobalStrandsAPI,createShaderHooksFunctions } from './user_API';

		function strands(p5, fn) {
		//////////////////////////////////////////////
Expand DownExpand Up		@@ -51,7 +51,7 @@ function strands(p5, fn) {
		// Reset the context object every time modify is called;
		const backend = WEBGL;
		initStrandsContext(strandsContext, backend);
		initShaderHooksFunctions(strandsContext, fn, this);
		createShaderHooksFunctions(strandsContext, fn, this);

		// 1. Transpile from strands DSL to JS
		let strandsCallback;
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -4,8 +4,9 @@ import {
		createVariableNode,
		createStatementNode,
		createTypeConstructorNode,
		createUnaryOpNode,
		} from './builder'
		import { OperatorTable,SymbolToOpCode,BlockType, TypeInfo, BaseType, TypeInfoFromGLSLName } from './utils'
		import { OperatorTable, BlockType, TypeInfo, BaseType, TypeInfoFromGLSLName } from './utils'
		import { strandsShaderFunctions } from './shader_functions'
		import { StrandsConditional } from './strands_conditionals'
		import * as CFG from './control_flow_graph'
Expand All		@@ -23,19 +24,19 @@ export class StrandsNode {
		export function initGlobalStrandsAPI(p5, fn, strandsContext) {
		// We augment the strands node with operations programatically
		// this means methods like .add, .sub, etc can be chained
		for (const { name,symbol, arity } of OperatorTable) {
		for (const { name,arity, opCode, symbol } of OperatorTable) {
		if (arity === 'binary') {
		StrandsNode.prototype[name] = function (...right) {
		const id = createBinaryOpNode(strandsContext, this, right,SymbolToOpCode[symbol]);
		const id = createBinaryOpNode(strandsContext, this, right,opCode);
		return new StrandsNode(id);
		};
		}
		//if (arity === 'unary') {
		// StrandsNode.prototype[name] = function () {
		//const id =createUnaryExpressionNode(this, SymbolToOpCode[symbol]);
		// return new StrandsNode(id);
		// };
		//}
		if (arity === 'unary') {
		fn[name] = function (strandsNode) {
		const id =createUnaryOpNode(strandsContext, strandsNode, opCode);
		return new StrandsNode(id);
		}
		}
		}

		//////////////////////////////////////////////
Expand DownExpand Up		@@ -134,17 +135,20 @@ export function initGlobalStrandsAPI(p5, fn, strandsContext) {
		//////////////////////////////////////////////
		// Per-Hook functions
		//////////////////////////////////////////////
		const structTypes = ['Vertex', ]

		function createHookArguments(strandsContext, parameters){
		const structTypes = ['Vertex', ]
		const args = [];

		for (const param of parameters) {
		const paramType = param.type;
		if(structTypes.includes(paramType.typeName)) {
		const propertiesNodes = paramType.properties.map(
		(prop) => [prop.name, createVariableNode(strandsContext, TypeInfoFromGLSLName[prop.dataType], prop.name)]
		);
		const argObject = Object.fromEntries(propertiesNodes);
		const propertyEntries = paramType.properties.map((prop) => {
		const typeInfo = TypeInfoFromGLSLName[prop.dataType];
		const variableNode = createVariableNode(strandsContext, typeInfo, prop.name);
		return [prop.name, variableNode];
		});
		const argObject = Object.fromEntries(propertyEntries);
		args.push(argObject);
		} else {
		const typeInfo = TypeInfoFromGLSLName[paramType.typeName];
Expand All		@@ -155,24 +159,63 @@ function createHookArguments(strandsContext, parameters){
		return args;
		}

		export functioninitShaderHooksFunctions(strandsContext, fn, shader) {
		export functioncreateShaderHooksFunctions(strandsContext, fn, shader) {
		const availableHooks = {
		...shader.hooks.vertex,
		...shader.hooks.fragment,
		}
		const hookTypes = Object.keys(availableHooks).map(name => shader.hookTypes(name));
		const { cfg } = strandsContext;
		const { cfg, dag } = strandsContext;

		for (const hookType of hookTypes) {
		window[hookType.name] = function(hookUserCallback) {
		const entryBlockID = CFG.createBasicBlock(cfg, BlockType.FUNCTION);
		CFG.addEdge(cfg, cfg.currentBlock, entryBlockID);
		CFG.pushBlock(cfg, entryBlockID);

		const args = createHookArguments(strandsContext, hookType.parameters);
		const rootNodeID = hookUserCallback(args).id;
		const returned = hookUserCallback(args);
		let returnedNode;

		const expectedReturnType = hookType.returnType;
		if(structTypes.includes(expectedReturnType.typeName)) {

		}
		else {
		// In this case we are expecting a native shader type, probably vec4 or vec3.
		const expected = TypeInfoFromGLSLName[expectedReturnType.typeName];
		// User may have returned a raw value like [1,1,1,1] or 25.
		if (!(returned instanceof StrandsNode)) {
		const id = createTypeConstructorNode(strandsContext, { baseType: BaseType.DEFER, dimension: null }, returned);
		returnedNode = new StrandsNode(id);
		}
		else {
		returnedNode = returned;
		}

		const received = {
		baseType: dag.baseTypes[returnedNode.id],
		dimension: dag.dimensions[returnedNode.id],
		}
		if (received.dimension !== expected.dimension) {
		if (received.dimension !== 1) {
		FES.userError('type error', `You have returned a vector with ${received.dimension} components in ${hookType.name} when a ${expected.baseType + expected.dimension} was expected!`);
		}
		else {
		const newID = createTypeConstructorNode(strandsContext, expected, returnedNode);
		returnedNode = new StrandsNode(newID);
		}
		}
		else if (received.baseType !== expected.baseType) {
		const newID = createTypeConstructorNode(strandsContext, expected, returnedNode);
		returnedNode = new StrandsNode(newID);
		}
		}

		strandsContext.hooks.push({
		hookType,
		entryBlockID,
		rootNodeID,
		rootNodeID: returnedNode.id,
		});
		CFG.popBlock(cfg);
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -102,22 +102,22 @@ export const OpCode = {
		};

		export const OperatorTable = [
		{ arity: "unary", name: "not", symbol: "!",opcode: OpCode.Unary.LOGICAL_NOT },
		{ arity: "unary", name: "neg", symbol: "-",opcode: OpCode.Unary.NEGATE },
		{ arity: "unary", name: "plus", symbol: "+",opcode: OpCode.Unary.PLUS },
		{ arity: "binary", name: "add", symbol: "+",opcode: OpCode.Binary.ADD },
		{ arity: "binary", name: "sub", symbol: "-",opcode: OpCode.Binary.SUBTRACT },
		{ arity: "binary", name: "mult", symbol: "*",opcode: OpCode.Binary.MULTIPLY },
		{ arity: "binary", name: "div", symbol: "/",opcode: OpCode.Binary.DIVIDE },
		{ arity: "binary", name: "mod", symbol: "%",opcode: OpCode.Binary.MODULO },
		{ arity: "binary", name: "equalTo", symbol: "==",opcode: OpCode.Binary.EQUAL },
		{ arity: "binary", name: "notEqual", symbol: "!=",opcode: OpCode.Binary.NOT_EQUAL },
		{ arity: "binary", name: "greaterThan", symbol: ">",opcode: OpCode.Binary.GREATER_THAN },
		{ arity: "binary", name: "greaterEqual", symbol: ">=",opcode: OpCode.Binary.GREATER_EQUAL },
		{ arity: "binary", name: "lessThan", symbol: "<",opcode: OpCode.Binary.LESS_THAN },
		{ arity: "binary", name: "lessEqual", symbol: "<=",opcode: OpCode.Binary.LESS_EQUAL },
		{ arity: "binary", name: "and", symbol: "&&",opcode: OpCode.Binary.LOGICAL_AND },
		{ arity: "binary", name: "or", symbol: "\|\|",opcode: OpCode.Binary.LOGICAL_OR },
		{ arity: "unary", name: "not", symbol: "!",opCode: OpCode.Unary.LOGICAL_NOT },
		{ arity: "unary", name: "neg", symbol: "-",opCode: OpCode.Unary.NEGATE },
		{ arity: "unary", name: "plus", symbol: "+",opCode: OpCode.Unary.PLUS },
		{ arity: "binary", name: "add", symbol: "+",opCode: OpCode.Binary.ADD },
		{ arity: "binary", name: "sub", symbol: "-",opCode: OpCode.Binary.SUBTRACT },
		{ arity: "binary", name: "mult", symbol: "*",opCode: OpCode.Binary.MULTIPLY },
		{ arity: "binary", name: "div", symbol: "/",opCode: OpCode.Binary.DIVIDE },
		{ arity: "binary", name: "mod", symbol: "%",opCode: OpCode.Binary.MODULO },
		{ arity: "binary", name: "equalTo", symbol: "==",opCode: OpCode.Binary.EQUAL },
		{ arity: "binary", name: "notEqual", symbol: "!=",opCode: OpCode.Binary.NOT_EQUAL },
		{ arity: "binary", name: "greaterThan", symbol: ">",opCode: OpCode.Binary.GREATER_THAN },
		{ arity: "binary", name: "greaterEqual", symbol: ">=",opCode: OpCode.Binary.GREATER_EQUAL },
		{ arity: "binary", name: "lessThan", symbol: "<",opCode: OpCode.Binary.LESS_THAN },
		{ arity: "binary", name: "lessEqual", symbol: "<=",opCode: OpCode.Binary.LESS_EQUAL },
		{ arity: "binary", name: "and", symbol: "&&",opCode: OpCode.Binary.LOGICAL_AND },
		{ arity: "binary", name: "or", symbol: "\|\|",opCode: OpCode.Binary.LOGICAL_OR },
		];

		export const ConstantFolding = {
Expand All		@@ -138,13 +138,10 @@ export const ConstantFolding = {

		export const SymbolToOpCode = {};
		export const OpCodeToSymbol = {};
		export const OpCodeArgs = {};
		export const OpCodeToOperation = {};

		for (const { arity, symbol, opcode } of OperatorTable) {
		SymbolToOpCode[symbol] = opcode;
		OpCodeToSymbol[opcode] = symbol;
		OpCodeArgs[opcode] = args;
		for (const { symbol, opCode } of OperatorTable) {
		SymbolToOpCode[symbol] = opCode;
		OpCodeToSymbol[opCode] = symbol;
		}

		export const BlockType = {
Expand All		@@ -158,63 +155,8 @@ export const BlockType = {
		FOR: 7,
		MERGE: 8,
		DEFAULT: 9,

		}

		export const BlockTypeToName = Object.fromEntries(
		Object.entries(BlockType).map(([key, val]) => [val, key])
		);

		////////////////////////////
		// Type Checking helpers
		////////////////////////////
		export function arrayToFloatType(array) {
		let type = false;
		if (array.length === 1) {
		type = `FLOAT`;
		} else if (array.length >= 2 && array.length <= 4) {
		type = `VEC${array.length}`;
		} else {
		throw new Error('Tried to construct a float / vector with and empty array, or more than 4 components!')
		}
		}

		////////////////////////////
		// Graph utils
		////////////////////////////
		export function dfsPostOrder(adjacencyList, start) {
		const visited = new Set();
		const postOrder = [];

		function dfs(v) {
		if (visited.has(v)) {
		return;
		}
		visited.add(v);
		for (let w of adjacencyList[v]) {
		dfs(w);
		}
		postOrder.push(v);
		}

		dfs(start);
		return postOrder;
		}

		export function dfsReversePostOrder(adjacencyList, start) {
		const visited = new Set();
		const postOrder = [];

		function dfs(v) {
		if (visited.has(v)) {
		return;
		}
		visited.add(v);
		for (let w of adjacencyList[v].sort((a, b) => b-a) \|\| []) {
		dfs(w);
		}
		postOrder.push(v);
		}

		dfs(start);
		return postOrder.reverse();
		}
		);