Added matrix common and ops

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/MaterialGraphPresenter.cs

             typeMapper[typeof(Matrix2Node)] = typeof(Matrix2NodePresenter);
             typeMapper[typeof(Matrix3Node)] = typeof(Matrix3NodePresenter);
             typeMapper[typeof(Matrix4Node)] = typeof(Matrix4NodePresenter);
+            typeMapper[typeof(MatrixCommonNode)] = typeof(MatrixCommonNodePresenter);
 			typeMapper[typeof(TransformNode)] = typeof(TransformNodePresenter);
         }
     }

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Math/Matrix/MatrixMultiplyNode.cs

 
         protected MaterialSlot GetInputSlot1()
         {
-            return new MaterialSlot(InputSlot1Id, GetInputSlot1Name(), kInputSlot1ShaderName, SlotType.Input, SlotValueType.Matrix3, Vector4.zero);
+            return new MaterialSlot(InputSlot1Id, GetInputSlot1Name(), kInputSlot1ShaderName, SlotType.Input, SlotValueType.Matrix4, Vector4.zero);
-            return new MaterialSlot(InputSlot2Id, GetInputSlot2Name(), kInputSlot2ShaderName, SlotType.Input, SlotValueType.Matrix3, Vector4.zero);
+            return new MaterialSlot(InputSlot2Id, GetInputSlot2Name(), kInputSlot2ShaderName, SlotType.Input, SlotValueType.Matrix4, Vector4.zero);
-            return new MaterialSlot(OutputSlotId, GetOutputSlotName(), kOutputSlotShaderName, SlotType.Output, SlotValueType.Matrix3, Vector4.zero);
+            return new MaterialSlot(OutputSlotId, GetOutputSlotName(), kOutputSlotShaderName, SlotType.Output, SlotValueType.Matrix4, Vector4.zero);
         }
 
         protected virtual string GetInputSlot1Name()

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Math/Matrix/MatrixTransposeNode.cs

 
         protected override MaterialSlot GetInputSlot()
         {
-            return new MaterialSlot(InputSlotId, GetInputSlotName(), kInputSlotShaderName, SlotType.Input, SlotValueType.Matrix3, Vector4.zero);
+            return new MaterialSlot(InputSlotId, GetInputSlotName(), kInputSlotShaderName, SlotType.Input, SlotValueType.Matrix4, Vector4.zero);
-            return new MaterialSlot(OutputSlotId, GetOutputSlotName(), kOutputSlotShaderName, SlotType.Output, SlotValueType.Matrix3, Vector4.zero);
+            return new MaterialSlot(OutputSlotId, GetOutputSlotName(), kOutputSlotShaderName, SlotType.Output, SlotValueType.Matrix4, Vector4.zero);
         }
     }
 }

MaterialGraphProject/Assets/Matt/CommonMatrixType.cs

+namespace UnityEngine.MaterialGraph
+{
+    public enum CommonMatrixType
+    {
+        ModelView,
+        View,
+        Projection,
+        ViewProjection,
+        TransposeModelView,
+        InverseTransposeModelView,
+        ObjectToWorld,
+        WorldToObject
+    };
+}

MaterialGraphProject/Assets/Matt/CommonMatrixType.cs.meta

+fileFormatVersion: 2
+guid: e466cff33b1ebe64eb2b897b9534a4a4
+timeCreated: 1495703998
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/MatrixCommonNodePresenter.cs

+using System;
+using System.Collections.Generic;
+using UnityEngine.MaterialGraph;
+using RMGUI.GraphView;
+using UnityEditor.Graphing.Drawing;
+
+namespace UnityEditor.MaterialGraph.Drawing
+{
+    [Serializable]
+    class MatrixCommonContolPresenter : GraphControlPresenter
+    {
+
+        private string[] m_MatrixTypeNames;
+        private string[] matrixTypeNames
+        {
+            get
+            {
+                if (m_MatrixTypeNames == null)
+                    m_MatrixTypeNames = Enum.GetNames(typeof(CommonMatrixType));
+                return m_MatrixTypeNames;
+            }
+        }
+
+        public override void OnGUIHandler()
+        {
+            base.OnGUIHandler();
+
+            var cNode = node as UnityEngine.MaterialGraph.MatrixCommonNode;
+            if (cNode == null)
+                return;
+
+            cNode.matrix = (CommonMatrixType)EditorGUILayout.Popup((int)cNode.matrix, matrixTypeNames, EditorStyles.popup);
+        }
+
+        public override float GetHeight()
+        {
+            return EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+        }
+    }
+
+    [Serializable]
+    public class MatrixCommonNodePresenter : MaterialNodePresenter
+    {
+        protected override IEnumerable<GraphElementPresenter> GetControlData()
+        {
+            var instance = CreateInstance<MatrixCommonContolPresenter>();
+            instance.Initialize(node);
+            return new List<GraphElementPresenter> { instance };
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/MatrixCommonNodePresenter.cs.meta

+fileFormatVersion: 2
+guid: b7283eb87c37e4a43b5eddbf2d4360d1
+timeCreated: 1495448531
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Input/Matrix/MatrixCommonNode.cs

+using System.ComponentModel;
+using UnityEngine.Graphing;
+using System.Collections.Generic;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Title("Input/Matrix/CommonMatrix")]
+    public class MatrixCommonNode : AbstractMaterialNode
+    {
+        static Dictionary<CommonMatrixType, string> m_matrixList = new Dictionary<CommonMatrixType, string>
+        {
+            {CommonMatrixType.ModelView, "UNITY_MATRIX_MV"},
+            {CommonMatrixType.View, "UNITY_MATRIX_V"},
+            {CommonMatrixType.Projection, "UNITY_MATRIX_P"},
+            {CommonMatrixType.ViewProjection, "UNITY_MATRIX_VP"},
+            {CommonMatrixType.TransposeModelView, "UNITY_MATRIX_T_MV"},
+            {CommonMatrixType.InverseTransposeModelView, "UNITY_MATRIX_IT_MV"},
+            {CommonMatrixType.ObjectToWorld, "unity_ObjectToWorld"},
+            {CommonMatrixType.WorldToObject, "unity_WorldToObject"},
+        };
+
+        [SerializeField]
+        private CommonMatrixType m_matrix = CommonMatrixType.ModelView;
+
+        private const int kOutputSlotId = 0;
+        private const string kOutputSlotName = "Output";
+
+        public override bool hasPreview { get { return false; } }
+
+        public CommonMatrixType matrix
+        {
+            get { return m_matrix; }
+            set
+            {
+                if (m_matrix == value)
+                    return;
+
+                m_matrix = value;
+                if (onModified != null)
+                {
+                    onModified(this, ModificationScope.Graph);
+                }
+            }
+        }
+
+        public MatrixCommonNode()
+        {
+            name = "CommonMatrix";
+            UpdateNodeAfterDeserialization();
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, SlotValueType.Matrix4, Vector4.zero));
+            RemoveSlotsNameNotMatching(new[] { kOutputSlotId });
+        }
+
+        public override string GetVariableNameForSlot(int slotId)
+        {
+            return m_matrixList[matrix];
+        }
+
+        public bool RequiresVertexColor()
+        {
+            return true;
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Input/Matrix/MatrixCommonNode.cs.meta

+fileFormatVersion: 2
+guid: 080829bc2938e23489292a936367364d
+timeCreated: 1481123160
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Math/Matrix.meta

+fileFormatVersion: 2
+guid: bfc8dbcaa9711c945b8fd983b819335d
+folderAsset: yes
+timeCreated: 1495700996
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Math/Matrix/MatrixMultiplyByVectorNode.cs

+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Title("Math/Matrix/MultiplyMatrixByVector")]
+    public class MatrixMultiplyByVectorNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction
+    {
+        protected const string kInputSlot1ShaderName = "Input1";
+        protected const string kInputSlot2ShaderName = "Input2";
+        protected const string kOutputSlotShaderName = "Output";
+
+        public const int InputSlot1Id = 0;
+        public const int InputSlot2Id = 1;
+        public const int OutputSlotId = 2;
+
+        public override bool hasPreview
+        {
+            get { return false; }
+        }
+
+        public MatrixMultiplyByVectorNode()
+        {
+            name = "MultiplyMatrixByVector";
+            UpdateNodeAfterDeserialization();
+        }
+
+        protected string GetFunctionName()
+        {
+            return "unity_matrix_multiplybyvector_" + precision;
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(GetInputSlot1());
+            AddSlot(GetInputSlot2());
+            AddSlot(GetOutputSlot());
+            RemoveSlotsNameNotMatching(validSlots);
+        }
+
+        protected int[] validSlots
+        {
+            get { return new[] { InputSlot1Id, InputSlot2Id, OutputSlotId }; }
+        }
+
+        protected MaterialSlot GetInputSlot1()
+        {
+            return new MaterialSlot(InputSlot1Id, GetInputSlot1Name(), kInputSlot1ShaderName, SlotType.Input, SlotValueType.Matrix4, Vector4.zero);
+        }
+
+        protected MaterialSlot GetInputSlot2()
+        {
+            return new MaterialSlot(InputSlot2Id, GetInputSlot2Name(), kInputSlot2ShaderName, SlotType.Input, SlotValueType.Vector4, Vector4.zero);
+        }
+
+        protected MaterialSlot GetOutputSlot()
+        {
+            return new MaterialSlot(OutputSlotId, GetOutputSlotName(), kOutputSlotShaderName, SlotType.Output, SlotValueType.Vector4, Vector4.zero);
+        }
+
+        protected virtual string GetInputSlot1Name()
+        {
+            return "Input1";
+        }
+
+        protected virtual string GetInputSlot2Name()
+        {
+            return "Input2";
+        }
+
+        protected string GetOutputSlotName()
+        {
+            return "Output";
+        }
+
+        protected string GetFunctionPrototype(string arg1Name, string arg2Name)
+        {
+            return "inline " + precision + outputDimension + " " + GetFunctionName() + " ("
+                   + precision + input1Dimension + " " + arg1Name + ", "
+                   + precision + input2Dimension + " " + arg2Name + ")";
+        }
+
+        public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
+        {
+            NodeUtils.SlotConfigurationExceptionIfBadConfiguration(this, new[] { InputSlot1Id, InputSlot2Id }, new[] { OutputSlotId });
+            string input1Value = GetSlotValue(InputSlot1Id, generationMode);
+            string input2Value = GetSlotValue(InputSlot2Id, generationMode);
+            visitor.AddShaderChunk(precision + outputDimension + " " + GetVariableNameForSlot(OutputSlotId) + " = " + GetFunctionCallBody(input1Value, input2Value) + ";", true);
+        }
+
+        protected string GetFunctionCallBody(string input1Value, string input2Value)
+        {
+            return GetFunctionName() + " (" + input1Value + ", " + input2Value + ")";
+        }
+
+        public string outputDimension
+        {
+            get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(InputSlot2Id).concreteValueType); }
+        }
+
+        private string input1Dimension
+        {
+            get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(InputSlot1Id).concreteValueType); }
+        }
+
+        private string input2Dimension
+        {
+            get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(InputSlot2Id).concreteValueType); }
+        }
+
+        public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
+        {
+            var outputString = new ShaderGenerator();
+            outputString.AddShaderChunk(GetFunctionPrototype("arg1", "arg2"), false);
+            outputString.AddShaderChunk("{", false);
+            outputString.Indent();
+            outputString.AddShaderChunk("return mul(arg1, arg2);", false);
+            outputString.Deindent();
+            outputString.AddShaderChunk("}", false);
+
+            visitor.AddShaderChunk(outputString.GetShaderString(0), true);
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Math/Matrix/MatrixMultiplyByVectorNode.cs.meta

+fileFormatVersion: 2
+guid: ad9cec4b346abf749b3eb1730875ee5d
+timeCreated: 1495542985
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: