Initial commit - working implementations of L-Systems and DLAs.

Author: PSvils

.gitignore

@@ -0,0 +1 @@
+/test/progen-test/bin

progen/dla/DLA.hx

@@ -0,0 +1,101 @@
+package progen.dla;
+import progen.dla.bounds.IBounds;
+
+/**
+ * DLA for generating weird structures of segments and points.
+ * @author P Svilans
+ */
+
+class DLA 
+{
+	
+	/**
+	 * The number of active points in the simulation.
+	 */
+	public var points:Array<DLAPoint>;
+	
+	/**
+	 * Generated segments from the simulation.
+	 */
+	public var segments:Array<DLASegment>;
+	
+	public var origin:IBounds;
+	public var target:IBounds;
+	
+	public var gravity:Float = 1.0;
+	public var threshold:Float;
+	public var motion:DLAPoint;
+	
+	/**
+	 * Creates a DLA with the given origin and target bounds. Points will be spawned along the origin bound,
+	 * and will freeze once they come in range of the target bound. All generated segments are guaranteed to
+	 * be interconnected with one another (no islands).
+	 * @param	origin Origin bound on which to spawn points.
+	 * @param	target Bound that freezes points on contact.
+	 */
+	public function new(origin:IBounds, target:IBounds, gravity:Float = 1.0, threshold:Float = 10.0, motion:DLAPoint = null) 
+	{
+		this.origin = origin;
+		this.target = target;
+		
+		this.gravity = gravity;
+		this.threshold = threshold;
+		this.motion = (motion != null) ? motion : new DLAPoint(10.0, 10.0);
+	}
+	
+	/**
+	 * Simulate a certain number of points to construct the DLA.
+	 * @param	amount The amount of points to simulate.
+	 * @param	iterations How many iterations before terminating.
+	 * @return If all points have been frozen, returns true. If some point haven't stuck to the DLA yet, returns false.
+	 */
+	public function construct(amount:Int = 500, iterations:Int = 1000):Bool
+	{
+		var joined:Array<DLAPoint> = new Array<DLAPoint>();
+		points = [];
+		segments = [];
+		
+		for (i in 0...amount) points.push(origin.create(Math.random()));
+		
+		for (i in 0...iterations)
+		{
+			for (point in points)
+			{
+				var d = target.distanceToBound(point);
+				var o = target.getClosestVector(point);
+				
+				point.x += o.x * gravity + Math.random() * motion.x - motion.x * 0.5;
+				point.y += o.y * gravity + Math.random() * motion.y - motion.y * 0.5;
+				
+				var minimumDistance:Float = Math.min(d * d + 1, threshold * threshold);
+				var minimumPoint:DLAPoint = null;
+				
+				for (set in joined)
+				{
+					var d = set.distance_2(point);
+					
+					if (d < minimumDistance)
+					{
+						minimumDistance = d;
+						minimumPoint = set;
+					}
+				}
+				
+				if (minimumDistance < threshold * threshold && (minimumPoint != null || joined.length == 0))
+				{
+					point.isSet = true;
+					
+					points.remove(point);
+					joined.push(point);
+				}
+				
+				if (minimumPoint != null) segments.push(new DLASegment(point, minimumPoint));
+			}
+			
+			if (points.length == 0) return true;
+		}
+		
+		return false;
+	}
+	
+}

progen/dla/DLAPoint.hx

@@ -0,0 +1,65 @@
+package progen.dla;
+
+/**
+ * Simple Point class to hold x/y values and attached segments.
+ * @author P Svilans
+ */
+
+class DLAPoint 
+{
+	
+	public var isSet:Bool;
+	
+	public var x:Float;
+	public var y:Float;
+	
+	public var segments:Array<DLASegment>;
+	
+	public function new(x:Float = 0.0, y:Float = 0.0) 
+	{
+		this.x = x;
+		this.y = y;
+		
+		segments = new Array<DLASegment>();
+		
+		isSet = false;
+	}
+	
+	/**
+	 * Finds the distance between this and another point.
+	 * @param	point
+	 * @return The distance - surprise! :O
+	 */
+	public inline function distance(point:DLAPoint):Float
+	{
+		return Math.sqrt(distance_2( point));
+	}
+	
+	/**
+	 * Finds the distance squared between this and another point.
+	 * @param	point
+	 * @return
+	 */
+	public inline function distance_2(point:DLAPoint):Float
+	{
+		var dx:Float = point.x - this.x;
+		var dy:Float = point.y - this.y;
+		
+		return dx * dx + dy * dy;
+	}
+	
+	/**
+	 * Clones this point.
+	 * @return
+	 */
+	public inline function clone():DLAPoint
+	{
+		return new DLAPoint(x, y);
+	}
+	
+	public function destroy():Void
+	{
+		for (segment in segments) segment.destroy();
+	}
+	
+}

progen/dla/DLASegment.hx

@@ -0,0 +1,32 @@
+package progen.dla;
+
+/**
+ * A segment joining 2 points.
+ * @author P Svilans
+ */
+
+class DLASegment 
+{
+	
+	public var a:DLAPoint;
+	public var b:DLAPoint;
+	
+	public function new(a:DLAPoint, b:DLAPoint) 
+	{
+		this.a = a;
+		a.segments.push( this);
+		
+		this.b = b;
+		b.segments.push( this);
+	}
+	
+	public function destroy():Void
+	{
+		a.segments.remove( this);
+		b.segments.remove( this);
+		
+		a = null;
+		b = null;
+	}
+	
+}

progen/dla/bounds/CircleBounds.hx

@@ -0,0 +1,63 @@
+package progen.dla.bounds;
+import progen.dla.DLAPoint;
+
+/**
+ * ...
+ * @author P Svilans
+ */
+
+class CircleBounds extends DLAPoint implements IBounds
+{
+	
+	public var gravity:Float;
+	public var radius:Float;
+	
+	public function new(radius:Float, x:Float = 0.0, y:Float = 0.0, gravity:Float = 1.0) 
+	{
+		super(x, y);
+		
+		this.gravity = gravity;
+		this.radius = radius;
+	}
+	
+	/* INTERFACE progen.dla.bounds.IBounds */
+	
+	public function center():DLAPoint
+	{
+		return this;
+	}
+	
+	public function create(t:Float):DLAPoint 
+	{
+		var rads:Float = t * Math.PI * 2;
+		
+		return new DLAPoint(Math.cos(rads) * radius + x, Math.sin(rads) * radius + y);
+	}
+	
+	public function getClosestVector(point:DLAPoint):DLAPoint
+	{
+		var dx = x - point.x;
+		var dy = y - point.y;
+		var d = Math.sqrt(dx * dx + dy * dy);
+		dx = dx / d;
+		dy = dy / d;
+		
+		if (isWithinBounds(point)) return new DLAPoint(-dx * gravity, -dy * gravity);
+		else return new DLAPoint(dx * gravity, dy * gravity);
+	}
+	
+	public function distanceToBound(point:DLAPoint):Float 
+	{
+		var d = distance(point);
+		
+		return radius - d;
+	}
+	
+	public function isWithinBounds(point:DLAPoint):Bool 
+	{
+		var d = distance_2(point);
+		if (d < radius * radius) return true;
+		return false;
+	}
+	
+}

progen/dla/bounds/IBounds.hx

@@ -0,0 +1,31 @@
+package progen.dla.bounds;
+import progen.dla.DLAPoint;
+
+/**
+ * ...
+ * @author P Svilans
+ */
+
+interface IBounds 
+{
+	
+	public var gravity:Float;
+	
+	/**
+	 * Gets the center coordinates of the bound.
+	 * @return Center point.
+	 */
+	public function center():DLAPoint;
+	
+	/**
+	 * Creates a point on the perimeter of this bound.
+	 * @param	t 0.0 - 1.0 - distance along the bound on which to generate the point.
+	 * @return The point created.
+	 */
+	public function create(t:Float):DLAPoint;
+	
+	public function getClosestVector(point:DLAPoint):DLAPoint;
+	public function distanceToBound(point:DLAPoint):Float;
+	public function isWithinBounds(point:DLAPoint):Bool;
+	
+}

progen/dla/bounds/PointBounds.hx

@@ -0,0 +1,54 @@
+package progen.dla.bounds;
+import progen.dla.DLAPoint;
+
+/**
+ * ...
+ * @author P Svilans
+ */
+
+class PointBounds extends DLAPoint implements IBounds
+{
+	
+	public var gravity:Float;
+
+	public function new(x:Float = 0.0, y:Float = 0.0, gravity:Float = 1.0) 
+	{
+		super(x, y);
+		
+		this.gravity = gravity;
+	}
+	
+	/* INTERFACE progen.dla.bounds.IBounds */
+	
+	public function center():DLAPoint
+	{
+		return this;
+	}
+	
+	public function create(t:Float):DLAPoint 
+	{
+		return new DLAPoint(x, y);
+	}
+	
+	public function getClosestVector(point:DLAPoint):DLAPoint
+	{
+		var dx = x - point.x;
+		var dy = y - point.y;
+		var d = Math.sqrt( dx * dx + dy * dy);
+		dx = dx / d;
+		dy = dy / d;
+		
+		return new DLAPoint(dx * gravity, dy * gravity);
+	}
+	
+	public function distanceToBound(point:DLAPoint):Float 
+	{
+		return distance(point);
+	}
+	
+	public function isWithinBounds(point:DLAPoint):Bool
+	{
+		return false;
+	}
+	
+}