EntryPoint.hx

package haxe;

/**
	If haxe.MainLoop is kept from DCE, then we will insert an haxe.EntryPoint.run() call just at then end of main().
	This class can be redefined by custom frameworks so they can handle their own main loop logic.
**/
class EntryPoint {

	/**
		Wakeup a sleeping run()
	**/
	public static function wakeup() {
		if( sleepMutex != null ) sleepMutex.release();
	}

	/**
		Start the main loop. Depending on the platform, this can return immediately or will only return when the application exits.
	**/
	public static function run() @:privateAccess {
		#if js
		
		tick();
		var window : Dynamic = js.Browser.window;
		var rqf : Dynamic = window.requestAnimationFrame ||
			window.webkitRequestAnimationFrame ||
			window.mozRequestAnimationFrame;
		rqf(run);
		
		#elseif flash
		
		flash.Lib.current.stage.addEventListener(flash.events.Event.ENTER_FRAME, function(_) tick());
		
		#else
		
		while( MainLoop.hasEvents() ) {
			var nextTick = MainLoop.tick();
			if( nextTick > 0 ) {
				if( sleepMutex == null ) sleepMutex = new sys.vm.Mutex();
				sleepMutex.tryAcquire(nextTick); // wait until nextTick or wakeup() call
			}
		}
		
		#endif
	}
}

MainLoop.hx

package haxe;
import haxe.EntryPoint;

class MainEvent {

	var f : Void -> Void;
	var prev : MainEvent;
	var next : MainEvent;
	public var nextRun(default,null) : Float;
	public var priority(default,null) : Int;
	
	function new(f,p) {
		this.f = f;
		this.priority = p;
	}
	
	/**
		Delay the execution of the event for the given time, in seconds.
		If t is null, the event will be run at tick() time.
	**/	
	public function delay( t : Null<Float> ) {
		nextRun = t == null ? null : haxe.Timer.stamp() + t;
	}

	/**
		Call the event. Will do nothing is the event has been stopped.
	**/	
	public inline function call() {
		if( f != null ) f();
	}
	
	/**
		Stop the event from firing anymore.
	**/
	public inline function stop() {
		f = null;
		delay = null;
		if( prev == null )
			@:privateAccess MainLoop.pending = next;
		else
			prev.next = next;
		if( next != null )
			next.prev = prev;
	}

}

class MainLoop {

	static var pending : MainEvent = null;

	public static function hasEvents() {
		return pending != null;
	}
	
	/**
		Add a pending event to be run into the main loop.
	**/
	public static function add( f : Void -> Void, priority = 0 ) : MainEvent @:privateAccess {
		var e = new MainEvent(f,priority);
		var head = pending;
		if( head == null ) {
			pending = e;
			return e;
		}
		var prev = null;
		while( head != null && head.priority > priority ) {
			prev = head;
			head = head.next;
		}
		if( prev == null ) {
			e.next = head;
			head.prev = e;
			pending = e;
		} else {
			var n = prev.next;
			if( n != null ) n.prev = e;
			e.next = n;
			prev.next = e;
			e.prev = prev;
		}
		return e;
	}
	
	/**
		Run the pending events. Return the time for next event.
	**/
	static function tick() {
		// TODO : it will be necessary to reorder the events based on nextRun before 
		//		  processing them so they get run in correct order. this can be done in MainEvent.delay() as well but might
		//		  cause ordering issues since we're processing events here
		var e = pending;
		var now = haxe.Timer.stamp();
		var wait = 1e9;
		while( e != null ) {
			var next = e.next;
			if( e.nextRun == null ) {
				wait = 0;
				e.call();
			} else {
				var wt = e.nextRun - now;
				if( wt <= 0 ) {
					wait = 0;
					e.call();
				} else if( wait > wt )
					wait = wt;
			}
			e = next;
		}
		return wait;
	}

}