options = options || {};

this._inTools = false;

// Add event support

pc.events.attach(this);

this.canvas = canvas;

this.fillMode = pc.fw.FillMode.KEEP_ASPECT;

this.resolutionMode = pc.fw.ResolutionMode.FIXED;

this.librariesLoaded = false;

this._link = new pc.fw.LiveLink("application");

this._link.addDestinationWindow(window);

this._link.listen(this._handleMessage.bind(this));

// Open the log

pc.log.open();

// Create the graphics device

this.graphicsDevice = new pc.gfx.Device(canvas);

// Enable validation of each WebGL command

this.graphicsDevice.enableValidation(false);

var registry = new pc.fw.ComponentSystemRegistry();

this.audioManager = new pc.audio.AudioManager();

// Create resource loader

var loader = new pc.resources.ResourceLoader();

if( options.cache === false )

loader.cache = false;

// Display shows debug loading information. Only really fit for debug display at the moment.

if (options.displayLoader) {

var loaderdisplay = new pc.resources.ResourceLoaderDisplay(document.body, loader);

}

// The ApplicationContext is passed to new Components and user scripts

this.context = new pc.fw.ApplicationContext(loader, new pc.scene.Scene(), this.graphicsDevice, registry, options);

if (options.content) {

this.content = options.content;

// Add the assets from all TOCs to the

Object.keys(this.content.toc).forEach(function (key) {

this.context.assets.addGroup(key, this.content.toc[key]);

}.bind(this));

}

// Enable new texture bank feature to cache textures

var textureCache = new pc.resources.TextureCache(loader);

loader.registerHandler(pc.resources.JsonRequest, new pc.resources.JsonResourceHandler());

loader.registerHandler(pc.resources.TextRequest, new pc.resources.TextResourceHandler());

loader.registerHandler(pc.resources.ImageRequest, new pc.resources.ImageResourceHandler());

loader.registerHandler(pc.resources.MaterialRequest, new pc.resources.MaterialResourceHandler( this.graphicsDevice, this.context.assets));

loader.registerHandler(pc.resources.TextureRequest, new pc.resources.TextureResourceHandler(this.graphicsDevice));

loader.registerHandler(pc.resources.ModelRequest, new pc.resources.ModelResourceHandler(this.graphicsDevice, this.context.assets));

loader.registerHandler(pc.resources.AnimationRequest, new pc.resources.AnimationResourceHandler());

loader.registerHandler(pc.resources.PackRequest, new pc.resources.PackResourceHandler(registry, options.depot));

loader.registerHandler(pc.resources.AudioRequest, new pc.resources.AudioResourceHandler(this.audioManager));

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

// Register the ScriptResourceHandler late as we need the context

loader.registerHandler(pc.resources.ScriptRequest, new pc.resources.ScriptResourceHandler(this.context, options.scriptPrefix));

var rigidbodysys = new pc.fw.RigidBodyComponentSystem(this.context);

var collisionsys = new pc.fw.CollisionComponentSystem(this.context);

var ballsocketjointsys = new pc.fw.BallSocketJointComponentSystem(this.context);

var animationsys = new pc.fw.AnimationComponentSystem(this.context);

var modelsys = new pc.fw.ModelComponentSystem(this.context);

var camerasys = new pc.fw.CameraComponentSystem(this.context);

var cubemapsys = new pc.fw.CubeMapComponentSystem(this.context);

var staticcubemapsys = new pc.fw.StaticCubeMapComponentSystem(this.context);

var lightsys = new pc.fw.LightComponentSystem(this.context);

var packsys = new pc.fw.PackComponentSystem(this.context);

var skyboxsys = new pc.fw.SkyboxComponentSystem(this.context);

var scriptsys = new pc.fw.ScriptComponentSystem(this.context);

var picksys = new pc.fw.PickComponentSystem(this.context);

var audiosourcesys = new pc.fw.AudioSourceComponentSystem(this.context, this.audioManager);

var audiolistenersys = new pc.fw.AudioListenerComponentSystem(this.context, this.audioManager);

var designersys = new pc.fw.DesignerComponentSystem(this.context);

// Load libraries

this.on('librariesloaded', this.onLibrariesLoaded, this);

if (options.libraries && options.libraries.length) {

var requests = options.libraries.map(function (url) {

return new pc.resources.ScriptRequest(url);

});

loader.request(requests).then( function (resources) {

this.fire('librariesloaded', this);

this.librariesLoaded = true;

}.bind(this));

} else {

this.fire('librariesloaded', this);

this.librariesLoaded = true;

}

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

// in this._hiddenAttr.

if (typeof document.hidden !== 'undefined') {

this._hiddenAttr = 'hidden';

document.addEventListener('visibilitychange', this.onVisibilityChange.bind(this), false);

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

this._hiddenAttr = 'mozHidden';

document.addEventListener('mozvisibilitychange', this.onVisibilityChange.bind(this), false);

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

this._hiddenAttr = 'msHidden';

document.addEventListener('msvisibilitychange', this.onVisibilityChange.bind(this), false);

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

this._hiddenAttr = 'webkitHidden';

document.addEventListener('webkitvisibilitychange', this.onVisibilityChange.bind(this), false);

}

// Store application instance

Application._applications[this.canvas.id] = this;

if (!this.content) {

error('No content');

}

var toc = this.content.toc[name];

success = success || function () {};

error = error || function () {};

progress = progress || function () {};

var requests = [];

var guid = toc.packs[0];

var onLoaded = function (resources) {

// load pack

this.context.loader.request(new pc.resources.PackRequest(guid)).then(function (resources) {

var pack = resources[0];

this.context.root.addChild(pack.hierarchy);

pc.fw.ComponentSystem.initialize(pack.hierarchy);

pc.fw.ComponentSystem.postInitialize(pack.hierarchy);

// Initialise pack settings

if (this.context.systems.rigidbody && typeof(Ammo) !== 'undefined') {

var gravity = pack.settings.physics.gravity;

this.context.systems.rigidbody.setGravity(gravity[0], gravity[1], gravity[2]);

}

var ambientLight = pack.settings.render.global_ambient;

this.context.scene.ambientLight = new pc.Color(ambientLight[0], ambientLight[1], ambientLight[2]);

this.context.scene.fog = pack.settings.render.fog;

var fogColor = pack.settings.render.fog_color;

this.context.scene.fogColor = new pc.Color(fogColor[0], fogColor[1], fogColor[2]);

this.context.scene.fogStart = pack.settings.render.fog_start;

this.context.scene.fogEnd = pack.settings.render.fog_end;

this.context.scene.fogDensity = pack.settings.render.fog_density;

this.context.scene.shadowDistance = pack.settings.render.shadow_distance;

success(pack);

this.context.loader.off('progress', progress);

}.bind(this), function (msg) {

error(msg);

}).then(null, function (error) {

// Re-throw any exceptions from the script's initialize method to stop them being swallowed by the Promises lib

setTimeout(function () {

throw error;

}, 0);

});

}.bind(this);

var load = function () {

// Get a list of asset for the first Pack

var assets = this.context.assets.list(guid);

// start recording loading progress from here

this.context.loader.on('progress', progress);

if (assets.length) {

this.context.assets.load(assets).then(function (resources) {

onLoaded(resources);

});

} else {

// No assets to load

setTimeout(function () {

onLoaded([]);

}, 0);

}

}.bind(this);

if (!this.librariesLoaded) {

this.on('librariesloaded', function () {

load();

});

} else {

load();

}

if (!this.librariesLoaded) {

this.on('librariesloaded', function () {

this.tick();

}, this);

} else {

this.tick();

}

var context = this.context;

// Perform ComponentSystem update

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

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

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

// fire update event

this.fire("update", dt);

if (context.controller) {

context.controller.update(dt);

}

if (context.mouse) {

context.mouse.update(dt);

}

if (context.keyboard) {

context.keyboard.update(dt);

}

if (context.gamepads) {

context.gamepads.update(dt);

}

var context = this.context;

var cameras = context.systems.camera.cameras;

var camera = null;

var renderer = this.renderer;

context.root.syncHierarchy();

// render the scene from each camera

for (var i=0,len=cameras.length; i<len; i++) {

camera = cameras[i];

camera.frameBegin();

renderer.render(context.scene, camera.camera);

camera.frameEnd();

}

// Submit a request to queue up a new animation frame immediately

requestAnimationFrame(this.tick.bind(this), this.canvas);

var now = (window.performance && window.performance.now) ? performance.now() : Date.now();

var dt = (now - (time || now)) / 1000.0;

time = now;

dt = pc.math.clamp(dt, 0, 0.1); // Maximum delta is 0.1s or 10 fps.

this.update(dt);

this.render();

this.resolutionMode = mode;

// In AUTO mode the resolution is the same as the canvas size, unless specified

if (mode === pc.fw.ResolutionMode.AUTO && (width === undefined)) {

width = this.canvas.clientWidth;

height = this.canvas.clientHeight;

}

this.graphicsDevice.resizeCanvas(width, height);

element = element || this.canvas;

// success callback

var s = function () {

success();

document.removeEventListener('fullscreenchange', s);

};

// error callback

var e = function () {

error();

document.removeEventListener('fullscreenerror', e);

};

if (success) {

document.addEventListener('fullscreenchange', s, false);

}

if (error) {

document.addEventListener('fullscreenerror', e, false);

}

element.requestFullscreen();

// success callback

var s = function () {

success();

document.removeEventListener('fullscreenchange', s);

};

if (success) {

document.addEventListener('fullscreenchange', s, false);

}

document.exitFullscreen();

if (this.isHidden()) {

this.audioManager.suspend();

} else {

this.audioManager.resume();

}

var windowWidth = window.innerWidth;

var windowHeight = window.innerHeight;

if (navigator.isCocoonJS) {

width = windowWidth;

height = windowHeight;

var ratio = window.devicePixelRatio;

this.graphicsDevice.resizeCanvas(width * ratio, height * ratio);

} else {

if (this.fillMode === pc.fw.FillMode.KEEP_ASPECT) {

var r = this.canvas.width/this.canvas.height;

var winR = windowWidth / windowHeight;

if (r > winR) {

width = windowWidth;

height = width / r ;

} else {

height = windowHeight;

width = height * r;

}

} else if (this.fillMode === pc.fw.FillMode.FILL_WINDOW) {

width = windowWidth;

height = windowHeight;

} else {

// FillMode.NONE use width and height that are provided

}

this.canvas.style.width = width + 'px';

this.canvas.style.height = height + 'px';

// In AUTO mode the resolution is changed to match the canvas size

if (this.resolutionMode === pc.fw.ResolutionMode.AUTO) {

this.setCanvasResolution(pc.fw.ResolutionMode.AUTO);

}

}

// return the final values calculated for width and height

return {

width: width,

height: height

};

// Create systems that may require external libraries

// var rigidbodysys = new pc.fw.RigidBodyComponentSystem(this.context);

// var collisionsys = new pc.fw.CollisionComponentSystem(this.context);

// var ballsocketjointsys = new pc.fw.BallSocketJointComponentSystem(this.context);

this.context.systems.rigidbody.onLibraryLoaded();

this.context.systems.collision.onLibraryLoaded();

var entity;

switch(msg.type) {

case pc.fw.LiveLinkMessageType.UPDATE_COMPONENT:

this._linkUpdateComponent(msg.content.id, msg.content.component, msg.content.attribute, msg.content.value);

break;

case pc.fw.LiveLinkMessageType.UPDATE_ENTITY:

this._linkUpdateEntity(msg.content.id, msg.content.components);

break;

case pc.fw.LiveLinkMessageType.UPDATE_ENTITY_TRANSFORM:

this._linkUpdateEntityTransform(msg.content.id, msg.content.position, msg.content.rotation, msg.content.scale);

break;

case pc.fw.LiveLinkMessageType.UPDATE_ENTITY_NAME:

entity = this.context.root.findOne("getGuid", msg.content.id);

entity.setName(msg.content.name);

break;

case pc.fw.LiveLinkMessageType.UPDATE_ENTITY_ENABLED:

entity = this.context.root.findOne("getGuid", msg.content.id);

entity.enabled = msg.content.enabled;

break;

case pc.fw.LiveLinkMessageType.REPARENT_ENTITY:

this._linkReparentEntity(msg.content.id, msg.content.newParentId, msg.content.index);

break;

case pc.fw.LiveLinkMessageType.CLOSE_ENTITY:

entity = this.context.root.findOne("getGuid", msg.content.id);

if(entity) {

logDEBUG(pc.string.format("RT: Removed '{0}' from parent {1}", msg.content.id, entity.getParent().getGuid()));

entity.destroy();

}

break;

case pc.fw.LiveLinkMessageType.OPEN_PACK:

var pack = this.context.loader.open(pc.resources.PackRequest, msg.content.pack);

// Get the root entity back from the fake pack

var entity = pack.hierarchy;

if (entity.__parent) {

parent = this.context.root.findByGuid(entity.__parent);

parent.addChild(entity);

} else {

this.context.root.addChild(entity);

}

break;

case pc.fw.LiveLinkMessageType.OPEN_ENTITY:

var parent;

var entities = {};

var guid = null;

if (msg.content.entity) {

// Create a fake little pack to open the entity hierarchy

var pack = {

application_data: {},

hierarchy: msg.content.entity

};

pack = this.context.loader.open(pc.resources.PackRequest, pack);

// Get the root entity back from the fake pack

entity = pack.hierarchy;

if (entity.__parent) {

parent = this.context.root.findByGuid(entity.__parent);

parent.addChild(entity);

} else {

this.context.root.addChild(entity);

}

}

break;

case pc.fw.LiveLinkMessageType.UPDATE_ASSET:

this._linkUpdateAsset(msg.content.id, msg.content.attribute, msg.content.value);

break;

case pc.fw.LiveLinkMessageType.UPDATE_ASSETCACHE:

var id;

// Add new and Update existing assets

for (id in msg.content.assets) {

var asset = this.context.assets.getAssetById(id);

if (!asset) {

var assetData = msg.content.assets[id];

this.context.assets.createAndAddAsset(id, assetData);

} else {

pc.extend(asset, msg.content.assets[id]);

}

}

// Delete removed assets

for (id in msg.content.deleted) {

var asset = this.context.assets.getAssetById(id);

if (asset) {

this.context.assets.removeAsset(asset);

}

}

break;

case pc.fw.LiveLinkMessageType.UPDATE_PACK_SETTINGS:

this._linkUpdatePackSettings(msg.content.settings);

break;

}

var entity = this.context.root.findOne("getGuid", guid);

var attribute;

if (entity) {

if(componentName) {

if(entity[componentName]) {

attribute = editor.link.exposed[componentName][attributeName];

if (editor && attribute) {

// Override Type provided

if (attribute.RuntimeType) {

if (attribute.RuntimeType === pc.Vec3) {

entity[componentName][attributeName] = new attribute.RuntimeType(value[0], value[1], value[2]);

} else if (attribute.RuntimeType === pc.Vec4) {

entity[componentName][attributeName] = new attribute.RuntimeType(value[0], value[1], value[2], value[3]);

} else if (attribute.RuntimeType === pc.Vec2) {

entity[componentName][attributeName] = new attribute.RuntimeType(value[0], value[1]);

} else if (attribute.RuntimeType === pc.Color) {

if (value.length === 3) {

entity[componentName][attributeName] = new attribute.RuntimeType(value[0], value[1], value[2]);

} else {

entity[componentName][attributeName] = new attribute.RuntimeType(value[0], value[1], value[2], value[3]);

}

} else {

entity[componentName][attributeName] = new attribute.RuntimeType(value);

}

} else {

entity[componentName][attributeName] = value;

}

} else {

entity[componentName][attributeName] = value;

}

} else {

logWARNING(pc.string.format("No component system called '{0}' exists", componentName));

}

} else {

// set value on node

entity[attributeName] = value;

}

}

var entity = this.context.root.findByGuid(guid);

if(entity) {

entity.setLocalPosition(position[0], position[1], position[2]);

entity.setLocalEulerAngles(rotation[0], rotation[1], rotation[2]);

entity.setLocalScale(scale[0], scale[1], scale[2]);

// Fire event to notify listeners that the transform has been changed by an external tool

entity.fire('livelink:updatetransform', position, rotation, scale);

}

var entity = this.context.root.findByGuid(guid);

var parent = this.context.root.findByGuid(parentId);

entity.reparent(parent, index);

var type;

var entity = this.context.root.findOne("getGuid", guid);

if(entity) {

var order = this.context.systems.getComponentSystemOrder();

var i, len = order.length;

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

type = order[i];

if(components.hasOwnProperty(type) && this.context.systems.hasOwnProperty(type)) {

if (!entity[type]) {

this.context.systems[type].addComponent(entity, {});

}

}

}

for(type in this.context.systems) {

if(type === "gizmo" || type === "pick") {

continue;

}

if(this.context.systems.hasOwnProperty(type)) {

if(!components.hasOwnProperty(type) && entity[type]) {

this.context.systems[type].removeComponent(entity);

}

}

}

}

var asset = this.context.assets.getAssetById(id);

if (asset) {

asset[attribute] = value;

asset.fire('change', asset, attribute, value);

}

var ambient = settings.render.global_ambient;

this.context.scene.ambientLight.set(ambient[0], ambient[1], ambient[2]);

if (this.context.systems.rigidbody && typeof(Ammo) !== 'undefined') {

var gravity = settings.physics.gravity;

this.context.systems.rigidbody.setGravity(gravity[0], gravity[1], gravity[2]);