Merge pull request #8 from martinRenou/warp

Add Warp effect

Author: martinRenou

src/EffectBlock.ts

@@ -106,6 +106,17 @@ class Effect extends Block {
     }
   }
 
+  /**
+   * Add transform node to materials
+   */
+  addTransformNode (operation: NodeOperation, transformNode: Nodes.Node) {
+    for (const nodeMesh of this.meshes) {
+      nodeMesh.addTransformNode(operation, transformNode);
+    }
+
+    this.buildMaterial();
+  }
+
   /**
    * Add color node to materials
    */

src/Effects/Warp.ts

@@ -0,0 +1,82 @@
+import * as Nodes from 'three/examples/jsm/nodes/Nodes';
+
+import {
+  Effect, Input, InputDimension
+} from '../EffectBlock';
+
+import {
+  Block
+} from '../Block';
+
+import {
+  NodeOperation
+} from '../NodeMesh';
+
+
+/**
+ * Transform the vertices positions. The new vertice position is equal to `factor * (offset + input) + initialPosition`
+ **/
+export
+class Warp extends Effect {
+
+  constructor (parent: Block, input: Input, factor: THREE.Vector3, offset: THREE.Vector3) {
+    super(parent, input);
+
+    this.offsetNode = new Nodes.Vector3Node(offset.x, offset.y, offset.z);
+    this.factorNode = new Nodes.Vector3Node(factor.x, factor.y, factor.z);
+
+    this.intermediateTransformNode = new Nodes.OperatorNode(this.offsetNode, this.inputNode, Nodes.OperatorNode.ADD);
+
+    this.transformNode = new Nodes.OperatorNode(
+      this.intermediateTransformNode,
+      this.factorNode,
+      Nodes.OperatorNode.MUL
+    );
+
+    this.addTransformNode(NodeOperation.ADD, this.transformNode);
+
+    this.buildMaterial();
+
+    this.initialized = true;
+  }
+
+  setInput(input?: Input) : void {
+    super.setInput(input);
+
+    if (this.initialized) {
+      this.intermediateTransformNode.b = this.inputNode;
+
+      this.buildMaterial();
+    }
+  }
+
+  set offset (value: THREE.Vector3) {
+    this.offsetNode.value = value;
+  }
+
+  get offset () {
+    return this.offsetNode.value;
+  }
+
+  set factor (value: THREE.Vector3) {
+    this.factorNode.value = value;
+  }
+
+  get factor () {
+    return this.factorNode.value;
+  }
+
+  get inputDimension () : InputDimension {
+    return 3;
+  }
+
+  private initialized: boolean = false;
+
+  private offsetNode: Nodes.Vector3Node;
+  private factorNode: Nodes.Vector3Node;
+  private intermediateTransformNode: Nodes.OperatorNode;
+  private transformNode: Nodes.OperatorNode;
+
+  protected inputNode: Nodes.Node;
+
+}

src/Effects/effects.ts

@@ -4,3 +4,5 @@ export * from './IsoColor';
 
 export * from './IsoSurface';
 export * from './Threshold';
+
+export * from './Warp';

src/NodeMesh.ts

@@ -121,10 +121,14 @@ class NodeMesh {
   }
 
   buildMaterial () {
-    let position = new Nodes.PositionNode();
+    let position: NodeOperationResult<Nodes.Node> = new Nodes.PositionNode();
     let alpha: NodeOperationResult<Nodes.Node> = new Nodes.FloatNode(1.);
     let color: NodeOperationResult<Nodes.Node> = this.defaultColorNode;
 
+    for (const transformOperator of this.transformOperators) {
+      position = transformOperator.operate(position);
+    }
+
     for (const colorOperator of this.colorOperators) {
       color = colorOperator.operate(color);
     }
@@ -133,13 +137,11 @@ class NodeMesh {
       alpha = alphaOperator.operate(alpha);
     }
 
-    // TODO: Same for position Node, alpha Node and varyings
-
     this.material.flatShading = true;
     this.material.side = THREE.DoubleSide;
 
     // @ts-ignore
-    this.material.transform = position;
+    this.material.position = position;
     // @ts-ignore
     this.material.alpha = alpha;
     // @ts-ignore
@@ -164,7 +166,7 @@ class NodeMesh {
 
     copy.hasIndex = this.hasIndex;
 
-    // TODO: Copy other operators
+    copy.transformOperators = this.transformOperators.slice();
     copy.alphaOperators = this.alphaOperators.slice();
     copy.colorOperators = this.colorOperators.slice();
 
@@ -174,7 +176,7 @@ class NodeMesh {
   }
 
   copyMaterial (other: NodeMesh) {
-    // TODO: Copy other operators
+    this.transformOperators = other.transformOperators.slice();
     this.alphaOperators = other.alphaOperators.slice();
     this.colorOperators = other.colorOperators.slice();
 
@@ -200,6 +202,13 @@ class NodeMesh {
     return this._defaultColor;
   }
 
+  /**
+   * Add a Transform node to this mesh material
+   */
+  addTransformNode (operation: NodeOperation, transformNode: Nodes.Node) {
+    this.transformOperators.push(new NodeOperator<Nodes.Node>(operation, transformNode));
+  }
+
   /**
    * Add a Color node to this mesh material
    */
@@ -297,7 +306,7 @@ class NodeMesh {
 
   private meshCtor: MeshConstructor;
 
-  // private transformOperators: NodeOperator<Nodes.TransformNode>[];
+  private transformOperators: NodeOperator<Nodes.Node>[] = [];
   private alphaOperators: NodeOperator<Nodes.Node>[] = [];
   private colorOperators: NodeOperator<Nodes.Node>[] = [];