java-game-lib-cvs Mailing List for Lightweight Java Game Library

Update of /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv31476/src/java/org/lwjgl

Modified Files:
	Sys.java 
Log Message:
Fixed up bugs and problems in new timer calibration code.

Index: Sys.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/Sys.java,v
retrieving revision 1.80
retrieving revision 1.81
diff -u -d -r1.80 -r1.81
--- Sys.java	8 Mar 2005 14:46:46 -0000	1.80
+++ Sys.java	8 Mar 2005 23:13:50 -0000	1.81
@@ -97,8 +97,8 @@
 	/** Current recalibration timer value, in milliseconds */
 	private static long recalibrationNow;
 	
-	/** Total hires ticks that have passed since we started using recalibrated time */
-	private static long ticksSinceRecalibration;
+	/** Hires time when we started counting recalibration time */
+	private static long hiresRecalibrationThen;
 
 	/** Last lowres timer time, in milliseconds */
 	private static long lowresThen;
@@ -223,23 +223,35 @@
 				
 				if (currentResolution == defaultResolution) {
 					// Start timing
-					ticksSinceRecalibration = 0L;
+					hiresRecalibrationThen = hiresNow;
 					recalibrationThen = lowresNow;
 					recalibrationNow = lowresNow;
 				} else {
 					// Continue counting ticks
-					ticksSinceRecalibration += getTime();
-					recalibrationNow = lowresNow;
-					long totalTicksSinceRecalibrationStarted = recalibrationNow - recalibrationThen;
-					if (totalTicksSinceRecalibrationStarted > LONG_RECALIBRATION_THRESHOLD) {
-						// Ok, we've now been operating at a different resolution for long enough.
-						// Let's choose a new default resolution based on the average we've
-						// calculated since it first started needing recalibrating
-						long actualRecalibrationDuration = recalibrationNow - recalibrationThen;
-						defaultResolution = (long) (1000.0 * totalTicksSinceRecalibrationStarted / actualRecalibrationDuration);
-						tempResolution = defaultResolution;
-						if (DEBUG_CALIBRATION) {
-							System.err.println("Permanent recalibration to "+defaultResolution+" ticks per second");
+					long ticksSinceRecalibration = hiresNow - hiresRecalibrationThen;
+					if (ticksSinceRecalibration < 0) {
+						// Bah. Wrapped timer, so forget it this time and start over.
+						hiresRecalibrationThen = hiresNow;
+						recalibrationThen = lowresNow;
+					} else {
+						recalibrationNow = lowresNow;
+						long totalMillisSinceRecalibrationStarted = recalibrationNow - recalibrationThen;
+						if (totalMillisSinceRecalibrationStarted > LONG_RECALIBRATION_THRESHOLD) {
+							// Ok, we've now been operating at a different resolution for long enough.
+							// Let's choose a new default resolution based on the average we've
+							// calculated since it first started needing recalibrating
+							long totalTicksSinceRecalibrationStarted = hiresNow - hiresRecalibrationThen;
+							if (totalTicksSinceRecalibrationStarted > 0) {
+								defaultResolution = (long) (1000.0 * totalTicksSinceRecalibrationStarted / totalMillisSinceRecalibrationStarted);
+								tempResolution = defaultResolution;
+								if (DEBUG_CALIBRATION) {
+									System.err.println("Permanent recalibration to "+defaultResolution+" ticks per second");
+								}
+							} else {
+								// Bah. Once again, a wrapped timer.
+								hiresRecalibrationThen = hiresNow;
+								recalibrationThen = lowresNow;
+							}
 						}
 					}
 				}
@@ -247,11 +259,6 @@
 				// Temporarily change current resolution to the recently calculated resolution
 				currentResolution = tempResolution;
 			} else {
-				// Recalibrate the baseline using the operating system
-				defaultResolution = implementation.getTimerResolution();
-				if (DEBUG_CALIBRATION && currentResolution != defaultResolution) {
-					System.err.println("Resetting to system calibration "+defaultResolution+" ticks per second");
-				}
 				currentResolution = defaultResolution;
 			}
 		}

Update of /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/opengl
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24338/src/java/org/lwjgl/opengl

Modified Files:
	AWTGLCanvas.java 
Log Message:
fixed loading of awt through use of loadLibrary on windows

Index: AWTGLCanvas.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/opengl/AWTGLCanvas.java,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9
--- AWTGLCanvas.java	23 Feb 2005 11:11:06 -0000	1.8
+++ AWTGLCanvas.java	8 Mar 2005 20:44:41 -0000	1.9
@@ -65,6 +65,7 @@
 		if (OS_NAME.startsWith("Linux")) {
 			class_name = "org.lwjgl.opengl.LinuxCanvasImplementation";
 		} else if (OS_NAME.startsWith("Windows")) {
+			System.loadLibrary("jawt");
 			class_name = "org.lwjgl.opengl.Win32CanvasImplementation";
 		} else if (OS_NAME.startsWith("Mac")) {
 			class_name = "org.lwjgl.opengl.MacOSXCanvasImplementation";

Update of /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv21698/src/java/org/lwjgl

Modified Files:
	Sys.java 
Log Message:
New auto-calibrating system hires timer.

Index: Sys.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/Sys.java,v
retrieving revision 1.79
retrieving revision 1.80
diff -u -d -r1.79 -r1.80
--- Sys.java	23 Feb 2005 11:22:14 -0000	1.79
+++ Sys.java	8 Mar 2005 14:46:46 -0000	1.80
@@ -55,13 +55,69 @@
 
 	/** Debug flag. */
 	public static final boolean DEBUG = Boolean.getBoolean("org.lwjgl.Sys.debug");
-  
-  /** OS Name */
-  private final static String OS_NAME = System.getProperty("os.name");
+	
+  	/** OS Name */
+	private final static String OS_NAME = System.getProperty("os.name");
 
 	/** The implementation instance to delegate platform specific behavior to */
 	private final static SysImplementation implementation;
+	
+	/*
+	 * Timer calibration. The hires timers on some systems - notably SpeedStep chips,
+	 * HyperThreaded chips, or dual-processor/cores, are notoriously inaccurate. We
+	 * therefore need to calibrate the hires timer with a lowres timer that is known
+	 * to keep much more accurate time. System.currentTimeMillis() keeps accurate time
+	 * down to a worst-case resolution of 50ms, which is good enough for us as it means
+	 * at worst we will have 3-4 frames at the wrong rate if a hires timer resolution
+	 * change occurs.
+	 */
+
+	/** Master control: override all our clever recalibration */
+	private static final boolean OVERRIDE_CALIBRATION = Boolean.getBoolean("org.lwjgl.Sys.overrideCalibration");
+	
+	/** Turn on debugging for calibration */
+	private static final boolean DEBUG_CALIBRATION = Boolean.getBoolean("org.lwjgl.Sys.debugCalibration");
+	
+	/**
+	 * Timer calibration error, expressed as % variance either side of the baseline in the
+	 * system property org.lwjhgl.Sys.timerError. 35.0% is the default.
+	 */
+	private static final double UPPER_TIMER_ERROR = 1.0 + Double.parseDouble(System.getProperty("org.lwjgl.Sys.timerError", "35.0")) / 100.0;
+	private static final double LOWER_TIMER_ERROR = 1.0 - Double.parseDouble(System.getProperty("org.lwjgl.Sys.timerError", "35.0")) / 100.0;
+	
+	/** Short term recalibration threshold */
+	private static final long SHORT_RECALIBRATION_THRESHOLD = Long.parseLong(System.getProperty("org.lwjgl.Sys.shortRecalibrationThreshold", "50"));
+
+	/** Long term recalibration threshold */
+	private static final long LONG_RECALIBRATION_THRESHOLD = Long.parseLong(System.getProperty("org.lwjgl.Sys.longRecalibrationThreshold", "1000"));
+	
+	/** Last recalibration timer value, in milliseconds */
+	private static long recalibrationThen;
+	
+	/** Current recalibration timer value, in milliseconds */
+	private static long recalibrationNow;
+	
+	/** Total hires ticks that have passed since we started using recalibrated time */
+	private static long ticksSinceRecalibration;
 
+	/** Last lowres timer time, in milliseconds */
+	private static long lowresThen;
+	
+	/** Current lowres timer time, in milliseconds */
+	private static long lowresNow;
+	
+	/** Last hires timer time, in ticks */
+	private static long hiresThen;
+	
+	/** Current hires timer time, in ticks */
+	private static long hiresNow;
+	
+	/** Baseline hires resolution */
+	private static long defaultResolution;
+	
+	/** Current hires resolution */
+	private static long currentResolution;
+  
 	static {
 		implementation = createImplementation();
 		System.loadLibrary(LIBRARY_NAME);
@@ -117,12 +173,90 @@
 	}
 
 	/**
-	 * Obtains the number of ticks that the hires timer does in a second.
+	 * Obtains the number of ticks that the hires timer does in a second. This method is fast;
+	 * it should be called as frequently as possible, as it recalibrates the timer.
 	 *
 	 * @return timer resolution in ticks per second or 0 if no timer is present.
 	 */
 	public static long getTimerResolution() {
-		return implementation.getTimerResolution();
+		
+		// Check for explicit override
+		if (OVERRIDE_CALIBRATION) {
+			return implementation.getTimerResolution();
+		}
+		
+		// Firstly make sure we have at least some notion of a baseline
+		if (defaultResolution == 0L) {
+			defaultResolution = implementation.getTimerResolution();
+			currentResolution = defaultResolution;
+			if (DEBUG_CALIBRATION) {
+				System.err.println("Initial timer calibration "+defaultResolution+" ticks per second");
+			}
+		}
+		
+		lowresNow = System.currentTimeMillis() & 0x7FFFFFFFFFFFFFFFL;
+		hiresNow = getTime();
+		if (lowresNow > lowresThen + SHORT_RECALIBRATION_THRESHOLD && hiresNow > hiresThen) {
+			// We've had a lowres timer update. We can use this to calibrate the hires timer
+			// resolution.
+			double millis = lowresNow - lowresThen;
+			double ticks = hiresNow - hiresThen;
+			lowresThen = lowresNow;
+			hiresThen = hiresNow;
+			double ticksPerSecond = 1000.0 * ticks / millis;
+			// If the ticksPerSecond we've calcuated is out by more than the error % from
+			// the baseline resolution, we will discreetly replace the returned timer resolution
+			// by our calculated. If this persists for more than a second or so we will adjust
+			// the baseline resolution to the average that we've calculated over the second.
+			double errorRatio = ticksPerSecond / (double) defaultResolution;
+			if (errorRatio < LOWER_TIMER_ERROR || errorRatio > UPPER_TIMER_ERROR) {
+				// We're outside the acceptable range so we will use the newly calculated ticks
+				// per second. If we were already using recalibrated time, we start counting
+				// the ticks that pass over a certain length of time. If that duration is exceeded
+				// and we're still using recalibrated time, we permanently recalibrate.
+				
+				long tempResolution = (long) ticksPerSecond;
+				
+				if (DEBUG_CALIBRATION) {
+					System.err.println("Temporary recalibration to "+tempResolution+" ticks per second");
+				}
+				
+				if (currentResolution == defaultResolution) {
+					// Start timing
+					ticksSinceRecalibration = 0L;
+					recalibrationThen = lowresNow;
+					recalibrationNow = lowresNow;
+				} else {
+					// Continue counting ticks
+					ticksSinceRecalibration += getTime();
+					recalibrationNow = lowresNow;
+					long totalTicksSinceRecalibrationStarted = recalibrationNow - recalibrationThen;
+					if (totalTicksSinceRecalibrationStarted > LONG_RECALIBRATION_THRESHOLD) {
+						// Ok, we've now been operating at a different resolution for long enough.
+						// Let's choose a new default resolution based on the average we've
+						// calculated since it first started needing recalibrating
+						long actualRecalibrationDuration = recalibrationNow - recalibrationThen;
+						defaultResolution = (long) (1000.0 * totalTicksSinceRecalibrationStarted / actualRecalibrationDuration);
+						tempResolution = defaultResolution;
+						if (DEBUG_CALIBRATION) {
+							System.err.println("Permanent recalibration to "+defaultResolution+" ticks per second");
+						}
+					}
+				}
+
+				// Temporarily change current resolution to the recently calculated resolution
+				currentResolution = tempResolution;
+			} else {
+				// Recalibrate the baseline using the operating system
+				defaultResolution = implementation.getTimerResolution();
+				if (DEBUG_CALIBRATION && currentResolution != defaultResolution) {
+					System.err.println("Resetting to system calibration "+defaultResolution+" ticks per second");
+				}
+				currentResolution = defaultResolution;
+			}
+		}
+		
+		return currentResolution;
 	}
 
 	/**