constructor(length) {

this.length = length;

this.count = 0;

}

inc() {

this.count++;

}

done() {

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

}

constructor(canvas, options = {}) {

super();

console.log("Powered by PlayCanvas " + version + " " + revision);

// Store application instance

Application._applications[canvas.id] = this;

setApplication(this);

app = 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;

// enable if you want entity type script attributes

// to not be re-mapped when an entity is cloned

this.useLegacyScriptAttributeCloning = script.legacy;

this._librariesLoaded = false;

this._fillMode = FILLMODE_KEEP_ASPECT;

this._resolutionMode = RESOLUTION_FIXED;

this._allowResize = true;

// for compatibility

this.context = this;

if (! options.graphicsDeviceOptions)

options.graphicsDeviceOptions = { };

options.graphicsDeviceOptions.xrCompatible = true;

options.graphicsDeviceOptions.alpha = options.graphicsDeviceOptions.alpha || false;

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

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

this._soundManager = new SoundManager(options);

this.loader = new ResourceLoader(this);

WorldClusters.init(this.graphicsDevice);

// stores all entities that have been created

// for this app by guid

this._entityIndex = {};

this.scene = new Scene();

this.root = new Entity(this);

this.root._enabledInHierarchy = true;

this._enableList = [];

this._enableList.size = 0;

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

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

this.bundles = new BundleRegistry(this.assets);

// set this to false if you want to run without using bundles

// We set it to true only if TextDecoder is available because we currently

// rely on it for untarring.

this.enableBundles = (typeof TextDecoder !== 'undefined');

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

this.scripts = new ScriptRegistry(this);

this.i18n = new I18n(this);

this.scenes = new SceneRegistry(this);

var self = this;

this.defaultLayerWorld = new Layer({

name: "World",

id: LAYERID_WORLD

});

if (this.graphicsDevice.webgl2) {

// WebGL 2 depth layer just copies existing depth

this.defaultLayerDepth = new Layer({

enabled: false,

name: "Depth",

id: LAYERID_DEPTH,

onEnable: function () {

if (this.renderTarget) return;

var depthBuffer = new Texture(self.graphicsDevice, {

format: PIXELFORMAT_DEPTHSTENCIL,

width: self.graphicsDevice.width,

height: self.graphicsDevice.height,

mipmaps: false

});

depthBuffer.name = 'rt-depth2';

depthBuffer.minFilter = FILTER_NEAREST;

depthBuffer.magFilter = FILTER_NEAREST;

depthBuffer.addressU = ADDRESS_CLAMP_TO_EDGE;

depthBuffer.addressV = ADDRESS_CLAMP_TO_EDGE;

this.renderTarget = new 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 Layer({

enabled: false,

name: "Depth",

id: LAYERID_DEPTH,

shaderPass: SHADER_DEPTH,

onEnable: function () {

if (this.renderTarget) return;

var colorBuffer = new Texture(self.graphicsDevice, {

format: PIXELFORMAT_R8_G8_B8_A8,

width: self.graphicsDevice.width,

height: self.graphicsDevice.height,

mipmaps: false

});

colorBuffer.name = 'rt-depth1';

colorBuffer.minFilter = FILTER_NEAREST;

colorBuffer.magFilter = FILTER_NEAREST;

colorBuffer.addressU = ADDRESS_CLAMP_TO_EDGE;

colorBuffer.addressV = ADDRESS_CLAMP_TO_EDGE;

this.renderTarget = new 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;

// can't use self.defaultLayerWorld.renderTarget because projects that use the editor override default layers

var rt = self.scene.layers.getLayerById(LAYERID_WORLD).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: CLEARFLAG_COLOR | CLEARFLAG_DEPTH

};

}

this.defaultLayerSkybox = new Layer({

enabled: false,

name: "Skybox",

id: LAYERID_SKYBOX,

opaqueSortMode: SORTMODE_NONE

});

this.defaultLayerUi = new Layer({

enabled: true,

name: "UI",

id: LAYERID_UI,

transparentSortMode: SORTMODE_MANUAL,

passThrough: false

});

this.defaultLayerImmediate = new Layer({

enabled: true,

name: "Immediate",

id: LAYERID_IMMEDIATE,

opaqueSortMode: SORTMODE_NONE,

passThrough: true

});

const defaultLayerComposition = new LayerComposition(this.graphicsDevice, "default");

defaultLayerComposition.pushOpaque(this.defaultLayerWorld);

defaultLayerComposition.pushOpaque(this.defaultLayerDepth);

defaultLayerComposition.pushOpaque(this.defaultLayerSkybox);

defaultLayerComposition.pushTransparent(this.defaultLayerWorld);

defaultLayerComposition.pushOpaque(this.defaultLayerImmediate);

defaultLayerComposition.pushTransparent(this.defaultLayerImmediate);

defaultLayerComposition.pushTransparent(this.defaultLayerUi);

this.scene.layers = 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 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 LAYERID_UI:

layer.passThrough = self.defaultLayerUi.passThrough;

break;

case LAYERID_IMMEDIATE:

layer.passThrough = self.defaultLayerImmediate.passThrough;

break;

}

}

});

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

this.renderer.scene = this.scene;

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

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

this.batcher = new 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;

this.xr = new XrManager(this);

if (this.elementInput)

this.elementInput.attachSelectEvents();

this._inTools = false;

this._skyboxLast = 0;

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

if (this.enableBundles) {

this.loader.addHandler("bundle", new BundleHandler(this.assets));

}

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

this.loader.addHandler("animclip", new AnimClipHandler());

this.loader.addHandler("animstategraph", new AnimStateGraphHandler());

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

this.loader.addHandler("render", new RenderHandler(this.assets));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

this.loader.addHandler("template", new TemplateHandler(this));

this.loader.addHandler("container", new ContainerHandler(this.graphicsDevice, this.scene.defaultMaterial));

this.systems = new ComponentSystemRegistry();

this.systems.add(new RigidBodyComponentSystem(this));

this.systems.add(new CollisionComponentSystem(this));

this.systems.add(new JointComponentSystem(this));

this.systems.add(new AnimationComponentSystem(this));

this.systems.add(new AnimComponentSystem(this));

this.systems.add(new ModelComponentSystem(this));

this.systems.add(new RenderComponentSystem(this));

this.systems.add(new CameraComponentSystem(this));

this.systems.add(new LightComponentSystem(this));

if (script.legacy) {

this.systems.add(new ScriptLegacyComponentSystem(this));

} else {

this.systems.add(new ScriptComponentSystem(this));

}

this.systems.add(new AudioSourceComponentSystem(this, this._soundManager));

this.systems.add(new SoundComponentSystem(this, this._soundManager));

this.systems.add(new AudioListenerComponentSystem(this, this._soundManager));

this.systems.add(new ParticleSystemComponentSystem(this));

this.systems.add(new ScreenComponentSystem(this));

this.systems.add(new ElementComponentSystem(this));

this.systems.add(new ButtonComponentSystem(this));

this.systems.add(new ScrollViewComponentSystem(this));

this.systems.add(new ScrollbarComponentSystem(this));

this.systems.add(new SpriteComponentSystem(this));

this.systems.add(new LayoutGroupComponentSystem(this));

this.systems.add(new LayoutChildComponentSystem(this));

this.systems.add(new 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 (typeof document !== 'undefined') {

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

/* eslint-disable-next-line no-use-before-define */

this.tick = makeTick(this); // Circular linting issue as makeTick and Application reference each other

}

static _applications = {};

/**

static getApplication(id) {

return id ? Application._applications[id] : getApplication();

}

/**