three-stdlib 2.15.1 → 2.15.2

package/nodes/accessors/Object3DNode.mjs

@@ -0,0 +1,76 @@
+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 { Vector3 } from "three";
+import Node from "../core/Node.mjs";
+import UniformNode from "../core/UniformNode.mjs";
+import { NodeUpdateType } from "../core/constants.mjs";
+const _Object3DNode = class extends Node {
+  constructor(scope = _Object3DNode.VIEW_MATRIX, object3d = null) {
+    super();
+    this.scope = scope;
+    this.object3d = object3d;
+    this.updateType = NodeUpdateType.Object;
+    this._uniformNode = new UniformNode(null);
+  }
+  getNodeType() {
+    const scope = this.scope;
+    if (scope === _Object3DNode.WORLD_MATRIX || scope === _Object3DNode.VIEW_MATRIX) {
+      return "mat4";
+    } else if (scope === _Object3DNode.NORMAL_MATRIX) {
+      return "mat3";
+    } else if (scope === _Object3DNode.POSITION || scope === _Object3DNode.VIEW_POSITION) {
+      return "vec3";
+    }
+  }
+  update(frame) {
+    const object = this.object3d !== null ? this.object3d : frame.object;
+    const uniformNode = this._uniformNode;
+    const camera = frame.camera;
+    const scope = this.scope;
+    if (scope === _Object3DNode.VIEW_MATRIX) {
+      uniformNode.value = object.modelViewMatrix;
+    } else if (scope === _Object3DNode.NORMAL_MATRIX) {
+      uniformNode.value = object.normalMatrix;
+    } else if (scope === _Object3DNode.WORLD_MATRIX) {
+      uniformNode.value = object.matrixWorld;
+    } else if (scope === _Object3DNode.POSITION) {
+      uniformNode.value.setFromMatrixPosition(object.matrixWorld);
+    } else if (scope === _Object3DNode.VIEW_POSITION) {
+      uniformNode.value.setFromMatrixPosition(object.matrixWorld);
+      uniformNode.value.applyMatrix4(camera.matrixWorldInverse);
+    }
+  }
+  generate(builder) {
+    const scope = this.scope;
+    if (scope === _Object3DNode.WORLD_MATRIX || scope === _Object3DNode.VIEW_MATRIX) {
+      this._uniformNode.nodeType = "mat4";
+    } else if (scope === _Object3DNode.NORMAL_MATRIX) {
+      this._uniformNode.nodeType = "mat3";
+    } else if (scope === _Object3DNode.POSITION || scope === _Object3DNode.VIEW_POSITION) {
+      this._uniformNode.nodeType = "vec3";
+      this._uniformNode.value = new Vector3();
+    }
+    return this._uniformNode.build(builder);
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.scope = this.scope;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.scope = data.scope;
+  }
+};
+let Object3DNode = _Object3DNode;
+__publicField(Object3DNode, "VIEW_MATRIX", "viewMatrix");
+__publicField(Object3DNode, "NORMAL_MATRIX", "normalMatrix");
+__publicField(Object3DNode, "WORLD_MATRIX", "worldMatrix");
+__publicField(Object3DNode, "POSITION", "position");
+__publicField(Object3DNode, "VIEW_POSITION", "viewPosition");
+export {
+  Object3DNode as default
+};

package/nodes/accessors/PointUVNode.js

@@ -1,16 +1,12 @@
-import Node from '../core/Node.js';
-
+"use strict";
+const Node = require("../core/Node.js");
 class PointUVNode extends Node {
   constructor() {
-    super('vec2');
+    super("vec2");
   }
-
   generate() {
-    return 'vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y )';
+    return "vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y )";
   }
-
 }
-
 PointUVNode.prototype.isPointUVNode = true;
-
-export default PointUVNode;
+module.exports = PointUVNode;

package/nodes/accessors/PointUVNode.mjs

@@ -0,0 +1,13 @@
+import Node from "../core/Node.mjs";
+class PointUVNode extends Node {
+  constructor() {
+    super("vec2");
+  }
+  generate() {
+    return "vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y )";
+  }
+}
+PointUVNode.prototype.isPointUVNode = true;
+export {
+  PointUVNode as default
+};

package/nodes/accessors/PositionNode.js

@@ -1,63 +1,64 @@
-import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import Node from '../core/Node.js';
-import AttributeNode from '../core/AttributeNode.js';
-import VaryNode from '../core/VaryNode.js';
-import ModelNode from './ModelNode.js';
-import MathNode from '../math/MathNode.js';
-import OperatorNode from '../math/OperatorNode.js';
-
-class PositionNode extends Node {
-  constructor(scope = PositionNode.LOCAL) {
-    super('vec3');
+"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 AttributeNode = require("../core/AttributeNode.js");
+const VaryNode = require("../core/VaryNode.js");
+const ModelNode = require("./ModelNode.js");
+const MathNode = require("../math/MathNode.js");
+const OperatorNode = require("../math/OperatorNode.js");
+const _PositionNode = class extends Node {
+  constructor(scope = _PositionNode.LOCAL) {
+    super("vec3");
     this.scope = scope;
   }
-
   getHash() {
     return `position-${this.scope}`;
   }
-
   generate(builder) {
     const scope = this.scope;
     let outputNode = null;
-
-    if (scope === PositionNode.GEOMETRY) {
-      outputNode = new AttributeNode('position', 'vec3');
-    } else if (scope === PositionNode.LOCAL) {
-      outputNode = new VaryNode(new PositionNode(PositionNode.GEOMETRY));
-    } else if (scope === PositionNode.WORLD) {
-      const vertexPositionNode = new MathNode(MathNode.TRANSFORM_DIRECTION, new ModelNode(ModelNode.WORLD_MATRIX), new PositionNode(PositionNode.LOCAL));
+    if (scope === _PositionNode.GEOMETRY) {
+      outputNode = new AttributeNode("position", "vec3");
+    } else if (scope === _PositionNode.LOCAL) {
+      outputNode = new VaryNode(new _PositionNode(_PositionNode.GEOMETRY));
+    } else if (scope === _PositionNode.WORLD) {
+      const vertexPositionNode = new MathNode(
+        MathNode.TRANSFORM_DIRECTION,
+        new ModelNode(ModelNode.WORLD_MATRIX),
+        new _PositionNode(_PositionNode.LOCAL)
+      );
       outputNode = new VaryNode(vertexPositionNode);
-    } else if (scope === PositionNode.VIEW) {
-      const vertexPositionNode = new OperatorNode('*', new ModelNode(ModelNode.VIEW_MATRIX), new PositionNode(PositionNode.LOCAL));
+    } else if (scope === _PositionNode.VIEW) {
+      const vertexPositionNode = new OperatorNode(
+        "*",
+        new ModelNode(ModelNode.VIEW_MATRIX),
+        new _PositionNode(_PositionNode.LOCAL)
+      );
       outputNode = new VaryNode(vertexPositionNode);
-    } else if (scope === PositionNode.VIEW_DIRECTION) {
-      const vertexPositionNode = new MathNode(MathNode.NEGATE, new PositionNode(PositionNode.VIEW));
+    } else if (scope === _PositionNode.VIEW_DIRECTION) {
+      const vertexPositionNode = new MathNode(MathNode.NEGATE, new _PositionNode(_PositionNode.VIEW));
       outputNode = new MathNode(MathNode.NORMALIZE, new VaryNode(vertexPositionNode));
     }
-
     return outputNode.build(builder, this.getNodeType(builder));
   }
-
   serialize(data) {
     super.serialize(data);
     data.scope = this.scope;
   }
-
   deserialize(data) {
     super.deserialize(data);
     this.scope = data.scope;
   }
-
-}
-
-_defineProperty(PositionNode, "GEOMETRY", 'geometry');
-
-_defineProperty(PositionNode, "LOCAL", 'local');
-
-_defineProperty(PositionNode, "WORLD", 'world');
-
-_defineProperty(PositionNode, "VIEW", 'view');
-
-_defineProperty(PositionNode, "VIEW_DIRECTION", 'viewDirection');
-
-export default PositionNode;
+};
+let PositionNode = _PositionNode;
+__publicField(PositionNode, "GEOMETRY", "geometry");
+__publicField(PositionNode, "LOCAL", "local");
+__publicField(PositionNode, "WORLD", "world");
+__publicField(PositionNode, "VIEW", "view");
+__publicField(PositionNode, "VIEW_DIRECTION", "viewDirection");
+module.exports = PositionNode;

package/nodes/accessors/PositionNode.mjs

@@ -0,0 +1,65 @@
+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 AttributeNode from "../core/AttributeNode.mjs";
+import VaryNode from "../core/VaryNode.mjs";
+import ModelNode from "./ModelNode.mjs";
+import MathNode from "../math/MathNode.mjs";
+import OperatorNode from "../math/OperatorNode.mjs";
+const _PositionNode = class extends Node {
+  constructor(scope = _PositionNode.LOCAL) {
+    super("vec3");
+    this.scope = scope;
+  }
+  getHash() {
+    return `position-${this.scope}`;
+  }
+  generate(builder) {
+    const scope = this.scope;
+    let outputNode = null;
+    if (scope === _PositionNode.GEOMETRY) {
+      outputNode = new AttributeNode("position", "vec3");
+    } else if (scope === _PositionNode.LOCAL) {
+      outputNode = new VaryNode(new _PositionNode(_PositionNode.GEOMETRY));
+    } else if (scope === _PositionNode.WORLD) {
+      const vertexPositionNode = new MathNode(
+        MathNode.TRANSFORM_DIRECTION,
+        new ModelNode(ModelNode.WORLD_MATRIX),
+        new _PositionNode(_PositionNode.LOCAL)
+      );
+      outputNode = new VaryNode(vertexPositionNode);
+    } else if (scope === _PositionNode.VIEW) {
+      const vertexPositionNode = new OperatorNode(
+        "*",
+        new ModelNode(ModelNode.VIEW_MATRIX),
+        new _PositionNode(_PositionNode.LOCAL)
+      );
+      outputNode = new VaryNode(vertexPositionNode);
+    } else if (scope === _PositionNode.VIEW_DIRECTION) {
+      const vertexPositionNode = new MathNode(MathNode.NEGATE, new _PositionNode(_PositionNode.VIEW));
+      outputNode = new MathNode(MathNode.NORMALIZE, new VaryNode(vertexPositionNode));
+    }
+    return outputNode.build(builder, this.getNodeType(builder));
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.scope = this.scope;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.scope = data.scope;
+  }
+};
+let PositionNode = _PositionNode;
+__publicField(PositionNode, "GEOMETRY", "geometry");
+__publicField(PositionNode, "LOCAL", "local");
+__publicField(PositionNode, "WORLD", "world");
+__publicField(PositionNode, "VIEW", "view");
+__publicField(PositionNode, "VIEW_DIRECTION", "viewDirection");
+export {
+  PositionNode as default
+};

package/nodes/accessors/ReferenceNode.js

@@ -1,7 +1,7 @@
-import Node from '../core/Node.js';
-import UniformNode from '../core/UniformNode.js';
-import { NodeUpdateType } from '../core/constants.js';
-
+"use strict";
+const Node = require("../core/Node.js");
+const UniformNode = require("../core/UniformNode.js");
+const constants = require("../core/constants.js");
 class ReferenceNode extends Node {
   constructor(property, uniformType, object = null) {
     super();
@@ -9,35 +9,28 @@ class ReferenceNode extends Node {
     this.uniformType = uniformType;
     this.object = object;
     this.node = null;
-    this.updateType = NodeUpdateType.Object;
+    this.updateType = constants.NodeUpdateType.Object;
     this.setNodeType(uniformType);
   }
-
   setNodeType(uniformType) {
     this.node = new UniformNode(null, uniformType);
     this.nodeType = uniformType;
-
-    if (uniformType === 'color') {
-      this.nodeType = 'vec3';
-    } else if (uniformType === 'texture') {
-      this.nodeType = 'vec4';
+    if (uniformType === "color") {
+      this.nodeType = "vec3";
+    } else if (uniformType === "texture") {
+      this.nodeType = "vec4";
     }
   }
-
   getNodeType() {
     return this.uniformType;
   }
-
   update(frame) {
     const object = this.object !== null ? this.object : frame.object;
     const value = object[this.property];
     this.node.value = value;
   }
-
   generate(builder) {
     return this.node.build(builder, this.getNodeType(builder));
   }
-
 }
-
-export default ReferenceNode;
+module.exports = ReferenceNode;

package/nodes/accessors/ReferenceNode.mjs

@@ -0,0 +1,37 @@
+import Node from "../core/Node.mjs";
+import UniformNode from "../core/UniformNode.mjs";
+import { NodeUpdateType } from "../core/constants.mjs";
+class ReferenceNode extends Node {
+  constructor(property, uniformType, object = null) {
+    super();
+    this.property = property;
+    this.uniformType = uniformType;
+    this.object = object;
+    this.node = null;
+    this.updateType = NodeUpdateType.Object;
+    this.setNodeType(uniformType);
+  }
+  setNodeType(uniformType) {
+    this.node = new UniformNode(null, uniformType);
+    this.nodeType = uniformType;
+    if (uniformType === "color") {
+      this.nodeType = "vec3";
+    } else if (uniformType === "texture") {
+      this.nodeType = "vec4";
+    }
+  }
+  getNodeType() {
+    return this.uniformType;
+  }
+  update(frame) {
+    const object = this.object !== null ? this.object : frame.object;
+    const value = object[this.property];
+    this.node.value = value;
+  }
+  generate(builder) {
+    return this.node.build(builder, this.getNodeType(builder));
+  }
+}
+export {
+  ReferenceNode as default
+};

package/nodes/accessors/ReflectNode.js

@@ -1,45 +1,42 @@
-import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import Node from '../core/Node.js';
-import { normalize, sub, positionWorld, cameraPosition, reflect, normalWorld, nodeObject, join, negate } from '../ShaderNode.js';
-
-class ReflectNode extends Node {
-  constructor(scope = ReflectNode.CUBE) {
-    super('vec3');
+"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 ShaderNode = require("../ShaderNode.js");
+const _ReflectNode = class extends Node {
+  constructor(scope = _ReflectNode.CUBE) {
+    super("vec3");
     this.scope = scope;
   }
-
   getHash() {
     return `reflect-${this.scope}`;
   }
-
   generate(builder) {
     const scope = this.scope;
-
-    if (scope === ReflectNode.VECTOR) {
-      const cameraToFrag = normalize(sub(positionWorld, cameraPosition));
-      const reflectVec = reflect(cameraToFrag, normalWorld);
+    if (scope === _ReflectNode.VECTOR) {
+      const cameraToFrag = ShaderNode.normalize(ShaderNode.sub(ShaderNode.positionWorld, ShaderNode.cameraPosition));
+      const reflectVec = ShaderNode.reflect(cameraToFrag, ShaderNode.normalWorld);
       return reflectVec.build(builder);
-    } else if (scope === ReflectNode.CUBE) {
-      const reflectVec = nodeObject(new ReflectNode(ReflectNode.VECTOR));
-      const cubeUV = join(negate(reflectVec.x), reflectVec.yz);
+    } else if (scope === _ReflectNode.CUBE) {
+      const reflectVec = ShaderNode.nodeObject(new _ReflectNode(_ReflectNode.VECTOR));
+      const cubeUV = ShaderNode.join(ShaderNode.negate(reflectVec.x), reflectVec.yz);
       return cubeUV.build(builder);
     }
   }
-
   serialize(data) {
     super.serialize(data);
     data.scope = this.scope;
   }
-
   deserialize(data) {
     super.deserialize(data);
     this.scope = data.scope;
   }
-
-}
-
-_defineProperty(ReflectNode, "VECTOR", 'vector');
-
-_defineProperty(ReflectNode, "CUBE", 'cube');
-
-export default ReflectNode;
+};
+let ReflectNode = _ReflectNode;
+__publicField(ReflectNode, "VECTOR", "vector");
+__publicField(ReflectNode, "CUBE", "cube");
+module.exports = ReflectNode;

package/nodes/accessors/ReflectNode.mjs

@@ -0,0 +1,43 @@
+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 { normalize, sub, positionWorld, cameraPosition, reflect, normalWorld, nodeObject, join, negate } from "../ShaderNode.mjs";
+const _ReflectNode = class extends Node {
+  constructor(scope = _ReflectNode.CUBE) {
+    super("vec3");
+    this.scope = scope;
+  }
+  getHash() {
+    return `reflect-${this.scope}`;
+  }
+  generate(builder) {
+    const scope = this.scope;
+    if (scope === _ReflectNode.VECTOR) {
+      const cameraToFrag = normalize(sub(positionWorld, cameraPosition));
+      const reflectVec = reflect(cameraToFrag, normalWorld);
+      return reflectVec.build(builder);
+    } else if (scope === _ReflectNode.CUBE) {
+      const reflectVec = nodeObject(new _ReflectNode(_ReflectNode.VECTOR));
+      const cubeUV = join(negate(reflectVec.x), reflectVec.yz);
+      return cubeUV.build(builder);
+    }
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.scope = this.scope;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.scope = data.scope;
+  }
+};
+let ReflectNode = _ReflectNode;
+__publicField(ReflectNode, "VECTOR", "vector");
+__publicField(ReflectNode, "CUBE", "cube");
+export {
+  ReflectNode as default
+};

package/nodes/accessors/SkinningNode.js

@@ -1,59 +1,57 @@
-import Node from '../core/Node.js';
-import { ShaderNode, element, mul, positionLocal, add, transformDirection, normalLocal, assign, attribute, uniform, mat4, buffer } from '../ShaderNode.js';
-import { NodeUpdateType } from '../core/constants.js';
-
-const Skinning = new ShaderNode((inputs, builder) => {
-  const {
-    index,
-    weight,
-    bindMatrix,
-    bindMatrixInverse,
-    boneMatrices
-  } = inputs;
-  const boneMatX = element(boneMatrices, index.x);
-  const boneMatY = element(boneMatrices, index.y);
-  const boneMatZ = element(boneMatrices, index.z);
-  const boneMatW = element(boneMatrices, index.w); // POSITION
-
-  const skinVertex = mul(bindMatrix, positionLocal);
-  const skinned = add(mul(mul(boneMatX, skinVertex), weight.x), mul(mul(boneMatY, skinVertex), weight.y), mul(mul(boneMatZ, skinVertex), weight.z), mul(mul(boneMatW, skinVertex), weight.w));
-  const skinPosition = mul(bindMatrixInverse, skinned).xyz; // NORMAL
-
-  let skinMatrix = add(mul(weight.x, boneMatX), mul(weight.y, boneMatY), mul(weight.z, boneMatZ), mul(weight.w, boneMatW));
-  skinMatrix = mul(mul(bindMatrixInverse, skinMatrix), bindMatrix);
-  const skinNormal = transformDirection(skinMatrix, normalLocal).xyz; // ASSIGNS
-
-  assign(positionLocal, skinPosition).build(builder);
-  assign(normalLocal, skinNormal).build(builder);
+"use strict";
+const Node = require("../core/Node.js");
+const ShaderNode = require("../ShaderNode.js");
+const constants = require("../core/constants.js");
+const Skinning = new ShaderNode.ShaderNode((inputs, builder) => {
+  const { index, weight, bindMatrix, bindMatrixInverse, boneMatrices } = inputs;
+  const boneMatX = ShaderNode.element(boneMatrices, index.x);
+  const boneMatY = ShaderNode.element(boneMatrices, index.y);
+  const boneMatZ = ShaderNode.element(boneMatrices, index.z);
+  const boneMatW = ShaderNode.element(boneMatrices, index.w);
+  const skinVertex = ShaderNode.mul(bindMatrix, ShaderNode.positionLocal);
+  const skinned = ShaderNode.add(
+    ShaderNode.mul(ShaderNode.mul(boneMatX, skinVertex), weight.x),
+    ShaderNode.mul(ShaderNode.mul(boneMatY, skinVertex), weight.y),
+    ShaderNode.mul(ShaderNode.mul(boneMatZ, skinVertex), weight.z),
+    ShaderNode.mul(ShaderNode.mul(boneMatW, skinVertex), weight.w)
+  );
+  const skinPosition = ShaderNode.mul(bindMatrixInverse, skinned).xyz;
+  let skinMatrix = ShaderNode.add(
+    ShaderNode.mul(weight.x, boneMatX),
+    ShaderNode.mul(weight.y, boneMatY),
+    ShaderNode.mul(weight.z, boneMatZ),
+    ShaderNode.mul(weight.w, boneMatW)
+  );
+  skinMatrix = ShaderNode.mul(ShaderNode.mul(bindMatrixInverse, skinMatrix), bindMatrix);
+  const skinNormal = ShaderNode.transformDirection(skinMatrix, ShaderNode.normalLocal).xyz;
+  ShaderNode.assign(ShaderNode.positionLocal, skinPosition).build(builder);
+  ShaderNode.assign(ShaderNode.normalLocal, skinNormal).build(builder);
 });
-
 class SkinningNode extends Node {
   constructor(skinnedMesh) {
-    super('void');
+    super("void");
     this.skinnedMesh = skinnedMesh;
-    this.updateType = NodeUpdateType.Object; //
-
-    this.skinIndexNode = attribute('skinIndex', 'uvec4');
-    this.skinWeightNode = attribute('skinWeight', 'vec4');
-    this.bindMatrixNode = uniform(mat4(skinnedMesh.bindMatrix));
-    this.bindMatrixInverseNode = uniform(mat4(skinnedMesh.bindMatrixInverse));
-    this.boneMatricesNode = buffer(skinnedMesh.skeleton.boneMatrices, 'mat4', skinnedMesh.skeleton.bones.length);
+    this.updateType = constants.NodeUpdateType.Object;
+    this.skinIndexNode = ShaderNode.attribute("skinIndex", "uvec4");
+    this.skinWeightNode = ShaderNode.attribute("skinWeight", "vec4");
+    this.bindMatrixNode = ShaderNode.uniform(ShaderNode.mat4(skinnedMesh.bindMatrix));
+    this.bindMatrixInverseNode = ShaderNode.uniform(ShaderNode.mat4(skinnedMesh.bindMatrixInverse));
+    this.boneMatricesNode = ShaderNode.buffer(skinnedMesh.skeleton.boneMatrices, "mat4", skinnedMesh.skeleton.bones.length);
   }
-
   generate(builder) {
-    Skinning({
-      index: this.skinIndexNode,
-      weight: this.skinWeightNode,
-      bindMatrix: this.bindMatrixNode,
-      bindMatrixInverse: this.bindMatrixInverseNode,
-      boneMatrices: this.boneMatricesNode
-    }, builder);
+    Skinning(
+      {
+        index: this.skinIndexNode,
+        weight: this.skinWeightNode,
+        bindMatrix: this.bindMatrixNode,
+        bindMatrixInverse: this.bindMatrixInverseNode,
+        boneMatrices: this.boneMatricesNode
+      },
+      builder
+    );
   }
-
   update() {
     this.skinnedMesh.skeleton.update();
   }
-
 }
-
-export default SkinningNode;
+module.exports = SkinningNode;

package/nodes/accessors/SkinningNode.mjs

@@ -0,0 +1,58 @@
+import Node from "../core/Node.mjs";
+import { ShaderNode, element, mul, positionLocal, add, transformDirection, normalLocal, assign, attribute, uniform, mat4, buffer } from "../ShaderNode.mjs";
+import { NodeUpdateType } from "../core/constants.mjs";
+const Skinning = new ShaderNode((inputs, builder) => {
+  const { index, weight, bindMatrix, bindMatrixInverse, boneMatrices } = inputs;
+  const boneMatX = element(boneMatrices, index.x);
+  const boneMatY = element(boneMatrices, index.y);
+  const boneMatZ = element(boneMatrices, index.z);
+  const boneMatW = element(boneMatrices, index.w);
+  const skinVertex = mul(bindMatrix, positionLocal);
+  const skinned = add(
+    mul(mul(boneMatX, skinVertex), weight.x),
+    mul(mul(boneMatY, skinVertex), weight.y),
+    mul(mul(boneMatZ, skinVertex), weight.z),
+    mul(mul(boneMatW, skinVertex), weight.w)
+  );
+  const skinPosition = mul(bindMatrixInverse, skinned).xyz;
+  let skinMatrix = add(
+    mul(weight.x, boneMatX),
+    mul(weight.y, boneMatY),
+    mul(weight.z, boneMatZ),
+    mul(weight.w, boneMatW)
+  );
+  skinMatrix = mul(mul(bindMatrixInverse, skinMatrix), bindMatrix);
+  const skinNormal = transformDirection(skinMatrix, normalLocal).xyz;
+  assign(positionLocal, skinPosition).build(builder);
+  assign(normalLocal, skinNormal).build(builder);
+});
+class SkinningNode extends Node {
+  constructor(skinnedMesh) {
+    super("void");
+    this.skinnedMesh = skinnedMesh;
+    this.updateType = NodeUpdateType.Object;
+    this.skinIndexNode = attribute("skinIndex", "uvec4");
+    this.skinWeightNode = attribute("skinWeight", "vec4");
+    this.bindMatrixNode = uniform(mat4(skinnedMesh.bindMatrix));
+    this.bindMatrixInverseNode = uniform(mat4(skinnedMesh.bindMatrixInverse));
+    this.boneMatricesNode = buffer(skinnedMesh.skeleton.boneMatrices, "mat4", skinnedMesh.skeleton.bones.length);
+  }
+  generate(builder) {
+    Skinning(
+      {
+        index: this.skinIndexNode,
+        weight: this.skinWeightNode,
+        bindMatrix: this.bindMatrixNode,
+        bindMatrixInverse: this.bindMatrixInverseNode,
+        boneMatrices: this.boneMatricesNode
+      },
+      builder
+    );
+  }
+  update() {
+    this.skinnedMesh.skeleton.update();
+  }
+}
+export {
+  SkinningNode as default
+};