// Update is called once per frame
	void Update () {
    if (timer == 0) {
      LastColor = SoupMaterial.color;
    }

    if (!NextColor.Equals(SoupMaterial.color)) {
      timer += Time.deltaTime;
      Color c = Color.Lerp(LastColor, NextColor, timer / duration);
      SoupMaterial.color = c;
      SoupLight.color = c;
      SoupLight.intensity = Mathf.Max(1.5f * (duration - timer), 1);

      var col = Smoke.colorOverLifetime;
      col.enabled = true;

      Gradient grad = new Gradient();
      grad.SetKeys( new GradientColorKey[] { new GradientColorKey(c, 0.0f), new GradientColorKey(Color.gray, 1.0f) }, new GradientAlphaKey[] { new GradientAlphaKey(1.0f, 0.0f), new GradientAlphaKey(0.0f, 1.0f) } );

      col.color = new ParticleSystem.MinMaxGradient(grad);

      if (timer >= duration) {
        SoupMaterial.color = NextColor;
        SoupLight.intensity = 1;
        timer = 0;
      }
    }
	}

    // Use this for initialization
    void Start()
    {
        //activated = true;
        //cachedY = timeTransform.position.y;

        minXValue = 0;
        maxXValue = timeTransform.rect.width;

        //currentTime = maxTime;
        g = new Gradient();

        // Populate the color keys at the relative time 0 and 1 (0 and 100%)
        gck = new GradientColorKey[3];
        gck[0].color = new Color32(9,183,62,1);
        gck[0].time = 0.0f;
        gck[1].color = new Color32(255,228,0,1);
        gck[1].time = 0.5f;
        gck[2].color = new Color32(219,101,63,1);
        gck[2].time = 1.0f;

        // Populate the alpha  keys at relative time 0 and 1  (0 and 100%)
        gak = new GradientAlphaKey[2];
        gak[0].alpha = 1.0f;
        gak[0].time = 0.0f;
        gak[1].alpha = 1.0f;
        gak[1].time = 1.0f;
        g.SetKeys(gck, gak);

        CurrentTime = maxTime;
    }

        private void LoadData(object sender, EventArgs e)
        {
            Gradient gradient = new Gradient(9, 0.01, 2.0, 10, 1.5);

            chart1.Series["Series1"].ChartType = SeriesChartType.Spline;

            gradient.SetStartPoint();

            double length = 0.0;
            int i = 0;
            do 
            {
                length = gradient.GetNext();
                chart1.Series["Series1"].Points.AddXY(i, length);
                i++;
            } while (length > epsilon && i < maxIteration);

            Console.WriteLine("\nIteration = " + (i - 1));
            Console.WriteLine("Distance between atoms = " + gradient.GetPoint() + "\n");

            chart1.ChartAreas[0].AxisX.Minimum = 0;
            chart1.ChartAreas[0].AxisY.Minimum = 0;

            chart1.Update();
        }

        /// <summary>
        /// Initializes a new instance of Gradient.
        /// </summary>
        static GradientPresets()
        {
            // Grayscale gradient color keys
            var grayscaleColorKeys = new List<GradientColorKey>
            {
                new GradientColorKey(Color.black, 0),
                new GradientColorKey(Color.white, 1)
            };

            // RGB gradient color keys
            var rgbColorKeys = new List<GradientColorKey>
            {
                new GradientColorKey(Color.red, 0),
                new GradientColorKey(Color.green, 0.5f),
                new GradientColorKey(Color.blue, 1)
            };

            // RGBA gradient color keys
            var rgbaColorKeys = new List<GradientColorKey>
            {
                new GradientColorKey(Color.red, 0),
                new GradientColorKey(Color.green, 1 / 3f),
                new GradientColorKey(Color.blue, 2 / 3f),
                new GradientColorKey(Color.black, 1)
            };

            // RGBA gradient alpha keys
            var rgbaAlphaKeys = new List<GradientAlphaKey> {new GradientAlphaKey(0, 2 / 3f), new GradientAlphaKey(1, 1)};

            // Terrain gradient color keys
            var terrainColorKeys = new List<GradientColorKey>
            {
                new GradientColorKey(new Color(0, 0, 0.5f), 0),
                new GradientColorKey(new Color(0.125f, 0.25f, 0.5f), 0.4f),
                new GradientColorKey(new Color(0.25f, 0.375f, 0.75f), 0.48f),
                new GradientColorKey(new Color(0, 0.75f, 0), 0.5f),
                new GradientColorKey(new Color(0.75f, 0.75f, 0), 0.625f),
                new GradientColorKey(new Color(0.625f, 0.375f, 0.25f), 0.75f),
                new GradientColorKey(new Color(0.5f, 1, 1), 0.875f),
                new GradientColorKey(Color.white, 1)
            };

            // Generic gradient alpha keys
            var alphaKeys = new List<GradientAlphaKey> {new GradientAlphaKey(1, 0), new GradientAlphaKey(1, 1)};

            _empty = new Gradient();

            _rgb = new Gradient();
            _rgb.SetKeys(rgbColorKeys.ToArray(), alphaKeys.ToArray());

            _rgba = new Gradient();
            _rgba.SetKeys(rgbaColorKeys.ToArray(), rgbaAlphaKeys.ToArray());

            _grayscale = new Gradient();
            _grayscale.SetKeys(grayscaleColorKeys.ToArray(), alphaKeys.ToArray());

            _terrain = new Gradient();
            _terrain.SetKeys(terrainColorKeys.ToArray(), alphaKeys.ToArray());
        }

        /// <summary>
        /// Creates a 1 pixel wide vertical gradient texture using the provided <see cref="GradientStop"/> array.
        /// </summary>
        /// <param name="device"><see cref="Microsoft.Xna.Framework.Graphics.GraphicsDevice"/> instance to use.</param>
        /// <param name="gradientStops">Array of <see cref="GradientStop"/> instances to use when generating the gradient.</param>
        /// <param name="height">Height of the generated texture in pixels.</param>
        /// <returns>A texture 1 pixel wide and the height specified.</returns>
        public static Texture2D CreateVerticalGradient(GraphicsDevice device, Gradient gradient, int height)
        {
            Texture2D texture = new Texture2D(device, 1, height, false, SurfaceFormat.Color);
            Color[] colors = gradient.GetColors(height);
            texture.SetData<Color>(colors);

            return texture;
        }

        /// <summary>
        /// Creates a 1 pixel high horizontal gradient texture using the provided <see cref="GradientStop"/> array.
        /// </summary>
        /// <param name="device"><see cref="Microsoft.Xna.Framework.Graphics.GraphicsDevice"/> instance to use.</param>
        /// <param name="gradientStops">Array of <see cref="GradientStop"/> instances to use when generating the gradient.</param>
        /// <param name="width">Width of the generated texture in pixels.</param>
        /// <returns>A texture with the width specified and 1 pixel high.</returns>
        public static Texture2D CreateHorizontalGradient(GraphicsDevice device, Gradient gradient, int width)
        {
            Texture2D texture = new Texture2D(device, width, 1, false, SurfaceFormat.Color);
            Color[] colors = gradient.GetColors(width);
            texture.SetData<Color>(colors);

            return texture;
        }

        public SceneFilter(float angle, Gradient gradient)
        {
            gradientFx = new GradientFilter();
            gradientFx.Gradientf = gradient;
            gradientFx.OriginAngleDegree = angle;

            saturationFx = new SaturationModifyFilter();
            saturationFx.SaturationFactor = -0.6f;
        }

	void SaveGraient(Gradient gradient)
	{
		var path = EditorUtility.SaveFilePanel("Save gradient.", "Assets/", "", "asset");
		if (!string.IsNullOrEmpty(path))
		{
			GradientObject obj = GradientObject.CreateInstance<GradientObject>();
			obj.data = gradient;
			AssetDatabase.CreateAsset(obj, LocalPath(path));
		}
	}

 private void AddGradient_Click(object sender, EventArgs e)
 {
     Gradient newGradient = new Gradient();
       newGradient.Name = CreateUniqueGradientName(Strings.NewGradient);
       gradients.Add(newGradient);
       gradientList.DataSource = null;
       gradientList.DataSource = gradients;
       gradientList.SelectedIndex = gradients.Count - 1;
       deleteGradient.Enabled = (gradients.Count > 0);
       gradientNameTextbox.Focus();
 }

    public ExtendedTerrainArea(float averageHeight, float flatness, float roughness, 
	                                  Gradient coloring00, Gradient coloring10, Gradient coloring01, Gradient coloring11,
	                                  float deltaX, float deltaY)
        : base(averageHeight, flatness, roughness, null)
    {
        this.coloring00 = coloring00;
        this.coloring10 = coloring10;
        this.coloring01 = coloring01;
        this.coloring11 = coloring11;
        this.deltaX = deltaX;
        this.deltaY = deltaY;
    }

        // This constructor takes a Gradient value from the
        // design-time environment, which will be used to display
        // the initial state.
        public GradientViewer(Gradient gradient, IWindowsFormsEditorService editorService)
        {
            // This call is required by the designer.
              InitializeComponent();

              // Cache the light shape value provided by the
              // design-time environment.
              this.gradient = gradient;

              // Cache the reference to the editor service.
              this.editorService = editorService;
        }

	private void InitImpulseGradient ()
	{
		impulseGradient = new Gradient ();
		GradientColorKey[] gck = new GradientColorKey[impulseGradientColors.Length];
		GradientAlphaKey[] gak = new GradientAlphaKey[impulseGradientColors.Length];
		for (int i = 0; i < impulseGradientColors.Length; i++) {
			gck [i].color = impulseGradientColors [i];
			gak [i].alpha = 1.0f;
			gck [i].time = gak [i].time = impulseGradientTimes [i];
		}
		impulseGradient.SetKeys (gck, gak);
	}

	private int id; // just for debugging / can be deleted after

	#endregion

	public WindParticle(int _id, Vector3 _position, int _maxDistance, Quaternion _direction, float _speed, int _maxMountainHeight, float _temperature, float _saturation, Gradient _colorArea) {
		id = _id;
		position = _position;
		source = _position;
		maxDistance = _maxDistance;
		direction = _direction;
		speed = _speed;
		maxMountainHeight = _maxMountainHeight;
		temperature = _temperature;
		saturation = getSFromFRel(_saturation,getPFromHeight((position.y-groundHeight)/scale),temperature); // saturation kommt als relative Luftfeuchte, daher die Umrechnung
		colorArea = _colorArea;
		visible = true;
	}

		// Use this for initialization
		void Awake () 
		{
		
			//set RectTransform parameters
			RectTransform rectTransform = this.GetComponent<RectTransform> ();
			rectTransform.anchorMin = new Vector2(0,0);
			rectTransform.anchorMax = new Vector2(1,1);
			rectTransform.anchoredPosition = new Vector2(1,1);

			colorGradient = GetColorGradient (bottomColor, topColor); // create the color gradient

	
		}

    public Gradient BlendGradient(Gradient terrain_gradient, Gradient object_gradient)
    {
        List<ColorHSV> targetPalette = new List<ColorHSV>();
        List<ColorHSV> currentPalette = new List<ColorHSV>();
        targetPalette = RandomE.TetradicPalette(0.25f, 0.75f);
        Debug.Log(targetPalette.Count);
        ColorHSV groundColor = new ColorHSV(terrain_gradient.Evaluate(0));
        ColorHSV newColor = new ColorHSV(object_gradient.Evaluate(1));
        targetPalette.Add(ColorHSV.Lerp(groundColor, newColor, 0.5f));
        var gradient = ColorE.Gradient(from: targetPalette[2].WithSV(0.8f, 0.8f),
            to: targetPalette[3].WithSV(0.8f, 0.8f));

        return object_gradient;
    }

	public void CreateGradTexture(){
		// Create gradient object and assign generic starting colours
		Grad = new Gradient();
		LastGrad = new Gradient();
		GradientColorKey[] gck = new GradientColorKey[2];
		gck[0] = new GradientColorKey(Color.black, 0f);
		gck[1] = new GradientColorKey(Color.white, 1f);
		GradientAlphaKey[] gak = new GradientAlphaKey[2];
		gak[0] = new GradientAlphaKey(1f, 0f);
		gak[1] = new GradientAlphaKey(1f, 1f);
		Grad.SetKeys(gck, gak);
		LastGrad.SetKeys(gck, gak);
		
		outTexture = new Texture2D(_gradientSizeX,_gradientSizeY);
		outTexture.hideFlags = HideFlags.HideAndDontSave;
//		Debug.Log (outTexture);
	}

    void Start () {
        GradientColorKey[] gradColorKey;
        GradientAlphaKey[] gradAlphaKey;

        grad = new Gradient();
        gradColorKey = new GradientColorKey[3];
        gradAlphaKey = new GradientAlphaKey[1];

        gradColorKey[0].color = Color.magenta;
        gradColorKey[0].time = 0.0f;
        gradColorKey[1].color = Color.green;
        gradColorKey[1].time = 0.5f;
        gradColorKey[2].color = Color.magenta;
        gradColorKey[2].time = 1.0f;

        gradAlphaKey[0].alpha = 1.0f;

        grad.SetKeys(gradColorKey,gradAlphaKey);
    }

    public static Color Grad(float x)
    {
        /*
        // Terrain gradient color keys
        List<GradientColorKey> terrainColorKeys = new List<GradientColorKey>
        {
            new GradientColorKey(new Color(0, 0, 0.5f), 0),
            new GradientColorKey(new Color(0.125f, 0.25f, 0.5f), 0.4f),
            new GradientColorKey(new Color(0.25f, 0.375f, 0.75f), 0.48f),
            new GradientColorKey(new Color(0, 0.75f, 0), 0.5f),
            new GradientColorKey(new Color(0.75f, 0.75f, 0), 0.625f),
            new GradientColorKey(new Color(0.625f, 0.375f, 0.25f), 0.75f),
            new GradientColorKey(new Color(0.5f, 1, 1), 0.875f),
            new GradientColorKey(Color.white, 1)
        };

        // Generic gradient alpha keys
        var alphaKeys = new List<GradientAlphaKey> {new GradientAlphaKey(1, 0), new GradientAlphaKey(1, 1)};
        */

        Gradient g = new Gradient();
        GradientColorKey[] gck;
        GradientAlphaKey[] gak;

        // Populate the color keys at the relative time 0 and 1 (0 and 100%)
        gck = new GradientColorKey[2];
        gck[0].color = Color.red;
        gck[0].time = 0.0f;
        gck[1].color = Color.blue;
        gck[1].time = 1.0f;

        // Populate the alpha  keys at relative time 0 and 1  (0 and 100%)
        gak = new GradientAlphaKey[2];
        gak[0].alpha = 1.0f;
        gak[0].time = 0.0f;
        gak[1].alpha = 0.0f;
        gak[1].time = 1.0f;

        //g.SetKeys(terrainColorKeys.ToArray(), alphaKeys.ToArray());
        g.SetKeys(gck,gak);

        return g.Evaluate(x);;
    }

        /*
        protected override IEnumerable ListParameters()
        {
          yield return "Type: " + Abbreviations.Get(_type.Value);
          yield return ((_dither) ? "With" : "Without") + " Dither";
          yield return ((_useMask) ? "With" : "Without") + " Use Mask";
        }
        */
        public static Gradient CreateGradient(string name, ListParameter colors)
        {
            Gradient gradient = new Gradient("Photoshop." + name);
              gradient.SegmentRangeSplitUniform(0, -1, colors.Count);

              int segment = 0;

              foreach (ObjcParameter parameter in colors)
            {
              RGB color;

              string type = parameter.GetValueAsString("Type");
              switch (type)
            {
            case "BckC":
              color = Context.Background;
              break;
            case "FrgC":
              color = Context.Foreground;
              break;
            case "UsrS":
              color = parameter.GetValueAsColor("Clr");
              break;
            default:
              Console.WriteLine("Gradient-1: " + type);
              color = new RGB(0, 0, 0);
              break;
            }

              long location = parameter.GetValueAsLong("Lctn");
              long midpoint = parameter.GetValueAsLong("Mdpn");
              Console.WriteLine("type: {0}, location: {1}, midpoint: {2}",
                type, location, midpoint);
              gradient.SegmentSetLeftPosition(segment, location / 4096.0);
              gradient.SegmentSetLeftColor(segment, color, 100);
              if (segment > 0)
            {
              gradient.SegmentSetRightColor(segment - 1, color, 100);
            }
              segment++;
            }
              return gradient;
        }

        /// <summary>
        /// Returns a gradient filled into a shape.
        /// </summary>
        public static Texture2D GetTexture(GraphicsDevice device, Gradient gradient, IShape shape)
        {
            string comparer = string.Concat(new string[] { shape.GetType().Name, shape.ToString(), gradient.ToString() });

            Texture2D texture;

            //Search for the texture in the dictionary, so it doesn't have to be created twice.
            if (_tempTextures.Keys.Contains(comparer))
            {
                texture = _tempTextures[comparer];
            }
            else
            {
                texture = createTexture(device, gradient, shape);
                _tempTextures.Add(comparer, texture);
            }

            return texture;
        }