Converted all nodes to use no-presenter.

MaterialGraphProject/Assets/NewNodes/Editor/BlendModeNodePresenter.cs

 using System;
 using System.Collections.Generic;
 using UnityEditor.Experimental.UIElements.GraphView;
+using UnityEngine;
 using UnityEngine.MaterialGraph;
 
 namespace UnityEditor.MaterialGraph.Drawing
         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class BlendModeNodePresenter : MaterialNodePresenter
     {
+            instance.Initialize(node);
+            return new List<GraphControlPresenter> { instance };
+        }
+    }
+#endif
+
+    public class BlendModeNodeView : MaterialNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<BlendModeNodeControlPresenter>();
             instance.Initialize(node);
             return new List<GraphControlPresenter> { instance };
         }

MaterialGraphProject/Assets/NewNodes/Editor/ConstantsNodePresenter.cs

 using System.Collections.Generic;
 using UnityEngine.MaterialGraph;
 using UnityEditor.Experimental.UIElements.GraphView;
+using UnityEngine;
 
 namespace UnityEditor.MaterialGraph.Drawing
 {
         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class ConstantsNodePresenter : MaterialNodePresenter
     {
+            instance.Initialize(node);
+            return new List<GraphControlPresenter> { instance };
+        }
+    }
+#endif
+
+    public class ConstantsNodeView : MaterialNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<ConstantsContolPresenter>();
             instance.Initialize(node);
             return new List<GraphControlPresenter> { instance };
         }

MaterialGraphProject/Assets/NewNodes/Editor/TransformNodePresenter.cs

         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class TransformNodePresenter : PropertyNodePresenter
     {
             instance.Initialize(node);
             return new List<GraphControlPresenter>(base.GetControlData()) { instance };
+        }
+    }
+#endif
+
+    public class TransformNodeView : PropertyNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<TransformControlPresenter>();
+            instance.Initialize(node);
+            return new List<GraphControlPresenter> { instance };
         }
     }
 }

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

 
         protected MaterialGraphPresenter()
         {
+#if WITH_PRESENTERS
             typeMapper = new GraphTypeMapper(typeof(MaterialNodePresenter));
             typeMapper[typeof(AbstractMaterialNode)] = typeof(MaterialNodePresenter);
             typeMapper[typeof(ColorNode)] = typeof(ColorNodePresenter);
             typeMapper[typeof(TransformNode)] = typeof(TransformNodePresenter);
 
 //            typeMapper[typeof(ConvolutionFilterNode)] = typeof(ConvolutionFilterNodePresenter);
+#else
+            typeMapper = new GraphTypeMapper(typeof(MaterialNodeView));
+            typeMapper[typeof(AbstractMaterialNode)] = typeof(MaterialNodeView);
+            typeMapper[typeof(ColorNode)] = typeof(ColorNodeView);
+            typeMapper[typeof(GradientNode)] = typeof(GradientNodeView);
+
+            // typeMapper[typeof(ScatterNode)] = typeof(ScatterNodeView);
+            //typeMapper[typeof(TextureNode)] = typeof(TextureNodeView);
+            //typeMapper[typeof(SamplerAssetNode)] = typeof(SamplerAssetNodeView);
+            //typeMapper[typeof(TextureSamplerNode)] = typeof(TextureSamplerNodeView);
+            //            typeMapper[typeof(Texture2DNode)] = typeof(TextureAssetNodeView);
+            //           typeMapper[typeof(TextureLODNode)] = typeof(TextureLODNodeView);
+            typeMapper[typeof(SamplerStateNode)] = typeof(SamplerStateNodeView);
+            //         typeMapper[typeof(CubemapNode)] = typeof(CubeNodeView);
+            //       typeMapper[typeof(ToggleNode)] = typeof(ToggleNodeView);
+            typeMapper[typeof(UVNode)] = typeof(UVNodeView);
+            typeMapper[typeof(Vector1Node)] = typeof(Vector1NodeView);
+            typeMapper[typeof(Vector2Node)] = typeof(Vector2NodeView);
+            typeMapper[typeof(Vector3Node)] = typeof(Vector3NodeView);
+            typeMapper[typeof(Vector4Node)] = typeof(Vector4NodeView);
+            typeMapper[typeof(PropertyNode)] = typeof(PropertyNodeView);
+
+            /* typeMapper[typeof(ScaleOffsetNode)] = typeof(AnyNodeView);         // anything derived from AnyNode should use the AnyNodeView
+             typeMapper[typeof(RadialShearNode)] = typeof(AnyNodeView);         // anything derived from AnyNode should use the AnyNodeView
+             typeMapper[typeof(SphereWarpNode)] = typeof(AnyNodeView);          // anything derived from AnyNode should use the AnyNodeView
+             typeMapper[typeof(SphericalIndentationNode)] = typeof(AnyNodeView);          // anything derived from AnyNode should use the AnyNodeView
+             typeMapper[typeof(AACheckerboardNode)] = typeof(AnyNodeView);         // anything derived from AnyNode should use the AnyNodeView
+             typeMapper[typeof(AACheckerboard3dNode)] = typeof(AnyNodeView);         // anything derived from AnyNode should use the AnyNodeView*/
+            typeMapper[typeof(SubGraphNode)] = typeof(SubgraphNodeView);
+            typeMapper[typeof(MasterRemapNode)] = typeof(MasterRemapNodeView);
+
+            // typeMapper[typeof(MasterRemapInputNode)] = typeof(RemapInputNodeView);
+            typeMapper[typeof(AbstractSubGraphIONode)] = typeof(SubgraphIONodeView);
+            //            typeMapper[typeof(AbstractSurfaceMasterNode)] = typeof(SurfaceMasterNodeView);
+            typeMapper[typeof(LevelsNode)] = typeof(LevelsNodeView);
+            typeMapper[typeof(ConstantsNode)] = typeof(ConstantsNodeView);
+
+            //typeMapper[typeof(SwizzleNode)] = typeof(SwizzleNodeView);
+            typeMapper[typeof(BlendModeNode)] = typeof(BlendModeNodeView);
+
+            // typeMapper[typeof(AddManyNode)] = typeof(AddManyNodeView);
+            typeMapper[typeof(IfNode)] = typeof(IfNodeView);
+
+            //typeMapper[typeof(CustomCodeNode)] = typeof(CustomCodeView);
+            typeMapper[typeof(Matrix2Node)] = typeof(Matrix2NodeView);
+            typeMapper[typeof(Matrix3Node)] = typeof(Matrix3NodeView);
+            typeMapper[typeof(Matrix4Node)] = typeof(Matrix4NodeView);
+            typeMapper[typeof(MatrixCommonNode)] = typeof(MatrixCommonNodeView);
+            typeMapper[typeof(TransformNode)] = typeof(TransformNodeView);
+
+            //            typeMapper[typeof(ConvolutionFilterNode)] = typeof(ConvolutionFilterNodeView);
+#endif
         }
 
         public override List<NodeAnchorPresenter> GetCompatibleAnchors(NodeAnchorPresenter startAnchor, NodeAdapter nodeAdapter)
 
         void NodeAdded(NodeAddedGraphChange change)
         {
-            if (change.node is Vector1Node)
-            {
-                var nodeView = new Vector1NodeView();
-                change.node.onModified += OnNodeChanged;
-                nodeView.Initialize(change.node, m_PreviewSystem);
-                m_GraphView.AddElement(nodeView);
-                return;
-            }
-
-            if (change.node is Vector2Node)
-            {
-                var nodeView = new Vector2NodeView();
-                change.node.onModified += OnNodeChanged;
-                nodeView.Initialize(change.node, m_PreviewSystem);
-                m_GraphView.AddElement(nodeView);
-                return;
-            }
-
-            if (change.node is FractalNode)
-            {
-                var nodeView = new MaterialNodeView();
-                change.node.onModified += OnNodeChanged;
-                nodeView.Initialize(change.node, m_PreviewSystem);
-                m_GraphView.AddElement(nodeView);
-                return;
-            }
-
+#if WITH_PRESENTER
+#else
+            var nodeView = (MaterialNodeView)typeMapper.Create(change.node);
+            change.node.onModified += OnNodeChanged;
+            nodeView.Initialize(change.node, m_PreviewSystem);
+            m_GraphView.AddElement(nodeView);
+#endif
         }
 
         void NodeRemoved(NodeRemovedGraphChange change)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/ColorNodePresenter.cs

         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class ColorNodePresenter : MaterialNodePresenter
     {
+            instance.Initialize(node);
+            return new List<GraphControlPresenter> { instance };
+        }
+    }
+#endif
+
+    public class ColorNodeView : MaterialNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<ColorContolPresenter>();
             instance.Initialize(node);
             return new List<GraphControlPresenter> { instance };
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/GradientNodePresenter.cs

         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class GradientNodePresenter : MaterialNodePresenter
     {
+            instance.Initialize(node);
+            return new List<GraphControlPresenter> { instance };
+        }
+    }
+#endif
+
+    public class GradientNodeView : MaterialNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<GradientContolPresenter>();
             instance.Initialize(node);
             return new List<GraphControlPresenter> { instance };
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/IfNodePresenter.cs

         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class IfNodePresenter : PropertyNodePresenter
     {
+            instance.Initialize(node);
+            return new List<GraphControlPresenter>(base.GetControlData()) { instance };
+        }
+    }
+#endif
+
+    public class IfNodeView : MaterialNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<IfControlPresenter>();
             instance.Initialize(node);
             return new List<GraphControlPresenter>(base.GetControlData()) { instance };
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/LevelsNodePresenter.cs

 using System;
 using System.Collections.Generic;
 using UnityEditor.Experimental.UIElements.GraphView;
+using UnityEngine;
 using UnityEngine.MaterialGraph;
 
 namespace UnityEditor.MaterialGraph.Drawing
         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class LevelsNodePresenter : PropertyNodePresenter
     {
+            instance.Initialize(node);
+            return new List<GraphControlPresenter>(base.GetControlData()) { instance };
+        }
+    }
+#endif
+
+    public class LevelsNodeView : MaterialNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<LevelsControlPresenter>();
             instance.Initialize(node);
             return new List<GraphControlPresenter>(base.GetControlData()) { instance };
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/Matrix2NodePresenter.cs

         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class Matrix2NodePresenter : PropertyNodePresenter
     {
+            instance.Initialize(node);
+            return new List<GraphControlPresenter>(base.GetControlData()) { instance };
+        }
+    }
+#endif
+
+    public class Matrix2NodeView : PropertyNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<Matrix2ControlPresenter>();
             instance.Initialize(node);
             return new List<GraphControlPresenter>(base.GetControlData()) { instance };
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/Matrix3NodePresenter.cs

         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class Matrix3NodePresenter : PropertyNodePresenter
     {
+            instance.Initialize(node);
+            return new List<GraphControlPresenter>(base.GetControlData()) { instance };
+        }
+    }
+#endif
+
+    public class Matrix3NodeView : PropertyNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<Matrix3ControlPresenter>();
             instance.Initialize(node);
             return new List<GraphControlPresenter>(base.GetControlData()) { instance };
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/Matrix4NodePresenter.cs

         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class Matrix4NodePresenter : PropertyNodePresenter
     {
+            instance.Initialize(node);
+            return new List<GraphControlPresenter>(base.GetControlData()) { instance };
+        }
+    }
+#endif
+
+    public class Matrix4NodeView : PropertyNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<Matrix4ControlPresenter>();
             instance.Initialize(node);
             return new List<GraphControlPresenter>(base.GetControlData()) { instance };
         }

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

 using System.Collections.Generic;
 using UnityEngine.MaterialGraph;
 using UnityEditor.Experimental.UIElements.GraphView;
+using UnityEngine;
 
 namespace UnityEditor.MaterialGraph.Drawing
 {
         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class MatrixCommonNodePresenter : MaterialNodePresenter
     {
+            instance.Initialize(node);
+            return new List<GraphControlPresenter> { instance };
+        }
+    }
+#endif
+
+    public class MatrixCommonNodeView : MaterialNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<MatrixCommonContolPresenter>();
             instance.Initialize(node);
             return new List<GraphControlPresenter> { instance };
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/RemapMasterNodePresenter.cs

         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class MasterRemapNodePresenter : MaterialNodePresenter
     {
+            instance.Initialize(node);
+            return new List<GraphControlPresenter> { instance };
+        }
+    }
+#endif
+
+    public class MasterRemapNodeView : MaterialNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<RemapContolPresenter>();
             instance.Initialize(node);
             return new List<GraphControlPresenter> { instance };
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/SamplerStateNodePresenter.cs

 using System.Collections.Generic;
 using UnityEngine.MaterialGraph;
 using UnityEditor.Experimental.UIElements.GraphView;
+using UnityEngine;
 
 namespace UnityEditor.MaterialGraph.Drawing
 {
         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class SamplerStateNodePresenter : MaterialNodePresenter
     {
+            instance.Initialize(node);
+            return new List<GraphControlPresenter> { instance };
+        }
+    }
+#endif
+
+    public class SamplerStateNodeView : MaterialNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<SamplerStateControlPresenter>();
             instance.Initialize(node);
             return new List<GraphControlPresenter> { instance };
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/SubgraphIONodePresenter.cs

         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class SubgraphIONodePresenter : MaterialNodePresenter
     {
+            instance.Initialize(node);
+            return new List<GraphControlPresenter> { instance };
+        }
+    }
+#endif
+
+    public class SubgraphIONodeView : MaterialNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<SubgraphIONodeControlPresenter>();
             instance.Initialize(node);
             return new List<GraphControlPresenter> { instance };
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/SubgraphNodePresenter.cs

             return new List<GraphControlPresenter> { instance };
         }
     }
+
+    public class SubgraphNodeView : MaterialNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<SubgraphContolPresenter>();
+            instance.Initialize(node);
+            return new List<GraphControlPresenter> { instance };
+        }
+    }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/SwizzleNodePresenter.cs

 using System;
 using System.Collections.Generic;
 using UnityEditor.Experimental.UIElements.GraphView;
+using UnityEngine;
 using UnityEngine.MaterialGraph;
 
 namespace UnityEditor.MaterialGraph.Drawing
         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class SwizzleNodePresenter : PropertyNodePresenter
     {
+            instance.Initialize(node);
+            return new List<GraphControlPresenter>(base.GetControlData()) { instance };
+        }
+    }
+#endif
+
+    public class SwizzleNodeView : MaterialNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<SwizzleControlPresenter>();
             instance.Initialize(node);
             return new List<GraphControlPresenter>(base.GetControlData()) { instance };
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/UVNodePresenter.cs

 using System;
 using System.Collections.Generic;
 using UnityEditor.Experimental.UIElements.GraphView;
+using UnityEngine;
 using UnityEngine.MaterialGraph;
 
 namespace UnityEditor.MaterialGraph.Drawing
         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class UVNodePresenter : MaterialNodePresenter
     {
+            instance.Initialize(node);
+            return new List<GraphControlPresenter> { instance };
+        }
+    }
+#endif
+
+    public class UVNodeView : MaterialNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<UVNodeContolPresenter>();
             instance.Initialize(node);
             return new List<GraphControlPresenter> { instance };
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/Vector1NodePresenter.cs

         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class Vector1NodePresenter : PropertyNodePresenter
     {
             return new List<GraphControlPresenter>(base.GetControlData()) { instance };
         }
     }
+#endif
 
     public class Vector1NodeView : PropertyNodeView
     {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/Vector2NodePresenter.cs

         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class Vector2NodePresenter : PropertyNodePresenter
     {
             return new List<GraphControlPresenter>(base.GetControlData()) { instance };
         }
     }
+#endif
 
     public class Vector2NodeView : PropertyNodeView
     {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/Vector3NodePresenter.cs

         }
     }
 
+#if WITH_PRESENTER
     [Serializable]
     public class Vector3NodePresenter : PropertyNodePresenter
     {
+            instance.Initialize(node);
+            return new List<GraphControlPresenter>(base.GetControlData()) { instance };
+        }
+    }
+#endif
+
+    public class Vector3NodeView : PropertyNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<Vector3ControlPresenter>();
             instance.Initialize(node);
             return new List<GraphControlPresenter>(base.GetControlData()) { instance };
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/Vector4NodePresenter.cs

             return new List<GraphControlPresenter>(base.GetControlData()) { instance };
         }
     }
+
+    public class Vector4NodeView : PropertyNodeView
+    {
+        protected override IEnumerable<GraphControlPresenter> GetControlData()
+        {
+            var instance = ScriptableObject.CreateInstance<Vector4ControlPresenter>();
+            instance.Initialize(node);
+            return new List<GraphControlPresenter>(base.GetControlData()) { instance };
+        }
+    }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Util/GraphTypeMapper.cs

 
 namespace UnityEditor.Graphing.Util
 {
+#if WITH_PRESENTER
     public class GraphTypeMapper : BaseTypeFactory<INode, ScriptableObject>
     {
         public GraphTypeMapper(Type fallbackType) : base(fallbackType)
             return ScriptableObject.CreateInstance(valueType);
         }
     }
+#else
+    public class GraphTypeMapper : BaseTypeFactory<INode, GraphElement>
+    {
+        public GraphTypeMapper(Type fallbackType) : base(fallbackType)
+        {
+        }
+
+        protected override GraphElement InternalCreate(Type valueType)
+        {
+            return (GraphElement) Activator.CreateInstance(valueType);
+        }
+    }
+#endif
 }

MaterialGraphProject/GeneratedShader.shader

-Shader "hidden/preview/Fractal_2C974170"
+Shader "hidden/preview/Multiply_156218A9"
+				[HideInInspector] [NonModifiableTextureData] [NoScaleOffset] Texture_FD0EDC2E("Texture", 2D) = "white" {}
-			void Unity_Fractal_float(float2 uv, float2 pan, float zoom, float aspect, out float result)
+			void Unity_Combine_float(float R, float G, float B, float A, out float4 RGBA)
+			{
+			    RGBA = float4(R, G, B, A);
+			}
+			void Unity_Multiply_float(float4 first, float4 second, out float4 result)
+			{
+			    result = first * second;
+			}
+			void Unity_HSVToRGB_float(float3 hsv, out float3 rgb)
+			{
+			    //Reference code from:https://github.com/Unity-Technologies/PostProcessing/blob/master/PostProcessing/Resources/Shaders/ColorGrading.cginc#L175
+			    float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+			    float3 P = abs(frac(hsv.xxx + K.xyz) * 6.0 - K.www);
+			    rgb = hsv.z * lerp(K.xxx, saturate(P - K.xxx), hsv.y);
+			}
+			void Unity_Multiply_float(float first, float second, out float result)
+			{
+			    result = first * second;
+			}
+			void Unity_Subtract_float(float first, float second, out float result)
+			{
+			    result = first - second;
+			}
+			void Unity_OneMinus_float(float argument, out float result)
-			    const int Iterations = 128;
-			    float2 c = (uv - 0.5) * zoom * float2(1, aspect) - pan;
-			    float2 v = 0;
-			    for (int n = 0; n < Iterations && dot(v,v) < 4; n++)
-			    {
-			        v = float2(v.x * v.x - v.y * v.y, v.x * v.y * 2) + c;
-			    }
-			    result = (dot(v, v) > 4) ? (float)n / (float)Iterations : 0;
+			    result = argument * -1 + 1;;
+			}
+			void Unity_Multiply_float(float3 first, float3 second, out float3 result)
+			{
+			    result = first * second;
 			}
 	struct GraphVertexInput
 	{
 				half4 uv0;
 			};
 			struct SurfaceDescription{
-				float Fractal_2C974170_result;
+				float3 Multiply_156218A9_result;
-			float4 Fractal_2C974170_uv;
-			float4 Fractal_2C974170_pan;
-			float Fractal_2C974170_zoom;
-			float Fractal_2C974170_aspect;
+			UNITY_DECLARE_TEX2D(Texture_FD0EDC2E);
+			float Combine_76C873_G;
+			float Combine_76C873_B;
+			float Combine_76C873_A;
+			float4 Property_23AD7FD4_UV;
+			float Subtract_4053AE6C_first;
+			float Combine_EBDC57C5_G;
+			float Combine_EBDC57C5_B;
+			float Combine_EBDC57C5_A;
+			float Multiply_77943E40_second;
+			float4 Multiply_156218A9_second;
-				float Fractal_2C974170_result;
-				Unity_Fractal_float(uv0, Fractal_2C974170_pan, Fractal_2C974170_zoom, Fractal_2C974170_aspect, Fractal_2C974170_result);
+				float4 Combine_76C873_RGBA;
+				Unity_Combine_float(_Time.y, Combine_76C873_G, Combine_76C873_B, Combine_76C873_A, Combine_76C873_RGBA);
+				float4 Property_23AD7FD4_RGBA = UNITY_SAMPLE_TEX2D(Texture_FD0EDC2E,uv0.xy);
+				float Property_23AD7FD4_R = Property_23AD7FD4_RGBA.r;
+				float Property_23AD7FD4_G = Property_23AD7FD4_RGBA.g;
+				float Property_23AD7FD4_B = Property_23AD7FD4_RGBA.b;
+				float Property_23AD7FD4_A = Property_23AD7FD4_RGBA.a;
+				float4 Multiply_89C71AC1_result;
+				Unity_Multiply_float(Property_23AD7FD4_RGBA, Combine_76C873_RGBA, Multiply_89C71AC1_result);
+				float3 HSVtoRGB_AE8D0A0E_rgb;
+				Unity_HSVToRGB_float((Multiply_89C71AC1_result.xyz), HSVtoRGB_AE8D0A0E_rgb);
+				float Split_81BA869A_R = HSVtoRGB_AE8D0A0E_rgb[0];
+				float Split_81BA869A_G = HSVtoRGB_AE8D0A0E_rgb[1];
+				float Split_81BA869A_B = HSVtoRGB_AE8D0A0E_rgb[2];
+				float Split_81BA869A_A = 1.0;
+				float Multiply_9164EC34_result;
+				Unity_Multiply_float(Split_81BA869A_R, Split_81BA869A_G, Multiply_9164EC34_result);
+				float Subtract_4053AE6C_result;
+				Unity_Subtract_float(Subtract_4053AE6C_first, _Time.y, Subtract_4053AE6C_result);
+				float Multiply_841C266E_result;
+				Unity_Multiply_float(Multiply_9164EC34_result, Split_81BA869A_B, Multiply_841C266E_result);
+				float4 Combine_EBDC57C5_RGBA;
+				Unity_Combine_float(Subtract_4053AE6C_result, Combine_EBDC57C5_G, Combine_EBDC57C5_B, Combine_EBDC57C5_A, Combine_EBDC57C5_RGBA);
+				float Multiply_77943E40_result;
+				Unity_Multiply_float(Multiply_841C266E_result, Multiply_77943E40_second, Multiply_77943E40_result);
+				float3 HSVtoRGB_6DD0292E_rgb;
+				Unity_HSVToRGB_float((Combine_EBDC57C5_RGBA.xyz), HSVtoRGB_6DD0292E_rgb);
+				float OneMinus_F47415CA_result;
+				Unity_OneMinus_float(Multiply_77943E40_result, OneMinus_F47415CA_result);
+				float3 Multiply_E8E6BAEA_result;
+				Unity_Multiply_float((OneMinus_F47415CA_result.xxx), HSVtoRGB_6DD0292E_rgb, Multiply_E8E6BAEA_result);
+				float3 Multiply_156218A9_result;
+				Unity_Multiply_float(Multiply_E8E6BAEA_result, Multiply_156218A9_second, Multiply_156218A9_result);
-				surface.Fractal_2C974170_result = Fractal_2C974170_result;
+				surface.Multiply_156218A9_result = Multiply_156218A9_result;
 				return surface;
 			}
 	ENDCG
 	            SurfaceInputs surfaceInput = (SurfaceInputs)0;;
 	            surfaceInput.uv0  =uv0;
 	            SurfaceDescription surf = PopulateSurfaceData(surfaceInput);
-	            return half4(surf.Fractal_2C974170_result, surf.Fractal_2C974170_result, surf.Fractal_2C974170_result, 1.0);
+	            return half4(surf.Multiply_156218A9_result.x, surf.Multiply_156218A9_result.y, surf.Multiply_156218A9_result.z, 1.0);
 	        }
 	        ENDCG
 	    }