6.0 Details of the New Node-based Modifier System

6.1 Advantages of the system

Having node-based modifiers would be a new and exciting paradigm for Blender.
Node systems have the advantage of allowing multiple roots in the execution
graph, and for the execution branches to grow back together (unlike a stack
or a tree form).

Practically, this results in a more flexible system.  One single mesh input
could drive multiple modifiers.  Modifiers could be blended together in
a configurable way with special blend nodes.

The priority for the SoC period is to port all current modifiers to the new
system, as well as implement the nodes listed in 6.2.  In addition, the 
following nodes will be created if time permits:

 * UV Unwrap node
   A UV Unwrap node, supporting all UV unwrap modes.
   
 * Spherical effectors (e.g. a "bulge" modifier that bulges meshes at where an object is)
   Riggers use these as part of rough muscle simulator setups.

6.2 List of Nodes
  The following is a rough list of what would be desired in a complete node
  modifier system. The nodes in this list will be completed within the SoC period.
  The list will change to take user feedback into account.
  
  The following node socket types will be defined: Color, Value, Vector3, Vector4
  and Matrix.
  
6.2.1 Input nodes
 * Mesh input - Inputs: None; Outputs: Mesh
   Inputs a mesh into the node tree
   
 * Object input - Inputs: None; Outputs: Mesh, Matrix
   Inputs from an object and output a mesh (if needed
   by the graph) and a matrix representing the object's
   transform.
   
 * Color input
 
 * Vector input - Outputs: Vector
    A four-component vector
 
 * Matrix - Inputs: Vector, Vector, Vector, Vector; Outputs: Matrix
   A generic matrix input node, that takes either three or four vectors
   (depending on whether the user desires a 3x3 or 4x4 matrix) as inputs.
   The vectors represent rows in the final matrix.

6.2.2 Math Nodes
  * Matrix Math (multiply, invert, transpose) - Inputs: Matrix, Matrix; Outputs: Matrix
  * Vector-Matrix Math (multiply, multiply with inverse) - Inputs: Matrix, Vector; Outputs: Vector
  * Vector Math (multiply, subtract, add, divide, cross product)
      Inputs: Vector, Vector; Outputs: Vector, Value (dot product result)

6.2.3 Transform Nodes
  * Matrix Transform - Inputs: Matrix, Mesh; Outputs: Mesh
  * Generic Transform (rotate/translate/scale/shear/warp)
      Inputs: Vector(rotate), Vector(scale), Vector(translate); Outputs: Mesh
  * Mesh Blend node
    A simple blending node to blend between two deformed meshes.  Note that
    both meshes would have to have to have identical vertex ordering, and also
    an identical number of verts.

6.2.4 Modifiers
  * Triangulation node - Inputs: Mesh; Outputs: Mesh
  * Mesh Concatenation - Inputs: Mesh, Matrix, Mesh, Matrix; Outputs: Mesh
    This node would concatenate two meshes together.  Each mesh would be transformed
    by the matrix input following its input.
  * All the currently implemented modifiers

6.3 Additional Node Ideas
  The following is a list of additional node ideas that would most likely
  be impractical to implement during the SoC period, but are nonetheless
  usefull.
 
 * Pynodes
   Pynodes would be used to implement python-driven modifiers
   
 * Cut
   This node would cut a mesh with a plane and remove all geometry on one side
   
 * Boolean
   A generic CSG node
   
 * An improved hook modifier with weight control and control
   over the falloff curve.