Object.assign(pc, function () {

/**

* @name pc.Application

* @class Default application which performs general setup code and initiates the main game loop.

* @description Create a new Application.

* @param {Element} canvas The canvas element

* @param {Object} options

* @param {pc.Keyboard} [options.keyboard] Keyboard handler for input

* @param {pc.Mouse} [options.mouse] Mouse handler for input

* @param {pc.TouchDevice} [options.touch] TouchDevice handler for input

* @param {pc.GamePads} [options.gamepads] Gamepad handler for input

* @param {String} [options.scriptPrefix] Prefix to apply to script urls before loading

* @param {String} [options.assetPrefix] Prefix to apply to asset urls before loading

* @param {Object} [options.graphicsDeviceOptions] Options object that is passed into the {@link pc.GraphicsDevice} constructor

*

* @example

* // Create application

* var app = new pc.Application(canvas, options);

* // Start game loop

* app.start()

*/

// PROPERTIES

/**

* @name pc.Application#scene

* @type {pc.Scene}

* @description The current {@link pc.Scene}

*/

/**

* @name pc.Application#timeScale

* @type {Number}

* @description Scales the global time delta.

*/

/**

* @name pc.Application#maxDeltaTime

* @type {Number}

* @description Clamps per-frame delta time to an upper bound. Useful since returning from a tab

* deactivation can generate huge values for dt, which can adversely affect game state. Defaults

* to 0.1 (seconds).

*/

/**

* @name pc.Application#assets

* @type {pc.AssetRegistry}

* @description The assets available to the application.

*/

/**

* @name pc.Application#graphicsDevice

* @type {pc.GraphicsDevice}

* @description The graphics device used by the application.

*/

/**

* @name pc.Application#systems

* @type {pc.ComponentSystemRegistry}

* @description The component systems.

*/

/**

* @name pc.Application#loader

* @type {pc.ResourceLoader}

* @description The resource loader.

*/

/**

* @name pc.Application#root

* @type {pc.Entity}

* @description The root {@link pc.Entity} of the application.

*/

/**

* @name pc.Application#keyboard

* @type {pc.Keyboard}

* @description The keyboard device.

*/

/**

* @name pc.Application#mouse

* @type {pc.Mouse}

* @description The mouse device.

*/

/**

* @name pc.Application#touch

* @type {pc.TouchDevice}

* @description Used to get touch events input.

*/

/**

* @name pc.Application#gamepads

* @type {pc.GamePads}

* @description Used to access GamePad input.

*/

/**

* @name pc.Application#elementInput

* @type {pc.ElementInput}

* @description Used to handle input for {@link pc.ElementComponent}s.

*/

/**

* @name pc.Application#scripts

* @type pc.ScriptRegistry

* @description The Script Registry of the Application

*/

/**

* @name pc.Application#batcher

* @type pc.BatchManager

* @description The Batch Manager of the Application

*/

/**

* @name pc.Application#autoRender

* @type Boolean

* @description When true (the default) the application's render function is called every frame.

*/

/**

* @name pc.Application#renderNextFrame

* @type Boolean

* @description If {@link pc.Application#autoRender} is false, set `app.renderNextFrame` true to force application to render the scene once next frame.

* @example

* // render the scene only while space key is pressed

* if (this.app.keyboard.isPressed(pc.KEY_SPACE)) {

* this.app.renderNextFrame = true;

* }

*/

var Application = function (canvas, options) {

options = options || {};

// Open the log

pc.log.open();

// Add event support

pc.events.attach(this);

// Store application instance

Application._applications[canvas.id] = this;

Application._currentApplication = this;

this._time = 0;

this.timeScale = 1;

this.maxDeltaTime = 0.1; // Maximum delta is 0.1s or 10 fps.

this.frame = 0; // the total number of frames the application has updated since start() was called

this.autoRender = true;

this.renderNextFrame = false;

this._librariesLoaded = false;

this._fillMode = pc.FILLMODE_KEEP_ASPECT;

this._resolutionMode = pc.RESOLUTION_FIXED;

this._allowResize = true;

// for compatibility

this.context = this;

this.graphicsDevice = new pc.GraphicsDevice(canvas, options.graphicsDeviceOptions);

this.stats = new pc.ApplicationStats(this.graphicsDevice);

this.systems = new pc.ComponentSystemRegistry();

this._audioManager = new pc.SoundManager(options);

this.loader = new pc.ResourceLoader();

this.scene = new pc.Scene();

this.root = new pc.Entity(this);

this.root._enabledInHierarchy = true;

this._enableList = [];

this._enableList.size = 0;

this.assets = new pc.AssetRegistry(this.loader);

if (options.assetPrefix) this.assets.prefix = options.assetPrefix;

this.scriptsOrder = options.scriptsOrder || [];

this.scripts = new pc.ScriptRegistry(this);

this._sceneRegistry = new pc.SceneRegistry(this);

var self = this;

this.defaultLayerWorld = new pc.Layer({

name: "World",

id: pc.LAYERID_WORLD

});

if (this.graphicsDevice.webgl2) {

// WebGL 2 depth layer just copies existing depth

this.defaultLayerDepth = new pc.Layer({

enabled: false,

name: "Depth",

id: pc.LAYERID_DEPTH,

onEnable: function () {

if (this.renderTarget) return;

var depthBuffer = new pc.Texture(self.graphicsDevice, {

format: pc.PIXELFORMAT_DEPTHSTENCIL,

width: self.graphicsDevice.width,

height: self.graphicsDevice.height

});

depthBuffer.minFilter = pc.FILTER_NEAREST;

depthBuffer.magFilter = pc.FILTER_NEAREST;

depthBuffer.addressU = pc.ADDRESS_CLAMP_TO_EDGE;

depthBuffer.addressV = pc.ADDRESS_CLAMP_TO_EDGE;

this.renderTarget = new pc.RenderTarget({

colorBuffer: null,

depthBuffer: depthBuffer,

autoResolve: false

});

self.graphicsDevice.scope.resolve("uDepthMap").setValue(depthBuffer);

},

onDisable: function () {

if (!this.renderTarget) return;

this.renderTarget._depthBuffer.destroy();

this.renderTarget.destroy();

this.renderTarget = null;

},

onPreRenderOpaque: function (cameraPass) { // resize depth map if needed

var gl = self.graphicsDevice.gl;

this.srcFbo = gl.getParameter(gl.FRAMEBUFFER_BINDING);

if (!this.renderTarget || (this.renderTarget.width !== self.graphicsDevice.width || this.renderTarget.height !== self.graphicsDevice.height)) {

this.onDisable();

this.onEnable();

}

// disable clearing

this.oldClear = this.cameras[cameraPass].camera._clearOptions;

this.cameras[cameraPass].camera._clearOptions = this.depthClearOptions;

},

onPostRenderOpaque: function (cameraPass) { // copy depth

if (!this.renderTarget) return;

this.cameras[cameraPass].camera._clearOptions = this.oldClear;

var gl = self.graphicsDevice.gl;

self.graphicsDevice.setRenderTarget(this.renderTarget);

self.graphicsDevice.updateBegin();

gl.bindFramebuffer(gl.READ_FRAMEBUFFER, this.srcFbo);

gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, this.renderTarget._glFrameBuffer);

gl.blitFramebuffer( 0, 0, this.renderTarget.width, this.renderTarget.height,

0, 0, this.renderTarget.width, this.renderTarget.height,

gl.DEPTH_BUFFER_BIT,

gl.NEAREST);

}

});

this.defaultLayerDepth.depthClearOptions = {

flags: 0

};

} else {

// WebGL 1 depth layer just renders same objects as in World, but with RGBA-encoded depth shader

this.defaultLayerDepth = new pc.Layer({

enabled: false,

name: "Depth",

id: pc.LAYERID_DEPTH,

shaderPass: pc.SHADER_DEPTH,

onEnable: function () {

if (this.renderTarget) return;

var colorBuffer = new pc.Texture(self.graphicsDevice, {

format: pc.PIXELFORMAT_R8_G8_B8_A8,

width: self.graphicsDevice.width,

height: self.graphicsDevice.height

});

colorBuffer.minFilter = pc.FILTER_NEAREST;

colorBuffer.magFilter = pc.FILTER_NEAREST;

colorBuffer.addressU = pc.ADDRESS_CLAMP_TO_EDGE;

colorBuffer.addressV = pc.ADDRESS_CLAMP_TO_EDGE;

this.renderTarget = new pc.RenderTarget(self.graphicsDevice, colorBuffer, {

depth: true,

stencil: self.graphicsDevice.supportsStencil

});

self.graphicsDevice.scope.resolve("uDepthMap").setValue(colorBuffer);

},

onDisable: function () {

if (!this.renderTarget) return;

this.renderTarget._colorBuffer.destroy();

this.renderTarget.destroy();

this.renderTarget = null;

},

onPostCull: function (cameraPass) {

// Collect all rendered mesh instances with the same render target as World has, depthWrite == true and prior to this layer to replicate blitFramebuffer on WebGL2

var visibleObjects = this.instances.visibleOpaque[cameraPass];

var visibleList = visibleObjects.list;

var visibleLength = 0;

var layers = self.scene.layers.layerList;

var subLayerEnabled = self.scene.layers.subLayerEnabled;

var isTransparent = self.scene.layers.subLayerList;

var rt = self.defaultLayerWorld.renderTarget;

var cam = this.cameras[cameraPass];

var layer;

var j;

var layerVisibleList, layerCamId, layerVisibleListLength, drawCall, transparent;

for (var i = 0; i < layers.length; i++) {

layer = layers[i];

if (layer === this) break;

if (layer.renderTarget !== rt || !layer.enabled || !subLayerEnabled[i]) continue;

layerCamId = layer.cameras.indexOf(cam);

if (layerCamId < 0) continue;

transparent = isTransparent[i];

layerVisibleList = transparent ? layer.instances.visibleTransparent[layerCamId] : layer.instances.visibleOpaque[layerCamId];

layerVisibleListLength = layerVisibleList.length;

layerVisibleList = layerVisibleList.list;

for (j = 0; j < layerVisibleListLength; j++) {

drawCall = layerVisibleList[j];

if (drawCall.material && drawCall.material.depthWrite && !drawCall._noDepthDrawGl1) {

visibleList[visibleLength] = drawCall;

visibleLength++;

}

}

}

visibleObjects.length = visibleLength;

},

onPreRenderOpaque: function (cameraPass) { // resize depth map if needed

if (!this.renderTarget || (this.renderTarget.width !== self.graphicsDevice.width || this.renderTarget.height !== self.graphicsDevice.height)) {

this.onDisable();

this.onEnable();

}

this.oldClear = this.cameras[cameraPass].camera._clearOptions;

this.cameras[cameraPass].camera._clearOptions = this.rgbaDepthClearOptions;

},

onDrawCall: function () {

self.graphicsDevice.setColorWrite(true, true, true, true);

},

onPostRenderOpaque: function (cameraPass) {

if (!this.renderTarget) return;

this.cameras[cameraPass].camera._clearOptions = this.oldClear;

}

});

this.defaultLayerDepth.rgbaDepthClearOptions = {

color: [254.0 / 255, 254.0 / 255, 254.0 / 255, 254.0 / 255],

depth: 1.0,

flags: pc.CLEARFLAG_COLOR | pc.CLEARFLAG_DEPTH

};

}

this.defaultLayerSkybox = new pc.Layer({

enabled: false,

name: "Skybox",

id: pc.LAYERID_SKYBOX,

opaqueSortMode: pc.SORTMODE_NONE

});

this.defaultLayerUi = new pc.Layer({

enabled: true,

name: "UI",

id: pc.LAYERID_UI,

transparentSortMode: pc.SORTMODE_MANUAL,

passThrough: true

});

this.defaultLayerImmediate = new pc.Layer({

enabled: true,

name: "Immediate",

id: pc.LAYERID_IMMEDIATE,

opaqueSortMode: pc.SORTMODE_NONE,

passThrough: true

});

this.defaultLayerComposition = new pc.LayerComposition();

this.defaultLayerComposition.pushOpaque(this.defaultLayerWorld);

this.defaultLayerComposition.pushOpaque(this.defaultLayerDepth);

this.defaultLayerComposition.pushOpaque(this.defaultLayerSkybox);

this.defaultLayerComposition.pushTransparent(this.defaultLayerWorld);

this.defaultLayerComposition.pushOpaque(this.defaultLayerImmediate);

this.defaultLayerComposition.pushTransparent(this.defaultLayerImmediate);

this.defaultLayerComposition.pushTransparent(this.defaultLayerUi);

this.scene.layers = this.defaultLayerComposition;

this._immediateLayer = this.defaultLayerImmediate;

// Default layers patch

this.scene.on('set:layers', function (oldComp, newComp) {

var list = newComp.layerList;

var layer;

for (var i = 0; i < list.length; i++) {

layer = list[i];

switch (layer.id) {

case pc.LAYERID_DEPTH:

layer.onEnable = self.defaultLayerDepth.onEnable;

layer.onDisable = self.defaultLayerDepth.onDisable;

layer.onPreRenderOpaque = self.defaultLayerDepth.onPreRenderOpaque;

layer.onPostRenderOpaque = self.defaultLayerDepth.onPostRenderOpaque;

layer.depthClearOptions = self.defaultLayerDepth.depthClearOptions;

layer.rgbaDepthClearOptions = self.defaultLayerDepth.rgbaDepthClearOptions;

layer.shaderPass = self.defaultLayerDepth.shaderPass;

layer.onPostCull = self.defaultLayerDepth.onPostCull;

layer.onDrawCall = self.defaultLayerDepth.onDrawCall;

break;

case pc.LAYERID_UI:

layer.passThrough = self.defaultLayerUi.passThrough;

break;

case pc.LAYERID_IMMEDIATE:

layer.passThrough = self.defaultLayerImmediate.passThrough;

break;

}

}

});

this.renderer = new pc.ForwardRenderer(this.graphicsDevice);

this.renderer.scene = this.scene;

this.lightmapper = new pc.Lightmapper(this.graphicsDevice, this.root, this.scene, this.renderer, this.assets);

this.once('prerender', this._firstBake, this);

this.batcher = new pc.BatchManager(this.graphicsDevice, this.root, this.scene);

this.once('prerender', this._firstBatch, this);

this.keyboard = options.keyboard || null;

this.mouse = options.mouse || null;

this.touch = options.touch || null;

this.gamepads = options.gamepads || null;

this.elementInput = options.elementInput || null;

if (this.elementInput)

this.elementInput.app = this;

this.vr = null;

// you can enable vr here, or in application properties

if (options.vr) {

this._onVrChange(options.vr);

}

this._inTools = false;

this._skyboxLast = 0;

this._scriptPrefix = options.scriptPrefix || '';

this.loader.addHandler("animation", new pc.AnimationHandler());

this.loader.addHandler("model", new pc.ModelHandler(this.graphicsDevice));

this.loader.addHandler("material", new pc.MaterialHandler(this));

this.loader.addHandler("texture", new pc.TextureHandler(this.graphicsDevice, this.assets, this.loader));

this.loader.addHandler("text", new pc.TextHandler());

this.loader.addHandler("json", new pc.JsonHandler());

this.loader.addHandler("audio", new pc.AudioHandler(this._audioManager));

this.loader.addHandler("script", new pc.ScriptHandler(this));

this.loader.addHandler("scene", new pc.SceneHandler(this));

this.loader.addHandler("cubemap", new pc.CubemapHandler(this.graphicsDevice, this.assets, this.loader));

this.loader.addHandler("html", new pc.HtmlHandler());

this.loader.addHandler("css", new pc.CssHandler());

this.loader.addHandler("shader", new pc.ShaderHandler());

this.loader.addHandler("hierarchy", new pc.HierarchyHandler(this));

this.loader.addHandler("scenesettings", new pc.SceneSettingsHandler(this));

this.loader.addHandler("folder", new pc.FolderHandler());

this.loader.addHandler("font", new pc.FontHandler(this.loader));

this.loader.addHandler("binary", new pc.BinaryHandler());

this.loader.addHandler("textureatlas", new pc.TextureAtlasHandler(this.loader));

this.loader.addHandler("sprite", new pc.SpriteHandler(this.assets, this.graphicsDevice));

new pc.RigidBodyComponentSystem(this);

new pc.CollisionComponentSystem(this);

new pc.AnimationComponentSystem(this);

new pc.ModelComponentSystem(this);

new pc.CameraComponentSystem(this);

new pc.LightComponentSystem(this);

if (pc.script.legacy) {

new pc.ScriptLegacyComponentSystem(this);

} else {

new pc.ScriptComponentSystem(this);

}

new pc.AudioSourceComponentSystem(this, this._audioManager);

new pc.SoundComponentSystem(this, this._audioManager);

new pc.AudioListenerComponentSystem(this, this._audioManager);

new pc.ParticleSystemComponentSystem(this);

new pc.ScreenComponentSystem(this);

new pc.ElementComponentSystem(this);

new pc.ButtonComponentSystem(this);

new pc.ScrollViewComponentSystem(this);

new pc.ScrollbarComponentSystem(this);

new pc.SpriteComponentSystem(this);

new pc.LayoutGroupComponentSystem(this);

new pc.LayoutChildComponentSystem(this);

new pc.ZoneComponentSystem(this);

this._visibilityChangeHandler = this.onVisibilityChange.bind(this);

// Depending on browser add the correct visibiltychange event and store the name of the hidden attribute

// in this._hiddenAttr.

if (document.hidden !== undefined) {

this._hiddenAttr = 'hidden';

document.addEventListener('visibilitychange', this._visibilityChangeHandler, false);

} else if (document.mozHidden !== undefined) {

this._hiddenAttr = 'mozHidden';

document.addEventListener('mozvisibilitychange', this._visibilityChangeHandler, false);

} else if (document.msHidden !== undefined) {

this._hiddenAttr = 'msHidden';

document.addEventListener('msvisibilitychange', this._visibilityChangeHandler, false);

} else if (document.webkitHidden !== undefined) {

this._hiddenAttr = 'webkitHidden';

document.addEventListener('webkitvisibilitychange', this._visibilityChangeHandler, false);

}

// bind tick function to current scope

this.tick = makeTick(this);

};

Application._currentApplication = null;

Application._applications = {};

Application.getApplication = function (id) {

return id ? Application._applications[id] : Application._currentApplication;

};

// Mini-object used to measure progress of loading sets

var Progress = function (length) {

this.length = length;

this.count = 0;

this.inc = function () {

this.count++;

};

this.done = function () {

return (this.count === this.length);

};

};

Object.assign(Application.prototype, {

/**

* @function

* @name pc.Application#configure

* @description Load the application configuration file and apply application properties and fill the asset registry

* @param {String} url The URL of the configuration file to load

* @param {Function} callback The Function called when the configuration file is loaded and parsed

*/

configure: function (url, callback) {

var self = this;

pc.http.get(url, function (err, response) {

if (err) {

callback(err);

return;

}

var props = response.application_properties;

var scenes = response.scenes;

var assets = response.assets;

self._parseApplicationProperties(props, function (err) {

self._onVrChange(props.vr);

self._parseScenes(scenes);

self._parseAssets(assets);

if (!err) {

callback(null);

} else {

callback(err);

}

});

});

},

/**

* @function

* @name pc.Application#preload

* @description Load all assets in the asset registry that are marked as 'preload'

* @param {Function} callback Function called when all assets are loaded

*/

preload: function (callback) {

var self = this;

self.fire("preload:start");

// get list of assets to preload

var assets = this.assets.list({

preload: true

});

var _assets = new Progress(assets.length);

var _done = false;

// check if all loading is done

var done = function () {

// do not proceed if application destroyed

if (!self.graphicsDevice) {

return;

}

if (!_done && _assets.done()) {

_done = true;

self.fire("preload:end");

callback();

}

};

// totals loading progress of assets

var total = assets.length;

var count = function () {

return _assets.count;

};

var i;

if (_assets.length) {

var onAssetLoad = function (asset) {

_assets.inc();

self.fire('preload:progress', count() / total);

if (_assets.done())

done();

};

var onAssetError = function (err, asset) {

_assets.inc();

self.fire('preload:progress', count() / total);

if (_assets.done())

done();

};

// for each asset

for (i = 0; i < assets.length; i++) {

if (!assets[i].loaded) {

assets[i].once('load', onAssetLoad);

assets[i].once('error', onAssetError);

this.assets.load(assets[i]);

} else {

_assets.inc();

self.fire("preload:progress", count() / total);

if (_assets.done())

done();

}

}

} else {

done();

}

},

/**

* @function

* @name pc.Application#getSceneUrl

* @description Look up the URL of the scene hierarchy file via the name given to the scene in the editor. Use this to in {@link pc.Application#loadSceneHierarchy}.

* @param {String} name The name of the scene file given in the Editor

* @returns {String} The URL of the scene file

*/

getSceneUrl: function (name) {

var entry = this._sceneRegistry.find(name);

if (entry) {

return entry.url;

}

return null;

},

/**

* @function

* @name pc.Application#loadSceneHierarchy

* @description Load a scene file, create and initialize the Entity hierarchy

* and add the hierarchy to the application root Entity.

* @param {String} url The URL of the scene file. Usually this will be "scene_id.json"

* @param {Function} callback The function to call after loading, passed (err, entity) where err is null if no errors occurred.

* @example

*

* app.loadSceneHierarchy("1000.json", function (err, entity) {

* if (!err) {

* var e = app.root.find("My New Entity");

* } else {

* // error

* }

* }

* });

*/

loadSceneHierarchy: function (url, callback) {

this._sceneRegistry.loadSceneHierarchy(url, callback);

},

/**

* @function

* @name pc.Application#loadSceneSettings

* @description Load a scene file and apply the scene settings to the current scene

* @param {String} url The URL of the scene file. Usually this will be "scene_id.json"

* @param {Function} callback The function called after the settings are applied. Passed (err) where err is null if no error occurred.

* @example

* app.loadSceneSettings("1000.json", function (err) {

* if (!err) {

* // success

* } else {

* // error

* }

* }

* });

*/

loadSceneSettings: function (url, callback) {

this._sceneRegistry.loadSceneSettings(url, callback);

},

loadScene: function (url, callback) {

this._sceneRegistry.loadScene(url, callback);

},

_preloadScripts: function (sceneData, callback) {

if (!pc.script.legacy) {

callback();

return;

}

var self = this;

self.systems.script.preloading = true;

var scripts = this._getScriptReferences(sceneData);

var i = 0, l = scripts.length;

var progress = new Progress(l);

var scriptUrl;

var regex = /^http(s)?:\/\//;

if (l) {

var onLoad = function (err, ScriptType) {

if (err)

console.error(err);

progress.inc();

if (progress.done()) {

self.systems.script.preloading = false;

callback();

}

};

for (i = 0; i < l; i++) {

scriptUrl = scripts[i];

// support absolute URLs (for now)

if (!regex.test(scriptUrl.toLowerCase()) && self._scriptPrefix)

scriptUrl = pc.path.join(self._scriptPrefix, scripts[i]);

this.loader.load(scriptUrl, 'script', onLoad);

}

} else {

self.systems.script.preloading = false;

callback();

}

},

// set application properties from data file

_parseApplicationProperties: function (props, callback) {

var i;

var len;

// TODO: remove this temporary block after migrating properties

if (!props.useDevicePixelRatio)

props.useDevicePixelRatio = props.use_device_pixel_ratio;

if (!props.resolutionMode)

props.resolutionMode = props.resolution_mode;

if (!props.fillMode)

props.fillMode = props.fill_mode;

if (!props.vrPolyfillUrl)

props.vrPolyfillUrl = props.vr_polyfill_url;

this._width = props.width;

this._height = props.height;

if (props.useDevicePixelRatio) {

this.graphicsDevice.maxPixelRatio = window.devicePixelRatio;

}

this.setCanvasResolution(props.resolutionMode, this._width, this._height);

this.setCanvasFillMode(props.fillMode, this._width, this._height);

// if VR is enabled in the project and there is no native VR support

// load the polyfill

if (props.vr && props.vrPolyfillUrl) {

if (!pc.VrManager.isSupported || pc.platform.android) {

props.libraries.push(props.vrPolyfillUrl);

}

}

// set up layers

if (props.layers && props.layerOrder) {

var composition = new pc.LayerComposition();

var layers = {};

for (var key in props.layers) {

var data = props.layers[key];

data.id = parseInt(key, 10);

// depth layer should only be enabled when needed

// by incrementing its ref counter

data.enabled = data.id !== pc.LAYERID_DEPTH;

layers[key] = new pc.Layer(data);

}

for (i = 0, len = props.layerOrder.length; i < len; i++) {

var sublayer = props.layerOrder[i];

var layer = layers[sublayer.layer];

if (!layer) continue;

if (sublayer.transparent) {

composition.pushTransparent(layer);

} else {

composition.pushOpaque(layer);

}

composition.subLayerEnabled[i] = sublayer.enabled;

}

this.scene.layers = composition;

}

// add batch groups

if (props.batchGroups) {

for (i = 0, len = props.batchGroups.length; i < len; i++) {

var grp = props.batchGroups[i];

this.batcher.addGroup(grp.name, grp.dynamic, grp.maxAabbSize, grp.id, grp.layers);

}

}

this._loadLibraries(props.libraries, callback);

},

_loadLibraries: function (urls, callback) {

var len = urls.length;

var count = len;

var self = this;

var regex = /^http(s)?:\/\//;

if (len) {

var onLoad = function (err, script) {

count--;

if (err) {

callback(err);

} else if (count === 0) {

self.onLibrariesLoaded();

callback(null);

}

};

for (var i = 0; i < len; ++i) {

var url = urls[i];

if (!regex.test(url.toLowerCase()) && self._scriptPrefix)

url = pc.path.join(self._scriptPrefix, url);

this.loader.load(url, 'script', onLoad);

}

} else {

callback(null);

}

},

// insert scene name/urls into the registry

_parseScenes: function (scenes) {

if (!scenes) return;

for (var i = 0; i < scenes.length; i++) {

this._sceneRegistry.add(scenes[i].name, scenes[i].url);

}

},

// insert assets into registry

_parseAssets: function (assets) {

var i, id;

var list = [];

var scriptsIndex = { };

if (!pc.script.legacy) {

// add scripts in order of loading first

for (i = 0; i < this.scriptsOrder.length; i++) {

id = this.scriptsOrder[i];

if (!assets[id])

continue;

scriptsIndex[id] = true;

list.push(assets[id]);

}

// then add rest of assets

for (id in assets) {

if (scriptsIndex[id])

continue;

list.push(assets[id]);

}

} else {

for (id in assets)

list.push(assets[id]);

}

for (i = 0; i < list.length; i++) {

var data = list[i];

var asset = new pc.Asset(data.name, data.type, data.file, data.data);

asset.id = parseInt(data.id, 10);

asset.preload = data.preload ? data.preload : false;

// tags

asset.tags.add(data.tags);

// registry

this.assets.add(asset);

}

},

_getScriptReferences: function (scene) {

var i, key;

var priorityScripts = [];

if (scene.settings.priority_scripts) {

priorityScripts = scene.settings.priority_scripts;

}

var _scripts = [];

var _index = {};

// first add priority scripts

for (i = 0; i < priorityScripts.length; i++) {

_scripts.push(priorityScripts[i]);

_index[priorityScripts[i]] = true;

}

// then iterate hierarchy to get referenced scripts

var entities = scene.entities;

for (key in entities) {

if (!entities[key].components.script) {

continue;

}

var scripts = entities[key].components.script.scripts;

for (i = 0; i < scripts.length; i++) {

if (_index[scripts[i].url])

continue;

_scripts.push(scripts[i].url);

_index[scripts[i].url] = true;

}

}

return _scripts;

},

/**

* @function

* @name pc.Application#start

* @description Start the Application updating

*/

start: function () {

this.frame = 0;

this.fire("start", {

timestamp: pc.now(),

target: this

});

if (!this._librariesLoaded) {

this.onLibrariesLoaded();

}

pc.ComponentSystem.initialize(this.root);

this.fire("initialize");

pc.ComponentSystem.postInitialize(this.root);

this.fire("postinitialize");

this.tick();

},

/**

* @function

* @name pc.Application#update

* @description Application specific update method. Override this if you have a custom Application

* @param {Number} dt The time delta since the last frame.

*/

update: function (dt) {

this.frame++;

this.graphicsDevice.updateClientRect();

if (this.vr) this.vr.poll();

// #ifdef PROFILER

this.stats.frame.updateStart = pc.now();

// #endif

// Perform ComponentSystem update

if (pc.script.legacy)

pc.ComponentSystem.fixedUpdate(1.0 / 60.0, this._inTools);

pc.ComponentSystem.update(dt, this._inTools);

pc.ComponentSystem.postUpdate(dt, this._inTools);

// fire update event

this.fire("update", dt);

if (this.controller) {

this.controller.update(dt);

}

if (this.mouse) {

this.mouse.update(dt);

}

if (this.keyboard) {

this.keyboard.update(dt);

}

if (this.gamepads) {

this.gamepads.update(dt);