")
.html(msg));
});
}
return false;
},
/**
* Prints the version of the engine.
* @memberOf Engine
*/
toString: function() {
return "The Render Engine " + this.version;
},
//====================================================================================================
//====================================================================================================
// THE WORLD TIMER
//====================================================================================================
//====================================================================================================
/**
* This is the process which updates the world. It starts with the default
* context, telling it to update itself. Since each context is a container,
* all of the objects in the container will be called to update, and then
* render themselves.
*
* @private
* @memberOf Engine
*/
engineTimer: function() {
if (Engine.shuttingDown) {
return;
}
var nextFrame = Engine.fpsClock;
// Update the world
if (Engine.running && Engine.getDefaultContext() != null) {
Engine.vObj = 0;
// Render a frame
Engine.worldTime = new Date().getTime();
Engine.getDefaultContext().update(null, Engine.worldTime);
Engine.frameTime = new Date().getTime() - Engine.worldTime;
Engine.liveTime = Engine.worldTime - Engine.upTime;
// Determine when the next frame should draw
// If we've gone over the allotted time, wait until the next available frame
var f = nextFrame - Engine.frameTime;
nextFrame = (Engine.skipFrames ? (f > 0 ? f : nextFrame) : Engine.fpsClock);
Engine.droppedFrames += (f <= 0 ? Math.round((f * -1) / Engine.fpsClock) : 0);
// Output any metrics
if (Engine.showMetricsWindow) {
Engine.renderMetrics();
} else if (!Engine.showMetricsWindow && Engine.metricDisplay) {
Engine.metricDisplay.remove();
Engine.metricDisplay = null;
}
}
// When the process is done, start all over again
Engine.globalTimer = setTimeout(function _engineTimer() { Engine.engineTimer(); }, nextFrame);
}
}, { // Interface
globalTimer: null
});
/**
* The Render Engine
*
* An extension to the engine for script loading and processing.
*
* @author: Brett Fattori (brettf@renderengine.com)
*
* @author: $Author$
* @version: $Revision$
*
* Copyright (c) 2010 Brett Fattori (brettf@renderengine.com)
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
//====================================================================================================
//====================================================================================================
// SCRIPT PROCESSING
//====================================================================================================
//====================================================================================================
var Engine = Engine.extend({
/** @lends Engine */
constructor: null,
/*
* Script queue
*/
scriptQueue: [],
loadedScripts: {}, // Cache of loaded scripts
scriptLoadCount: 0, // Number of queued scripts to load
scriptsProcessed: 0, // Number of scripts processed
scriptRatio: 0, // Ratio between processed/queued
queuePaused:false, // Script queue paused flag
pauseReps: 0, // Queue run repetitions while paused
/**
* Status message when a script is not found
* @memberOf Engine
*/
SCRIPT_NOT_FOUND: false,
/**
* Status message when a script is successfully loaded
* @memberOf Engine
*/
SCRIPT_LOADED: true,
/**
* Include a script file.
*
* @param scriptURL {String} The URL of the script file
* @memberOf Engine
*/
include: function(scriptURL) {
Engine.loadNow(scriptURL);
},
/**
* Perform an immediate load on the specified script. Objects within
* the script may not immediately initialize, unless their dependencies
* have been resolved.
*
* @param {String} scriptPath The path to the script to load
* @param {Function} [cb] The function to call when the script is loaded.
* the path of the script loaded and a status message
* will be passed as the two parameters.
* @memberOf Engine
* @private
*/
loadNow: function(scriptPath, cb) {
this.doLoad(this.getEnginePath() + scriptPath, scriptPath, cb);
},
/**
* Queue a script to load from the server and append it to
* the head element of the browser. Script names are
* cached so they will not be loaded again. Each script in the
* queue is processed synchronously.
*
* @param scriptPath {String} The URL of a script to load.
* @memberOf Engine
*/
loadScript: function(scriptPath, owner) {
// Put script into load queue
Engine.scriptQueue.push(scriptPath);
Engine.runScriptQueue();
},
/**
* Internal method which runs the script queue to handle scripts and functions
* which are queued to run sequentially.
* @private
* @memberOf Engine
*/
runScriptQueue: function() {
if (!Engine.scriptQueueTimer) {
// Process any waiting scripts
Engine.scriptQueueTimer = setInterval(function() {
if (Engine.queuePaused) {
if (Engine.pauseReps++ > 500) {
// If after ~5 seconds the queue is still paused, unpause it and
// warn the user that the situation occurred
Console.error("Script queue was paused for 5 seconds and not resumed -- restarting...");
Engine.pauseReps = 0;
Engine.pauseQueue(false);
}
return;
}
Engine.pauseReps = 0;
if (Engine.scriptQueue.length > 0) {
Engine.processScriptQueue();
} else {
// Stop the queue timer if there are no scripts
clearInterval(Engine.scriptQueueTimer);
Engine.scriptQueueTimer = null;
}
}, 10);
Engine.readyForNextScript = true;
}
},
/**
* Put a callback into the script queue so that when a
* certain number of files has been loaded, we can call
* a method. Allows for functionality to start with
* incremental loading.
*
* @param cb {Function} A callback to execute
* @memberOf Engine
*/
setQueueCallback: function(cb) {
// Put callback into load queue
Engine.scriptQueue.push(cb);
Engine.runScriptQueue();
},
/**
* You can pause the queue from a callback function, then
* unpause it to continue processing queued scripts. This will
* allow you to wait for an event to occur before continuing to
* to load scripts.
*
* @param state {Boolean}
true to put the queue processor
* in a paused state.
* @memberOf Engine
*/
pauseQueue: function(state) {
Engine.queuePaused = state;
},
/**
* Process any scripts that are waiting to be loaded.
* @private
* @memberOf Engine
*/
processScriptQueue: function() {
if (Engine.scriptQueue.length > 0 && Engine.readyForNextScript) {
// Hold the queue until the script is loaded
Engine.readyForNextScript = false;
// Get next script...
var scriptPath = Engine.scriptQueue.shift();
// If the queue element is a function, execute it and return
if (typeof scriptPath === "function") {
scriptPath();
Engine.readyForNextScript = true;
return;
}
this.doLoad(scriptPath);
}
},
/**
* This method performs the actual script loading.
* @private
* @memberOf Engine
*/
doLoad: function(scriptPath, simplePath, cb) {
if (!this.started) {
return;
}
var s = scriptPath.replace(/[\/\.]/g,"_");
if (this.loadedScripts[s] == null)
{
// Store the request in the cache
this.loadedScripts[s] = scriptPath;
Engine.scriptLoadCount++;
Engine.updateProgress();
if ($.browser.Wii) {
$.get(scriptPath, function(data) {
// Parse script code for syntax errors
if (Engine.parseSyntax(data)) {
var n = document.createElement("script");
n.type = "text/javascript";
$(n).text(data);
var h = document.getElementsByTagName("head")[0];
h.appendChild(n);
Engine.readyForNextScript = true;
Engine.scriptLoadCount--;
Engine.updateProgress();
Console.debug("Loaded '" + scriptPath + "'");
}
}, "text");
} else {
// We'll use our own script loader so we can detect errors (i.e. missing files).
var n = document.createElement("script");
n.src = scriptPath;
n.type = "text/javascript";
// When the file is loaded
var fn = function() {
if (!this.readyState || this.readyState == "loaded" || this.readyState == "complete") {
Console.debug("Loaded '" + scriptPath + "'");
Engine.handleScriptDone();
if (cb) {
cb(simplePath, Engine.SCRIPT_LOADED);
}
if (!Engine.localMode) {
// Delete the script node
$(n).remove();
}
}
Engine.readyForNextScript = true;
};
// When an error occurs
var eFn = function(msg) {
Console.error("File not found: ", scriptPath);
if (cb) {
cb(simplePath, Engine.SCRIPT_NOT_FOUND);
}
Engine.readyForNextScript = true;
};
if ($.browser.msie) {
n.defer = true;
n.onreadystatechange = fn;
n.onerror = eFn;
} else {
n.onload = fn;
n.onerror = eFn;
}
var h = document.getElementsByTagName("head")[0];
h.appendChild(n);
}
} else {
// Already have this script
Engine.readyForNextScript = true;
}
},
/**
* Loads a game's script. This will wait until the specified
*
gameObjectName is available before running it. Doing so will
* ensure that all dependencies have been resolved before starting a game.
* Also creates the default rendering context for the engine.
*
* All games should execute this method to start their processing, rather than
* using the script loading mechanism for engine or game scripts. This is used
* for the main game script only. Normally it would appear in the game's "index" file.
*
* <script type="text/javascript">
* // Load the game script
* Engine.loadGame('game.js','Spaceroids');
* </script>
*
*
* @param gameSource {String} The URL of the game script.
* @param gameObjectName {String} The string name of the game object to execute. When
* the framework if ready, the
startup() method of this
* object will be called.
* @param [gameDisplayName] {String} An optional string to display in the loading dialog
* @memberOf Engine
*/
loadGame: function(gameSource, gameObjectName/* , gameDisplayName */) {
var gameDisplayName = arguments[2] || gameObjectName;
$(document).ready(function() {
// Determine if the developer has provided a "loading" element of their own
if ($("span.loading").length == 0) {
// They haven't, so create one for them
$("head").append($(Engine.loadingCSS));
var loadingDialog = "
";
loadingDialog += "Loading ";
loadingDialog += gameDisplayName + "... |
";
$("body",document).append($(loadingDialog));
}
});
// We'll wait for the Engine to be ready before we load the game
var engine = this;
Engine.gameLoadTimer = setInterval(function() {
if (window["DocumentContext"] != null) {
// Start the engine
Engine.run();
// Stop the timer
clearInterval(Engine.gameLoadTimer);
Engine.gameLoadTimer = null;
// Load the game
Console.debug("Loading '" + gameSource + "'");
engine.loadScript(gameSource);
// Start the game when it's ready
if (gameObjectName) {
Engine.gameRunTimer = setInterval(function() {
if (typeof window[gameObjectName] != "undefined" &&
window[gameObjectName].setup) {
clearInterval(Engine.gameRunTimer);
Console.warn("Starting: " + gameObjectName);
// Remove the "loading" message (if we provided it)
$("#loading.intrinsic").remove();
// Start the game
window[gameObjectName].setup();
}
}, 100);
}
}
}, 2);
},
/**
* Load a script relative to the engine path. A simple helper method which calls
* {@link #loadScript} and prepends the engine path to the supplied script source.
*
* @param scriptSource {String} A URL to load that is relative to the engine path.
* @memberOf Engine
*/
load: function(scriptSource) {
this.loadScript(this.getEnginePath() + scriptSource);
},
/**
* After a script has been loaded, updates the progress
* @private
* @memberOf Engine
*/
handleScriptDone: function() {
Engine.scriptsProcessed++;
Engine.scriptRatio = Engine.scriptsProcessed / Engine.scriptLoadCount;
Engine.scriptRatio = Engine.scriptRatio > 1 ? 1 : Engine.scriptRatio;
Engine.updateProgress();
},
/**
* Updates the progress bar (if available)
* @private
* @memberOf Engine
*/
updateProgress: function() {
var pBar = jQuery("#engine-load-progress");
if (pBar.length > 0) {
// Update their progress bar
if (pBar.css("position") != "relative" || pBar.css("position") != "absolute") {
pBar.css("position", "relative");
}
var pW = pBar.width();
var fill = Math.floor(pW * Engine.scriptRatio);
var fBar = jQuery("#engine-load-progress .bar");
if (fBar.length == 0) {
fBar = jQuery("
");
pBar.append(fBar);
}
fBar.width(fill);
jQuery("#engine-load-info").text(Engine.scriptsProcessed + " of " + Engine.scriptLoadCount);
}
},
/**
* Load a stylesheet and append it to the document. Allows for
* scripts to specify additional stylesheets that can be loaded
* as needed. Additionally, you can use thise method to inject
* the engine path into the css being loaded. Using the variable
*
$<enginePath>, you can load css relative to the
* engine's path. For example:
*
* .foo {
* background: url('$<enginePath>/myGame/images/bar.png') no-repeat 50% 50%;
* }
*
*
* @param stylesheetPath {String} Path to the stylesheet, relative to
* the engine path.
* @memberOf Engine
*/
loadStylesheet: function(stylesheetPath, relative) {
stylesheetPath = (relative ? "" : this.getEnginePath()) + stylesheetPath;
var f = function() {
$.get(stylesheetPath, function(data) {
// process the data to replace the "enginePath" variable
var epRE = /(\$
)/g;
data = data.replace(epRE, Engine.getEnginePath());
$("head", document).append($("").text(data));
Console.debug("Stylesheet loaded '" + stylesheetPath + "'");
}, "text");
};
this.setQueueCallback(f);
},
/**
* Output the list of scripts loaded by the Engine to the console.
* @memberOf Engine
*/
dumpScripts: function() {
for (var f in this.loadedScripts)
{
Console.debug(this.loadedScripts[f]);
}
},
/**
* Clears the script name cache. Allows scripts to be loaded
* again. Use this method with caution, as it is not recommended
* to load a script if the object is in use. May cause unexpected
* results.
* @memberOf Engine
*/
clearScriptCache: function() {
this.loadedScripts = {};
}
});
/**
* The Render Engine
* Engine initialization
*
* @fileoverview Initializes the console and engine
*
* @author: Brett Fattori (brettf@renderengine.com)
* @author: $Author: bfattori $
* @version: $Revision: 1216 $
*
* Copyright (c) 2010 Brett Fattori (brettf@renderengine.com)
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
// Start the console so logging can take place immediately
Console.startup();
// Start the engine
Engine.startup();
// Set up the engine using whatever query params were passed
Engine.setDebugMode(EngineSupport.checkBooleanParam("debug"));
if (Engine.getDebugMode())
{
Console.setDebugLevel(EngineSupport.getNumericParam("debugLevel", Console.DEBUGLEVEL_DEBUG));
}
if (EngineSupport.checkBooleanParam("metrics"))
{
Engine.showMetrics();
}
// Local mode keeps loaded script source available
Engine.localMode = EngineSupport.checkBooleanParam("local");