Input Part 3

- Final for now
- No texture nodes
- No gradient nodes
- Havent check parity
- Fixes for PR

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/ConstantNode.cs

 using System.Collections.Generic;
-using UnityEditor.MaterialGraph.Drawing.Controls;
-using UnityEngine.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+using UnityEditor.ShaderGraph;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public enum ConstantType
     {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Scene/LightProbeNode.cs

 using System.Reflection;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
-        //public override bool hasPreview { get { return false; } }
+        public override bool hasPreview { get { return false; } }
 
         public LightProbeNode()
         {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Time/SinTimeNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
+    /*
     [Title("Input/Time/Sine Time")]
     public class SinTimeNode : AbstractMaterialNode, IMayRequireTime
     {
             return true;
         }
     }
+    */
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Time/TimeNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
+    /*
     [Title("Input/Time/Time")]
     public class TimeNode : AbstractMaterialNode, IMayRequireTime
     {
             return true;
         }
     }
+    */
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Texture/TextureSamplerNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Texture/Sample 2D")]
+    /*
+    [Title("Input/Texture/Sample 2D")]
     public class Sample2DTexture : AbstractMaterialNode, IGeneratesBodyCode, IMayRequireMeshUV
     {
         public const int OutputSlotRGBAId = 0;
             var edges = owner.GetEdges(uvSlot.slotReference).ToList();
             return edges.Count == 0;
         }
-    }
+    }*/
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Gradient/GradientNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Basic/Gradient")]
+    [Title("Input/Gradient/Gradient 2D")]
     public class GradientNode : AbstractMaterialNode, IGeneratesBodyCode
     {
         Gradient m_Gradient = new Gradient();

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/TimeNode.cs

+using UnityEngine;
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Input/Basic/Time")]
+    public class TimeNode : AbstractMaterialNode, IMayRequireTime
+    {
+        private const string kOutputSlotName = "Time";
+        private const string kOutputSlot1Name = "SinTime";
+        private const string kOutputSlot2Name = "CosTime";
+        private const string kOutputSlot3Name = "DeltaTime";
+        private const string kOutputSlot4Name = "SmoothDelta";
+
+        public const int OutputSlotId = 0;
+        public const int OutputSlot1Id = 1;
+        public const int OutputSlot2Id = 2;
+        public const int OutputSlot3Id = 3;
+        public const int OutputSlot4Id = 4;
+
+        public TimeNode()
+        {
+            name = "Time";
+            UpdateNodeAfterDeserialization();
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new Vector1MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, 0));
+            AddSlot(new Vector1MaterialSlot(OutputSlot1Id, kOutputSlot1Name, kOutputSlot1Name, SlotType.Output, 0));
+            AddSlot(new Vector1MaterialSlot(OutputSlot2Id, kOutputSlot2Name, kOutputSlot2Name, SlotType.Output, 0));
+            AddSlot(new Vector1MaterialSlot(OutputSlot3Id, kOutputSlot3Name, kOutputSlot3Name, SlotType.Output, 0));
+            AddSlot(new Vector1MaterialSlot(OutputSlot4Id, kOutputSlot4Name, kOutputSlot4Name, SlotType.Output, 0));
+            RemoveSlotsNameNotMatching(validSlots);
+        }
+
+        protected int[] validSlots
+        {
+            get { return new[] { OutputSlotId, OutputSlot1Id, OutputSlot2Id, OutputSlot3Id, OutputSlot4Id }; }
+        }
+
+        public override string GetVariableNameForSlot(int slotId)
+        {
+            switch (slotId)
+            {
+                case OutputSlot1Id:
+                    return "_SinTime.w";
+                case OutputSlot2Id:
+                    return "_CosTime.w";
+                case OutputSlot3Id:
+                    return "unity_DeltaTime.x";
+                case OutputSlot4Id:
+                    return "unity_DeltaTime.z";
+                default:
+                    return "_Time.y";
+            }
+        }
+
+        public bool RequiresTime()
+        {
+            return true;
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/TimeNode.cs.meta

+fileFormatVersion: 2
+guid: 66310de0dabd3074aa56ab7714324cc0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Geometry/ScreenPositionNode.cs

+using System.Reflection;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+
+namespace UnityEditor.ShaderGraph
+{
+    public interface IMayRequireScreenPosition
+    {
+        bool RequiresScreenPosition();
+    }
+
+    public enum ScreenSpaceType
+    {
+        Default,
+        Center,
+        Tiled
+    };
+
+    [Title("Input/Geometry/Screen Position")]
+    public class ScreenPositionNode : AbstractMaterialNode, IGeneratesBodyCode, IMayRequireScreenPosition
+    {
+        public ScreenPositionNode()
+        {
+            name = "Screen Position";
+            UpdateNodeAfterDeserialization();
+        }
+
+        [SerializeField]
+        private ScreenSpaceType m_ScreenSpaceType = ScreenSpaceType.Default;
+
+        [EnumControl("")]
+        public ScreenSpaceType screenSpaceType
+        {
+            get { return m_ScreenSpaceType; }
+            set
+            {
+                if (m_ScreenSpaceType == value)
+                    return;
+
+                m_ScreenSpaceType = value;
+                if (onModified != null)
+                {
+                    onModified(this, ModificationScope.Graph);
+                }
+            }
+        }
+
+        string GetCurrentType()
+        {
+            return System.Enum.GetName(typeof(ScreenSpaceType), m_ScreenSpaceType);
+        }
+
+        private const int kOutputSlot1Id = 0;
+        private const string kOutputSlot1Name = "Out";
+
+        public override bool hasPreview { get { return true; } }
+        public override PreviewMode previewMode
+        {
+            get { return PreviewMode.Preview2D; }
+        }
+
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new Vector2MaterialSlot(kOutputSlot1Id, kOutputSlot1Name, kOutputSlot1Name, SlotType.Output, Vector2.zero));
+            RemoveSlotsNameNotMatching(new[] { kOutputSlot1Id });
+        }
+
+        public override string GetVariableNameForSlot(int slotId)
+        {
+            return ShaderGeneratorNames.ScreenPosition;
+        }
+
+        public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
+        {
+            switch (m_ScreenSpaceType)
+            {
+                case ScreenSpaceType.Center:
+                    visitor.AddShaderChunk(string.Format("{0} = {1};", ShaderGeneratorNames.ScreenPosition, "float4((" + ShaderGeneratorNames.ScreenPosition + ".xy / " + ShaderGeneratorNames.ScreenPosition + ".w) * 2 - 1, 0, 0)"), false);
+                    break;
+                case ScreenSpaceType.Tiled:
+                    visitor.AddShaderChunk(string.Format("{0} = {1};", ShaderGeneratorNames.ScreenPosition, "float4((" + ShaderGeneratorNames.ScreenPosition + ".xy / " + ShaderGeneratorNames.ScreenPosition + ".w) * 2 - 1, 0, 0)"), false);
+                    visitor.AddShaderChunk(string.Format("{0} = {1};", ShaderGeneratorNames.ScreenPosition, "float4(" + ShaderGeneratorNames.ScreenPosition + ".x * _ScreenParams.x / _ScreenParams.y, " + ShaderGeneratorNames.ScreenPosition + ".y, 0, 0)"), false);
+                    break;
+                default:
+                    visitor.AddShaderChunk(string.Format("{0} = {1};", ShaderGeneratorNames.ScreenPosition, "float4(" + ShaderGeneratorNames.ScreenPosition + ".xy / " + ShaderGeneratorNames.ScreenPosition + ".w, 0, 0)"), false);
+                    break;
+            }
+        }
+
+        public bool RequiresScreenPosition()
+        {
+            return true;
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Gradient.meta

+fileFormatVersion: 2
+guid: 4655415e388e6914ebefaaf9e2148ff1
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Scene/ScreenPosNode.cs

-using UnityEngine;
-using UnityEditor.Graphing;
-
-namespace UnityEditor.ShaderGraph
-{
-    public interface IMayRequireScreenPosition
-    {
-        bool RequiresScreenPosition();
-    }
-
-    [Title("Input/Scene Data/Screen Position")]
-    public class ScreenPosNode : AbstractMaterialNode, IMayRequireScreenPosition
-    {
-        public ScreenPosNode()
-        {
-            name = "ScreenPosition";
-            UpdateNodeAfterDeserialization();
-        }
-
-        private const int kOutputSlot1Id = 0;
-        private const string kOutputSlot1Name = "Raw ScreenPos";
-        private const int kOutputSlot2Id = 1;
-        private const string kOutputSlot2Name = "Normalized";
-
-        public override bool hasPreview { get { return true; } }
-        public override PreviewMode previewMode
-        {
-            get { return PreviewMode.Preview2D; }
-        }
-
-
-        public sealed override void UpdateNodeAfterDeserialization()
-        {
-            AddSlot(new Vector4MaterialSlot(kOutputSlot1Id, kOutputSlot1Name, kOutputSlot1Name, SlotType.Output, Vector4.zero));
-            AddSlot(new Vector3MaterialSlot(kOutputSlot2Id, kOutputSlot2Name, kOutputSlot2Name, SlotType.Output, Vector3.zero));
-            RemoveSlotsNameNotMatching(new[] { kOutputSlot1Id, kOutputSlot2Id });
-        }
-
-        public override string GetVariableNameForSlot(int slotId)
-        {
-            string returnString = "";
-            switch (slotId)
-            {
-                case 0:
-                    returnString = ShaderGeneratorNames.ScreenPosition;
-                    break;
-                case 1:
-                    returnString = "float3(" + ShaderGeneratorNames.ScreenPosition + ".xy / " + ShaderGeneratorNames.ScreenPosition + ".w, 0)";
-                    break;
-            }
-            return returnString;
-        }
-
-        public bool RequiresScreenPosition()
-        {
-            return true;
-        }
-    }
-}