Working implementations for Julia and Mandelbrot sets. Supports zooming and moving, but currently slow generation.

Author: PSvils

progen/geom/Vector2D.hx

@@ -0,0 +1,19 @@
+package progen.geom;
+
+/**
+ * ...
+ * @author P Svilans
+ */
+class Vector2D
+{
+	
+	public var x:Float;
+	public var y:Float;
+	
+	public function new(x:Float = 0.0, y:Float = 0.0):Void
+	{
+		this.x = x;
+		this.y = y;
+	}
+	
+}

progen/julia/ComplexData.hx

@@ -0,0 +1,26 @@
+package progen.julia;
+
+/**
+ * ...
+ * @author P Svilans
+ */
+
+class ComplexData
+{
+	
+	public var real:Float;
+	public var imaginary:Float;
+	
+	public var valid:Bool;
+	public var iterations:Int;
+	
+	public function new(real:Float = 0.0, imaginary:Float = 0.0):Void
+	{
+		this.real = real;
+		this.imaginary = imaginary;
+		
+		valid = true;
+		iterations = 0;
+	}
+	
+}

progen/julia/ComplexSet.hx

@@ -0,0 +1,72 @@
+package progen.julia;
+import progen.geom.Vector2D;
+
+/**
+ * ...
+ * @author P Svilans
+ */
+class ComplexSet
+{
+	
+	public var position:Vector2D;
+	public var zoom:Vector2D;
+	
+	public var width:UInt;
+	public var height:UInt;
+	
+	public var data:Array<ComplexData>;
+	
+	public function new():Void
+	{
+		position = new Vector2D();
+		zoom = new Vector2D(1.0, 1.0);
+	}
+	
+	public function initialize(width:UInt, height:UInt):Void
+	{
+		this.width = width;
+		this.height = height;
+		
+		data = createBuffer(width * height);
+	}
+	
+	private inline function createBuffer(length:UInt):Array<ComplexData>
+	{
+		var buffer = new Array<ComplexData>();
+		for (i in 0...length) buffer.push(new ComplexData());
+		
+		return buffer;
+	}
+	
+	public function generate(iterations:UInt = 1):Void
+	{
+		for (x in 0...width)
+		for (y in 0...height)
+		{
+			var current = data[y * width + x];
+			
+			if (current.valid)
+			{
+				for (i in 0...iterations)
+				{
+					process(current);
+					
+					current.iterations++;
+					
+					//if the point is outside the circle with radius 2: stop
+					if ((current.real * current.real + current.imaginary * current.imaginary) > 4)
+					{
+						current.valid = false;
+						break;
+					}
+				}
+			}
+		}
+	}
+	
+	private function process(current:ComplexData):Void
+	{
+		
+	}
+	
+}

progen/julia/JuliaSet.hx

@@ -0,0 +1,49 @@
+package progen.julia;
+import progen.geom.Vector2D;
+import progen.julia.ComplexData;
+
+/**
+ * ...
+ * @author P Svilans
+ */
+class JuliaSet extends ComplexSet
+{
+	
+	public var constant_real:Float;
+	public var constant_imaginary:Float;
+	
+	public function new(constant_real:Float = -0.7, constant_imaginary:Float = 0.27015):Void
+	{
+		this.constant_real = constant_real;
+		this.constant_imaginary = constant_imaginary;
+		
+		super();
+	}
+	
+	override public function initialize(width:UInt, height:UInt):Void
+	{
+		super.initialize(width, height);
+		
+		for (y in 0...height)
+		for (x in 0...width)
+		{
+			var current = data[y * width + x];
+			
+			//calculate the initial real and imaginary part of z, based on the pixel location and zoom and position values
+			current.real = 1.5 * (x - width / 2) / (0.5 * zoom.x * width) + position.x;
+			current.imaginary = (y - height / 2) / (0.5 * zoom.y * height) + position.y;
+		}
+	}
+	
+	override function process(current:ComplexData):Void 
+	{
+		//remember value of previous iteration
+		var old_real:Float = current.real;
+		var old_imaginary:Float = current.imaginary;
+		
+		//the actual iteration, the real and imaginary part are calculated
+		current.real = old_real * old_real - old_imaginary * old_imaginary + constant_real;
+		current.imaginary = 2 * old_real * old_imaginary + constant_imaginary;
+	}
+	
+}

progen/julia/MandelbrotSet.hx

@@ -0,0 +1,33 @@
+package progen.julia;
+import progen.geom.Vector2D;
+import progen.julia.ComplexData;
+
+/**
+ * ...
+ * @author P Svilans
+ */
+
+class MandelbrotSet extends ComplexSet
+{
+	
+	public function new():Void
+	{
+		super();
+	}
+	
+	override function process(current:ComplexData):Void 
+	{
+		//calculate the initial real and imaginary part of z, based on the pixel location and zoom and position values
+		var pr = 1.5 * (x - width / 2) / (0.5 * zoom.x * width) + position.x;
+		var pi = (y - height / 2) / (0.5 * zoom.y * width) + position.y;
+		
+		//remember value of previous iteration
+		var old_real:Float = current.real;
+		var old_imaginary:Float = current.imaginary;
+		
+		//the actual iteration, the real and imaginary part are calculated
+		current.real = old_real * old_real - old_imaginary * old_imaginary + pr;
+		current.imaginary = 2 * old_real * old_imaginary + pi;
+	}
+	
+}