END OF AN ERA, FRACTALFORUMS.COM IS CONTINUED ON FRACTALFORUMS.ORG

float2 Pan;
float Zoom;
float Aspect;
int Iterations;

float4 PixelShader(float4 texCoord : TEXCOORD0) : COLOR0
{
	float2 c = (texCoord - 0.5) * Zoom * float2(1, Aspect) - Pan;
	float2 v = 0;
	float4 result;
    int it = 0;
	float minV = 4;
	float minVx = 4;
	float minVy = 4;
		
	result.r = 0; result.g = 0;	result.b = 0; result.a = 0;

	while((it < Iterations) && (dot(v, v) < 8))
	{
		v = float2(v.x * v.x - v.y * v.y, v.x * v.y * 2) + c;

		if(length(v) < minV) { minV = length(v); }
		if(abs(v.x) < minVx) { minVx = abs(v.x); }
		if(abs(v.y) < minVy) { minVy = abs(v.y); }
		
		it = it +1;
	}
	
	if(it != Iterations)
	{
		//result =  (float)((float)it/(float)Iterations);
		//result = minV;
		result.r = (minVx);
		result.g = (minVy);
		result.b = minV;
	} else {
		result.r = (minVx);
		result.g = (minVy);
		result.b = minV;
	}
    
	return result;
}

technique
{
    pass
    {
	    PixelShader = compile ps_3_0 PixelShader();
    }
}

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 Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;

namespace XNAMandelbrot
{
    /// <summary>
    /// This is the main type for your game
    /// </summary>
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;

        SpriteBatch spriteBatch;
        SpriteFont font1;

        Effect mandelbrotEffect;
        Texture2D dummyTexture;

        Vector2 pan = new Vector2(0.25f, 0.000f);
        float zoom = 3;
        int iteration = 50;

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            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()
        {
            base.Initialize();
        }

        /// <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);
            font1 = Content.Load<SpriteFont>("SpriteFont1");
            mandelbrotEffect = Content.Load<Effect>("Mandelbrot");
            dummyTexture = new Texture2D(graphics.GraphicsDevice, 
                graphics.GraphicsDevice.Viewport.Width, 
                graphics.GraphicsDevice.Viewport.Height, 
                1, 
                TextureUsage.None, 
                SurfaceFormat.Color);
        }

        /// <summary>
        /// UnloadContent will be called once per game and is the place to unload
        /// all content.
        /// </summary>
        protected override void UnloadContent()
        {
            // TODO: Unload any non ContentManager content here
        }

        /// <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)
        {
            KeyboardState keyboardState = Keyboard.GetState();

            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();

            // TODO: Add your update logic here
            if (keyboardState.IsKeyDown(Keys.Up))
            {
                //pan = pan + new Vector2(0, 0.01f);
                pan.Y += (0.01f * zoom);
            }

            if (keyboardState.IsKeyDown(Keys.Down))
            {
                //pan = pan - new Vector2(0, 0.01f);
                pan.Y -= (0.01f * zoom);
            }

            if (keyboardState.IsKeyDown(Keys.Left))
            {
                pan.X += (0.01f * zoom);
            }

            if (keyboardState.IsKeyDown(Keys.Right))
            {
                pan.X -= (0.01f * zoom);
            }

            if (keyboardState.IsKeyDown(Keys.Add)) {
                zoom /= 1.01f;
            }

            if (keyboardState.IsKeyDown(Keys.Subtract))
            {
                zoom *= 1.01f;
            }

            if (keyboardState.IsKeyDown(Keys.Multiply))
            {
                iteration++;
            }

            if (keyboardState.IsKeyDown(Keys.Divide))
            {
                iteration--;
            }


            base.Update(gameTime);
        }

        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.Black);

            

            

            float aspectRatio = (float)GraphicsDevice.Viewport.Height / (float)GraphicsDevice.Viewport.Width;

            mandelbrotEffect.Parameters["Pan"].SetValue(pan);
            mandelbrotEffect.Parameters["Zoom"].SetValue(zoom);
            mandelbrotEffect.Parameters["Aspect"].SetValue(aspectRatio);
            mandelbrotEffect.Parameters["Iterations"].SetValue(iteration);

            spriteBatch.Begin(SpriteBlendMode.None, SpriteSortMode.Immediate, SaveStateMode.None);
            mandelbrotEffect.Begin();
            mandelbrotEffect.CurrentTechnique.Passes[0].Begin();

            spriteBatch.Draw(dummyTexture, Vector2.Zero,Color.Black);

            spriteBatch.End();
            mandelbrotEffect.CurrentTechnique.Passes[0].End();
            mandelbrotEffect.End();

            spriteBatch.Begin();
            String IterationText = "Iteration : " + iteration;
            Vector2 FontOrigin = font1.MeasureString(IterationText) / 2;
            spriteBatch.DrawString(font1, IterationText, new Vector2(10, 10) + FontOrigin, Color.Green,
                0, FontOrigin, 1.0f, SpriteEffects.None, 0.5f);

            spriteBatch.End();

            base.Draw(gameTime);
        }
    }
}