three-stdlib 2.22.7 → 2.22.8

package/dist/nodes/math/OperatorNode.js

@@ -0,0 +1,102 @@
+"use strict";
+const TempNode = require("../core/TempNode.js");
+class OperatorNode extends TempNode {
+  constructor(op, aNode, bNode, ...params) {
+    super();
+    this.op = op;
+    if (params.length > 0) {
+      let finalBNode = bNode;
+      for (let i = 0; i < params.length; i++) {
+        finalBNode = new OperatorNode(op, finalBNode, params[i]);
+      }
+      bNode = finalBNode;
+    }
+    this.aNode = aNode;
+    this.bNode = bNode;
+  }
+  getNodeType(builder, output) {
+    const op = this.op;
+    const aNode = this.aNode;
+    const bNode = this.bNode;
+    const typeA = aNode.getNodeType(builder);
+    const typeB = bNode.getNodeType(builder);
+    if (typeA === "void" || typeB === "void") {
+      return "void";
+    } else if (op === "=" || op === "%") {
+      return typeA;
+    } else if (op === "&" || op === "|" || op === "^" || op === ">>" || op === "<<") {
+      return "int";
+    } else if (op === "==" || op === "&&" || op === "||" || op === "^^") {
+      return "bool";
+    } else if (op === "<" || op === ">" || op === "<=" || op === ">=") {
+      const typeLength = builder.getTypeLength(output);
+      return typeLength > 1 ? `bvec${typeLength}` : "bool";
+    } else {
+      if (typeA === "float" && builder.isMatrix(typeB)) {
+        return typeB;
+      } else if (builder.isMatrix(typeA) && builder.isVector(typeB)) {
+        return builder.getVectorFromMatrix(typeA);
+      } else if (builder.isVector(typeA) && builder.isMatrix(typeB)) {
+        return builder.getVectorFromMatrix(typeB);
+      } else if (builder.getTypeLength(typeB) > builder.getTypeLength(typeA)) {
+        return typeB;
+      }
+      return typeA;
+    }
+  }
+  generate(builder, output) {
+    const op = this.op;
+    const aNode = this.aNode;
+    const bNode = this.bNode;
+    const type = this.getNodeType(builder, output);
+    let typeA = null;
+    let typeB = null;
+    if (type !== "void") {
+      typeA = aNode.getNodeType(builder);
+      typeB = bNode.getNodeType(builder);
+      if (op === "=") {
+        typeB = typeA;
+      } else if (op === "<" || op === ">" || op === "<=" || op === ">=") {
+        if (builder.isVector(typeA)) {
+          typeB = typeA;
+        } else {
+          typeA = typeB = "float";
+        }
+      } else if (builder.isMatrix(typeA) && builder.isVector(typeB)) {
+        typeB = builder.getVectorFromMatrix(typeA);
+      } else if (builder.isVector(typeA) && builder.isMatrix(typeB)) {
+        typeA = builder.getVectorFromMatrix(typeB);
+      } else {
+        typeA = typeB = type;
+      }
+    } else {
+      typeA = typeB = type;
+    }
+    const a = aNode.build(builder, typeA);
+    const b = bNode.build(builder, typeB);
+    const outputLength = builder.getTypeLength(output);
+    if (output !== "void") {
+      if (op === "=") {
+        builder.addFlowCode(`${a} ${this.op} ${b}`);
+        return a;
+      } else if (op === ">" && outputLength > 1) {
+        return builder.format(`${builder.getMethod("greaterThan")}( ${a}, ${b} )`, type, output);
+      } else if (op === "<=" && outputLength > 1) {
+        return builder.format(`${builder.getMethod("lessThanEqual")}( ${a}, ${b} )`, type, output);
+      } else {
+        return builder.format(`( ${a} ${this.op} ${b} )`, type, output);
+      }
+    } else if (typeA !== "void") {
+      return builder.format(`${a} ${this.op} ${b}`, type, output);
+    }
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.op = this.op;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.op = data.op;
+  }
+}
+module.exports = OperatorNode;

package/dist/nodes/math/OperatorNode.mjs

@@ -0,0 +1,103 @@
+import TempNode from "../core/TempNode.mjs";
+class OperatorNode extends TempNode {
+  constructor(op, aNode, bNode, ...params) {
+    super();
+    this.op = op;
+    if (params.length > 0) {
+      let finalBNode = bNode;
+      for (let i = 0; i < params.length; i++) {
+        finalBNode = new OperatorNode(op, finalBNode, params[i]);
+      }
+      bNode = finalBNode;
+    }
+    this.aNode = aNode;
+    this.bNode = bNode;
+  }
+  getNodeType(builder, output) {
+    const op = this.op;
+    const aNode = this.aNode;
+    const bNode = this.bNode;
+    const typeA = aNode.getNodeType(builder);
+    const typeB = bNode.getNodeType(builder);
+    if (typeA === "void" || typeB === "void") {
+      return "void";
+    } else if (op === "=" || op === "%") {
+      return typeA;
+    } else if (op === "&" || op === "|" || op === "^" || op === ">>" || op === "<<") {
+      return "int";
+    } else if (op === "==" || op === "&&" || op === "||" || op === "^^") {
+      return "bool";
+    } else if (op === "<" || op === ">" || op === "<=" || op === ">=") {
+      const typeLength = builder.getTypeLength(output);
+      return typeLength > 1 ? `bvec${typeLength}` : "bool";
+    } else {
+      if (typeA === "float" && builder.isMatrix(typeB)) {
+        return typeB;
+      } else if (builder.isMatrix(typeA) && builder.isVector(typeB)) {
+        return builder.getVectorFromMatrix(typeA);
+      } else if (builder.isVector(typeA) && builder.isMatrix(typeB)) {
+        return builder.getVectorFromMatrix(typeB);
+      } else if (builder.getTypeLength(typeB) > builder.getTypeLength(typeA)) {
+        return typeB;
+      }
+      return typeA;
+    }
+  }
+  generate(builder, output) {
+    const op = this.op;
+    const aNode = this.aNode;
+    const bNode = this.bNode;
+    const type = this.getNodeType(builder, output);
+    let typeA = null;
+    let typeB = null;
+    if (type !== "void") {
+      typeA = aNode.getNodeType(builder);
+      typeB = bNode.getNodeType(builder);
+      if (op === "=") {
+        typeB = typeA;
+      } else if (op === "<" || op === ">" || op === "<=" || op === ">=") {
+        if (builder.isVector(typeA)) {
+          typeB = typeA;
+        } else {
+          typeA = typeB = "float";
+        }
+      } else if (builder.isMatrix(typeA) && builder.isVector(typeB)) {
+        typeB = builder.getVectorFromMatrix(typeA);
+      } else if (builder.isVector(typeA) && builder.isMatrix(typeB)) {
+        typeA = builder.getVectorFromMatrix(typeB);
+      } else {
+        typeA = typeB = type;
+      }
+    } else {
+      typeA = typeB = type;
+    }
+    const a = aNode.build(builder, typeA);
+    const b = bNode.build(builder, typeB);
+    const outputLength = builder.getTypeLength(output);
+    if (output !== "void") {
+      if (op === "=") {
+        builder.addFlowCode(`${a} ${this.op} ${b}`);
+        return a;
+      } else if (op === ">" && outputLength > 1) {
+        return builder.format(`${builder.getMethod("greaterThan")}( ${a}, ${b} )`, type, output);
+      } else if (op === "<=" && outputLength > 1) {
+        return builder.format(`${builder.getMethod("lessThanEqual")}( ${a}, ${b} )`, type, output);
+      } else {
+        return builder.format(`( ${a} ${this.op} ${b} )`, type, output);
+      }
+    } else if (typeA !== "void") {
+      return builder.format(`${a} ${this.op} ${b}`, type, output);
+    }
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.op = this.op;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.op = data.op;
+  }
+}
+export {
+  OperatorNode as default
+};

package/dist/nodes/procedural/CheckerNode.js

@@ -0,0 +1,20 @@
+"use strict";
+const Node = require("../core/Node.js");
+const ShaderNode = require("../ShaderNode.js");
+const checkerShaderNode = new ShaderNode.ShaderNode((inputs) => {
+  const uv = ShaderNode.mul(inputs.uv, 2);
+  const cx = ShaderNode.floor(uv.x);
+  const cy = ShaderNode.floor(uv.y);
+  const result = ShaderNode.mod(ShaderNode.add(cx, cy), 2);
+  return ShaderNode.sign(result);
+});
+class CheckerNode extends Node {
+  constructor(uvNode = ShaderNode.uv()) {
+    super("float");
+    this.uvNode = uvNode;
+  }
+  generate(builder) {
+    return checkerShaderNode({ uv: this.uvNode }).build(builder);
+  }
+}
+module.exports = CheckerNode;

package/dist/nodes/procedural/CheckerNode.mjs

@@ -0,0 +1,21 @@
+import Node from "../core/Node.mjs";
+import { ShaderNode, mul, floor, mod, add, sign, uv } from "../ShaderNode.mjs";
+const checkerShaderNode = new ShaderNode((inputs) => {
+  const uv2 = mul(inputs.uv, 2);
+  const cx = floor(uv2.x);
+  const cy = floor(uv2.y);
+  const result = mod(add(cx, cy), 2);
+  return sign(result);
+});
+class CheckerNode extends Node {
+  constructor(uvNode = uv()) {
+    super("float");
+    this.uvNode = uvNode;
+  }
+  generate(builder) {
+    return checkerShaderNode({ uv: this.uvNode }).build(builder);
+  }
+}
+export {
+  CheckerNode as default
+};

package/dist/nodes/utils/ArrayElementNode.js

@@ -0,0 +1,18 @@
+"use strict";
+const Node = require("../core/Node.js");
+class ArrayElementNode extends Node {
+  constructor(node, indexNode) {
+    super();
+    this.node = node;
+    this.indexNode = indexNode;
+  }
+  getNodeType(builder) {
+    return this.node.getNodeType(builder);
+  }
+  generate(builder) {
+    const nodeSnippet = this.node.build(builder);
+    const indexSnippet = this.indexNode.build(builder, "int");
+    return `${nodeSnippet}[ ${indexSnippet} ]`;
+  }
+}
+module.exports = ArrayElementNode;

package/dist/nodes/utils/ArrayElementNode.mjs

@@ -0,0 +1,19 @@
+import Node from "../core/Node.mjs";
+class ArrayElementNode extends Node {
+  constructor(node, indexNode) {
+    super();
+    this.node = node;
+    this.indexNode = indexNode;
+  }
+  getNodeType(builder) {
+    return this.node.getNodeType(builder);
+  }
+  generate(builder) {
+    const nodeSnippet = this.node.build(builder);
+    const indexSnippet = this.indexNode.build(builder, "int");
+    return `${nodeSnippet}[ ${indexSnippet} ]`;
+  }
+}
+export {
+  ArrayElementNode as default
+};

package/dist/nodes/utils/ConvertNode.js

@@ -0,0 +1,24 @@
+"use strict";
+const Node = require("../core/Node.js");
+class ConvertNode extends Node {
+  constructor(node, convertTo) {
+    super();
+    this.node = node;
+    this.convertTo = convertTo;
+  }
+  getNodeType() {
+    return this.convertTo;
+  }
+  generate(builder) {
+    const convertTo = this.convertTo;
+    const node = this.node;
+    if (builder.isReference(convertTo) === false) {
+      const convertToSnippet = builder.getType(convertTo);
+      const nodeSnippet = node.build(builder, convertTo);
+      return `${builder.getVectorType(convertToSnippet)}( ${nodeSnippet} )`;
+    } else {
+      return node.build(builder, convertTo);
+    }
+  }
+}
+module.exports = ConvertNode;

package/dist/nodes/utils/ConvertNode.mjs

@@ -0,0 +1,25 @@
+import Node from "../core/Node.mjs";
+class ConvertNode extends Node {
+  constructor(node, convertTo) {
+    super();
+    this.node = node;
+    this.convertTo = convertTo;
+  }
+  getNodeType() {
+    return this.convertTo;
+  }
+  generate(builder) {
+    const convertTo = this.convertTo;
+    const node = this.node;
+    if (builder.isReference(convertTo) === false) {
+      const convertToSnippet = builder.getType(convertTo);
+      const nodeSnippet = node.build(builder, convertTo);
+      return `${builder.getVectorType(convertToSnippet)}( ${nodeSnippet} )`;
+    } else {
+      return node.build(builder, convertTo);
+    }
+  }
+}
+export {
+  ConvertNode as default
+};

package/dist/nodes/utils/JoinNode.js

@@ -0,0 +1,25 @@
+"use strict";
+const Node = require("../core/Node.js");
+class JoinNode extends Node {
+  constructor(nodes = []) {
+    super();
+    this.nodes = nodes;
+  }
+  getNodeType(builder) {
+    return builder.getTypeFromLength(
+      this.nodes.reduce((count, cur) => count + builder.getTypeLength(cur.getNodeType(builder)), 0)
+    );
+  }
+  generate(builder) {
+    const type = this.getNodeType(builder);
+    const nodes = this.nodes;
+    const snippetValues = [];
+    for (let i = 0; i < nodes.length; i++) {
+      const input = nodes[i];
+      const inputSnippet = input.build(builder);
+      snippetValues.push(inputSnippet);
+    }
+    return `${builder.getType(type)}( ${snippetValues.join(", ")} )`;
+  }
+}
+module.exports = JoinNode;

package/dist/nodes/utils/JoinNode.mjs

@@ -0,0 +1,26 @@
+import Node from "../core/Node.mjs";
+class JoinNode extends Node {
+  constructor(nodes = []) {
+    super();
+    this.nodes = nodes;
+  }
+  getNodeType(builder) {
+    return builder.getTypeFromLength(
+      this.nodes.reduce((count, cur) => count + builder.getTypeLength(cur.getNodeType(builder)), 0)
+    );
+  }
+  generate(builder) {
+    const type = this.getNodeType(builder);
+    const nodes = this.nodes;
+    const snippetValues = [];
+    for (let i = 0; i < nodes.length; i++) {
+      const input = nodes[i];
+      const inputSnippet = input.build(builder);
+      snippetValues.push(inputSnippet);
+    }
+    return `${builder.getType(type)}( ${snippetValues.join(", ")} )`;
+  }
+}
+export {
+  JoinNode as default
+};

package/dist/nodes/utils/MatcapUVNode.js

@@ -0,0 +1,15 @@
+"use strict";
+const TempNode = require("../core/TempNode.js");
+const ShaderNode = require("../ShaderNode.js");
+class MatcapUVNode extends TempNode {
+  constructor() {
+    super("vec2");
+  }
+  generate(builder) {
+    const x = ShaderNode.normalize(ShaderNode.join(ShaderNode.positionViewDirection.z, 0, ShaderNode.negate(ShaderNode.positionViewDirection.x)));
+    const y = ShaderNode.cross(ShaderNode.positionViewDirection, x);
+    const uv = ShaderNode.add(ShaderNode.mul(ShaderNode.join(ShaderNode.dot(x, ShaderNode.transformedNormalView), ShaderNode.dot(y, ShaderNode.transformedNormalView)), 0.495), 0.5);
+    return uv.build(builder, this.getNodeType(builder));
+  }
+}
+module.exports = MatcapUVNode;

package/dist/nodes/utils/MatcapUVNode.mjs

@@ -0,0 +1,16 @@
+import TempNode from "../core/TempNode.mjs";
+import { normalize, join, positionViewDirection, negate, cross, add, mul, dot, transformedNormalView } from "../ShaderNode.mjs";
+class MatcapUVNode extends TempNode {
+  constructor() {
+    super("vec2");
+  }
+  generate(builder) {
+    const x = normalize(join(positionViewDirection.z, 0, negate(positionViewDirection.x)));
+    const y = cross(positionViewDirection, x);
+    const uv = add(mul(join(dot(x, transformedNormalView), dot(y, transformedNormalView)), 0.495), 0.5);
+    return uv.build(builder, this.getNodeType(builder));
+  }
+}
+export {
+  MatcapUVNode as default
+};

package/dist/nodes/utils/OscNode.js

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const Node = require("../core/Node.js");
+const TimerNode = require("./TimerNode.js");
+const ShaderNode = require("../ShaderNode.js");
+const _OscNode = class extends Node {
+  constructor(method = _OscNode.SINE, timeNode = new TimerNode()) {
+    super();
+    this.method = method;
+    this.timeNode = timeNode;
+  }
+  getNodeType(builder) {
+    return this.timeNode.getNodeType(builder);
+  }
+  generate(builder) {
+    const method = this.method;
+    const timeNode = this.timeNode;
+    let outputNode = null;
+    if (method === _OscNode.SINE) {
+      outputNode = ShaderNode.add(ShaderNode.mul(ShaderNode.sin(ShaderNode.mul(ShaderNode.add(timeNode, 0.75), Math.PI * 2)), 0.5), 0.5);
+    } else if (method === _OscNode.SQUARE) {
+      outputNode = ShaderNode.round(ShaderNode.fract(timeNode));
+    } else if (method === _OscNode.TRIANGLE) {
+      outputNode = ShaderNode.abs(ShaderNode.sub(1, ShaderNode.mul(ShaderNode.fract(ShaderNode.add(timeNode, 0.5)), 2)));
+    } else if (method === _OscNode.SAWTOOTH) {
+      outputNode = ShaderNode.fract(timeNode);
+    }
+    return outputNode.build(builder);
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.method = this.method;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.method = data.method;
+  }
+};
+let OscNode = _OscNode;
+__publicField(OscNode, "SINE", "sine");
+__publicField(OscNode, "SQUARE", "square");
+__publicField(OscNode, "TRIANGLE", "triangle");
+__publicField(OscNode, "SAWTOOTH", "sawtooth");
+module.exports = OscNode;

package/dist/nodes/utils/OscNode.mjs

@@ -0,0 +1,50 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import Node from "../core/Node.mjs";
+import TimerNode from "./TimerNode.mjs";
+import { add, mul, sin, round, fract, abs, sub } from "../ShaderNode.mjs";
+const _OscNode = class extends Node {
+  constructor(method = _OscNode.SINE, timeNode = new TimerNode()) {
+    super();
+    this.method = method;
+    this.timeNode = timeNode;
+  }
+  getNodeType(builder) {
+    return this.timeNode.getNodeType(builder);
+  }
+  generate(builder) {
+    const method = this.method;
+    const timeNode = this.timeNode;
+    let outputNode = null;
+    if (method === _OscNode.SINE) {
+      outputNode = add(mul(sin(mul(add(timeNode, 0.75), Math.PI * 2)), 0.5), 0.5);
+    } else if (method === _OscNode.SQUARE) {
+      outputNode = round(fract(timeNode));
+    } else if (method === _OscNode.TRIANGLE) {
+      outputNode = abs(sub(1, mul(fract(add(timeNode, 0.5)), 2)));
+    } else if (method === _OscNode.SAWTOOTH) {
+      outputNode = fract(timeNode);
+    }
+    return outputNode.build(builder);
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.method = this.method;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.method = data.method;
+  }
+};
+let OscNode = _OscNode;
+__publicField(OscNode, "SINE", "sine");
+__publicField(OscNode, "SQUARE", "square");
+__publicField(OscNode, "TRIANGLE", "triangle");
+__publicField(OscNode, "SAWTOOTH", "sawtooth");
+export {
+  OscNode as default
+};

package/dist/nodes/utils/SplitNode.js

@@ -0,0 +1,44 @@
+"use strict";
+const Node = require("../core/Node.js");
+const NodeBuilder = require("../core/NodeBuilder.js");
+class SplitNode extends Node {
+  constructor(node, components = "x") {
+    super();
+    this.node = node;
+    this.components = components;
+  }
+  getVectorLength() {
+    let vectorLength = this.components.length;
+    for (const c of this.components) {
+      vectorLength = Math.max(NodeBuilder.vector.indexOf(c) + 1, vectorLength);
+    }
+    return vectorLength;
+  }
+  getNodeType(builder) {
+    return builder.getTypeFromLength(this.components.length);
+  }
+  generate(builder) {
+    const node = this.node;
+    const nodeTypeLength = builder.getTypeLength(node.getNodeType(builder));
+    if (nodeTypeLength > 1) {
+      let type = null;
+      const componentsLength = this.getVectorLength();
+      if (componentsLength >= nodeTypeLength) {
+        type = builder.getTypeFromLength(this.getVectorLength());
+      }
+      const nodeSnippet = node.build(builder, type);
+      return `${nodeSnippet}.${this.components}`;
+    } else {
+      return node.build(builder);
+    }
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.components = this.components;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.components = data.components;
+  }
+}
+module.exports = SplitNode;

package/dist/nodes/utils/SplitNode.mjs

@@ -0,0 +1,45 @@
+import Node from "../core/Node.mjs";
+import { vector } from "../core/NodeBuilder.mjs";
+class SplitNode extends Node {
+  constructor(node, components = "x") {
+    super();
+    this.node = node;
+    this.components = components;
+  }
+  getVectorLength() {
+    let vectorLength = this.components.length;
+    for (const c of this.components) {
+      vectorLength = Math.max(vector.indexOf(c) + 1, vectorLength);
+    }
+    return vectorLength;
+  }
+  getNodeType(builder) {
+    return builder.getTypeFromLength(this.components.length);
+  }
+  generate(builder) {
+    const node = this.node;
+    const nodeTypeLength = builder.getTypeLength(node.getNodeType(builder));
+    if (nodeTypeLength > 1) {
+      let type = null;
+      const componentsLength = this.getVectorLength();
+      if (componentsLength >= nodeTypeLength) {
+        type = builder.getTypeFromLength(this.getVectorLength());
+      }
+      const nodeSnippet = node.build(builder, type);
+      return `${nodeSnippet}.${this.components}`;
+    } else {
+      return node.build(builder);
+    }
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.components = this.components;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.components = data.components;
+  }
+}
+export {
+  SplitNode as default
+};

package/dist/nodes/utils/SpriteSheetUVNode.js

@@ -0,0 +1,39 @@
+"use strict";
+const Node = require("../core/Node.js");
+const ConstNode = require("../core/ConstNode.js");
+const UVNode = require("../accessors/UVNode.js");
+const MathNode = require("../math/MathNode.js");
+const OperatorNode = require("../math/OperatorNode.js");
+const SplitNode = require("./SplitNode.js");
+const JoinNode = require("./JoinNode.js");
+class SpriteSheetUVNode extends Node {
+  constructor(countNode, uvNode = new UVNode(), frameNode = new ConstNode(0)) {
+    super("vec2");
+    this.countNode = countNode;
+    this.uvNode = uvNode;
+    this.frameNode = frameNode;
+  }
+  generate(builder) {
+    const count = this.countNode;
+    const uv = this.uvNode;
+    const frame = this.frameNode;
+    const one = new ConstNode(1);
+    const width = new SplitNode(count, "x");
+    const height = new SplitNode(count, "y");
+    const total = new OperatorNode("*", width, height);
+    const roundFrame = new MathNode(MathNode.FLOOR, new MathNode(MathNode.MOD, frame, total));
+    const frameNum = new OperatorNode("+", roundFrame, one);
+    const cell = new MathNode(MathNode.MOD, roundFrame, width);
+    const row = new MathNode(MathNode.CEIL, new OperatorNode("/", frameNum, width));
+    const rowInv = new OperatorNode("-", height, row);
+    const scale = new OperatorNode("/", one, count);
+    const uvFrameOffset = new JoinNode([
+      new OperatorNode("*", cell, new SplitNode(scale, "x")),
+      new OperatorNode("*", rowInv, new SplitNode(scale, "y"))
+    ]);
+    const uvScale = new OperatorNode("*", uv, scale);
+    const uvFrame = new OperatorNode("+", uvScale, uvFrameOffset);
+    return uvFrame.build(builder, this.getNodeType(builder));
+  }
+}
+module.exports = SpriteSheetUVNode;