source: 2014/30/MikkoI/rainbowSimulator/frakt/frakt/Game1.cs @ 5650

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
using System.Threading;

namespace frakt
{
    /// <summary>
    /// This is the main type for your game
    /// </summary>
    public class WooooFract : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        Vector2 viewportSize;

        Texture2D pixel;
        Texture2D image;

        const int threads = 4;
        Thread[] apurit = new Thread[threads];
        float anim;
        Color[] data;



        public WooooFract()
        {
            graphics = new GraphicsDeviceManager(this);
            graphics.PreferredBackBufferWidth = 800;
            graphics.PreferredBackBufferHeight = 600;
            Content.RootDirectory = "Content";
        }

        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        /// </summary>
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here
            pixel = new Texture2D(GraphicsDevice, 1, 1);
            pixel.SetData(new UInt32[] { UInt32.MaxValue });

            image = new Texture2D(GraphicsDevice, Window.ClientBounds.Width, Window.ClientBounds.Height);
            data = new Color[image.Width * image.Height];
            image.GetData(data);

            for (int y = 0; y < threads; y++)
            {
                int yy = y;
                apurit[y] = new Thread(delegate(object o)
                {
                    Test(image.Height / threads * yy, image.Height / threads * (yy + 1));
                });

                apurit[y].Start(null);
            }

            piirraKuva();

            base.Initialize();

            startRender();
        }

        void piirraKuva(float anim = 0)
        {
            GraphicsDevice.Textures[0] = null;
            this.anim = anim;

            /*
            for (int y = 0; y < threads; y++)
            {
                //int yy = y;
                //apurit[y] = new Thread(delegate (object o) {
                //    Test(image.Height / threads * yy, image.Height / threads * (yy+1), (Color[])o);
                //});
                if (apurit[y].IsAlive)
                    apurit[y].Abort();
                
            }
             

            for (int y = 0; y < threads; y++)
            {
                apurit[y].Join();
            }
             */
            
            image.SetData(data);
        }

        void Test(int alku, int loppu)
        {
            Random random = new Random();
            while (true)
            {
                for (int y = alku; y < loppu; y++)
                {
                    for (int x = 0; x < image.Width; x++)
                    {
                        data[x + y * image.Width] = getColor(x + (float)random.NextDouble() * anim / 100 + anim, y + 2);
                    }
                }
            }
        }

        /// <summary>
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// </summary>
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);

            // TODO: use this.Content to load your game content here
        }

        /// <summary>
        /// UnloadContent will be called once per game and is the place to unload
        /// all content.
        /// </summary>
        protected override void UnloadContent()
        {
            for (int y = 0; y < threads; y++)
            {
                apurit[y].Abort();
            }
        }

        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit

            //if (Keyboard.GetState().IsKeyDown(Keys.Enter))
                piirraKuva((float)gameTime.TotalGameTime.TotalSeconds * 100);

            if (Keyboard.GetState().IsKeyDown(Keys.Escape))
                this.Exit();

            // TODO: Add your update logic here

            base.Update(gameTime);
        }

        void startRender()
        {
            viewportSize.X = Window.ClientBounds.Width;
            viewportSize.Y = Window.ClientBounds.Height;
        }

        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        Color getColor(float index, float size)
        {
            Color[] palette = { new Color(0, 0, 0), new Color(255, 0, 0), new Color(255, 255, 0), new Color(0, 255, 0), new Color(0, 255, 255), new Color(0, 0, 255), new Color(0, 0, 0) };
            index = index % size;
            size--;
            float realIndex = ((float)Math.Floor(index) / size) * (palette.Length - 1);
            Color col1 = palette[(int)Math.Floor(realIndex)];
            Color col2 = palette[(int)Math.Ceiling(realIndex)];
            float rel = realIndex - (float)Math.Floor(realIndex);
            return Color.Lerp(col1, col2, rel);
        }
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.Black);
            // TODO: Add your drawing code here

            spriteBatch.Begin();
            spriteBatch.Draw(image, new Vector2(0, 0), Color.White);
            spriteBatch.End();

            base.Draw(gameTime);
        }
    }
}