(Self: T, Super: U): T & U;
+}
diff --git a/types/playcanvas/engine/core/log.d.ts b/types/playcanvas/engine/core/log.d.ts
new file mode 100644
index 0000000000..75b23a8253
--- /dev/null
+++ b/types/playcanvas/engine/core/log.d.ts
@@ -0,0 +1,78 @@
+declare namespace pc {
+
+ namespace log {
+
+ /**
+ * @private
+ * @function
+ * @name pc.log.write
+ * @description Write text to the console
+ * @param {String} text
+ */
+ function write (text: string): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.log.open
+ * @description Starting logging to the console
+ * @param {String} text
+ */
+ function open(text: string): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.log.info
+ * @description Write text to the log preceded by 'INFO:'
+ * @param {String} text
+ */
+ function info(text: string): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.log.debug
+ * @description Write text to the log preceded by 'DEBUG:'
+ * @param {String} text
+ */
+ function debug(text: string): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.log.error
+ * @description Write text to the log preceded by 'ERROR:'
+ * @param {String} text
+ */
+ function error(text: string): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.log.warning
+ * @description Write text to the log preceded by 'WARNING:'
+ * @param {String} text
+ */
+ function warning(text: string): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.log.alert
+ * @description Write text to the log preceded by 'ALERT:' and pop up an alert dialog box with the text
+ * @param {String} text
+ */
+ function alert(text: string): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.log.assert
+ * @description If condition is false, then write text to the log preceded by 'ASSERT:' and pop up a dialog box.
+ * @param {Boolean} condition
+ * @param {String} text
+ */
+ function assert(condition: boolean, text: string): void;
+ }
+}
diff --git a/types/playcanvas/engine/core/path.d.ts b/types/playcanvas/engine/core/path.d.ts
new file mode 100644
index 0000000000..d6fa94abad
--- /dev/null
+++ b/types/playcanvas/engine/core/path.d.ts
@@ -0,0 +1,65 @@
+declare namespace pc {
+
+ /**
+ * @namespace pc.path
+ * @description File path API
+ */
+ namespace path {
+
+ /**
+ * The character that separates path segments
+ * @name pc.path.delimiter
+ */
+ const delimiter = "/",
+ /**
+ * Join two sections of file path together, insert a delimiter if needed.
+ * @param {String} one First part of path to join
+ * @param {String} two Second part of path to join
+ * @function
+ * @name pc.path.join
+ */
+ /*
+ join: function(one, two) {
+ if(two[0] === pc.path.delimiter) {
+ return two;
+ }
+
+ if(one && two && one[one.length - 1] !== pc.path.delimiter && two[0] !== pc.path.delimiter) {
+ return one + pc.path.delimiter + two;
+ }
+ else {
+ return one + two;
+ }
+ },
+ */
+ function join(one: string, two: string): string;
+
+ /**
+ * @function
+ * @name pc.path.split
+ * @description Split the pathname path into a pair [head, tail] where tail is the final part of the path
+ * after the last delimiter and head is everything leading up to that. tail will never contain a slash
+ */
+ function split(path: string): [string, string];
+
+ /**
+ * @function
+ * @name pc.path.getBasename
+ * @description Return the basename of the path. That is the second element of the pair returned by
+ * passing path into {@link pc.path.split}.
+ * @example
+ * pc.path.getBasename("/path/to/file.txt"); // returns "path.txt"
+ * pc.path.getBasename("/path/to/dir"); // returns "dir"
+ * @returns {String} The basename
+ */
+ function getBasename(path: string): string;
+
+ /**
+ * Get the directory name from the path. This is everything up to the final instance of pc.path.delimiter
+ * @param {String} path The path to get the directory from
+ * @function
+ * @name pc.path.getDirectory
+ */
+ function getDirectory(path: string): string;
+ }
+}
diff --git a/types/playcanvas/engine/core/platform.d.ts b/types/playcanvas/engine/core/platform.d.ts
new file mode 100644
index 0000000000..15d1995415
--- /dev/null
+++ b/types/playcanvas/engine/core/platform.d.ts
@@ -0,0 +1,69 @@
+import { platform } from "os";
+
+declare namespace pc {
+
+ /**
+ * @name pc.platform
+ * @namespace
+ * @description global namespace that stores flags regarding platform environment and features support
+ * @example
+ * if (pc.platform.touch) {
+ * // touch is supported
+ * }
+ */
+ namespace platform {
+ /**
+ * @name pc.platform.desktop
+ * @description is it a desktop or laptop device
+ */
+ const desktop: boolean;
+
+ /**
+ * @name pc.platform.mobile
+ * @description is it a mobile or tablet device
+ */
+ const mobile: boolean;
+
+ /**
+ * @name pc.platform.ios
+ * @description if it is iOS
+ */
+ const ios: boolean;
+
+ /**
+ * @name pc.platform.android
+ * @description if it is Android
+ */
+ const android: boolean;
+
+ /**
+ * @name pc.platform.windows
+ * @description if it is Windows
+ */
+ const windows: boolean;
+
+ /**
+ * @name pc.platform.cocoonjs
+ * @description if it is CocoonJS
+ */
+ const cocoonjs: boolean;
+
+ /**
+ * @name pc.platform.xbox
+ * @description if it is Xbox
+ */
+ const xbox: boolean;
+
+ /**
+ * @name pc.platform.gamepads
+ * @description if platform supports gamepads
+ */
+ const gamepads: boolean;
+
+ /**
+ * @name pc.platform.touch
+ * @description if platform supports touch input
+ */
+ const touch: boolean;
+ }
+}
diff --git a/types/playcanvas/engine/core/string.d.ts b/types/playcanvas/engine/core/string.d.ts
new file mode 100644
index 0000000000..245e712264
--- /dev/null
+++ b/types/playcanvas/engine/core/string.d.ts
@@ -0,0 +1,56 @@
+declare namespace pc {
+
+ /**
+ * @namespace
+ * @name pc.string
+ * @description Extended String API
+ */
+ namespace string {
+
+ /**
+ * @name pc.string.ASCII_LOWERCASE
+ * @description All lowercase letters
+ * @type String
+ */
+ const ASCII_LOWERCASE = "abcdefghijklmnopqrstuvwxyz";
+
+ /**
+ * @name pc.string.ASCII_UPPERCASE
+ * @description All uppercase letters
+ * @type String
+ */
+ const ASCII_UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+ /**
+ * @name pc.string.ASCII_LETTERS
+ * @description All ASCII letters
+ * @type String
+ */
+ const ASCII_LETTERS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+ /**
+ * @function
+ * @name pc.string.format
+ * @description Return a string with {n} replaced with the n-th argument
+ * @param {String} s The string to format
+ * @param {Object} [arguments] All other arguments are substituted into the string
+ * @returns {String} The formatted string
+ * @example
+ * var s = pc.string.format("Hello {0}", "world");
+ * console.log(s); // Prints "Hello world"
+ */
+ function format(s: string, arguments?: any): string;
+
+ /**
+ * @function
+ * @name pc.string.toBool
+ * @description Convert a string value to a boolean. In non-strict mode (the default), 'true' is converted to true, all other values
+ * are converted to false. In strict mode, 'true' is converted to true, 'false' is converted to false, all other values will throw
+ * an Exception.
+ * @param {String} s The string to convert
+ * @param {Boolean} [strict] In strict mode an Exception is thrown if s is not an accepted string value. Defaults to false
+ * @returns {Boolean} The converted value
+ */
+ function toBool(s: string, strict?: boolean): boolean;
+ }
+}
diff --git a/types/playcanvas/engine/core/tags.d.ts b/types/playcanvas/engine/core/tags.d.ts
new file mode 100644
index 0000000000..ddb0a1b905
--- /dev/null
+++ b/types/playcanvas/engine/core/tags.d.ts
@@ -0,0 +1,170 @@
+declare namespace pc {
+
+ /**
+ * @name pc.Tags
+ * @class Set of tag names
+ * @description Create an instance of a Tags.
+ * @param {Object} [parent] Parent object who tags belong to.
+ * Note: Tags are used as addition of `pc.Entity` and `pc.Asset` as `tags` field.
+ */
+ class Tags {
+ constructor(parent: pc.Entity | pc.Asset)
+
+ /**
+ * @function
+ * @name pc.Tags#add
+ * @description Add a tag, duplicates are ignored. Can be array or comma separated arguments for multiple tags.
+ * @param {String} name Name of a tag, or array of tags
+ * @returns {Boolean} true if any tag were added
+ * @example
+ * tags.add('level-1');
+ * @example
+ * tags.add('ui', 'settings');
+ * @example
+ * tags.add([ 'level-2', 'mob' ]);
+ */
+ add(): boolean;
+
+
+ /**
+ * @function
+ * @name pc.Tags#remove
+ * @description Remove tag.
+ * @param {String} name Name of a tag or array of tags
+ * @returns {Boolean} true if any tag were removed
+ * @example
+ * tags.remove('level-1');
+ * @example
+ * tags.remove('ui', 'settings');
+ * @example
+ * tags.remove([ 'level-2', 'mob' ]);
+ */
+ remove(): boolean;
+
+
+ /**
+ * @function
+ * @name pc.Tags#clear
+ * @description Remove all tags.
+ * @example
+ * tags.clear();
+ */
+ clear(): void;
+
+
+ /**
+ * @function
+ * @name pc.Tags#has
+ * @description Check if tags satisfy filters.
+ * Filters can be provided by simple name of tag, as well as by array of tags.
+ * When an array is provided it will check if tags contain each tag within the array.
+ * If any of comma separated argument is satisfied, then it will return true.
+ * Any number of combinations are valid, and order is irrelevant.
+ * @param {String} name of tag, or array of names
+ * @returns {Boolean} true if filters are satisfied
+ * @example
+ * tags.has('player'); // player
+ * @example
+ * tags.has('mob', 'player'); // player OR mob
+ * @example
+ * tags.has([ 'level-1', 'mob' ]); // monster AND level-1
+ * @example
+ * tags.has([ 'ui', 'settings' ], [ 'ui', 'levels' ]); // (ui AND settings) OR (ui AND levels)
+ */
+ has(): boolean;
+
+
+ /**
+ * @function
+ * @name pc.Tags#list
+ * @description Returns immutable array of tags
+ * @returns {String[]} copy of tags array
+ */
+ list(): string[];
+
+ /**
+ * @field
+ * @readonly
+ * @type Number
+ * @name pc.Tags#size
+ * @description Number of tags in set
+ */
+ readonly size: number;
+
+
+ // Events
+
+ /**
+ * @function
+ * @name pc.Tags#on
+ * @description Attach an event handler to an event
+ * @param {String} name Name of the event to bind the callback to
+ * @param {Function} callback Function that is called when event is fired. Note the callback is limited to 8 arguments.
+ * @param {Object} [scope] Object to use as 'this' when the event is fired, defaults to current this
+ * @example
+ * obj.on('test', function (a, b) {
+ * console.log(a + b);
+ * });
+ * obj.fire('test', 1, 2); // prints 3 to the console
+ */
+ on(name: string, callback: (...args: any[]) => void, scope: any): any;
+
+ /**
+ * @function
+ * @name pc.Tags#off
+ * @description Detach an event handler from an event. If callback is not provided then all callbacks are unbound from the event,
+ * if scope is not provided then all events with the callback will be unbound.
+ * @param {String} [name] Name of the event to unbind
+ * @param {Function} [callback] Function to be unbound
+ * @param {Object} [scope] Scope that was used as the this when the event is fired
+ * @example
+ * var handler = function () {
+ * };
+ * obj.on('test', handler);
+ *
+ * obj.off(); // Removes all events
+ * obj.off('test'); // Removes all events called 'test'
+ * obj.off('test', handler); // Removes all handler functions, called 'test'
+ * obj.off('test', handler, this); // Removes all hander functions, called 'test' with scope this
+ */
+ off(name: string, callback: (...args: any[]) => void, scope: any): any;
+
+ /**
+ * @function
+ * @name pc.Tags#fire
+ * @description Fire an event, all additional arguments are passed on to the event listener
+ * @param {Object} name Name of event to fire
+ * @param {*} [...] Arguments that are passed to the event handler
+ * @example
+ * obj.fire('test', 'This is the message');
+ */
+ fire(name: string, arg1: any, arg2?: any, arg3?: any, arg4?: any, arg5?: any, arg6?: any, arg7?: any, arg8?: any): any;
+
+ /**
+ * @function
+ * @name pc.Tags#once
+ * @description Attach an event handler to an event. This handler will be removed after being fired once.
+ * @param {String} name Name of the event to bind the callback to
+ * @param {Function} callback Function that is called when event is fired. Note the callback is limited to 8 arguments.
+ * @param {Object} [scope] Object to use as 'this' when the event is fired, defaults to current this
+ * @example
+ * obj.once('test', function (a, b) {
+ * console.log(a + b);
+ * });
+ * obj.fire('test', 1, 2); // prints 3 to the console
+ * obj.fire('test', 1, 2); // not going to get handled
+ */
+ once(name: string, callback: (...args: any[]) => void, scope: any): any;
+
+ /**
+ * @function
+ * @name pc.Tags#hasEvent
+ * @description Test if there are any handlers bound to an event name
+ * @param {String} name The name of the event to test
+ * @example
+ * obj.on('test', function () { }); // bind an event to 'test'
+ * obj.hasEvent('test'); // returns true
+ */
+ hasEvent(name: string): boolean;
+ }
+}
diff --git a/types/playcanvas/engine/core/time.d.ts b/types/playcanvas/engine/core/time.d.ts
new file mode 100644
index 0000000000..a23b617026
--- /dev/null
+++ b/types/playcanvas/engine/core/time.d.ts
@@ -0,0 +1,43 @@
+declare namespace pc {
+
+ /**
+ * @private
+ * @name pc.Timer
+ * @description Create a new Timer instance
+ * @class A Timer counts milliseconds from when start() is called until when stop() is called.
+ */
+ class Timer {
+ /**
+ * @private
+ * @function
+ * @name pc.Timer#start
+ * @description Start the timer
+ */
+ start(): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.Timer#stop
+ * @description Stop the timer
+ */
+ stop(): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.Timer#getMilliseconds
+ * @description Get the number of milliseconds that passed between start() and stop() being called
+ */
+ getMilliseconds(): number;
+ }
+
+ /**
+ * @private
+ * @function
+ * @name pc.now
+ * @description Get current time in milliseconds. Use it to measure time difference. Reference time may differ on different platforms.
+ * @return {Number} The time in milliseconds
+ */
+ function now(): number;
+}
diff --git a/types/playcanvas/engine/core/uri.d.ts b/types/playcanvas/engine/core/uri.d.ts
new file mode 100644
index 0000000000..8b42cfcf1d
--- /dev/null
+++ b/types/playcanvas/engine/core/uri.d.ts
@@ -0,0 +1,104 @@
+declare namespace pc {
+
+ /**
+ * @private
+ * @function
+ * @name pc.createURI
+ * @description Create a URI object from constituent parts
+ * @param {Object} options Parts of the URI to build
+ * @param {String} [options.scheme] The URI scheme (e.g. http)
+ * @param {String} [options.authority] The URI authority (e.g. www.example.com)
+ * @param {String} [options.host] Combination of scheme and authority (e.g. http://www.example.com)
+ * @param {String} [options.path] The URI path (e.g. /users/example)
+ * @param {String} [options.hostpath] Combination of scheme, authority and path (e.g. http://www.example.com/users/example)
+ * @param {String} [options.query] The query section, after the ?(e.g. http://example.com?key=value&another=123)
+ * @param {String} [options.fragment] The fragment section, after the # (e.g. http://example.com#fragment/data)
+ * @returns {String} A URI string
+ */
+ function createURI(options: {
+ scheme?: string,
+ authority?: string,
+ host?: string,
+ path?: string,
+ hostpath?: string,
+ query?: string,
+ fragment?: string
+ }): string;
+
+ /**
+ * @private
+ * @name pc.URI
+ * @description Create a new URI object
+ * @class A URI object
+ * @param {String} uri URI string
+ */
+ class URI {
+ constructor(uri: string)
+
+ /**
+ * @name pc.URI#scheme
+ * @description The scheme. (e.g. http)
+ */
+ scheme: string;
+
+ /**
+ * @name pc.URI#authority
+ * @description The authority. (e.g. www.example.com)
+ */
+ authority: string;
+
+ /**
+ * @name pc.URI#path
+ * @description The path. (e.g. /users/example)
+ */
+ path: string;
+
+ /**
+ * @name pc.URI#query
+ * @description The query, the section after a ?. (e.g. search=value)
+ */
+ query: string;
+
+ /**
+ * @name pc.URI#fragment
+ * @description The fragment, the section after a #
+ */
+ fragment: string;
+
+ /**
+ * @function
+ * @name pc.URI#toString
+ * @description Convert URI back to string
+ */
+ toString(): string;
+
+ /**
+ * @function
+ * @name pc.URI#getQuery
+ * @description Returns the query parameters as an Object
+ * @example
+ *
+ * var s = "http://example.com?a=1&b=2&c=3
+ * var uri = new pc.URI(s);
+ * var q = uri.getQuery();
+ * console.log(q.a); // logs "1"
+ * console.log(q.b); // logs "2"
+ * console.log(q.c); // logs "3"
+ *
+ * - pc.FILLMODE_NONE: the canvas will always match the size provided.
+ * - pc.FILLMODE_FILL_WINDOW: the canvas will simply fill the window, changing aspect ratio.
+ * - pc.FILLMODE_KEEP_ASPECT: the canvas will grow to fill the window as best it can while maintaining the aspect ratio.
+ *
+ * @param {Number} [width] The width of the canvas (only used when mode is pc.FILLMODE_NONE).
+ * @param {Number} [height] The height of the canvas (only used when mode is pc.FILLMODE_NONE).
+ */
+ setCanvasFillMode(mode: string, width?: number, height?: number): void;
+
+ /**
+ * @function
+ * @name pc.Application#setCanvasResolution
+ * @description Change the resolution of the canvas, and set the way it behaves when the window is resized
+ * @param {string} mode The mode to use when setting the resolution. Can be:
+ *
+ * - pc.RESOLUTION_AUTO: if width and height are not provided, canvas will be resized to match canvas client size.
+ * - pc.RESOLUTION_FIXED: resolution of canvas will be fixed.
+ *
+ * @param {Number} [width] The horizontal resolution, optional in AUTO mode, if not provided canvas clientWidth is used
+ * @param {Number} [height] The vertical resolution, optional in AUTO mode, if not provided canvas clientHeight is used
+ */
+ setCanvasResolution(mode: string, width?: number, height?: number): void;
+
+ /**
+ * @function
+ * @name pc.Application#isFullscreen
+ * @description Returns true if the application is currently running fullscreen
+ * @returns {Boolean} True if the application is running fullscreen
+ */
+ isFullscreen(): boolean;
+
+ /**
+ * @function
+ * @name pc.Application#enableFullscreen
+ * @description Request that the browser enters fullscreen mode. This is not available on all browsers.
+ * Note: Switching to fullscreen can only be initiated by a user action, e.g. in the event hander for a mouse or keyboard input
+ * @param {Element} [element] The element to display in fullscreen, if element is not provided the application canvas is used
+ * @param {Function} [success] Function called if the request for fullscreen was successful
+ * @param {Function} [error] Function called if the request for fullscreen was unsuccessful
+ * @example
+ * var button = document.getElementById('my-button');
+ * button.addEventListener('click', function () {
+ * app.enableFullscreen(canvas, function () {
+ * console.log('Now fullscreen');
+ * }, function () {
+ * console.log('Something went wrong!');
+ * });
+ * }, false);
+ */
+ enableFullscreen(element?: Element, success?: (...args: any[]) => {}, error?: () => {}): void;
+
+ /**
+ * @function
+ * @name pc.Application#disableFullscreen
+ * @description If application is currently displaying an element as fullscreen, then stop and return to normal.
+ * @param {Function} [success] Function called when transition to normal mode is finished
+ */
+ disableFullscreen(success: (...args: any[]) => {}): void;
+
+ /**
+ * @function
+ * @name pc.Application#isHidden
+ * @description Queries the visibility of the window or tab in which the application is running.
+ * @returns {Boolean} True if the application is not visible and false otherwise.
+ */
+ isHidden(): boolean
+
+ /**
+ * @private
+ * @function
+ * @name pc.Application#onVisibilityChange
+ * @description Called when the visibility state of the current tab/window changes
+ */
+ private onVisibilityChange(e: any): void;
+
+ /**
+ * @function
+ * @name pc.Application#resizeCanvas
+ * @description Resize the canvas in line with the current FillMode
+ * In KEEP_ASPECT mode, the canvas will grow to fill the window as best it can while maintaining the aspect ratio
+ * In FILL_WINDOW mode, the canvas will simply fill the window, changing aspect ratio
+ * In NONE mode, the canvas will always match the size provided
+ * @param {Number} [width] The width of the canvas, only used in NONE mode
+ * @param {Number} [height] The height of the canvas, only used in NONE mode
+ * @returns {Object} A object containing the values calculated to use as width and height
+ */
+ resizeCanvas(width?: number, height?: number): {
+ width: number,
+ height: number
+ }
+
+ /**
+ * @private
+ * @name pc.Application#onLibrariesLoaded
+ * @description Event handler called when all code libraries have been loaded
+ * Code libraries are passed into the constructor of the Application and the application won't start running or load packs until all libraries have
+ * been loaded
+ */
+ private onLibrariesLoaded(): void;
+
+ /**
+ * @function
+ * @name pc.Application#setSkybox
+ * @description Sets the skybox asset to current scene, and subscribes to asset load/change events
+ * @param {pc.Asset} asset Asset of type `skybox` to be set to, or null to remove skybox
+ */
+ setSkybox(asset: pc.Asset): void;
+
+ /**
+ * @function
+ * @name pc.Application#destroy
+ * @description Destroys application and removes all event listeners.
+ */
+ destroy(): void;
+
+ /**
+ * @function
+ * @name pc.Application#renderLine
+ * @description Draw a line in one color
+ * @param {pc.Vec3} start The start of the line
+ * @param {pc.Vec3} end The end of the line
+ * @param {pc.Color} color The color of the line
+ * @example
+ * var start = new pc.Vec3(0,0,0);
+ * var end = new pc.Vec3(1,0,0);
+ * var color = new pc.Color(1,1,1);
+ * app.renderLine(start, end, color);
+ */
+ renderLine(start: pc.Vec3, end: pc.Vec3, color: pc.Color): void;
+
+ /**
+ * @function
+ * @name pc.Application#renderLine^2
+ * @description Draw a line which blends between two colors
+ * @param {pc.Vec3} start The start of the line
+ * @param {pc.Vec3} end The end of the line
+ * @param {pc.Color} startColor The start color of the line
+ * @param {pc.Color} endColor The end color of the line
+ * @example
+ * var start = new pc.Vec3(0,0,0);
+ * var end = new pc.Vec3(1,0,0);
+ * var startColor = new pc.Color(1,1,1);
+ * var endColor = new pc.Color(1,0,0);
+ * app.renderLine(start, end, startColor, endColor);
+ */
+ renderLine(start: pc.Vec3, end: pc.Vec3, startColor: pc.Color, endColor: pc.Color): void;
+
+ /**
+ * @function
+ * @name pc.Application#renderLine^3
+ * @description Draw a line of one color with specified line type
+ * @param {pc.Vec3} start The start of the line
+ * @param {pc.Vec3} end The end of the line
+ * @param {pc.Color} color The color of the line
+ * @param {Number} lineType The type of rendering to use: pc.LINEBATCH_WORLD, pc.LINEBATCH_OVERLAY, pc.LINEBATCH_GIZMO. Default is pc.LINEBATCH_WORLD
+ * @example
+ * var start = new pc.Vec3(0,0,0);
+ * var end = new pc.Vec3(1,0,0);
+ * var color = new pc.Color(1,1,1);
+ * app.renderLine(start, end, color, pc.LINEBATCH_OVERLAY);
+ */
+ renderLine(start: pc.Vec3, end: pc.Vec3, color: pc.Color, lineType: number): void;
+
+ /**
+ * @function
+ * @name pc.Application#renderLine^4
+ * @description Draw a line which blends between two colors with specified line type
+ * @param {pc.Vec3} start The start of the line
+ * @param {pc.Vec3} end The end of the line
+ * @param {pc.Color} startColor The start color of the line
+ * @param {pc.Color} endColor The end color of the line
+ * @param {Number} lineType The type of rendering to use: pc.LINEBATCH_WORLD, pc.LINEBATCH_OVERLAY, pc.LINEBATCH_GIZMO. Default is pc.LINEBATCH_WORLD
+ * @example
+ * var start = new pc.Vec3(0,0,0);
+ * var end = new pc.Vec3(1,0,0);
+ * var startColor = new pc.Color(1,1,1);
+ * var endColor = new pc.Color(1,0,0);
+ * app.renderLine(start, end, startColor, endColor, pc.LINEBATCH_OVERLAY);
+ */
+ renderLine(start: pc.Vec3, end: pc.Vec3, startColor: pc.Color, endColor: pc.Color, lineType: number): void;
+
+ /**
+ * @function
+ * @name pc.Application#renderLines
+ * @description Draw an array of lines.
+ * @param {pc.Vec3[]} position An array of points to draw lines between
+ * @param {pc.Color[]} color An array of colors to color the lines. This must be the same size as the position array
+ * @param {Number} [lineType] The type of rendering to use: pc.LINEBATCH_WORLD, pc.LINEBATCH_OVERLAY, pc.LINEBATCH_GIZMO. Default is pc.LINEBATCH_WORLD
+ * @example
+ * var points = [new pc.Vec3(0,0,0), new pc.Vec3(1,0,0), new pc.Vec3(1,1,0), new pc.Vec3(1,1,1)];
+ * var colors = [new pc.Color(1,0,0), new pc.Color(1,1,0), new pc.Color(0,1,1), new pc.Color(0,0,1)];
+ * app.renderLines(points, colors);
+ */
+ renderLines(position: pc.Vec3[], color: pc.Color[], lineType?: number): void;
+
+
+
+
+ // Events
+
+ /**
+ * @function
+ * @name pc.Application#on
+ * @description Attach an event handler to an event
+ * @param {String} name Name of the event to bind the callback to
+ * @param {Function} callback Function that is called when event is fired. Note the callback is limited to 8 arguments.
+ * @param {Object} [scope] Object to use as 'this' when the event is fired, defaults to current this
+ * @example
+ * obj.on('test', function (a, b) {
+ * console.log(a + b);
+ * });
+ * obj.fire('test', 1, 2); // prints 3 to the console
+ */
+ on(name: string, callback: (...args: any[]) => void, scope?: any): any;
+
+ /**
+ * @function
+ * @name pc.Application#off
+ * @description Detach an event handler from an event. If callback is not provided then all callbacks are unbound from the event,
+ * if scope is not provided then all events with the callback will be unbound.
+ * @param {String} [name] Name of the event to unbind
+ * @param {Function} [callback] Function to be unbound
+ * @param {Object} [scope] Scope that was used as the this when the event is fired
+ * @example
+ * var handler = function () {
+ * };
+ * obj.on('test', handler);
+ *
+ * obj.off(); // Removes all events
+ * obj.off('test'); // Removes all events called 'test'
+ * obj.off('test', handler); // Removes all handler functions, called 'test'
+ * obj.off('test', handler, this); // Removes all hander functions, called 'test' with scope this
+ */
+ off(name?: string, callback?: (...args: any[]) => void, scope?: any): any;
+
+ /**
+ * @function
+ * @name pc.Application#fire
+ * @description Fire an event, all additional arguments are passed on to the event listener
+ * @param {Object} name Name of event to fire
+ * @param {*} [...] Arguments that are passed to the event handler
+ * @example
+ * obj.fire('test', 'This is the message');
+ */
+ fire(name: string, arg1: any, arg2?: any, arg3?: any, arg4?: any, arg5?: any, arg6?: any, arg7?: any, arg8?: any): any;
+
+ /**
+ * @function
+ * @name pc.Application#once
+ * @description Attach an event handler to an event. This handler will be removed after being fired once.
+ * @param {String} name Name of the event to bind the callback to
+ * @param {Function} callback Function that is called when event is fired. Note the callback is limited to 8 arguments.
+ * @param {Object} [scope] Object to use as 'this' when the event is fired, defaults to current this
+ * @example
+ * obj.once('test', function (a, b) {
+ * console.log(a + b);
+ * });
+ * obj.fire('test', 1, 2); // prints 3 to the console
+ * obj.fire('test', 1, 2); // not going to get handled
+ */
+ once(name: string, callback: (...args: any[]) => void, scope?: any): any;
+
+ /**
+ * @function
+ * @name pc.Application#hasEvent
+ * @description Test if there are any handlers bound to an event name
+ * @param {String} name The name of the event to test
+ * @example
+ * obj.on('test', function () { }); // bind an event to 'test'
+ * obj.hasEvent('test'); // returns true
+ */
+ hasEvent(name: string): boolean;
+ }
+
+ /**
+ * @enum pc.FILLMODE
+ * @name pc.FILLMODE_NONE
+ * @description When resizing the window the size of the canvas will not change.
+ */
+ const FILLMODE_NONE = 'NONE';
+ /**
+ * @enum pc.FILLMODE
+ * @name pc.FILLMODE_FILL_WINDOW
+ * @description When resizing the window the size of the canvas will change to fill the window exactly.
+ */
+ const FILLMODE_FILL_WINDOW = 'FILL_WINDOW';
+ /**
+ * @enum pc.FILLMODE
+ * @name pc.FILLMODE_KEEP_ASPECT
+ * @description When resizing the window the size of the canvas will change to fill the window as best it can, while maintaining the same aspect ratio.
+ */
+ const FILLMODE_KEEP_ASPECT = 'KEEP_ASPECT';
+ /**
+ * @enum pc.RESOLUTION
+ * @name pc.RESOLUTION_AUTO
+ * @description When the canvas is resized the resolution of the canvas will change to match the size of the canvas.
+ */
+ const RESOLUTION_AUTO = 'AUTO';
+ /**
+ * @enum pc.RESOLUTION
+ * @name pc.RESOLUTION_FIXED
+ * @description When the canvas is resized the resolution of the canvas will remain at the same value and the output will just be scaled to fit the canvas.
+ */
+ const RESOLUTION_FIXED = 'FIXED';
+}
diff --git a/types/playcanvas/engine/framework/components/animation/component.d.ts b/types/playcanvas/engine/framework/components/animation/component.d.ts
new file mode 100644
index 0000000000..5060499b3d
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/animation/component.d.ts
@@ -0,0 +1,46 @@
+declare namespace pc {
+ /**
+ * @component Animation
+ * @name pc.AnimationComponent
+ * @description Create a new AnimationComponent
+ * @class The Animation Component allows an Entity to playback animations on models
+ * @param {pc.AnimationComponentSystem} system The {@link pc.ComponentSystem} that created this Component
+ * @param {pc.Entity} entity The Entity that this Component is attached to
+ * @extends pc.Component
+ * @property {Number} speed Speed multiplier for animation play back speed. 1.0 is playback at normal speed, 0.0 pauses the animation
+ * @property {Boolean} loop If true the animation will restart from the beginning when it reaches the end
+ * @property {Boolean} activate If true the first animation asset will begin playing when the Pack is loaded
+ * @property {pc.Asset[]} assets The array of animation assets - can also be an array of asset ids.
+ * @property {Number} currentTime Get or Set the current time position (in seconds) of the animation
+ * @property {Number} duration Get the duration in seconds of the current animation.
+ */
+ class AnimationComponent extends pc.Component {
+ constructor(system: pc.AnimationComponentSystem, entity: pc.Entity)
+
+ speed: number;
+ loop: boolean;
+ activate: boolean;
+ assets: pc.Asset[];
+ currentTime: number;
+ duration: number;
+
+ /**
+ * @function
+ * @name pc.AnimationComponent#play
+ * @description Start playing an animation
+ * @param {String} name The name of the animation asset to begin playing.
+ * @param {Number} [blendTime] The time in seconds to blend from the current
+ * animation state to the start of the animation being set.
+ */
+ play(name: string, blendTime: number): void;
+
+ /**
+ * @function
+ * @name pc.AnimationComponent#getAnimation
+ * @description Return an animation
+ * @param {String} name The name of the animation asset
+ * @returns {pc.Animation} An Animation
+ */
+ getAnimation(name: string): void;
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/animation/system.d.ts b/types/playcanvas/engine/framework/components/animation/system.d.ts
new file mode 100644
index 0000000000..c2b51936dc
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/animation/system.d.ts
@@ -0,0 +1,15 @@
+declare namespace pc {
+
+ /**
+ * @name pc.AnimationComponentSystem
+ * @description Create an AnimationComponentSystem
+ * @class The AnimationComponentSystem manages creating and deleting AnimationComponents
+ * @param {pc.Application} app The Application for the current application
+ * @extends pc.ComponentSystem
+ */
+ class AnimationComponentSystem extends pc.ComponentSystem {
+ constructor(app: pc.Application)
+
+
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/audio-listener/component.d.ts b/types/playcanvas/engine/framework/components/audio-listener/component.d.ts
new file mode 100644
index 0000000000..873f76d81f
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/audio-listener/component.d.ts
@@ -0,0 +1,15 @@
+declare namespace pc {
+
+ /**
+ * @component
+ * @name pc.AudioListenerComponent
+ * @class Represents the audio listener in the 3D world, so that 3D positioned audio sources are heard correctly.
+ * @description Create new AudioListenerComponent
+ * @param {pc.AudioListenerComponentSystem} system The ComponentSystem that created this Component
+ * @param {pc.Entity} entity The Entity that this Component is attached to.
+ * @extends pc.Component
+ */
+ class AudioListenerComponent extends pc.Component {
+ constructor(system: pc.AudioListenerComponentSystem, entity: pc.Entity)
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/audio-listener/system.d.ts b/types/playcanvas/engine/framework/components/audio-listener/system.d.ts
new file mode 100644
index 0000000000..8ca30e9955
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/audio-listener/system.d.ts
@@ -0,0 +1,12 @@
+declare namespace pc {
+
+ /**
+ * @name pc.AudioListenerComponentSystem
+ * @class Component System for adding and removing {@link pc.AudioComponent} objects to Entities.
+ * @description Create a new AudioListenerComponentSystem
+ * @extends pc.ComponentSystem
+ */
+ class AudioListenerComponentSystem extends pc.ComponentSystem {
+ constructor(app: pc.Application, manager: pc.SoundManager)
+ }
+}
\ No newline at end of file
diff --git a/types/playcanvas/engine/framework/components/audio-source/component.d.ts b/types/playcanvas/engine/framework/components/audio-source/component.d.ts
new file mode 100644
index 0000000000..08e821533e
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/audio-source/component.d.ts
@@ -0,0 +1,38 @@
+declare namespace pc {
+
+ /**
+ * @component
+ * @name pc.AudioSourceComponent
+ * @class The AudioSource Component controls playback of an audio sample. This class will be deprecated in favor of {@link pc.SoundComponent}.
+ * @description Create a new AudioSource Component
+ * @param {pc.AudioSourceComponentSystem} system The ComponentSystem that created this Component
+ * @param {pc.Entity} entity The entity that the Component is attached to
+ * @extends pc.Component
+ * @property {pc.Asset[]} assets The list of audio assets - can also be an array of asset ids.
+ * @property {Boolean} activate If true the audio will begin playing as soon as the Pack is loaded
+ * @property {Number} volume The volume modifier to play the audio with. In range 0-1.
+ * @property {Number} pitch The pitch modifier to play the audio with. Must be larger than 0.01
+ * @property {Boolean} loop If true the audio will restart when it finishes playing
+ * @property {Boolean} 3d If true the audio will play back at the location of the Entity in space, so the audio will be affect by the position of the {@link pc.AudioListenerComponent}
+ * @property {String} distanceModel Determines which algorithm to use to reduce the volume of the audio as it moves away from the listener. Can be one of 'linear', 'inverse' or 'exponential'. Default is 'inverse'.
+ * @property {Number} minDistance The minimum distance from the listener at which audio falloff begins.
+ * @property {Number} maxDistance The maximum distance from the listener at which audio falloff stops. Note the volume of the audio is not 0 after this distance, but just doesn't fall off anymore
+ * @property {Number} rollOffFactor The factor used in the falloff equation.
+ */
+ class AudioSourceComponent extends pc.Component {
+ constructor(system: pc.AudioSourceComponentSystem, entity: pc.Entity)
+
+ assets: pc.Asset[];
+ activate: boolean;
+ volume: number;
+ pitch: number;
+ loop: boolean;
+ distanceModel: string;
+ minDistance: number;
+ maxDistance: number;
+ rollOffFactor: number;
+ }
+
+
+
+}
\ No newline at end of file
diff --git a/types/playcanvas/engine/framework/components/audio-source/system.d.ts b/types/playcanvas/engine/framework/components/audio-source/system.d.ts
new file mode 100644
index 0000000000..dd5a4a63e9
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/audio-source/system.d.ts
@@ -0,0 +1,21 @@
+declare namespace pc {
+
+ /**
+ * @name pc.AudioSourceComponentSystem
+ * @class Controls playback of an audio sample. This class will be deprecated in favor of {@link pc.SoundComponentSystem}.
+ * @param {pc.Application} app The Application
+ * @param {pc.SoundManager} manager The sound manager
+ * @extends pc.ComponentSystem
+ */
+ class AudioSourceComponentSystem extends pc.ComponentSystem {
+ constructor(app: pc.Application, manager: pc.SoundManager)
+
+ /**
+ * @name pc.AudioSourceComponentSystem#setVolume()
+ * @function
+ * @description Set the volume for the entire AudioSource system. All sources will have their volume multiplied by this value
+ * @param {Number} value The value to set the volume to. Valid from 0.0 - 1.0
+ */
+ setVolume(volume: number): void;
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/camera/component.d.ts b/types/playcanvas/engine/framework/components/camera/component.d.ts
new file mode 100644
index 0000000000..639fe9b0d2
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/camera/component.d.ts
@@ -0,0 +1,230 @@
+declare namespace pc {
+
+ /**
+ * @component
+ * @name pc.CameraComponent
+ * @extends pc.Component
+ * @class The Camera Component enables an Entity to render the scene. A scene requires at least one
+ * enabled camera component to be rendered. Note that multiple camera components can be enabled
+ * simultaneously (for split-screen or offscreen rendering, for example).
+ * @description Create a new Camera Component.
+ * @param {pc.CameraComponentSystem} system The ComponentSystem that created this Component.
+ * @param {pc.Entity} entity The Entity that this Component is attached to.
+ * @example
+ * // Add a pc.CameraComponent to an entity
+ * var entity = new pc.Entity();
+ * entity.addComponent('camera', {
+ * nearClip: 1,
+ * farClip: 100,
+ * fov: 55
+ * });
+ * @example
+ * // Get the pc.CameraComponent on an entity
+ * var cameraComponent = entity.camera;
+ * @example
+ * // Update a property on a camera component
+ * entity.camera.nearClip = 2;
+ * @property {Number} projection The type of projection used to render the camera. Can be:
+ *
+ * - {@link pc.PROJECTION_PERSPECTIVE}: A perspective projection. The camera frustum resembles a truncated pyramid.
+ * - {@link pc.PROJECTION_ORTHOGRAPHIC}: An orthographic projection. The camera frustum is a cuboid.
+ *
+ * Defaults to pc.PROJECTION_PERSPECTIVE.
+ * @property {Number} nearClip The distance from the camera before which no rendering will take place.
+ * @property {Number} farClip The distance from the camera after which no rendering will take place.
+ * @property {Number} aspectRatio The aspect ratio of the camera. This is the ratio of width divided by height. Default to 16/9.
+ * @property {Boolean} horizontalFov Set which axis to use for the Field of View calculation. Defaults to false (use Y-axis).
+ * @property {Number} fov The field of view of the camera in degrees. Usually this is the Y-axis field of
+ * view, see {@link pc.CameraComponent#horizontalFov}. Used for {@link pc.PROJECTION_PERSPECTIVE} cameras only. Defaults to 45.
+ * @property {Number} orthoHeight The half-height of the orthographic view window (in the Y-axis). Used for
+ * {@link pc.PROJECTION_ORTHOGRAPHIC} cameras only. Defaults to 10.
+ * @property {Number} priority Controls the order in which cameras are rendered. Cameras with smaller values for priority are rendered first.
+ * @property {pc.Color} clearColor The color used to clear the canvas to before the camera starts to render.
+ * @property {Boolean} clearColorBuffer If true the camera will clear the color buffer to the color set in clearColor.
+ * @property {Boolean} clearDepthBuffer If true the camera will clear the depth buffer.
+ * @property {Boolean} clearStencilBuffer If true the camera will clear the stencil buffer.
+ * @property {pc.Vec4} rect Controls where on the screen the camera will be rendered in normalized screen coordinates.
+ * @property {pc.Vec4} scissorRect Clips all pixels which are not in the rectangle.
+ * The order of the values is [x, y, width, height].
+ * @property {pc.RenderTarget} renderTarget The render target of the camera. Defaults to null, which causes
+ * the camera to render to the canvas' back buffer. Setting a valid render target effectively causes the camera
+ * to render to an offscreen buffer, which can then be used to achieve certain graphics effect (normally post
+ * effects).
+ * @property {pc.PostEffectQueue} postEffects The post effects queue for this camera. Use this to add or remove post effects from the camera.
+ * @property {Boolean} frustumCulling Controls the culling of mesh instances against the camera frustum. If true, culling is enabled.
+ * If false, all mesh instances in the scene are rendered by the camera, regardless of visibility. Defaults to false.
+ * @property {Function} calculateTransform Custom function you can provide to calculate the camera transformation matrix manually. Can be used for complex effects like reflections. Function is called using component's scope.
+ * Arguments:
+ * {pc.Mat4} transformMatrix: output of the function
+ * {Number} view: Type of view. Can be pc.VIEW_CENTER, pc.VIEW_LEFT or pc.VIEW_RIGHT. Left and right are only used in stereo rendering.
+ * @property {Function} calculateProjection Custom function you can provide to calculate the camera projection matrix manually. Can be used for complex effects like doing oblique projection. Function is called using component's scope.
+ * Arguments:
+ * {pc.Mat4} transformMatrix: output of the function
+ * {Number} view: Type of view. Can be pc.VIEW_CENTER, pc.VIEW_LEFT or pc.VIEW_RIGHT. Left and right are only used in stereo rendering.
+ * @property {Boolean} cullFaces If true the camera will take material.cull into account. Otherwise both front and back faces will be rendered.
+ * @property {Boolean} flipFaces If true the camera will invert front and back faces. Can be useful for reflection rendering.
+ */
+ class CameraComponent extends pc.Component {
+ constructor(system: pc.CameraComponentSystem, entity: pc.Entity)
+
+ projection: number;
+ nearClip: number;
+ farClip: number;
+ aspectRatio: number;
+ horizontalFov: boolean;
+ fov: number;
+ orthoHeight: number;
+ priority: number;
+ clearColor: pc.Color;
+ clearColorBuffer: boolean;
+ clearDepthBuffer: boolean;
+ clearStencilBuffer: boolean;
+ rect: pc.Vec4;
+ scissorRect: pc.Vec4;
+ renderTarget: pc.RenderTarget;
+ postEffects: pc.PostEffectQueue;
+ frustumCulling: boolean;
+ calculateTransform: Function;
+ calculateProjection: Function;
+ cullFaces: boolean;
+ flipFaces: boolean;
+
+ /**
+ * @readonly
+ * @name pc.CameraComponent#projectionMatrix
+ * @type pc.Mat4
+ * @description Queries the camera's projection matrix.
+ */
+ readonly projectionMatrix: pc.Mat4;
+
+ /**
+ * @readonly
+ * @name pc.CameraComponent#viewMatrix
+ * @type pc.Mat4
+ * @description Queries the camera's view matrix.
+ */
+ readonly viewMatrix: pc.Mat4;
+
+ /**
+ * @readonly
+ * @name pc.CameraComponent#frustum
+ * @type pc.Frustum
+ * @description Queries the camera's frustum shape.
+ */
+ readonly frustum: pc.Frustum;
+
+ /**
+ * @name pc.CameraComponent#vrDisplay
+ * @type pc.VrDisplay
+ * @description The {@link pc.VrDisplay} that the camera is current displaying to. This is set automatically by calls to {@link pc.CameraComponent#enterVr}
+ * or {@link pc.CameraComponent#exitVr}. Setting this property to a display directly enables the camera to use the transformation information
+ * from a display without rendering stereo to it, e.g. for "magic window" style experiences.
+ * @example
+ * // enable magic window style interface
+ * var display = this.app.vr.display;
+ * if (display) {
+ * this.entity.camera.vrDisplay = display;
+ * }
+ *
+ * var camera = this.entity.camera;
+ * camera.enterVr(function (err) {
+ * if (err) { return; }
+ * var display = camera.vrDisplay; // access presenting pc.VrDisplay
+ * });
+ */
+ vrDisplay: pc.VrDisplay;
+
+ /**
+ * @readonly
+ * @name pc.CameraComponent#node
+ * @type pc.GraphNode
+ * @description Queries the camera's GraphNode. Can be used to get position and rotation.
+ */
+ readonly node: pc.GraphNode
+
+ /**
+ * @function
+ * @name pc.CameraComponent#screenToWorld
+ * @description Convert a point from 2D screen space to 3D world space.
+ * @param {Number} screenx x coordinate on PlayCanvas' canvas element.
+ * @param {Number} screeny y coordinate on PlayCanvas' canvas element.
+ * @param {Number} cameraz The distance from the camera in world space to create the new point.
+ * @param {pc.Vec3} [worldCoord] 3D vector to receive world coordinate result.
+ * @example
+ * // Get the start and end points of a 3D ray fired from a screen click position
+ * var start = entity.camera.screenToWorld(clickX, clickY, entity.camera.nearClip);
+ * var end = entity.camera.screenToWorld(clickX, clickY, entity.camera.farClip);
+ *
+ * // Use the ray coordinates to perform a raycast
+ * app.systems.rigidbody.raycastFirst(start, end, function (result) {
+ * console.log("Entity " + result.entity.name + " was selected");
+ * });
+ * @returns {pc.Vec3} The world space coordinate.
+ */
+ screenToWorld(screenx: number, screeny: number, cameraz: number, worldCoord?: pc.Vec3): pc.Vec3;
+
+ /**
+ * @function
+ * @name pc.CameraComponent#worldToScreen
+ * @description Convert a point from 3D world space to 2D screen space.
+ * @param {pc.Vec3} worldCoord The world space coordinate.
+ * @param {pc.Vec3} [screenCoord] 3D vector to receive screen coordinate result.
+ * @returns {pc.Vec3} The screen space coordinate.
+ */
+ worldToScreen(worldCoord: pc.Vec3, screenCoord: pc.Vec3): pc.Vec3;
+
+ /**
+ * @function
+ * @private
+ * @name pc.CameraComponent#frameBegin
+ * @description Start rendering the frame for this camera.
+ */
+ private frameBegin(): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.CameraComponent#frameEnd
+ * @description End rendering the frame for this camera
+ */
+ private frameEnd(): void;
+
+
+ /**
+ * @function
+ * @name pc.CameraComponent#enterVr
+ * @description Attempt to start presenting this camera to a {@link pc.VrDisplay}.
+ * @param {pc.VrDisplay} [display] The VrDisplay to present. If not supplied this uses {@link pc.VrManager#display} as the default
+ * @param {Function} callback Function called once to indicate success of failure. The callback takes one argument (err).
+ * On success it returns null on failure it returns the error message.
+ * @example
+ * // On an entity with a camera component
+ * this.entity.camera.enterVr(function (err) {
+ * if (err) {
+ * console.error(err);
+ * return;
+ * } else {
+ * // in VR!
+ * }
+ * });
+ */
+ enterVr(display: pc.VrDisplay, callback: Function): void;
+
+ /**
+ * @function
+ * @name pc.CameraComponent#exitVr
+ * @description Attempt to stop presenting this camera.
+ * @param {Function} callback Function called once to indicate success of failure. The callback takes one argument (err).
+ * On success it returns null on failure it returns the error message.
+ * @example
+ * this.entity.camera.exitVr(function (err) {
+ * if (err) {
+ * console.error(err);
+ * } else {
+ *
+ * }
+ * });
+ */
+ exitVr(callback: Function): void;
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/camera/post-effect-queue.d.ts b/types/playcanvas/engine/framework/components/camera/post-effect-queue.d.ts
new file mode 100644
index 0000000000..e0d81f1ea4
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/camera/post-effect-queue.d.ts
@@ -0,0 +1,62 @@
+declare namespace pc {
+
+ /**
+ * @name pc.PostEffectQueue
+ * @description Create a new PostEffectQueue
+ * @class Used to manage multiple post effects for a camera
+ * @param {pc.Application} app The application
+ * @param {pc.CameraComponent} camera The camera component
+ */
+ class PostEffectQueue {
+ constructor(app: pc.Application, camera: pc.CameraComponent)
+
+ /**
+ * @private
+ * @function
+ * @name pc.PostEffectQueue#_createOffscreenTarget
+ * @description Creates a render target with the dimensions of the canvas, with an optional depth buffer
+ * @param {Boolean} useDepth Set to true if you want to create a render target with a depth buffer
+ * @param {Boolean} hdr Use HDR render target format
+ * @returns {pc.RenderTarget} The render target
+ */
+ private _createOffscreenTarget(useDepth: boolean, hdr: boolean): pc.RenderTarget;
+
+ /**
+ * @function
+ * @name pc.PostEffectQueue#addEffect
+ * @description Adds a post effect to the queue. If the queue is disabled adding a post effect will
+ * automatically enable the queue.
+ * @param {pc.PostEffect} effect The post effect to add to the queue.
+ */
+ addEffect(effect: pc.PostEffect): void;
+
+ /**
+ * @function
+ * @name pc.PostEffectQueue#removeEffect
+ * @description Removes a post effect from the queue. If the queue becomes empty it will be disabled automatically.
+ * @param {pc.PostEffect} effect The post effect to remove.
+ */
+ removeEffect(effect: pc.PostEffect): void;
+
+ /**
+ * @function
+ * @name pc.PostEffectQueue#destroy
+ * @description Removes all the effects from the queue and disables it
+ */
+ destroy(): void;
+
+ /**
+ * @function
+ * @name pc.PostEffectQueue#enable
+ * @description Enables the queue and all of its effects. If there are no effects then the queue will not be enabled.
+ */
+ enable(): void;
+
+ /**
+ * @function
+ * @name pc.PostEffectQueue#disable
+ * @description Disables the queue and all of its effects.
+ */
+ disable(): void;
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/camera/system.d.ts b/types/playcanvas/engine/framework/components/camera/system.d.ts
new file mode 100644
index 0000000000..1c3e36265b
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/camera/system.d.ts
@@ -0,0 +1,18 @@
+declare namespace pc {
+
+ /**
+ * @name pc.CameraComponentSystem
+ * @class Used to add and remove {@link pc.CameraComponent}s from Entities. It also holds an
+ * array of all active cameras.
+ * @description Create a new CameraComponentSystem
+ * @param {pc.Application} app The Application
+ *
+ * @property {pc.CameraComponent[]} cameras Holds all the active camera components
+ * @extends pc.ComponentSystem
+ */
+ class CameraComponentSystem extends pc.ComponentSystem {
+ constructor(app: pc.Application)
+
+ cameras: pc.CameraComponent[];
+ }
+}
\ No newline at end of file
diff --git a/types/playcanvas/engine/framework/components/collision/component.d.ts b/types/playcanvas/engine/framework/components/collision/component.d.ts
new file mode 100644
index 0000000000..b71978b10b
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/collision/component.d.ts
@@ -0,0 +1,80 @@
+declare namespace pc {
+
+ /**
+ * @component
+ * @name pc.CollisionComponent
+ * @description Create a new CollisionComponent
+ * @class A collision volume. use this in conjunction with a {@link pc.RigidBodyComponent} to make a collision volume that can be simulated using the physics engine.
+ * If the {@link pc.Entity} does not have a {@link pc.RigidBodyComponent} then this collision volume will act as a trigger volume. When an entity with a dynamic
+ * or kinematic body enters or leaves an entity with a trigger volume, both entities will receive trigger events.
+ *
The following table shows all the events that can be fired between two Entities:
+ *
+ * | Rigid Body (Static) | Rigid Body (Dynamic or Kinematic) | Trigger Volume |
+ *
+ * | Rigid Body (Static) |
+ * - |
+ *
+ * - contact
+ * - collisionstart
+ * - collisionend
+ * |
+ * - |
+ *
+ *
+ * | Rigid Body (Dynamic or Kinematic) |
+ *
+ * - contact
+ * - collisionstart
+ * - collisionend
+ * |
+ *
+ * - contact
+ * - collisionstart
+ * - collisionend
+ * |
+ *
+ * - triggerenter
+ * - triggerleave
+ * |
+ *
+ *
+ * | Trigger Volume |
+ * - |
+ *
+ * - triggerenter
+ * - triggerleave
+ * |
+ * - |
+ *
+ *
+ *
+ * @param {pc.CollisionComponentSystem} system The ComponentSystem that created this Component
+ * @param {pc.Entity} entity The Entity that this Component is attached to.
+ * @property {String} type The type of the collision volume. Defaults to 'box'. Can be one of the following:
+ *
+ * - box: A box-shaped collision volume.
+ * - sphere: A sphere-shaped collision volume.
+ * - capsule: A capsule-shaped collision volume.
+ * - cylinder: A cylinder-shaped collision volume.
+ * - mesh: A collision volume that uses a model asset as its shape.
+ *
+ * @property {pc.Vec3} halfExtents The half-extents of the box-shaped collision volume in the x, y and z axes. Defaults to [0.5, 0.5, 0.5]
+ * @property {Number} radius The radius of the sphere, capsule or cylinder-shaped collision volumes. Defaults to 0.5
+ * @property {Number} axis The local space axis with which the capsule or cylinder-shaped collision volume's length is aligned. 0 for X, 1 for Y and 2 for Z. Defaults to 1 (Y-axis).
+ * @property {Number} height The total height of the capsule or cylinder-shaped collision volume from tip to tip. Defaults to 2.
+ * @property {pc.Asset} asset The asset for the model of the mesh collision volume - can also be an asset id.
+ * @property {pc.Model} model The model that is added to the scene graph for the mesh collision volume.
+ * @extends pc.Component
+ */
+ class CollisionComponent extends pc.Component {
+ constructor(system: pc.CollisionComponentSystem, entity: pc.Entity)
+
+ type: string;
+ halfExtents: pc.Vec3;
+ radius: number;
+ axis: number;
+ height: number;
+ asset: pc.Asset;
+ model: pc.Model;
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/collision/system.d.ts b/types/playcanvas/engine/framework/components/collision/system.d.ts
new file mode 100644
index 0000000000..4c01118541
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/collision/system.d.ts
@@ -0,0 +1,13 @@
+declare namespace pc {
+
+ /**
+ * @name pc.CollisionComponentSystem
+ * @description Creates a new CollisionComponentSystem.
+ * @class Manages creation of {@link pc.CollisionComponent}s.
+ * @param {pc.Application} app The running {pc.Application}
+ * @extends pc.ComponentSystem
+ */
+ class CollisionComponentSystem extends pc.ComponentSystem {
+ constructor(app: pc.Application)
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/component.d.ts b/types/playcanvas/engine/framework/components/component.d.ts
new file mode 100644
index 0000000000..5b47908106
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/component.d.ts
@@ -0,0 +1,104 @@
+declare namespace pc {
+
+ /**
+ * @name pc.Component
+ * @description Base constructor for a Component
+ * @class Components are used to attach functionality on a {@link pc.Entity}. Components
+ * can receive update events each frame, and expose properties to the PlayCanvas Editor.
+ * @param {pc.ComponentSystem} system The ComponentSystem used to create this Component
+ * @param {pc.Entity} entity The Entity that this Component is attached to
+ * @property {Boolean} enabled Enables or disables the component.
+ */
+ class Component {
+ constructor(system: pc.ComponentSystem, entity: pc.Entity)
+
+ /**
+ * @private
+ * @readonly
+ * @name pc.Component#data
+ * @type pc.ComponentData
+ * @description Access the {@link pc.ComponentData} directly. Usually you should
+ * access the data properties via the individual properties as modifying this data
+ * directly will not fire 'set' events.
+ */
+ private readonly data: pc.ComponentData;
+
+ enabled: boolean;
+
+
+ // Events
+
+ /**
+ * @function
+ * @name pc.Component#on
+ * @description Attach an event handler to an event
+ * @param {String} name Name of the event to bind the callback to
+ * @param {Function} callback Function that is called when event is fired. Note the callback is limited to 8 arguments.
+ * @param {Object} [scope] Object to use as 'this' when the event is fired, defaults to current this
+ * @example
+ * obj.on('test', function (a, b) {
+ * console.log(a + b);
+ * });
+ * obj.fire('test', 1, 2); // prints 3 to the console
+ */
+ on(name: string, callback: (...args: any[]) => void, scope: any): any;
+
+ /**
+ * @function
+ * @name pc.Component#off
+ * @description Detach an event handler from an event. If callback is not provided then all callbacks are unbound from the event,
+ * if scope is not provided then all events with the callback will be unbound.
+ * @param {String} [name] Name of the event to unbind
+ * @param {Function} [callback] Function to be unbound
+ * @param {Object} [scope] Scope that was used as the this when the event is fired
+ * @example
+ * var handler = function () {
+ * };
+ * obj.on('test', handler);
+ *
+ * obj.off(); // Removes all events
+ * obj.off('test'); // Removes all events called 'test'
+ * obj.off('test', handler); // Removes all handler functions, called 'test'
+ * obj.off('test', handler, this); // Removes all hander functions, called 'test' with scope this
+ */
+ off(name: string, callback: (...args: any[]) => void, scope: any): any;
+
+ /**
+ * @function
+ * @name pc.Component#fire
+ * @description Fire an event, all additional arguments are passed on to the event listener
+ * @param {Object} name Name of event to fire
+ * @param {*} [...] Arguments that are passed to the event handler
+ * @example
+ * obj.fire('test', 'This is the message');
+ */
+ fire(name: string, arg1: any, arg2?: any, arg3?: any, arg4?: any, arg5?: any, arg6?: any, arg7?: any, arg8?: any): any;
+
+ /**
+ * @function
+ * @name pc.Component#once
+ * @description Attach an event handler to an event. This handler will be removed after being fired once.
+ * @param {String} name Name of the event to bind the callback to
+ * @param {Function} callback Function that is called when event is fired. Note the callback is limited to 8 arguments.
+ * @param {Object} [scope] Object to use as 'this' when the event is fired, defaults to current this
+ * @example
+ * obj.once('test', function (a, b) {
+ * console.log(a + b);
+ * });
+ * obj.fire('test', 1, 2); // prints 3 to the console
+ * obj.fire('test', 1, 2); // not going to get handled
+ */
+ once(name: string, callback: (...args: any[]) => void, scope: any): any;
+
+ /**
+ * @function
+ * @name pc.Component#hasEvent
+ * @description Test if there are any handlers bound to an event name
+ * @param {String} name The name of the event to test
+ * @example
+ * obj.on('test', function () { }); // bind an event to 'test'
+ * obj.hasEvent('test'); // returns true
+ */
+ hasEvent(name: string): boolean;
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/data.d.ts b/types/playcanvas/engine/framework/components/data.d.ts
new file mode 100644
index 0000000000..eafb2ed916
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/data.d.ts
@@ -0,0 +1,11 @@
+declare namespace pc {
+
+ /**
+ * @private
+ * @name pc.ComponentData
+ * @class Base class for Component data storage.
+ */
+ class ComponentData {
+
+ }
+}
\ No newline at end of file
diff --git a/types/playcanvas/engine/framework/components/element/component.d.ts b/types/playcanvas/engine/framework/components/element/component.d.ts
new file mode 100644
index 0000000000..08620ed595
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/element/component.d.ts
@@ -0,0 +1,113 @@
+declare namespace pc {
+
+ /**
+ * @enum pc.ELEMENTTYPE
+ * @name pc.ELEMENTTYPE_GROUP
+ * @description A {@link pc.ElementComponent} that contains child {@link pc.ElementComponent}s.
+ */
+ const ELEMENTTYPE_GROUP = 'group';
+ /**
+ * @enum pc.ELEMENTTYPE
+ * @name pc.ELEMENTTYPE_IMAGE
+ * @description A {@link pc.ElementComponent} that displays an image.
+ */
+ const ELEMENTTYPE_IMAGE = 'image';
+ /**
+ * @enum pc.ELEMENTTYPE
+ * @name pc.ELEMENTTYPE_TEXT
+ * @description A {@link pc.ElementComponent} that displays text.
+ */
+ const ELEMENTTYPE_TEXT = 'text';
+
+ /**
+ * @component
+ * @name pc.ElementComponent
+ * @extends pc.Component
+ * @class Enables an Entity to be positioned using anchors and screen coordinates under a {@link pc.ScreenComponent} or under other ElementComponents.
+ * Depending on its type it can be used to render images, text or just as a layout mechanism to build 2D and 3D user interfaces.
+ * If the component is a descendant of a {@link pc.ScreenComponent}, then the Entity's {@link pc.Entity.setLocalPosition} is in the {@link pc.ScreenComponent}'s coordinate system.
+ * @param {pc.ElementComponentSystem} system The ComponentSystem that created this Component
+ * @param {pc.Entity} entity The Entity that this Component is attached to.
+ * @property {String} type The type of the ElementComponent. Can be one of the following:
+ *
+ * - pc.ELEMENTTYPE_GROUP: The component can be used as a layout mechanism to create groups of ElementComponents e.g. panels.
+ * - pc.ELEMENTTYPE_IMAGE: The component will render an image
+ * - pc.ELEMENTTYPE_TEXT: The component will render text
+ *
+ * @property {pc.Entity} screen The Entity with a {@link pc.ScreenComponent} that this component belongs to. This is automatically set when the component is a child of a ScreenComponent.
+ * @property {Number} drawOrder The draw order of the component. A higher value means that the component will be rendered on top of other components.
+ * @property {pc.Vec4} anchor Specifies where the left, bottom, right and top edges of the component are anchored relative to its parent. Each value
+ * ranges from 0 to 1. E.g. a value of [0,0,0,0] means that the element will be anchored to the bottom left of its parent. A value of [1, 1, 1, 1] means
+ * it will be anchored to the top right. A split anchor is when the left-right or top-bottom pairs of the anchor are not equal. In that case the component will be resized to cover that entire area. E.g. a value of [0,0,1,1] will make the component resize exactly as its parent.
+ * @property {pc.Vec2} pivot The position of the pivot of the component relative to its anchor. Each value ranges from 0 to 1 where [0,0] is the bottom left and [1,1] is the top right.
+ * @property {pc.Vec4} margin The distance from the left, bottom, right and top edges of the anchor. For example if we are using a split anchor like [0,0,1,1] and the margin is [0,0,0,0] then the component will be the same width and height as its parent.
+ * @property {Number} left The distance from the left edge of the anchor. Can be used in combination with a split anchor to make the component's left edge always be 'left' units away from the left.
+ * @property {Number} right The distance from the right edge of the anchor. Can be used in combination with a split anchor to make the component's right edge always be 'right' units away from the right.
+ * @property {Number} bottom The distance from the bottom edge of the anchor. Can be used in combination with a split anchor to make the component's top edge always be 'top' units away from the top.
+ * @property {Number} top The distance from the top edge of the anchor. Can be used in combination with a split anchor to make the component's bottom edge always be 'bottom' units away from the bottom.
+ * @property {Number} width The width of the element.
+ * @property {Number} height The height of the element.
+ * @property {pc.Vec3[]} screenCorners An array of 4 {@link pc.Vec3}s that represent the bottom left, bottom right, top right and top left corners of the component relative to its parent {@link pc.ScreenComponent}.
+ * @property {pc.Vec3[]} worldCorners An array of 4 {@link pc.Vec3}s that represent the bottom left, bottom right, top right and top left corners of the component in world space. Only works for 3D ElementComponents.
+ * @property {pc.Vec2[]} canvasCorners An array of 4 {@link pc.Vec2}s that represent the bottom left, bottom right, top right and top left corners of the component in canvas pixels. Only works for screen space ElementComponents.
+ * @property {Boolean} useInput If true then the component will receive Mouse or Touch input events.
+ * @property {pc.Color} color The color of the image for {@link pc.ELEMENTTYPE_IMAGE} types or the color of the text for {@link pc.ELEMENTTYPE_TEXT} types.
+ * @property {Number} opacity The opacity of the image for {@link pc.ELEMENTTYPE_IMAGE} types or the text for {@link pc.ELEMENTTYPE_TEXT} types.
+ * @property {Number} textWidth The width of the text rendered by the component. Only works for {@link pc.ELEMENTTYPE_TEXT} types.
+ * @property {Number} textHeight The height of the text rendered by the component. Only works for {@link pc.ELEMENTTYPE_TEXT} types.
+ * @property {Number} autoWidth Automatically set the width of the component to be the same as the textWidth. Only works for {@link pc.ELEMENTTYPE_TEXT} types.
+ * @property {Number} autoHeight Automatically set the height of the component to be the same as the textHeight. Only works for {@link pc.ELEMENTTYPE_TEXT} types.
+ * @property {Number} fontAsset The id of the font asset used for rendering the text. Only works for {@link pc.ELEMENTTYPE_TEXT} types.
+ * @property {pc.Font} font The font used for rendering the text. Only works for {@link pc.ELEMENTTYPE_TEXT} types.
+ * @property {Number} fontSize The size of the font. Only works for {@link pc.ELEMENTTYPE_TEXT} types.
+ * @property {Number} spacing The spacing between the letters of the text. Only works for {@link pc.ELEMENTTYPE_TEXT} types.
+ * @property {Number} lineHeight The height of each line of text. Only works for {@link pc.ELEMENTTYPE_TEXT} types.
+ * @property {pc.Vec2} alignment The horizontal and vertical alignment of the text. Values range from 0 to 1 where [0,0] is the bottom left and [1,1] is the top right. Only works for {@link pc.ELEMENTTYPE_TEXT} types.
+ * @property {String} text The text to render. Only works for {@link pc.ELEMENTTYPE_TEXT} types.
+ * @property {Number} textureAsset The id of the texture asset to render. Only works for {@link pc.ELEMENTTYPE_IMAGE} types.
+ * @property {pc.Texture} texture The texture to render. Only works for {@link pc.ELEMENTTYPE_IMAGE} types.
+ * @property {Number} materialAsset The id of the material asset to use when rendering an image. Only works for {@link pc.ELEMENTTYPE_IMAGE} types.
+ * @property {pc.Material} material The material to use when rendering an image. Only works for {@link pc.ELEMENTTYPE_IMAGE} types.
+ * @property {pc.Vec4} rect Specifies which region of the texture to use in order to render an image. Values range from 0 to 1 and indicate u, v, width, height. Only works for {@link pc.ELEMENTTYPE_IMAGE} types.
+ * @property {Number} batchGroupId Assign element to a specific batch group (see {@link pc.BatchGroup}). Default value is -1 (no group).
+ */
+ class ElementComponent extends pc.Component {
+ constructor(system: pc.ElementComponentSystem, entity: pc.Entity)
+
+ type: string;
+ screen: pc.Entity;
+ drawOrder: number;
+ anchor: pc.Vec4;
+ pivot: pc.Vec2;
+ margin: pc.Vec4;
+ left: number;
+ right: number;
+ bottom: number;
+ top: number;
+ width: number;
+ height: number;
+ screenCorners: pc.Vec3[];
+ worldCorners: pc.Vec3[];
+ canvasCorners: pc.Vec2[];
+ useInput: boolean;
+ color: pc.Color;
+ opacity: number;
+ textWidth: number;
+ textHeight: number;
+ autoWidth: number;
+ autoHeight: number;
+ fontAsset: number;
+ font: pc.Font;
+ fontSize: number;
+ spacing: number;
+ lineHeight: number;
+ alignment: pc.Vec2;
+ text: string;
+ textureAsset: number;
+ texture: pc.Texture;
+ materialAsset: number;
+ material: pc.Material;
+ rect: pc.Vec4;
+ batchGroupId: number;
+ }
+}
\ No newline at end of file
diff --git a/types/playcanvas/engine/framework/components/element/system.d.ts b/types/playcanvas/engine/framework/components/element/system.d.ts
new file mode 100644
index 0000000000..2bd9aa5352
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/element/system.d.ts
@@ -0,0 +1,12 @@
+declare namespace pc {
+
+ /**
+ * @name pc.ElementComponentSystem
+ * @class Manages creation of {@link pc.ElementComponent}s.
+ * @param {pc.Application} app The application
+ * @extends pc.ComponentSystem
+ */
+ class ElementComponentSystem extends pc.ComponentSystem {
+ constructor(app: pc.Application)
+ }
+}
\ No newline at end of file
diff --git a/types/playcanvas/engine/framework/components/light/component.d.ts b/types/playcanvas/engine/framework/components/light/component.d.ts
new file mode 100644
index 0000000000..668428164d
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/light/component.d.ts
@@ -0,0 +1,137 @@
+declare namespace pc {
+
+ /**
+ * @component
+ * @name pc.LightComponent
+ * @class The Light Component enables the Entity to light the scene. There are three types
+ * of light: directional, point and spot. Directional lights are global in that they are
+ * considered to be infinitely far away and light the entire scene. Point and spot lights
+ * are local in that they have a position and a range. A spot light is a specialization of
+ * a point light where light is emitted in a cone rather than in all directions. Lights
+ * also have the ability to cast shadows to add realism to your scenes.
+ * @description Creates a new Light Component.
+ * @param {pc.LightComponentSystem} system The ComponentSystem that created this Component.
+ * @param {pc.Entity} entity The Entity that this Component is attached to.
+ * @example
+ * // Add a pc.LightComponent to an entity
+ * var entity = new pc.Entity();
+ * entity.addComponent('light', {
+ * type: "point",
+ * color: new pc.Color(1, 0, 0),
+ * range: 10
+ * });
+ * @example
+ * // Get the pc.LightComponent on an entity
+ * var lightComponent = entity.light;
+ * @example
+ * // Update a property on a light component
+ * entity.light.range = 20;
+ * @property {String} type The type of light. Can be:
+ *
+ * - "directional": A light that is infinitely far away and lights the entire scene from one direction.
+ * - "point": A light that illuminates in all directions from a point.
+ * - "spot": A light that illuminates in all directions from a point and is bounded by a cone.
+ *
+ * Defaults to "directional".
+ * @property {pc.Color} color The Color of the light. The alpha component of the color is
+ * ignored. Defaults to white (1, 1, 1).
+ * @property {Number} intensity The brightness of the light. Defaults to 1.
+ * @property {Boolean} castShadows If enabled the light will cast shadows. Defaults to false.
+ * @property {Number} shadowDistance The distance from the viewpoint beyond which shadows
+ * are no longer rendered. Affects directional lights only. Defaults to 40.
+ * @property {Number} shadowResolution The size of the texture used for the shadow map.
+ * Valid sizes are 64, 128, 256, 512, 1024, 2048. Defaults to 1024.
+ * @property {Number} shadowBias The depth bias for tuning the appearance of the shadow
+ * mapping generated by this light. Defaults to 0.05.
+ * @property {Number} normalOffsetBias Normal offset depth bias. Defaults to 0.
+ * @property {Number} range The range of the light. Affects point and spot lights only.
+ * Defaults to 10.
+ * @property {Number} innerConeAngle The angle at which the spotlight cone starts
+ * to fade off. The angle is specified in degrees. Affects spot lights only. Defaults
+ * to 40.
+ * @property {Number} outerConeAngle The angle at which the spotlight cone has faded
+ * to nothing. The angle is specified in degrees. Affects spot lights only. Defaults
+ * to 45.
+ * @property {Number} falloffMode Controls the rate at which a light attentuates from
+ * its position. Can be:
+ *
+ * - {@link pc.LIGHTFALLOFF_LINEAR}: Linear.
+ * - {@link pc.LIGHTFALLOFF_INVERSESQUARED}: Inverse squared.
+ *
+ * Affects point and spot lights only. Defaults to pc.LIGHTFALLOFF_LINEAR.
+ * @property {Number} mask Defines a mask to determine which {@link pc.MeshInstance}s are
+ * lit by this light. Defaults to 1.
+ * @property {Boolean} affectDynamic If enabled the light will affect non-lightmapped objects
+ * @property {Boolean} affectLightmapped If enabled the light will affect lightmapped objects
+ * @property {Boolean} bake If enabled the light will be rendered into lightmaps
+ * @property {Boolean} bakeDir If enabled and bake=true, the light's direction will contribute to directional lightmaps.
+ * Be aware, that directional lightmap is an approximation and can only hold single direction per pixel.
+ * Intersecting multiple lights with bakeDir=true may lead to incorrect look of specular/bump-mapping in the area of intersection.
+ * The error is not always visible though, and highly scene-dependent.
+ * @property {Number} shadowUpdateMode Tells the renderer how often shadows must be updated for this light. Options:
+ *
+ * - {@link pc.SHADOWUPDATE_NONE}: Don't render shadows.
+ * - {@link pc.SHADOWUPDATE_THISFRAME}: Render shadows only once (then automatically switches to pc.SHADOWUPDATE_NONE).
+ * - {@link pc.SHADOWUPDATE_REALTIME}: Render shadows every frame (default).
+ *
+ * @property {Number} shadowType Type of shadows being rendered by this light. Options:
+ *
+ * - {@link pc.SHADOW_PCF3}: Render depth (color-packed on WebGL 1.0), can be used for PCF 3x3 sampling.
+ * - {@link pc.SHADOW_VSM8}: Render packed variance shadow map. All shadow receivers must also cast shadows for this mode to work correctly.
+ * - {@link pc.SHADOW_VSM16}: Render 16-bit exponential variance shadow map. Requires OES_texture_half_float extension. Falls back to pc.SHADOW_VSM8, if not supported.
+ * - {@link pc.SHADOW_VSM32}: Render 32-bit exponential variance shadow map. Requires OES_texture_float extension. Falls back to pc.SHADOW_VSM16, if not supported.
+ * - {@link pc.SHADOW_PCF5}: Render depth buffer only, can be used for hardware-accelerated PCF 5x5 sampling. Requires WebGL2. Falls back to pc.SHADOW_PCF3 on WebGL 1.0.
+ *
+ * @property {Number} vsmBlurMode Blurring mode for variance shadow maps:
+ *
+ * - {@link pc.BLUR_BOX}: Box filter.
+ * - {@link pc.BLUR_GAUSSIAN}: Gaussian filter. May look smoother than box, but requires more samples.
+ *
+ * @property {Number} vsmBlurSize Number of samples used for blurring a variance shadow map. Only uneven numbers work, even are incremented. Minimum value is 1, maximum is 25.
+ * @property {Number} cookieAsset Asset that has texture that will be assigned to cookie internally once asset resource is available.
+ * @property {pc.Texture} cookie Projection texture. Must be 2D for spot and cubemap for point (ignored if incorrect type is used).
+ * @property {Number} cookieIntensity Projection texture intensity (default is 1).
+ * @property {Boolean} cookieFalloff Toggle normal spotlight falloff when projection texture is used. When set to false, spotlight will work like a pure texture projector (only fading with distance). Default is false.
+ * @property {String} cookieChannel Color channels of the projection texture to use. Can be "r", "g", "b", "a", "rgb" or any swizzled combination.
+ * @property {Number} cookieAngle Angle for spotlight cookie rotation.
+ * @property {pc.Vec2} cookieScale Spotlight cookie scale.
+ * @property {pc.Vec2} cookieOffset Spotlight cookie position offset.
+ * @property {Boolean} isStatic Mark light as non-movable (optimization)
+ * @extends pc.Component
+ */
+ class LightComponent extends pc.Component {
+ constructor(system: pc.LightComponentSystem, entity: pc.Entity)
+
+ type: string;
+ color: pc.Color;
+ intensity: number;
+ castShadows: boolean;
+ shadowDistance: number;
+ shadowResolution: number;
+ shadowBias: number;
+ normalOffsetBias: number;
+ range: number;
+ innerConeAngle: number;
+ outerConeAngle: number;
+ falloffMode: number;
+ mask: number;
+ affectDynamic: boolean;
+ affectLightmapped: boolean;
+ bake: boolean;
+ bakeDir: boolean;
+ shadowUpdateMode: number;
+ shadowType: number;
+ vsmBlurMode: number;
+ vsmBlurSize: number;
+ cookieAsset: number;
+ cookie: pc.Texture;
+ cookieIntensity: number;
+ cookieFalloff: boolean;
+ cookieChannel: string;
+ cookieAngle: number;
+ cookieScale: pc.Vec2;
+ cookieOffset: pc.Vec2;
+ isStatic: boolean;
+
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/light/system.d.ts b/types/playcanvas/engine/framework/components/light/system.d.ts
new file mode 100644
index 0000000000..7e08c90074
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/light/system.d.ts
@@ -0,0 +1,13 @@
+declare namespace pc {
+
+ /*
+ * @name pc.LightComponentSystem
+ * @description Create a new LightComponentSystem.
+ * @class A Light Component is used to dynamically light the scene.
+ * @param {pc.Application} app The application.
+ * @extends pc.ComponentSystem
+ */
+ class LightComponentSystem extends pc.ComponentSystem {
+ constructor(app: pc.Application)
+ }
+}
\ No newline at end of file
diff --git a/types/playcanvas/engine/framework/components/model/component.d.ts b/types/playcanvas/engine/framework/components/model/component.d.ts
new file mode 100644
index 0000000000..b89d52721c
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/model/component.d.ts
@@ -0,0 +1,84 @@
+declare namespace pc {
+
+ /**
+ * @component
+ * @name pc.ModelComponent
+ * @description Create a new ModelComponent
+ * @class Enables an Entity to render a model or a primitive shape. This Component attaches additional model geometry in to the scene graph below the Entity.
+ * @param {pc.ModelComponentSystem} system The ComponentSystem that created this Component
+ * @param {pc.Entity} entity The Entity that this Component is attached to.
+ * @extends pc.Component
+ * @property {String} type The type of the model, which can be one of the following values:
+ *
+ * - asset: The component will render a model asset
+ * - box: The component will render a box
+ * - capsule: The component will render a capsule
+ * - cone: The component will render a cone
+ * - cylinder: The component will render a cylinder
+ * - sphere: The component will render a sphere
+ *
+ * @property {pc.Asset} asset The asset for the model (only applies to models of type 'asset') - can also be an asset id.
+ * @property {Boolean} castShadows If true, this model will cast shadows for lights that have shadow casting enabled.
+ * @property {Boolean} receiveShadows If true, shadows will be cast on this model
+ * @property {Number} materialAsset The material {@link pc.Asset} that will be used to render the model (not used on models of type 'asset')
+ * @property {pc.Model} model The model that is added to the scene graph. It can be not set or loaded, so will return null.
+ * @property {Object} mapping A dictionary that holds material overrides for each mesh instance. Only applies to model components of type 'asset'. The mapping contains pairs of mesh instance index - material asset id.
+ * @property {Boolean} castShadowsLightmap If true, this model will cast shadows when rendering lightmaps
+ * @property {Boolean} lightmapped If true, this model will be lightmapped after using lightmapper.bake()
+ * @property {Number} lightmapSizeMultiplier Lightmap resolution multiplier
+ * @property {Boolean} isStatic Mark model as non-movable (optimization)
+ * @property {pc.MeshInstance[]} meshInstances An array of meshInstances contained in the component's model. If model is not set or loaded for component it will return null.
+ * @property {Number} batchGroupId Assign model to a specific batch group (see {@link pc.BatchGroup}). Default value is -1 (no group).
+ */
+ class ModelComponent extends pc.Component {
+ constructor(system: pc.ModelComponentSystem, entity: pc.Entity)
+
+ type: string;
+ asset: pc.Asset;
+ castShadows: boolean;
+ receiveShadows: boolean;
+ materialAsset: number;
+ model: pc.Model;
+ mapping: {};
+ castShadowsLightmap: boolean;
+ lightmapped: boolean;
+ lightmapSizeMultiplier: number;
+ isStatic: boolean;
+ meshInstances: pc.MeshInstance[];
+ batchGroupId: number;
+
+ /**
+ * @function
+ * @name pc.ModelComponent#hide
+ * @description Stop rendering model without removing it from the scene hierarchy.
+ * This method sets the {@link pc.MeshInstance#visible} property of every MeshInstance in the model to false
+ * Note, this does not remove the model or mesh instances from the scene hierarchy or draw call list.
+ * So the model component still incurs some CPU overhead.
+ * @example
+ * this.timer = 0;
+ * this.visible = true;
+ * // ...
+ * // blink model every 0.1 seconds
+ * this.timer += dt;
+ * if (this.timer > 0.1) {
+ * if (!this.visible) {
+ * this.entity.model.show();
+ * this.visible = true;
+ * } else {
+ * this.entity.model.hide();
+ * this.visible = false;
+ * }
+ * this.timer = 0;
+ * }
+ */
+ hide(): void;
+
+ /**
+ * @function
+ * @name pc.ModelComponent#show
+ * @description Enable rendering of the model if hidden using {@link pc.ModelComponent#hide}.
+ * This method sets all the {@link pc.MeshInstance#visible} property on all mesh instances to true.
+ */
+ show(): void;
+ }
+}
\ No newline at end of file
diff --git a/types/playcanvas/engine/framework/components/model/system.d.ts b/types/playcanvas/engine/framework/components/model/system.d.ts
new file mode 100644
index 0000000000..5b2ae4b11b
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/model/system.d.ts
@@ -0,0 +1,14 @@
+declare namespace pc {
+
+ /**
+ * @name pc.ModelComponentSystem
+ * @description Create a new ModelComponentSystem
+ * @class Allows an Entity to render a model or a primitive shape like a box,
+ * capsule, sphere, cylinder, cone etc.
+ * @param {pc.Application} app The Application.
+ * @extends pc.ComponentSystem
+ */
+ class ModelComponentSystem extends pc.ComponentSystem {
+ constructor(app: pc.Application)
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/particle-system/component.d.ts b/types/playcanvas/engine/framework/components/particle-system/component.d.ts
new file mode 100644
index 0000000000..a6adbc2cb4
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/particle-system/component.d.ts
@@ -0,0 +1,168 @@
+declare namespace pc {
+
+ /**
+ * @component
+ * @name pc.ParticleSystemComponent
+ * @description Create a new ParticleSystemComponent
+ * @class Used to simulate particles and produce renderable particle mesh on either CPU or GPU.
+ * GPU simulation is generally much faster than its CPU counterpart, because it avoids slow CPU-GPU synchronization and takes advantage of many GPU cores.
+ * However, it requires client to support reasonable uniform count, reading from multiple textures in vertex shader and OES_texture_float extension, including rendering into float textures.
+ * Most mobile devices fail to satisfy these requirements, so it's not recommended to simulate thousands of particles on them. GPU version also can't sort particles, so enabling sorting forces CPU mode too.
+ * Particle rotation is specified by a single angle parameter: default billboard particles rotate around camera facing axis, while mesh particles rotate around 2 different view-independent axes.
+ * Most of the simulation parameters are specified with pc.Curve or pc.CurveSet. Curves are interpolated based on each particle's lifetime, therefore parameters are able to change over time.
+ * Most of the curve parameters can also be specified by 2 minimum/maximum curves, this way each particle will pick a random value in-between.
+ * @param {pc.ParticleSystemComponentSystem} system The ComponentSystem that created this Component
+ * @param {pc.Entity} entity The Entity this Component is attached to
+ * @extends pc.Component
+ * @property {Boolean} autoPlay Controls whether the particle system plays automatically on creation. If set to false, it is necessary to call {@link pc.ParticleSystemComponent#play} for the particle system to play. Defaults to true.
+ * @property {Boolean} loop Enables or disables respawning of particles.
+ * @property {Boolean} preWarm If enabled, the particle system will be initialized as though it had already completed a full cycle. This only works with looping particle systems.
+ * @property {Boolean} lighting If enabled, particles will be lit by ambient and directional lights.
+ * @property {Boolean} halfLambert Enabling Half Lambert lighting avoids particles looking too flat in shadowed areas. It is a completely non-physical lighting model but can give more pleasing visual results.
+ * @property {Boolean} alignToMotion Orient particles in their direction of motion.
+ * @property {Boolean} depthWrite If enabled, the particles will write to the depth buffer. If disabled, the depth buffer is left unchanged and particles will be guaranteed to overwrite one another in the order in which they are rendered.
+ * @property {Boolean} noFog Disable fogging
+ * @property {Number} numParticles Maximum number of simulated particles.
+ * @property {Number} rate Minimal interval in seconds between particle births.
+ * @property {Number} rate2 Maximal interval in seconds between particle births.
+ * @property {Number} startAngle Minimal initial Euler angle of a particle.
+ * @property {Number} startAngle2 Maximal initial Euler angle of a particle.
+ * @property {Number} lifetime The length of time in seconds between a particle's birth and its death.
+ * @property {Number} stretch A value in world units that controls the amount by which particles are stretched based on their velocity. Particles are stretched from their center towards their previous position.
+ * @property {Number} intensity Color multiplier.
+ * @property {Boolean} animLoop Controls whether the sprite sheet animation plays once or loops continuously.
+ * @property {Number} animTilesX Number of horizontal tiles in the sprite sheet.
+ * @property {Number} animTilesY Number of vertical tiles in the sprite sheet.
+ * @property {Number} animNumFrames Number of sprite sheet frames to play. It is valid to set the number of frames to a value less than animTilesX multiplied by animTilesY.
+ * @property {Number} animSpeed Sprite sheet animation speed. 1 = particle lifetime, 2 = twice during lifetime etc...
+ * @property {Number} depthSoftening Controls fading of particles near their intersections with scene geometry. This effect, when it's non-zero, requires scene depth map to be rendered. Multiple depth-dependent effects can share the same map, but if you only use it for particles, bear in mind that it can double engine draw calls.
+ * @property {Number} initialVelocity Defines magnitude of the initial emitter velocity. Direction is given by emitter shape.
+ * @property {pc.Vec3} emitterExtents (Only for EMITTERSHAPE_BOX) The extents of a local space bounding box within which particles are spawned at random positions.
+ * @property {Number} emitterRadius (Only for EMITTERSHAPE_SPHERE) The radius within which particles are spawned at random positions.
+ * @property {pc.Vec3} wrapBounds The half extents of a world space box volume centered on the owner entity's position. If a particle crosses the boundary of one side of the volume, it teleports to the opposite side.
+ * @property {pc.Texture} colorMap The color map texture to apply to all particles in the system. If no texture is assigned, a default spot texture is used.
+ * @property {pc.Texture} normalMap The normal map texture to apply to all particles in the system. If no texture is assigned, an approximate spherical normal is calculated for each vertex.
+ * @property {pc.EMITTERSHAPE} emitterShape Shape of the emitter. Defines the bounds inside which particles are spawned. Also affects the direction of initial velocity.
+ *
+ * - {@link pc.EMITTERSHAPE_BOX}: Box shape parameterized by emitterExtents. Initial velocity is directed towards local Z axis.
+ * - {@link pc.EMITTERSHAPE_SPHERE}: Sphere shape parameterized by emitterRadius. Initial velocity is directed outwards from the center.
+ *
+ * @property {pc.PARTICLESORT} sort Sorting mode. Forces CPU simulation, so be careful.
+ *
+ * - {@link pc.PARTICLESORT_NONE}: No sorting, particles are drawn in arbitary order. Can be simulated on GPU.
+ * - {@link pc.PARTICLESORT_DISTANCE}: Sorting based on distance to the camera. CPU only.
+ * - {@link pc.PARTICLESORT_NEWER_FIRST}: Newer particles are drawn first. CPU only.
+ * - {@link pc.PARTICLESORT_OLDER_FIRST}: Older particles are drawn first. CPU only.
+ *
+ * @property {pc.Mesh} mesh Triangular mesh to be used as a particle. Only first vertex/index buffer is used. Vertex buffer must contain local position at first 3 floats of each vertex.
+ * @property {pc.BLEND} blend Blending mode.
+ * @property {pc.CurveSet} localVelocityGraph Velocity relative to emitter over lifetime.
+ * @property {pc.CurveSet} localVelocityGraph2 If not null, particles pick random values between localVelocityGraph and localVelocityGraph2.
+ * @property {pc.CurveSet} velocityGraph World-space velocity over lifetime.
+ * @property {pc.CurveSet} velocityGraph2 If not null, particles pick random values between velocityGraph and velocityGraph2.
+ * @property {pc.CurveSet} colorGraph Color over lifetime.
+ * @property {pc.Curve} rotationSpeedGraph Rotation speed over lifetime.
+ * @property {pc.Curve} rotationSpeedGraph2 If not null, particles pick random values between rotationSpeedGraph and rotationSpeedGraph2.
+ * @property {pc.Curve} scaleGraph Scale over lifetime.
+ * @property {pc.Curve} scaleGraph2 If not null, particles pick random values between scaleGraph and scaleGraph2.
+ * @property {pc.Curve} alphaGraph Alpha over lifetime.
+ * @property {pc.Curve} alphaGraph2 If not null, particles pick random values between alphaGraph and alphaGraph2.
+ */
+ class ParticleSystemComponent extends pc.Component {
+ constructor(system: pc.ParticleSystemComponentSystem, entity: pc.Entity)
+
+ autoPlay: boolean;
+ loop: boolean;
+ preWarm: boolean;
+ lighting: boolean;
+ halfLambert: boolean;
+ alignToMotion: boolean;
+ depthWrite: boolean;
+ noFog: boolean;
+ numParticles: number;
+ rate: number;
+ rate2: number;
+ startAngle: number;
+ startAngle2: number;
+ lifetime: number;
+ stretch: number;
+ intensity: number;
+ animLoop: boolean;
+ animTilesX: number;
+ animTilesY: number;
+ animNumFrames: number;
+ animSpeed: number;
+ depthSoftening: number;
+ initialVelocity: number;
+ emitterExtents: pc.Vec3;
+ emitterRadius: number;
+ wrapBounds: pc.Vec3;
+ colorMap: pc.Texture;
+ normalMap: pc.Texture;
+ emmitterShape: number;
+ sort: number;
+ mesh: pc.Mesh;
+ blend: number;
+ localVelocityGraph: pc.CurveSet;
+ localVelocityGraph2: pc.CurveSet;
+ velocityGraph: pc.CurveSet;
+ velocityGraph2: pc.CurveSet;
+ colorGraph: pc.CurveSet;
+ rotationSpeedGraph: pc.Curve;
+ rotationSpeedGraph2: pc.Curve;
+ scaleGraph: pc.Curve;
+ scaleGraph2: pc.Curve;
+ alphaGraph: pc.Curve;
+ alphaGraph2: pc.Curve;
+
+ /**
+ * @function
+ * @name pc.ParticleSystemComponent#reset
+ * @description Resets particle state, doesn't affect playing.
+ */
+ reset(): void;
+
+ /**
+ * @function
+ * @name pc.ParticleSystemComponent#stop
+ * @description Disables the emission of new particles, lets existing to finish their simulation.
+ */
+ stop(): void;
+
+ /**
+ * @function
+ * @name pc.ParticleSystemComponent#pause
+ * @description Freezes the simulation.
+ */
+ pause(): void;
+
+ /**
+ * @function
+ * @name pc.ParticleSystemComponent#unpause
+ * @description Unfreezes the simulation.
+ */
+ unpause(): void;
+
+ /**
+ * @function
+ * @name pc.ParticleSystemComponent#play
+ * @description Enables/unfreezes the simulation.
+ */
+ play(): void;
+
+ /**
+ * @function
+ * @name pc.ParticleSystemComponent#isPlaying
+ * @description Checks if simulation is in progress.
+ */
+ isPlaying(): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.ParticleSystemComponent#rebuild
+ * @description Rebuilds all data used by this particle system.
+ */
+ private rebuild(): void;
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/particle-system/system.d.ts b/types/playcanvas/engine/framework/components/particle-system/system.d.ts
new file mode 100644
index 0000000000..576e5ded6b
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/particle-system/system.d.ts
@@ -0,0 +1,13 @@
+declare namespace pc {
+
+ /**
+ * @name pc.ParticleSystemComponentSystem
+ * @description Create a new ParticleSystemComponentSystem
+ * @class Allows an Entity to render a particle system
+ * @param {pc.Application} app The Application.
+ * @extends pc.ComponentSystem
+ */
+ class ParticleSystemComponentSystem extends pc.ComponentSystem {
+ constructor(app: pc.Application)
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/registry.d.ts b/types/playcanvas/engine/framework/components/registry.d.ts
new file mode 100644
index 0000000000..cf74a651b0
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/registry.d.ts
@@ -0,0 +1,39 @@
+declare namespace pc {
+
+ /**
+ * @name pc.ComponentSystemRegistry
+ * @class Store, access and delete instances of the various ComponentSystems
+ * @description Create a new ComponentSystemRegistry
+ */
+ class ComponentSystemRegistry {
+
+ /**
+ * @private
+ * @function
+ * @name pc.ComponentSystemRegistry#add
+ * @description Add a new Component type
+ * @param {Object} name The name of the Component
+ * @param {Object} component The {pc.ComponentSystem} instance
+ */
+ private add(name: string, system: pc.ComponentSystem): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.ComponentSystemRegistry#remove
+ * @description Remove a Component type
+ * @param {Object} name The name of the Component remove
+ */
+ remove(name: string): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.ComponentSystemRegistry#list
+ * @description Return the contents of the registry as an array, this order of the array
+ * is the order in which the ComponentSystems must be initialized.
+ * @returns {pc.ComponentSystem[]} An array of component systems.
+ */
+ list(): pc.ComponentSystem[];
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/rigid-body.d.ts/component.d.ts b/types/playcanvas/engine/framework/components/rigid-body.d.ts/component.d.ts
new file mode 100644
index 0000000000..ff98a9437d
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/rigid-body.d.ts/component.d.ts
@@ -0,0 +1,366 @@
+declare namespace pc {
+ type rigidBodyType = 'pc.BODYTYPE_STATIC' | 'pc.BODYTYPE_DYNAMIC' | 'pc.BODYTYPE_KINEMATIC'
+
+ /**
+ * @component
+ * @name pc.RigidBodyComponent
+ * @description Create a new RigidBodyComponent
+ * @class The rigidbody component, when combined with a {@link pc.CollisionComponent}, allows your
+ * entities to be simulated using realistic physics.
+ * A rigidbody component will fall under gravity and collide with other rigid bodies. Using scripts, you
+ * can apply forces and impulses to rigid bodies.
+ * @param {pc.RigidBodyComponentSystem} system The ComponentSystem that created this component
+ * @param {pc.Entity} entity The entity this component is attached to
+ * @extends pc.Component
+ * @property {Number} mass The mass of the body. This is only relevant for {@link pc.BODYTYPE_DYNAMIC}
+ * bodies, other types have infinite mass. Defaults to 1.
+ * @property {pc.Vec3} linearVelocity Defines the speed of the body in a given direction.
+ * @property {pc.Vec3} angularVelocity Defines the rotational speed of the body around each world axis.
+ * @property {Number} linearDamping Controls the rate at which a body loses linear velocity over time.
+ * Defaults to 0.
+ * @property {Number} angularDamping Controls the rate at which a body loses angular velocity over time.
+ * Defaults to 0.
+ * @property {pc.Vec3} linearFactor Scaling factor for linear movement of the body in each axis.
+ * Defaults to 1 in all axes.
+ * @property {pc.Vec3} angularFactor Scaling factor for angular movement of the body in each axis.
+ * Defaults to 1 in all axes.
+ * @property {Number} friction The friction value used when contacts occur between two bodies. A higher
+ * value indicates more friction. Should be set in the range 0 to 1. Defaults to 0.5.
+ * @property {Number} restitution Influences the amount of energy lost when two rigid bodies collide. The
+ * calculation multiplies the restitution values for both colliding bodies. A multiplied value of 0 means
+ * that all energy is lost in the collision while a value of 1 means that no energy is lost. Should be
+ * set in the range 0 to 1. Defaults to 0.
+ * @property {Number} group The collision group this body belongs to. Combine the group and the mask to
+ * prevent bodies colliding with each other. Defaults to 1.
+ * @property {Number} mask The collision mask sets which groups this body collides with. It is a bitfield
+ * of 16 bits, the first 8 bits are reserved for engine use. Defaults to 65535.
+ * @property {String} type The rigid body type determines how the body is simulated. Can be:
+ *
+ * - pc.BODYTYPE_STATIC: infinite mass and cannot move.
+ * - pc.BODYTYPE_DYNAMIC: simulated according to applied forces.
+ * - pc.BODYTYPE_KINEMATIC: infinite mass and does not respond to forces but can still be moved by setting their velocity or position.
+ *
+ * Defaults to pc.BODYTYPE_STATIC.
+ */
+ class RigidBodyComponent extends pc.Component {
+ constructor(system: pc.RigidBodyComponentSystem, entity: pc.Entity)
+
+ /**
+ * Controls the rate at which a body loses angular velocity over time.
+ * @type {number}
+ * @memberof RigidBodyComponent
+ */
+ angularDamping: number;
+
+ /**
+ * Scaling factor for angular movement of the body in each axis.
+ * @type {pc.Vec3}
+ * @memberof RigidBodyComponent
+ */
+ angularFactor: pc.Vec3;
+
+ /**
+ * Defines the rotational speed of the body around each world axis.
+ * @type {pc.Vec3}
+ * @memberof RigidBodyComponent
+ */
+ angularVelocity: pc.Vec3;
+
+ /**
+ * The friction value used when contacts occur between two bodies. A higher value
+ * indicates more friction. Should be set in the range 0 to 1. Defaults to 0.5.
+ * @type {number}
+ * @memberof RigidBodyComponent
+ */
+ friction: number;
+
+ /**
+ * The collision group this body belongs to. Combine the group and the mask to
+ * prevent bodies colliding with each other. Defaults to 1.
+ * @type {number}
+ * @memberof RigidBodyComponent
+ */
+ group: number;
+
+ /**
+ * Controls the rate at which a body loses linear velocity over time.
+ * Defaults to 0.
+ * @type {number}
+ * @memberof RigidBodyComponent
+ */
+ linearDamping: number;
+
+ /**
+ * Scaling factor for linear movement of the body in each axis.
+ * Defaults to 1 in all axes.
+ * @type {pc.Vec3}
+ * @memberof RigidBodyComponent
+ */
+ linearFactor: pc.Vec3;
+
+ /**
+ * Defines the speed of the body in a given direction.
+ * @type {pc.Vec3}
+ * @memberof RigidBodyComponent
+ */
+ linearVelocity: pc.Vec3;
+
+ /**
+ * The collision mask sets which groups this body collides with. It is a bitfield
+ * of 16 bits, the first 8 bits are reserved for engine use. Defaults to 65535.
+ * @type {number}
+ * @memberof RigidBodyComponent
+ */
+ mask: number;
+
+ /**
+ * The mass of the body. This is only relevant for {@link pc.BODYTYPE_DYNAMIC}
+ * bodies, other types have infinite mass. Defaults to 1.
+ * @type {number}
+ * @memberof RigidBodyComponent
+ */
+ mass: number;
+
+ /**
+ * Influences the amount of energy lost when two rigid bodies collide. The
+ * calculation multiplies the restitution values for both colliding bodies. A multiplied value of 0 means
+ * that all energy is lost in the collision while a value of 1 means that no energy is lost. Should be
+ * set in the range 0 to 1. Defaults to 0.
+ * @type {number}
+ * @memberof RigidBodyComponent
+ */
+ restitution: number;
+
+ /**
+ * The rigid body type determines how the body is simulated. Can be:
+ *
+ * - pc.BODYTYPE_STATIC: infinite mass and cannot move.
+ * - pc.BODYTYPE_DYNAMIC: simulated according to applied forces.
+ * - pc.BODYTYPE_KINEMATIC: infinite mass and does not respond to forces but can still be moved by setting their velocity or position.
+ *
+ * Defaults to pc.BODYTYPE_STATIC.
+ * @type {string}
+ * @memberof RigidBodyComponent
+ */
+ type: rigidBodyType;
+
+
+
+ /**
+ * @private
+ * @function
+ * @name pc.RigidBodyComponent#createBody
+ * @description If the Entity has a Collision shape attached then create a rigid body using this shape. This method destroys the existing body.
+ */
+ private createBody(): void;
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponent#isActive
+ * @description Returns true if the rigid body is currently actively being simulated. i.e. not 'sleeping'
+ * @returns {Boolean} True if the body is active
+ */
+ isActive(): boolean;
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponent#activate
+ * @description Forcibly activate the rigid body simulation
+ */
+ activate(): void;
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponent#applyForce
+ * @description Apply an force to the body at a point. By default, the force is applied at the origin of the
+ * body. However, the force can be applied at an offset this point by specifying a world space vector from
+ * the body's origin to the point of application.
+ * @param {Number} x The x component of the force to apply, in world space.
+ * @param {Number} y The y component of the force to apply, in world space.
+ * @param {Number} z The z component of the force to apply, in world space.
+ * @param {Number} [px] The x component of a world space offset from the body's position where the force is applied.
+ * @param {Number} [py] The y component of a world space offset from the body's position where the force is applied.
+ * @param {Number} [pz] The z component of a world space offset from the body's position where the force is applied.
+ * @example
+ * // EXAMPLE 1: Apply an approximation of gravity at the body's center
+ * this.entity.rigidbody.applyForce(0, -10, 0);
+ *
+ * // EXAMPLE 2: Apply an approximation of gravity at 1 unit down the world Z from the center of the body
+ * this.entity.rigidbody.applyForce(0, -10, 0, 0, 0, 1);
+ */
+ applyForce(x: number, y: number, z: number, px?: number, py?: number, pz?: number): void;
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponent#applyForce^2
+ * @description Apply an force to the body at a point. By default, the force is applied at the origin of the
+ * body. However, the force can be applied at an offset this point by specifying a world space vector from
+ * the body's origin to the point of application.
+ * @param {pc.Vec3} force The force to apply, in world space.
+ * @param {pc.Vec3} [relativePoint] A world space offset from the body's position where the force is applied.
+ * @example
+ * // EXAMPLE 1: Apply a force at the body's center
+ * // Calculate a force vector pointing in the world space direction of the entity
+ * var force = this.entity.forward.clone().scale(100);
+ *
+ * // Apply the force
+ * this.entity.rigidbody.applyForce(force);
+ *
+ * // EXAMPLE 2: Apply a force at some relative offset from the body's center
+ * // Calculate a force vector pointing in the world space direction of the entity
+ * var force = this.entity.forward.clone().scale(100);
+ *
+ * // Calculate the world space relative offset
+ * var relativePos = new pc.Vec3();
+ * var childEntity = this.entity.findByName('Engine');
+ * relativePos.sub2(childEntity.getPosition(), this.entity.getPosition());
+ *
+ * // Apply the force
+ * this.entity.rigidbody.applyForce(force, relativePos);
+ */
+ applyForce(force: pc.Vec3, relativePoint: pc.Vec3): void;
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponent#applyTorque
+ * @description Apply torque (rotational force) to the body.
+ * @param {Number} x The x component of the torque to apply, in world space.
+ * @param {Number} y The y component of the torque to apply, in world space.
+ * @param {Number} z The z component of the torque to apply, in world space.
+ */
+ applyTorque(x: number, y: number, z: number): void;
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponent#applyTorque^2
+ * @description Apply torque (rotational force) to the body.
+ * @param {pc.Vec3} force The torque to apply, in world space.
+ */
+ applyTorque(force: pc.Vec3): void;
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponent#applyImpulse
+ * @description Apply an impulse (instantaneous change of velocity) to the body at a point.
+ * @param {Number} x The x component of the impulse to apply, in world space.
+ * @param {Number} y The y component of the impulse to apply, in world space.
+ * @param {Number} z The z component of the impulse to apply, in world space.
+ * @param {Number} [px] The x component of the point at which to apply the impulse, in local space (relative to the Entity).
+ * @param {Number} [py] The y component of the point at which to apply the impulse, in local space (relative to the Entity).
+ * @param {Number} [pz] The z component of the point at which to apply the impulse, in local space (relative to the Entity).
+ */
+ applyImpulse(x: number, y: number, z: number, px?: number, py?: number, pz?: number): void;
+
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponent#applyImpulse^2
+ * @description Apply an impulse (instantaneous change of velocity) to the body at a point.
+ * @param {pc.Vec3} impulse The impulse to apply, in world space.
+ * @param {pc.Vec3} [relativePoint] The point at which to apply the impulse, in local space (relative to the entity).
+ */
+ applyImpulse(impulse: pc.Vec3, relativePoint?: pc.Vec3): void;
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponent#applyTorqueImpulse
+ * @description Apply a torque impulse (rotational force applied instantaneously) to the body.
+ * @param {Number} x The x component of the torque impulse to apply, in world space.
+ * @param {Number} y The y component of the torque impulse to apply, in world space.
+ * @param {Number} z The z component of the torque impulse to apply, in world space.
+ */
+ applyTorqueImpulse(x: number, y: number, z: number): void;
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponent#applyTorqueImpulse^2
+ * @description Apply a torque impulse (rotational force applied instantaneously) to the body.
+ * @param {pc.Vec3} torqueImpulse The torque impulse to apply, in world space.
+ */
+ applyTorqueImpulse(torqueImpulse: pc.Vec3): void;
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponent#isStatic
+ * @description Returns true if the rigid body is of type {@link pc.BODYTYPE_STATIC}
+ * @returns {Boolean} True if static
+ */
+ isStatic(): boolean;
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponent#isStaticOrKinematic
+ * @description Returns true if the rigid body is of type {@link pc.BODYTYPE_STATIC} or {@link pc.BODYTYPE_KINEMATIC}
+ * @returns {Boolean} True if static or kinematic
+ */
+ isStaticOrKinematic(): boolean;
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponent#isKinematic
+ * @description Returns true if the rigid body is of type {@link pc.BODYTYPE_KINEMATIC}
+ * @returns {Boolean} True if kinematic
+ */
+ isKinematic(): boolean;
+
+
+ /**
+ * @private
+ * @function
+ * @name pc.RigidBodyComponent#syncEntityToBody
+ * @description Set the rigid body transform to be the same as the Entity transform.
+ * This must be called after any Entity transformation functions (e.g. {@link pc.Entity#setPosition}) are called
+ * in order to update the rigid body to match the Entity.
+ */
+ private syncEntityToBody(): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.RigidBodyComponent#syncBodyToEntity
+ * @description Update the Entity transform from the rigid body.
+ * This is called internally after the simulation is stepped, to keep the Entity transform in sync with the rigid body transform.
+ */
+ private syncBodyToEntity(): void;
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponent#teleport
+ * @description Teleport an entity to a new position and/or orientation
+ * @param {pc.Vec3} position The new position
+ * @param {pc.Vec3} [angles] The new set of Euler angles
+ */
+ teleport(position: pc.Vec3, angles?: pc.Vec3): void;
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponent#teleport^2
+ * @description Teleport an entity to a new position and/or orientation
+ * @param {pc.Vec3} position The new position
+ * @param {pc.Quat} [rotation] The new rotation
+ */
+ teleport(position: pc.Vec3, rotation?: pc.Vec3): void;
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponent#teleport^3
+ * @description Teleport an entity to a new position and/or orientation
+ * @param {Number} x The new position x value
+ * @param {Number} y The new position y value
+ * @param {Number} z The new position z value
+ * @param {Number} [x] The new x angle value
+ * @param {Number} [y] The new y angle value
+ * @param {Number} [z] The new z angle value
+ */
+ teleport(x: number, y: number, z: number, ax?: number, ay?: number, az?: number): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.RigidBodyComponent#_updateKinematic
+ * @description Kinematic objects maintain their own linear and angular velocities. This method updates their transform
+ * based on their current velocity. It is called in every frame in the main physics update loop, after the simulation is stepped.
+ */
+ private _updateKinematic(dt: number): void;
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/rigid-body.d.ts/constants.d.ts b/types/playcanvas/engine/framework/components/rigid-body.d.ts/constants.d.ts
new file mode 100644
index 0000000000..9ab24aa387
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/rigid-body.d.ts/constants.d.ts
@@ -0,0 +1,44 @@
+declare namespace pc {
+ // types
+ const BODYTYPE_STATIC = 'static';
+ const BODYTYPE_DYNAMIC = 'dynamic';
+ const BODYTYPE_KINEMATIC = 'kinematic';
+
+ // Collision flags
+ const BODYFLAG_STATIC_OBJECT = 1;
+ const BODYFLAG_KINEMATIC_OBJECT = 2;
+ const BODYFLAG_NORESPONSE_OBJECT = 4;
+
+ // Activation states
+ const BODYSTATE_ACTIVE_TAG = 1;
+ const BODYSTATE_ISLAND_SLEEPING = 2;
+ const BODYSTATE_WANTS_DEACTIVATION = 3;
+ const BODYSTATE_DISABLE_DEACTIVATION = 4;
+ const BODYSTATE_DISABLE_SIMULATION = 5;
+
+ // groups
+ const BODYGROUP_NONE = 0;
+ const BODYGROUP_DEFAULT = 1;
+ const BODYGROUP_DYNAMIC = 1;
+ const BODYGROUP_STATIC = 2;
+ const BODYGROUP_KINEMATIC = 4;
+ const BODYGROUP_ENGINE_1 = 8;
+ const BODYGROUP_TRIGGER = 16;
+ const BODYGROUP_ENGINE_2 = 32;
+ const BODYGROUP_ENGINE_3 = 64;
+ const BODYGROUP_USER_1 = 128;
+ const BODYGROUP_USER_2 = 256;
+ const BODYGROUP_USER_3 = 512;
+ const BODYGROUP_USER_4 = 1024;
+ const BODYGROUP_USER_5 = 2048;
+ const BODYGROUP_USER_6 = 4096;
+ const BODYGROUP_USER_7 = 8192;
+ const BODYGROUP_USER_8 = 16384;
+
+ // masks
+ const BODYMASK_NONE = 0;
+ const BODYMASK_ALL = 65535;
+ const BODYMASK_STATIC = 2;
+ const BODYMASK_NOT_STATIC: number;
+ const BODYMASK_NOT_STATIC_KINEMATIC: number;
+}
\ No newline at end of file
diff --git a/types/playcanvas/engine/framework/components/rigid-body.d.ts/system.d.ts b/types/playcanvas/engine/framework/components/rigid-body.d.ts/system.d.ts
new file mode 100644
index 0000000000..62e0cf2ec2
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/rigid-body.d.ts/system.d.ts
@@ -0,0 +1,130 @@
+declare namespace pc {
+
+ /**
+ * @name pc.RaycastResult
+ * @class Object holding the result of a successful raycast hit
+ * @description Create a new RaycastResult
+ * @param {pc.Entity} entity The entity that was hit
+ * @param {pc.Vec3} point The point at which the ray hit the entity in world space
+ * @param {pc.Vec3} normal The normal vector of the surface where the ray hit in world space.
+ * @property {pc.Entity} entity The entity that was hit
+ * @property {pc.Vec3} point The point at which the ray hit the entity in world space
+ * @property {pc.Vec3} normal The normal vector of the surface where the ray hit in world space.
+ */
+ class RaycastResult {
+ constructor(entity: pc.Entity, point: pc.Vec3, normal: pc.Vec3)
+
+ entity: pc.Entity;
+ point: pc.Vec3;
+ normal: pc.Vec3;
+ }
+
+ /**
+ * @name pc.SingleContactResult
+ * @class Object holding the result of a contact between two rigid bodies
+ * @description Create a new SingleContactResult
+ * @param {pc.Entity} a The first entity involved in the contact
+ * @param {pc.Entity} b The second entity involved in the contact
+ * @param {pc.ContactPoint} contactPoint The contact point between the two entities
+ * @property {pc.Entity} a The first entity involved in the contact
+ * @property {pc.Entity} b The second entity involved in the contact
+ * @property {pc.Vec3} localPointA The point on Entity A where the contact occurred, relative to A
+ * @property {pc.Vec3} localPointB The point on Entity B where the contact occurred, relative to B
+ * @property {pc.Vec3} pointA The point on Entity A where the contact occurred, in world space
+ * @property {pc.Vec3} pointB The point on Entity B where the contact occurred, in world space
+ * @property {pc.Vec3} normal The normal vector of the contact on Entity B, in world space
+ */
+ class SingleContactResult {
+ constructor(a: pc.Entity, b: pc.Entity, contactPoint: pc.ContactPoint)
+
+ a: pc.Entity;
+ b: pc.Entity;
+ localPointA: pc.Vec3;
+ localPointB: pc.Vec3;
+ pointA: pc.Vec3;
+ pointB: pc.Vec3;
+ normal: pc.Vec3
+ }
+
+ /**
+ * @name pc.ContactPoint
+ * @class Object holding the result of a contact between two Entities.
+ * @description Create a new ContactPoint
+ * @param {pc.Vec3} localPoint The point on the entity where the contact occurred, relative to the entity
+ * @param {pc.Vec3} localPointOther The point on the other entity where the contact occurred, relative to the other entity
+ * @param {pc.Vec3} point The point on the entity where the contact occurred, in world space
+ * @param {pc.Vec3} pointOther The point on the other entity where the contact occurred, in world space
+ * @param {pc.Vec3} normal The normal vector of the contact on the other entity, in world space
+ * @property {pc.Vec3} localPoint The point on the entity where the contact occurred, relative to the entity
+ * @property {pc.Vec3} localPointOther The point on the other entity where the contact occurred, relative to the other entity
+ * @property {pc.Vec3} point The point on the entity where the contact occurred, in world space
+ * @property {pc.Vec3} pointOther The point on the other entity where the contact occurred, in world space
+ * @property {pc.Vec3} normal The normal vector of the contact on the other entity, in world space
+ */
+ class ContactPoint {
+ constructor(localPoint: pc.Vec3, localPointOther: pc.Vec3, point: pc.Vec3, pointOther: pc.Vec3, normal: pc.Vec3)
+
+ localPoint: pc.Vec3;
+ localPointOther: pc.Vec3;
+ point: pc.Vec3;
+ pointOther: pc.Vec3;
+ normal: pc.Vec3;
+ }
+
+ /**
+ * @name pc.ContactResult
+ * @class Object holding the result of a contact between two Entities
+ * @description Create a new ContactResult
+ * @param {pc.Entity} other The entity that was involved in the contact with this entity
+ * @param {pc.ContactPoint[]} contacts An array of ContactPoints with the other entity
+ * @property {pc.Entity} other The entity that was involved in the contact with this entity
+ * @property {pc.ContactPoint[]} contacts An array of ContactPoints with the other entity
+ */
+ class ContactResult {
+ constructor(other: pc.Entity, contacts: pc.ContactPoint[])
+
+ other: pc.Entity;
+ contacts: pc.ContactPoint[];
+ }
+
+ /**
+ * @name pc.RigidBodyComponentSystem
+ * @description Create a new RigidBodyComponentSystem
+ * @class The RigidBodyComponentSystem maintains the dynamics world for simulating rigid bodies, it also controls global values for the world such as gravity.
+ * Note: The RigidBodyComponentSystem is only valid if 3D Physics is enabled in your application. You can enable this in the application settings for your Depot.
+ * @param {pc.Application} app The Application
+ * @extends pc.ComponentSystem
+ */
+ class RigidBodyComponentSystem extends pc.ComponentSystem {
+ constructor(app: pc.Application)
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponentSystem#setGravity
+ * @description Set the gravity vector for the 3D physics world
+ * @param {Number} x The x-component of the gravity vector
+ * @param {Number} y The y-component of the gravity vector
+ * @param {Number} z The z-component of the gravity vector
+ */
+ setGravity(x: number, y: number, z: number): void;
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponentSystem#setGravity^2
+ * @description Set the gravity vector for the 3D physics world
+ * @param {pc.Vec3} gravity The gravity vector to use for the 3D physics world.
+ */
+ setGravity(gravity: pc.Vec3): void;
+
+ /**
+ * @function
+ * @name pc.RigidBodyComponentSystem#raycastFirst
+ * @description Raycast the world and return the first entity the ray hits. Fire a ray into the world from start to end,
+ * if the ray hits an entity with a rigidbody component, it returns a {@link pc.RaycastResult}, otherwise returns null.
+ * @param {pc.Vec3} start The world space point where the ray starts
+ * @param {pc.Vec3} end The world space point where the ray ends
+ * @returns {pc.RaycastResult} The result of the raycasting or null if there was no hit.
+ */
+ raycastFirst(start: pc.Vec3, end: pc.Vec3): pc.RaycastResult;
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/screen/component.d.ts b/types/playcanvas/engine/framework/components/screen/component.d.ts
new file mode 100644
index 0000000000..049c550db8
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/screen/component.d.ts
@@ -0,0 +1,47 @@
+declare namespace pc {
+
+ /**
+ * @enum pc.SCALEMODE
+ * @name pc.SCALEMODE_NONE
+ * @description Always use the application's resolution as the resolution for the {@link pc.ScreenComponent}.
+ */
+ const SCALEMODE_NONE = "none";
+ /**
+ * @enum pc.SCALEMODE
+ * @name pc.SCALEMODE_BLEND
+ * @description Scale the {@link pc.ScreenComponent} when the application's resolution is different than the ScreenComponent's referenceResolution.
+ */
+ const SCALEMODE_BLEND = "blend";
+
+ /**
+ * @component
+ * @name pc.ScreenComponent
+ * @description Create a new ScreenComponent
+ * @class A ScreenComponent enables the Entity to render child {@link pc.ElementComponent}s using anchors and positions in the ScreenComponent's space.
+ * @param {pc.ScreenComponentSystem} system The ComponentSystem that created this Component
+ * @param {pc.Entity} entity The Entity that this Component is attached to.
+ * @extends pc.Component
+ * @property {Boolean} screenSpace If true then the ScreenComponent will render its child {@link pc.ElementComponent}s in screen space instead of world space. Enable this to create 2D user interfaces.
+ * @property {String} scaleMode Can either be {@link pc.SCALEMODE_NONE} or {@link pc.SCALEMODE_BLEND}. See the description of referenceResolution for more information.
+ * @property {Number} scaleBlend A value between 0 and 1 that is used when scaleMode is equal to {@link pc.SCALEMODE_BLEND}. Scales the ScreenComponent with width as a reference (when value is 0), the height as a reference (when value is 1) or anything in between.
+ * @property {pc.Vec2} resolution The width and height of the ScreenComponent. When screenSpace is true the resolution will always be equal to {@link pc.GraphicsDevice#width} x {@link pc.GraphicsDevice#height}.
+ * @property {pc.Vec2} referenceResolution The resolution that the ScreenComponent is designed for. This is only taken into account when screenSpace is true and scaleMode is {@link pc.SCALEMODE_BLEND}. If the actual resolution is different then the ScreenComponent will be scaled according to the scaleBlend value.
+ */
+ class ScreenComponent extends pc.Component {
+ constructor(system: pc.ScreenComponentSystem, entity: pc.Entity)
+
+ screenSpace: boolean;
+ scaleMode: string;
+ scaleBlend: number;
+ resolution: pc.Vec2;
+ referenceResolution: pc.Vec2;
+
+ /**
+ * @function
+ * @name pc.ScreenComponent#syncDrawOrder
+ * @description Set the drawOrder of each child {@link pc.ElementComponent}
+ * so that ElementComponents which are last in the hierarchy are rendered on top.
+ */
+ syncDrawOrder(): void;
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/screen/system.d.ts b/types/playcanvas/engine/framework/components/screen/system.d.ts
new file mode 100644
index 0000000000..0b10ce156a
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/screen/system.d.ts
@@ -0,0 +1,13 @@
+declare namespace pc {
+
+ /**
+ * @name pc.ScreenComponentSystem
+ * @description Create a new ScreenComponentSystem
+ * @class Manages creation of {@link pc.ScreenComponent}s.
+ * @param {pc.Application} app The application
+ * @extends pc.ComponentSystem
+ */
+ class ScreenComponentSystem extends pc.ComponentSystem {
+ constructor(app: pc.Application)
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/script/component.d.ts b/types/playcanvas/engine/framework/components/script/component.d.ts
new file mode 100644
index 0000000000..dbaf70b569
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/script/component.d.ts
@@ -0,0 +1,74 @@
+declare namespace pc {
+
+ /**
+ * @component
+ * @name pc.ScriptComponent
+ * @class The ScriptComponent allows you to extend the functionality of an Entity by attaching your own Script Types defined in JavaScript files
+ * to be executed with access to the Entity. For more details on scripting see Scripting.
+ * @param {pc.ScriptComponentSystem} system The ComponentSystem that created this Component
+ * @param {pc.Entity} entity The Entity that this Component is attached to.
+ * @extends pc.Component
+ * @property {ScriptType[]} scripts An array of all script instances attached to an entity. This Array shall not be modified by developer.
+ */
+ class ScriptComponent extends pc.Component {
+ constructor(system: pc.ScriptComponentSystem, entity: pc.Entity)
+
+ scripts: ScriptType[]
+
+ /**
+ * @function
+ * @name pc.ScriptComponent#has
+ * @description Detect if script is attached to an entity using name of {@link ScriptType}.
+ * @param {String} name The name of the Script Type
+ * @returns {Boolean} If script is attached to an entity
+ * @example
+ * if (entity.script.has('playerController')) {
+ * // entity has script
+ * }
+ */
+ has(name: string): boolean;
+
+ /**
+ * @function
+ * @name pc.ScriptComponent#create
+ * @description Create a script instance using name of a {@link ScriptType} and attach to an entity script component.
+ * @param {String} name The name of the Script Type
+ * @param {Object} [args] Object with arguments for a script
+ * @param {Boolean} [args.enabled] if script instance is enabled after creation
+ * @param {Object} [args.attributes] Object with values for attributes, where key is name of an attribute
+ * @returns {ScriptType} Returns an instance of a {@link ScriptType} if successfully attached to an entity,
+ * or null if it failed because a script with a same name has already been added
+ * or if the {@link ScriptType} cannot be found by name in the {@link pc.ScriptRegistry}.
+ * @example
+ * entity.script.create('playerController', {
+ * attributes: {
+ * speed: 4
+ * }
+ * });
+ */
+ create(name: string, args?: { enabled?: boolean, attributes?: {}}): ScriptType;
+
+ /**
+ * @function
+ * @name pc.ScriptComponent#destroy
+ * @description Destroy the script instance that is attached to an entity.
+ * @param {String} name The name of the Script Type
+ * @returns {Boolean} If it was successfully destroyed
+ * @example
+ * entity.script.destroy('playerController');
+ */
+ destroy(name: string): boolean;
+
+ /**
+ * @function
+ * @name pc.ScriptComponent#move
+ * @description Move script instance to different position to alter update order of scripts within entity.
+ * @param {String} name The name of the Script Type
+ * @param {Number} ind New position index
+ * @returns {Boolean} If it was successfully moved
+ * @example
+ * entity.script.move('playerController', 0);
+ */
+ move(name: string, ind: number): boolean;
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/script/system.d.ts b/types/playcanvas/engine/framework/components/script/system.d.ts
new file mode 100644
index 0000000000..0c51f890e5
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/script/system.d.ts
@@ -0,0 +1,13 @@
+declare namespace pc {
+
+ /**
+ * @name pc.ScriptComponentSystem
+ * @description Create a new ScriptComponentSystem
+ * @class Allows scripts to be attached to an Entity and executed
+ * @param {pc.Application} app The application
+ * @extends pc.ComponentSystem
+ */
+ class ScriptComponentSystem extends pc.ComponentSystem {
+ constructor(app: pc.Application)
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/sound/component.d.ts b/types/playcanvas/engine/framework/components/sound/component.d.ts
new file mode 100644
index 0000000000..0363d61a8f
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/sound/component.d.ts
@@ -0,0 +1,148 @@
+declare namespace pc {
+
+ /**
+ * @component
+ * @name pc.SoundComponent
+ * @class The Sound Component controls playback of {@link pc.Sound}s.
+ * @description Create a new Sound Component
+ * @param {pc.SoundComponentSystem} system The ComponentSystem that created this Component
+ * @param {pc.Entity} entity The entity that the Component is attached to
+ * @extends pc.Component
+ * @property {Number} volume The volume modifier to play the audio with. In range 0-1.
+ * @property {Number} pitch The pitch modifier to play the audio with. Must be larger than 0.01
+ * @property {Boolean} positional If true the audio will play back at the location of the Entity in space, so the audio will be affect by the position of the {@link pc.AudioListenerComponent}.
+ * @property {String} distanceModel Determines which algorithm to use to reduce the volume of the sound as it moves away from the listener. Can be one of {@link pc.DISTANCE_LINEAR}, {@link pc.DISTANCE_INVERSE} or {@link pc.DISTANCE_EXPONENTIAL}. Default is {@link pc.DISTANCE_LINEAR}.
+ * @property {Number} refDistance The reference distance for reducing volume as the sound source moves further from the listener.
+ * @property {Number} maxDistance The maximum distance from the listener at which audio falloff stops. Note the volume of the audio is not 0 after this distance, but just doesn't fall off anymore.
+ * @property {Number} rollOffFactor The factor used in the falloff equation.
+ * @property {Object} slots A dictionary that contains the {@link pc.SoundSlot}s managed by this Component.
+ */
+ class SoundComponent extends pc.Component {
+ constructor(system: pc.SoundComponentSystem, entity: pc.Entity)
+
+ volume: number;
+ pitch: number;
+ positional: boolean;
+ distanceModel: string;
+ refDistance: number;
+ maxDistance: number;
+ rollOffFactor: number;
+ slots: {};
+
+ /**
+ * @function
+ * @name pc.SoundComponent#addSlot
+ * @description Creates a new {@link pc.SoundSlot} with the specified name.
+ * @param {String} name The name of the slot
+ * @param {Object} options Settings for the slot
+ * @param {Number} [options.volume=1] The playback volume, between 0 and 1.
+ * @param {Number} [options.pitch=1] The relative pitch, default of 1, plays at normal pitch.
+ * @param {Boolean} [options.loop=false] If true the sound will restart when it reaches the end.
+ * @param {Number} [options.startTime=0] The start time from which the sound will start playing.
+ * @param {Number} [options.duration=null] The duration of the sound that the slot will play starting from startTime.
+ * @param {Boolean} [options.overlap=false] If true then sounds played from slot will be played independently of each other. Otherwise the slot will first stop the current sound before starting the new one.
+ * @param {Boolean} [options.autoPlay=false] If true the slot will start playing as soon as its audio asset is loaded.
+ * @param {Number} [options.asset=null] The asset id of the audio asset that is going to be played by this slot.
+ * @returns {pc.SoundSlot} The new slot.
+ * @example
+ * // get an asset by id
+ * var asset = app.assets.get(10);
+ * // add a slot
+ * this.entity.sound.addSlot('beep', {
+ * asset: asset
+ * });
+ * // play
+ * this.entity.sound.play('beep');
+ */
+ addSlot(name: string, options?: {
+ volume?: number;
+ pitch?: number;
+ loop?: boolean;
+ startTime?: number;
+ duration?: number;
+ overlap?: boolean;
+ autoPlay?: boolean;
+ asset?: number;
+ }): pc.SoundSlot;
+
+ /**
+ * @function
+ * @name pc.SoundComponent#removeSlot
+ * @description Removes the {@link pc.SoundSlot} with the specified name.
+ * @param {String} name The name of the slot
+ * @example
+ * // remove a slot called 'beep'
+ * this.entity.sound.removeSlot('beep');
+ */
+ removeSlot(name: string): void;
+
+ /**
+ * @function
+ * @name pc.SoundComponent#slot
+ * @description Returns the slot with the specified name
+ * @param {String} name The name of the slot
+ * @returns {pc.SoundSlot} The slot
+ * @example
+ * // get a slot and set its volume
+ * this.entity.sound.slot('beep').volume = 0.5;
+ *
+ */
+ slot(name: string): pc.Slot;
+
+ /**
+ * @function
+ * @name pc.SoundComponent#play
+ * @description Begins playing the sound slot with the specified name. The slot will restart playing if it is already playing unless the overlap field is true in which case a new sound will be created and played.
+ * @param {String} name The name of the {@link pc.SoundSlot} to play
+ * @example
+ * // get asset by id
+ * var asset = app.assets.get(10);
+ * // create a slot and play it
+ * this.entity.sound.addSlot('beep', {
+ * asset: asset
+ * });
+ * this.entity.sound.play('beep');
+ * @returns {pc.SoundInstance} The sound instance that will be played.
+ */
+ play(name: string): pc.SoundInstance;
+
+ /**
+ * @function
+ * @name pc.SoundComponent#pause
+ * @description Pauses playback of the slot with the specified name. If the name is undefined then all slots currently played will be paused. The slots can be resumed by calling {@link pc.SoundComponent#resume}.
+ * @param {String} [name] The name of the slot to pause. Leave undefined to pause everything.
+ * @example
+ * // pause all sounds
+ * this.entity.sound.pause();
+ * // pause a specific sound
+ * this.entity.sound.pause('beep');
+ */
+ pause(name: string): void;
+
+ /**
+ * @function
+ * @name pc.SoundComponent#resume
+ * @description Resumes playback of the sound slot with the specified name if it's paused. If no name is specified all slots will be resumed.
+ * @param {String} name The name of the slot to resume. Leave undefined to resume everything.
+ * @example
+ * // resume all sounds
+ * this.entity.sound.resume();
+ * // resume a specific sound
+ * this.entity.sound.resume('beep');
+ */
+ resume(name: string): void;
+
+ /**
+ * @function
+ * @name pc.SoundComponent#stop
+ * @description Stops playback of the sound slot with the specified name if it's paused. If no name is specified all slots will be stopped.
+ * @param {String} name The name of the slot to stop. Leave undefined to stop everything.
+ * @example
+ * // stop all sounds
+ * this.entity.sound.stop();
+ * // stop a specific sound
+ * this.entity.sound.stop('beep');
+ */
+ stop(name: string): void;
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/sound/constants.d.ts b/types/playcanvas/engine/framework/components/sound/constants.d.ts
new file mode 100644
index 0000000000..94469f5f09
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/sound/constants.d.ts
@@ -0,0 +1,28 @@
+declare namespace pc {
+ /**
+ * @static
+ * @readOnly
+ * @name pc.DISTANCE_LINEAR
+ * @type String
+ * @description Linear distance model
+ */
+ const DISTANCE_LINEAR = 'linear';
+
+ /**
+ * @static
+ * @readonly
+ * @type String
+ * @name pc.DISTANCE_INVERSE
+ * @description Inverse distance model
+ */
+ const DISTANCE_INVERSE = 'inverse';
+
+ /**
+ * @static
+ * @readonly
+ * @type String
+ * @name pc.DISTANCE_EXPONENTIAL
+ * @description Exponential distance model
+ */
+ const DISTANCE_EXPONENTIAL = 'exponential';
+}
diff --git a/types/playcanvas/engine/framework/components/sound/slot.d.ts b/types/playcanvas/engine/framework/components/sound/slot.d.ts
new file mode 100644
index 0000000000..34f5c00463
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/sound/slot.d.ts
@@ -0,0 +1,135 @@
+declare namespace pc {
+
+ /**
+ * @name pc.SoundSlot
+ * @class The SoundSlot controls playback of an audio asset.
+ * @description Create a new SoundSlot
+ * @param {pc.SoundComponent} component The Component that created this slot.
+ * @param {String} name The name of the slot.
+ * @param {Object} options Settings for the slot
+ * @param {Number} [options.volume=1] The playback volume, between 0 and 1.
+ * @param {Number} [options.pitch=1] The relative pitch, default of 1, plays at normal pitch.
+ * @param {Boolean} [options.loop=false] If true the sound will restart when it reaches the end.
+ * @param {Number} [options.startTime=0] The start time from which the sound will start playing.
+ * @param {Number} [options.duration=null] The duration of the sound that the slot will play starting from startTime.
+ * @param {Boolean} [options.overlap=false] If true then sounds played from slot will be played independently of each other. Otherwise the slot will first stop the current sound before starting the new one.
+ * @param {Boolean} [options.autoPlay=false] If true the slot will start playing as soon as its audio asset is loaded.
+ * @param {Number} [options.asset=null] The asset id of the audio asset that is going to be played by this slot.
+ * @property {String} name The name of the slot
+ * @property {String} asset The asset id
+ * @property {Boolean} autoPlay If true the slot will begin playing as soon as it is loaded
+ * @property {Number} volume The volume modifier to play the sound with. In range 0-1.
+ * @property {Number} pitch The pitch modifier to play the sound with. Must be larger than 0.01
+ * @property {Number} startTime The start time from which the sound will start playing.
+ * @property {Number} duration The duration of the sound that the slot will play starting from startTime.
+ * @property {Boolean} loop If true the slot will restart when it finishes playing
+ * @property {Boolean} overlap If true then sounds played from slot will be played independently of each other. Otherwise the slot will first stop the current sound before starting the new one.
+ * @property {Boolean} isLoaded Returns true if the asset of the slot is loaded.
+ * @property {Boolean} isPlaying Returns true if the slot is currently playing.
+ * @property {Boolean} isPaused Returns true if the slot is currently paused.
+ * @property {Boolean} isStopped Returns true if the slot is currently stopped.
+ * @property {pc.SoundInstance[]} instances An array that contains all the {@link pc.SoundInstance}s currently being played by the slot.
+ */
+ class SoundSlot {
+ constructor(component: pc.SoundComponent, name: string, options?: {
+ volume?: number;
+ pitch?: number;
+ loop?: boolean;
+ startTime?: number;
+ duration?: number;
+ overlap?: boolean;
+ autoPlay?: boolean;
+ asset?: number;
+ })
+
+ name: string;
+ volume?: number;
+ pitch?: number;
+ loop?: boolean;
+ startTime?: number;
+ duration?: number;
+ overlap?: boolean;
+ autoPlay?: boolean;
+ asset?: number;
+ isLoading: boolean;
+ isPlaying: boolean;
+ isPaused: boolean;
+ isStopped: boolean;
+ instances: pc.SoundInstance[];
+
+ /**
+ * @function pc.SoundSlot#play
+ * @description Plays a sound. If {@link pc.SoundSlot#overlap} is true the new sound
+ * instance will be played independently of any other instances already playing.
+ * Otherwise existing sound instances will stop before playing the new sound.
+ * @return {pc.SoundInstance} The new sound instance
+ */
+ play(): pc.SoundInstance;
+
+ /**
+ * @function
+ * @name pc.SoundSlot#pause
+ * @description Pauses all sound instances. To continue playback call {@link pc.SoundSlot#resume}.
+ */
+ pause(): boolean;
+
+ /**
+ * @function
+ * @name pc.SoundSlot#resume
+ * @description Resumes playback of all paused sound instances.
+ * @returns {Boolean} True if any instances were resumed.
+ */
+ resume(): boolean;
+
+ /**
+ * @function
+ * @name pc.SoundSlot#stop
+ * @description Stops playback of all sound instances.
+ * @returns {Boolean} True if any instances were stopped.
+ */
+ stop(): boolean;
+
+ /**
+ * @function
+ * @name pc.SoundSlot#load
+ * @description Loads the asset assigned to this slot.
+ */
+ load(): void;
+
+ /**
+ * @function
+ * @name pc.SoundSlot#setExternalNodes
+ * @description Connect external Web Audio API nodes. Any sound played by this slot will
+ * automatically attach the specified nodes to the source that plays the sound. You need to pass
+ * the first node of the node graph that you created externally and the last node of that graph. The first
+ * node will be connected to the audio source and the last node will be connected to the destination of the AudioContext (e.g. speakers).
+ * @param {AudioNode} firstNode The first node that will be connected to the audio source of sound instances.
+ * @param {AudioNode} [lastNode] The last node that will be connected to the destination of the AudioContext.
+ * If unspecified then the firstNode will be connected to the destination instead.
+ * @example
+ * var context = app.systems.sound.context;
+ * var analyzer = context.createAnalyzer();
+ * var distortion = context.createWaveShaper();
+ * var filter = context.createBiquadFilter();
+ * analyzer.connect(distortion);
+ * distortion.connect(filter);
+ * slot.setExternalNodes(analyzer, filter);
+ */
+ setExternalNodes(firstNode: AudioNode, lastNode: AudioNode): void;
+
+ /**
+ * @function
+ * @name pc.SoundSlot#clearExternalNodes
+ * @description Clears any external nodes set by {@link pc.SoundSlot#setExternalNodes}.
+ */
+ clearExternalNodes(): void;
+
+ /**
+ * @function
+ * @name pc.SoundSlot#getExternalNodes
+ * @description Gets an array that contains the two external nodes set by {@link pc.SoundSlot#setExternalNodes}.
+ * @returns {AudioNode[]} An array of 2 elements that contains the first and last nodes set by {@link pc.SoundSlot#setExternalNodes}.
+ */
+ getExternalNodes(): [AudioNode, AudioNode];
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/sound/system.d.ts b/types/playcanvas/engine/framework/components/sound/system.d.ts
new file mode 100644
index 0000000000..ba419db57c
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/sound/system.d.ts
@@ -0,0 +1,22 @@
+declare namespace pc {
+
+ /**
+ * @name pc.SoundComponentSystem
+ * @class Manages creation of {@link pc.SoundComponent}s.
+ * @description Create a SoundComponentSystem
+ * @param {pc.Application} app The Application
+ * @param {pc.SoundManager} manager The sound manager
+ * @property {Number} volume Sets / gets the volume for the entire Sound system. All sounds will have their volume
+ * multiplied by this value. Valid between [0, 1].
+ * @property {AudioContext} context Gets the AudioContext currently used by the sound manager. Requires Web Audio API support.
+ * @property {pc.SoundManager} manager Gets / sets the sound manager
+ * @extends pc.ComponentSystem
+ */
+ class SoundComponentSystem extends pc.ComponentSystem {
+ constructor(app: pc.Application, manager: pc.SoundManager)
+
+ volume: number;
+ context: AudioContext;
+ manager: pc.SoundManager;
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/system.d.ts b/types/playcanvas/engine/framework/components/system.d.ts
new file mode 100644
index 0000000000..572f387457
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/system.d.ts
@@ -0,0 +1,141 @@
+declare namespace pc {
+ /**
+ * @name pc.ComponentSystem
+ * @class Component Systems contain the logic and functionality to update all Components of a particular type
+ * @param {pc.Application} app The running Application
+ */
+ class ComponentSystem {
+ constructor(app: pc.Application)
+
+ /**
+ * @private
+ * @field
+ * @type Array
+ * @name pc.ComponentSystem#store
+ * @description The store where all {@link pc.ComponentData} objects are kept
+ */
+ private store: pc.ComponentData[];
+
+ /**
+ * @private
+ * @function
+ * @name pc.ComponentSystem#addComponent
+ * @description Create new {@link pc.Component} and {@link pc.ComponentData} instances and attach them to the entity
+ * @param {pc.Entity} entity The Entity to attach this component to
+ * @param {Object} data The source data with which to create the component
+ * @returns {pc.Component} Returns a Component of type defined by the component system
+ * @example
+ * var entity = new pc.Entity(app);
+ * app.systems.model.addComponent(entity, { type: 'box' });
+ * // entity.model is now set to a pc.ModelComponent
+ */
+ private addComponent(entity: pc.Entity, data: {}): pc.Component;
+
+ /**
+ * @private
+ * @function
+ * @name pc.ComponentSystem#removeComponent
+ * @description Remove the {@link pc.Component} from the entity and delete the associated {@link pc.ComponentData}
+ * @param {pc.Entity} entity The entity to remove the component from
+ * @example
+ * app.systems.model.removeComponent(entity);
+ * // entity.model === undefined
+ */
+ private removeComponent(entity: pc.Entity): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.ComponentSystem#cloneComponent
+ * @description Create a clone of component. This creates a copy all ComponentData variables.
+ * @param {pc.Entity} entity The entity to clone the component from
+ * @param {pc.Entity} clone The entity to clone the component into
+ */
+ private cloneComponent(entity: pc.Entity, clone: pc.Entity): pc.Component;
+
+ /**
+ * @private
+ * @function
+ * @name pc.ComponentSystem#initializeComponentData
+ * @description Called during {@link pc.ComponentSystem#addComponent} to initialize the {@link pc.ComponentData} in the store
+ * This can be overridden by derived Component Systems and either called by the derived System or replaced entirely
+ */
+ private initializeComponentData(component: pc.Component, data: {}, properties: {}): void;
+
+
+ // Events
+
+ /**
+ * @function
+ * @name pc.ComponentSystem#on
+ * @description Attach an event handler to an event
+ * @param {String} name Name of the event to bind the callback to
+ * @param {Function} callback Function that is called when event is fired. Note the callback is limited to 8 arguments.
+ * @param {Object} [scope] Object to use as 'this' when the event is fired, defaults to current this
+ * @example
+ * obj.on('test', function (a, b) {
+ * console.log(a + b);
+ * });
+ * obj.fire('test', 1, 2); // prints 3 to the console
+ */
+ on(name: string, callback: (...args: any[]) => void, scope: any): any;
+
+ /**
+ * @function
+ * @name pc.ComponentSystem#off
+ * @description Detach an event handler from an event. If callback is not provided then all callbacks are unbound from the event,
+ * if scope is not provided then all events with the callback will be unbound.
+ * @param {String} [name] Name of the event to unbind
+ * @param {Function} [callback] Function to be unbound
+ * @param {Object} [scope] Scope that was used as the this when the event is fired
+ * @example
+ * var handler = function () {
+ * };
+ * obj.on('test', handler);
+ *
+ * obj.off(); // Removes all events
+ * obj.off('test'); // Removes all events called 'test'
+ * obj.off('test', handler); // Removes all handler functions, called 'test'
+ * obj.off('test', handler, this); // Removes all hander functions, called 'test' with scope this
+ */
+ off(name: string, callback: (...args: any[]) => void, scope: any): any;
+
+ /**
+ * @function
+ * @name pc.ComponentSystem#fire
+ * @description Fire an event, all additional arguments are passed on to the event listener
+ * @param {Object} name Name of event to fire
+ * @param {*} [...] Arguments that are passed to the event handler
+ * @example
+ * obj.fire('test', 'This is the message');
+ */
+ fire(name: string, arg1: any, arg2?: any, arg3?: any, arg4?: any, arg5?: any, arg6?: any, arg7?: any, arg8?: any): any;
+
+ /**
+ * @function
+ * @name pc.ComponentSystem#once
+ * @description Attach an event handler to an event. This handler will be removed after being fired once.
+ * @param {String} name Name of the event to bind the callback to
+ * @param {Function} callback Function that is called when event is fired. Note the callback is limited to 8 arguments.
+ * @param {Object} [scope] Object to use as 'this' when the event is fired, defaults to current this
+ * @example
+ * obj.once('test', function (a, b) {
+ * console.log(a + b);
+ * });
+ * obj.fire('test', 1, 2); // prints 3 to the console
+ * obj.fire('test', 1, 2); // not going to get handled
+ */
+ once(name: string, callback: (...args: any[]) => void, scope: any): any;
+
+ /**
+ * @function
+ * @name pc.ComponentSystem#hasEvent
+ * @description Test if there are any handlers bound to an event name
+ * @param {String} name The name of the event to test
+ * @example
+ * obj.on('test', function () { }); // bind an event to 'test'
+ * obj.hasEvent('test'); // returns true
+ */
+ hasEvent(name: string): boolean;
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/text/font.d.ts b/types/playcanvas/engine/framework/components/text/font.d.ts
new file mode 100644
index 0000000000..9c310d2bb4
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/text/font.d.ts
@@ -0,0 +1,15 @@
+declare namespace pc {
+
+ /**
+ * @name pc.Font
+ * @class Represents the resource of a font asset.
+ * @param {pc.Texture} texture The font texture
+ * @param {Object} data The font data
+ * @property {Number} intensity The font intensity
+ */
+ class Font {
+ constructor(texture: pc.Texture, data: {})
+
+ intensity: number;
+ }
+}
\ No newline at end of file
diff --git a/types/playcanvas/engine/framework/components/zone/component.d.ts b/types/playcanvas/engine/framework/components/zone/component.d.ts
new file mode 100644
index 0000000000..a1e223e448
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/zone/component.d.ts
@@ -0,0 +1,17 @@
+declare namespace pc {
+
+ /**
+ * @component
+ * @name pc.ZoneComponent
+ * @extends pc.Component
+ * @class The ZoneComponent allows you to define an area in world space of certain size.
+ * This can be used in various ways, such as affecting audio reverb when audiolistener is within zone.
+ * Or create culling system with portals between zones to hide whole indoor sections for performance reasons.
+ * And many other possible options. Zones are building blocks and meant to be used in many different ways.
+ * @param {pc.ZoneComponentSystem} system The ComponentSystem that created this Component
+ * @param {pc.Vec3} size The Size of Box of a Zone.
+ */
+ class ZoneComponent extends pc.Component {
+ constructor(system: ZoneComponentSystem, entity: pc.Entity)
+ }
+}
diff --git a/types/playcanvas/engine/framework/components/zone/system.d.ts b/types/playcanvas/engine/framework/components/zone/system.d.ts
new file mode 100644
index 0000000000..5e1d663c9a
--- /dev/null
+++ b/types/playcanvas/engine/framework/components/zone/system.d.ts
@@ -0,0 +1,13 @@
+declare namespace pc {
+
+ /**
+ * @name pc.ZoneComponentSystem
+ * @description Create a new ZoneComponentSystem
+ * @class Defines zone in world.
+ * @param {pc.Application} app The application
+ * @extends pc.ComponentSystem
+ */
+ class ZoneComponentSystem extends pc.ComponentSystem {
+ constructor(app: pc.Application)
+ }
+}
diff --git a/types/playcanvas/engine/framework/entity.d.ts b/types/playcanvas/engine/framework/entity.d.ts
new file mode 100644
index 0000000000..0b1f12ae55
--- /dev/null
+++ b/types/playcanvas/engine/framework/entity.d.ts
@@ -0,0 +1,189 @@
+declare namespace pc {
+ type ComponentTypes = 'animation' | 'audiolistner' | 'camera' | 'collision' |
+ 'element' | 'light' | 'model' | 'particlesystem' |
+ 'rigidbody' | 'screen' | 'script' | 'sound' | 'zone';
+
+ /**
+ * @name pc.Entity
+ * @param {String} [name] The non-unique name of the entity, default is "Untitled".
+ * @param {pc.Application} [app] The application the entity belongs to, default is the current application.
+ * @class The Entity is the core primitive of a PlayCanvas game. Generally speaking an object in your game will consist of an {@link pc.Entity},
+ * and a set of {@link pc.Component}s which are managed by their respective {@link pc.ComponentSystem}s. One of those components maybe a
+ * {@link pc.ScriptComponent} which allows you to write custom code to attach to your Entity.
+ *
+ * The Entity uniquely identifies the object and also provides a transform for position and orientation
+ * which it inherits from {@link pc.GraphNode} so can be added into the scene graph.
+ * The Component and ComponentSystem provide the logic to give an Entity a specific type of behavior. e.g. the ability to
+ * render a model or play a sound. Components are specific to an instance of an Entity and are attached (e.g. `this.entity.model`)
+ * ComponentSystems allow access to all Entities and Components and are attached to the {@link pc.Application}.
+ *
+ *
+ * @example
+ * var app = ... // Get the pc.Application
+ *
+ * var entity = new pc.Entity();
+ *
+ * // Add a Component to the Entity
+ * entity.addComponent("camera", {
+ * fov: 45,
+ * nearClip: 1,
+ * farClip: 10000
+ * });
+ *
+ * // Add the Entity into the scene graph
+ * app.root.addChild(entity);
+ *
+ * // Move the entity
+ * entity.translate(10, 0, 0);
+ *
+ * // Or translate it by setting it's position directly
+ * var p = entity.getPosition();
+ * entity.setPosition(p.x + 10, p.y, p.z);
+ *
+ * // Change the entity's rotation in local space
+ * var e = entity.getLocalEulerAngles();
+ * entity.setLocalEulerAngles(e.x, e.y + 90, e.z);
+ *
+ * // Or use rotateLocal
+ * entity.rotateLocal(0, 90, 0);
+ *
+ * @extends pc.GraphNode
+ */
+ class Entity extends pc.GraphNode {
+
+ constructor(name?: string, app?: pc.Application)
+ constructor(app?: pc.Application)
+
+ /**
+ * @function
+ * @name pc.Entity#addComponent
+ * @description Create a new component and add it to the entity.
+ * Use this to add functionality to the entity like rendering a model, playing sounds and so on.
+ * @param {String} type The name of the component to add. Valid strings are:
+ *
+ * - "animation" - see {@link pc.AnimationComponent}
+ * - "audiolistener" - see {@link pc.AudioListenerComponent}
+ * - "camera" - see {@link pc.CameraComponent}
+ * - "collision" - see {@link pc.CollisionComponent}
+ * - "element" - see {@link pc.ElementComponent}
+ * - "light" - see {@link pc.LightComponent}
+ * - "model" - see {@link pc.ModelComponent}
+ * - "particlesystem" - see {@link pc.ParticleSystemComponent}
+ * - "rigidbody" - see {@link pc.RigidBodyComponent}
+ * - "screen" - see {@link pc.ScreenComponent}
+ * - "script" - see {@link pc.ScriptComponent}
+ * - "sound" - see {@link pc.SoundComponent}
+ * - "zone" - see {@link pc.ZoneComponent}
+ *
+ * @param {Object} data The initialization data for the specific component type. Refer to each
+ * specific component's API reference page for details on valid values for this parameter.
+ * @returns {pc.Component} The new Component that was attached to the entity
+ * @example
+ * var entity = new pc.Entity();
+ * entity.addComponent("light"); // Add a light component with default properties
+ * entity.addComponent("camera", { // Add a camera component with some specified properties
+ * fov: 45,
+ * clearColor: new pc.Color(1,0,0),
+ * });
+ */
+ addComponent(type: pc.ComponentTypes, data?: any): pc.Component;
+
+ /**
+ * @function
+ * @name pc.Entity#removeComponent
+ * @description Remove a component from the Entity.
+ * @param {String} type The name of the Component type
+ * @example
+ * var entity = new pc.Entity();
+ * entity.addComponent("light"); // add new light component
+ * //...
+ * entity.removeComponent("light"); // remove light component
+ */
+ removeComponent(type: pc.ComponentTypes): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.Entity#getGuid
+ * @description Get the GUID value for this Entity
+ * @returns {String} The GUID of the Entity
+ */
+ private getGuid(): string;
+
+ /**
+ * @private
+ * @function
+ * @name pc.Entity#setGuid
+ * @description Set the GUID value for this Entity.
+ *
+ * N.B. It is unlikely that you should need to change the GUID value of an Entity at run-time. Doing so will corrupt the graph this Entity is in.
+ * @param {String} guid The GUID to assign to the Entity
+ */
+ setGuid(guid: string): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.Entity#setRequest
+ * @description Used during resource loading to ensure that child resources of Entities are tracked
+ * @param {ResourceRequest} request The request being used to load this entity
+ */
+ private setRequest(request: any): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.Entity#getRequest
+ * @description Get the Request that is being used to load this Entity
+ * @returns {ResourceRequest} The Request
+ */
+ private getRequest(): any;
+
+ /**
+ * @function
+ * @name pc.Entity#findByGuid
+ * @description Find a descendant of this Entity with the GUID
+ * @returns {pc.Entity} The Entity with the GUID or null
+ */
+ findByGuid(guid: string): pc.Entity;
+
+ /**
+ * @function
+ * @name pc.Entity#destroy
+ * @description Remove all components from the Entity and detach it from the Entity hierarchy. Then recursively destroy all ancestor Entities
+ * @example
+ * var firstChild = this.entity.children[0];
+ * firstChild.destroy(); // delete child, all components and remove from hierarchy
+ */
+ destroy(): void;
+
+ /**
+ * @function
+ * @name pc.Entity#clone
+ * @description Create a deep copy of the Entity. Duplicate the full Entity hierarchy, with all Components and all descendants.
+ * Note, this Entity is not in the hierarchy and must be added manually.
+ * @returns {pc.Entity} A new Entity which is a deep copy of the original.
+ * @example
+ * var e = this.entity.clone(); // Clone Entity
+ * this.entity.parent.addChild(e); // Add it as a sibling to the original
+ */
+ clone(): pc.Entity;
+
+
+ // Possible attached components
+ animation: pc.AnimationComponent;
+ audiolistner: pc.AudioListenerComponent;
+ camera: pc.CameraComponent;
+ collision: pc.CollisionComponent;
+ element: pc.ElementComponent;
+ light: pc.LightComponent;
+ model: pc.ModelComponent;
+ particlesystem: pc.ParticleSystemComponent;
+ rigidbody: pc.RigidBodyComponent;
+ screen: pc.ScreenComponent;
+ script: pc.ScriptComponent;
+ sound: pc.SoundComponent;
+ zone: pc.ZoneComponent;
+
+ }
+}
\ No newline at end of file
diff --git a/types/playcanvas/engine/framework/script.d.ts b/types/playcanvas/engine/framework/script.d.ts
new file mode 100644
index 0000000000..30c6da8f0f
--- /dev/null
+++ b/types/playcanvas/engine/framework/script.d.ts
@@ -0,0 +1,114 @@
+declare namespace pc {
+
+ /**
+ * @name pc.script
+ * @namespace
+ * @description Functions for creating user scripts for the script component
+ * @property {Boolean} legacy If True, then engine will use legacy scripting system, defaults to true (subject to change)
+ */
+ namespace script {
+
+ /**
+ * @function
+ * @name pc.script.create
+ * @description Create a script resource object. A script file should contain a single call to pc.script.create and the callback should return a script object which will be
+ * instantiated when attached to Entities.
+ * @param {String} name The name of the script object.
+ * @param {Function} callback The callback function which is passed an {pc.Application} object,
+ * which is used to access Entities and Components, and should return the Type of the script resource
+ * to be instanced for each Entity.
+ * @example
+ * pc.script.create( function (app) {
+ * var Scriptable = function (entity) {
+ * // store entity
+ * this.entity = entity;
+ *
+ * // use app
+ * app.components.model.addComponent(entity, {...});
+ * };
+ *
+ * return Scriptable;
+ * }
+ */
+ function create(name: string, callback: Function): void;
+
+ /**
+ * @function
+ * @name pc.script.attribute
+ * @description Creates a script attribute for the current script. The script attribute can be accessed
+ * inside the script instance like so 'this.attributeName' or outside a script instance like so 'entity.script.attributeName'.
+ * Script attributes can be edited from the Attribute Editor of the PlayCanvas Editor like normal Components.
+ * @param {String} name The name of the attribute
+ * @param {String} type The type of the attribute. Can be one of the following: 'number', 'string', 'boolean', 'asset', 'entity', 'rgb', 'rgba', 'vector', 'enumeration', 'curve', 'colorcurve'
+ * @param {Object} defaultValue The default value of the attribute
+ * @param {Object} options Optional parameters for the attribute. Valid values are:
+ *
+ * - {Number} min: The minimum value of the attribute
+ * - {Number} max: The maximum value of the attribute
+ * - {Number} step: The step that will be used when changing the attribute value in the PlayCanvas Editor
+ * - {Number} decimalPrecision: A number that specifies the number of decimal digits allowed for the value
+ * - {Object[]} enumerations: An array of name, value pairs from which the user can select one if the attribute type is an enumeration
+ * - {String[]} curves: (For 'curve' attributes only) An array of strings that define the names of each curve in the curve editor.
+ * - {Array} color: (For 'curve' attributes only) If true then the curve attribute will be a color curve.
+ *
+ * @example
+ * pc.script.attribute('speed', 'number', 5);
+ * pc.script.attribute('message', 'string', "My message");
+ * pc.script.attribute('enemyPosition', 'vector', [1,0,0]);
+ * pc.script.attribute('spellType', 'enumeration', 0, {
+ * enumerations: [{
+ * name: "Fire",
+ * value: 0
+ * }, {
+ * name: "Ice",
+ * value: 1
+ * }]
+ * });
+ * pc.script.attribute('enemy', 'entity');
+ * pc.script.attribute('enemySpeed', 'curve');
+ * pc.script.attribute('enemyPosition', 'curve', null, {
+ * curves: ['x', 'y', 'z']
+ * });
+ * pc.script.attribute('color', 'colorcurve', null, {
+ * type: 'rgba'
+ * });
+ *
+ * pc.script.create('scriptable', function (app) {
+ * var Scriptable = function (entity) {
+ * // store entity
+ * this.entity = entity;
+ * };
+ *
+ * return Scriptable;
+ * }
+ */
+ function attribute(name: string, type: string, defaultValue: any, options?: {
+ min?: number,
+ max?: number,
+ step?: number,
+ decimalPrecision?: number,
+ enumerations?: any[],
+ curves?: string[],
+ color?: any[]
+ }): void;
+
+ /**
+ * @function
+ * @name pc.script.createLoadingScreen
+ * @description Handles the creation of the loading screen of the application. A script can subscribe to
+ * the events of a {@link pc.Application} to show a loading screen, progress bar etc. In order for this to work
+ * you need to set the project's loading screen script to the script that calls this method.
+ * @param {Function} callback A function which can set up and tear down a customised loading screen.
+ * @example
+ * pc.script.createLoadingScreen(function (app) {
+ * var showSplashScreen = function () { // }
+ * var hideSplashScreen = function () { // }
+ * var showProgress = function (progress) { // }
+ * app.on("preload:start", showSplashScreen);
+ * app.on("preload:progress", showProgress);
+ * app.on("start", hideSplashScreen);
+ * });
+ */
+ function createLoadingScreen(callback: Function): void;
+ }
+}
diff --git a/types/playcanvas/engine/graphics/device.d.ts b/types/playcanvas/engine/graphics/device.d.ts
new file mode 100644
index 0000000000..188de0b1a3
--- /dev/null
+++ b/types/playcanvas/engine/graphics/device.d.ts
@@ -0,0 +1,665 @@
+declare namespace pc {
+
+ /**
+ * @name pc.GraphicsDevice
+ * @class The graphics device manages the underlying graphics context. It is responsible
+ * for submitting render state changes and graphics primitives to the hardware. A graphics
+ * device is tied to a specific canvas HTML element. It is valid to have more than one
+ * canvas element per page and create a new graphics device against each.
+ * @description Creates a new graphics device.
+ * @param {Object} canvas The canvas to which the graphics device is tied.
+ * @param {Object} [options] Options passed when creating the WebGL context. More info here https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/getContext
+ */
+ class GraphicsDevice {
+ constructor(canvas: HTMLCanvasElement, options?: {})
+
+ /**
+ * @readonly
+ * @name pc.GraphicsDevice#precision
+ * @type String
+ * @description The highest shader precision supported by this graphics device. Can be 'hiphp', 'mediump' or 'lowp'.
+ */
+ readonly precision: string;
+
+ /**
+ * @readonly
+ * @name pc.GraphicsDevice#maxCubeMapSize
+ * @type Number
+ * @description The maximum supported dimension of a cube map.
+ */
+ readonly maxCubeMapSize: number;
+
+ /**
+ * @readonly
+ * @name pc.GraphicsDevice#maxTextureSize
+ * @type Number
+ * @description The maximum supported dimension of a texture.
+ */
+ readonly maxTextureSize: number;
+
+ /**
+ * @readonly
+ * @name pc.GraphicsDevice#maxVolumeSize
+ * @type Number
+ * @description The maximum supported dimension of a 3D texture (any axis).
+ */
+ readonly maxVolumeSize: number;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setViewport
+ * @description Set the active rectangle for rendering on the specified device.
+ * @param {Number} x The pixel space x-coordinate of the bottom left corner of the viewport.
+ * @param {Number} y The pixel space y-coordinate of the bottom left corner of the viewport.
+ * @param {Number} w The width of the viewport in pixels.
+ * @param {Number} h The height of the viewport in pixels.
+ */
+ setViewport(x: number, y: number, w: number, h: number): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setScissor
+ * @description Set the active scissor rectangle on the specified device.
+ * @param {Number} x The pixel space x-coordinate of the bottom left corner of the scissor rectangle.
+ * @param {Number} y The pixel space y-coordinate of the bottom left corner of the scissor rectangle.
+ * @param {Number} w The width of the scissor rectangle in pixels.
+ * @param {Number} h The height of the scissor rectangle in pixels.
+ */
+ setScissor(x: number, y: number, w: number, h: number): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.GraphicsDevice#getProgramLibrary
+ * @description Retrieves the program library assigned to the specified graphics device.
+ * @returns {pc.ProgramLibrary} The program library assigned to the device.
+ */
+ private getProgramLibrary(): pc.ProgramLibrary;
+
+ /**
+ * @private
+ * @function
+ * @name pc.GraphicsDevice#setProgramLibrary
+ * @description Assigns a program library to the specified device. By default, a graphics
+ * device is created with a program library that manages all of the programs that are
+ * used to render any graphical primitives. However, this function allows the user to
+ * replace the existing program library with a new one.
+ * @param {pc.ProgramLibrary} programLib The program library to assign to the device.
+ */
+ private setProgramLibrary(programLib): pc.ProgramLibrary;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#updateBegin
+ * @description Marks the beginning of a block of rendering. Internally, this function
+ * binds the render target currently set on the device. This function should be matched
+ * with a call to pc.GraphicsDevice#updateEnd. Calls to pc.GraphicsDevice#updateBegin
+ * and pc.GraphicsDevice#updateEnd must not be nested.
+ */
+ updateBegin(): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#updateEnd
+ * @description Marks the end of a block of rendering. This function should be called
+ * after a matching call to pc.GraphicsDevice#updateBegin. Calls to pc.GraphicsDevice#updateBegin
+ * and pc.GraphicsDevice#updateEnd must not be nested.
+ */
+ updateEnd(): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#draw
+ * @description Submits a graphical primitive to the hardware for immediate rendering.
+ * @param {Object} primitive Primitive object describing how to submit current vertex/index buffers defined as follows:
+ * @param {Number} primitive.type The type of primitive to render. Can be:
+ *
+ * - pc.PRIMITIVE_POINTS
+ * - pc.PRIMITIVE_LINES
+ * - pc.PRIMITIVE_LINELOOP
+ * - pc.PRIMITIVE_LINESTRIP
+ * - pc.PRIMITIVE_TRIANGLES
+ * - pc.PRIMITIVE_TRISTRIP
+ * - pc.PRIMITIVE_TRIFAN
+ *
+ * @param {Number} primitive.base The offset of the first index or vertex to dispatch in the draw call.
+ * @param {Number} primitive.count The number of indices or vertices to dispatch in the draw call.
+ * @param {Boolean} primitive.indexed True to interpret the primitive as indexed, thereby using the currently set index buffer and false otherwise.
+ * @example
+ * // Render a single, unindexed triangle
+ * device.draw({
+ * type: pc.PRIMITIVE_TRIANGLES,
+ * base: 0,
+ * count: 3,
+ * indexed: false
+ * )};
+ */
+ draw(primitive: { type: number, base: number, count: number, indexed: boolean }, numInstances?: number): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#clear
+ * @description Clears the frame buffer of the currently set render target.
+ * @param {Object} options Optional options object that controls the behavior of the clear operation defined as follows:
+ * @param {Number[]} options.color The color to clear the color buffer to in the range 0.0 to 1.0 for each component.
+ * @param {Number} options.depth The depth value to clear the depth buffer to in the range 0.0 to 1.0.
+ * @param {Number} options.flags The buffers to clear (the types being color, depth and stencil). Can be any bitwise
+ * combination of:
+ *
+ * - pc.CLEARFLAG_COLOR
+ * - pc.CLEARFLAG_DEPTH
+ * - pc.CLEARFLAG_STENCIL
+ *
+ * @example
+ * // Clear color buffer to black and depth buffer to 1.0
+ * device.clear();
+ *
+ * // Clear just the color buffer to red
+ * device.clear({
+ * color: [1, 0, 0, 1],
+ * flags: pc.CLEARFLAG_COLOR
+ * });
+ *
+ * // Clear color buffer to yellow and depth to 1.0
+ * device.clear({
+ * color: [1, 1, 0, 1],
+ * depth: 1.0,
+ * flags: pc.CLEARFLAG_COLOR | pc.CLEARFLAG_DEPTH
+ * });
+ */
+ clear(options: { color: number[], depth: number, flags: number }): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setRenderTarget
+ * @description Sets the specified render target on the device. If null
+ * is passed as a parameter, the back buffer becomes the current target
+ * for all rendering operations.
+ * @param {pc.RenderTarget} renderTarget The render target to activate.
+ * @example
+ * // Set a render target to receive all rendering output
+ * device.setRenderTarget(renderTarget);
+ *
+ * // Set the back buffer to receive all rendering output
+ * device.setRenderTarget(null);
+ */
+ setRenderTarget(renderTarget: pc.RenderTarget): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#getRenderTarget
+ * @description Queries the currently set render target on the device.
+ * @returns {pc.RenderTarget} The current render target.
+ * @example
+ * // Get the current render target
+ * var renderTarget = device.getRenderTarget();
+ */
+ getRenderTarget(): pc.RenderTarget;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#getDepthTest
+ * @description Queries whether depth testing is enabled.
+ * @returns {Boolean} true if depth testing is enabled and false otherwise.
+ * @example
+ * var depthTest = device.getDepthTest();
+ * console.log('Depth testing is ' + depthTest ? 'enabled' : 'disabled');
+ */
+ getDepthTest(): boolean;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setDepthTest
+ * @description Enables or disables depth testing of fragments. Once this state
+ * is set, it persists until it is changed. By default, depth testing is enabled.
+ * @param {Boolean} depthTest true to enable depth testing and false otherwise.
+ * @example
+ * device.setDepthTest(true);
+ */
+ setDepthTest(depthTest: boolean): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setDepthFunc
+ * @description Configures the depth test.
+ * @param {Number} func A function to compare a new depth value with an existing z-buffer value and decide if to write a pixel. Can be:
+ *
+ * - pc.FUNC_NEVER: don't draw
+ * - pc.FUNC_LESS: draw if new depth < depth buffer
+ * - pc.FUNC_EQUAL: draw if new depth == depth buffer
+ * - pc.FUNC_LESSEQUAL: draw if new depth <= depth buffer
+ * - pc.FUNC_GREATER: draw if new depth > depth buffer
+ * - pc.FUNC_NOTEQUAL: draw if new depth != depth buffer
+ * - pc.FUNC_GREATEREQUAL: draw if new depth >= depth buffer
+ * - pc.FUNC_ALWAYS: always draw
+ *
+ */
+ setDepthFunc(func: number): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#getDepthWrite
+ * @description Queries whether writes to the depth buffer are enabled.
+ * @returns {Boolean} true if depth writing is enabled and false otherwise.
+ * @example
+ * var depthWrite = device.getDepthWrite();
+ * console.log('Depth writing is ' + depthWrite ? 'enabled' : 'disabled');
+ */
+ getDepthWrite(): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setDepthWrite
+ * @description Enables or disables writes to the depth buffer. Once this state
+ * is set, it persists until it is changed. By default, depth writes are enabled.
+ * @param {Boolean} writeDepth true to enable depth writing and false otherwise.
+ * @example
+ * device.setDepthWrite(true);
+ */
+ setDepthWrite(writeDepth: boolean): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setColorWrite
+ * @description Enables or disables writes to the color buffer. Once this state
+ * is set, it persists until it is changed. By default, color writes are enabled
+ * for all color channels.
+ * @param {Boolean} writeRed true to enable writing of the red channel and false otherwise.
+ * @param {Boolean} writeGreen true to enable writing of the green channel and false otherwise.
+ * @param {Boolean} writeBlue true to enable writing of the blue channel and false otherwise.
+ * @param {Boolean} writeAlpha true to enable writing of the alpha channel and false otherwise.
+ * @example
+ * // Just write alpha into the frame buffer
+ * device.setColorWrite(false, false, false, true);
+ */
+ setColorWrite(writeRed: boolean, writeGreen: boolean, writeBlue: boolean, writeAlpha: boolean): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.GraphicsDevice#setAlphaToCoverage
+ * @description Enables or disables alpha to coverage (WebGL2 only).
+ * @param {Boolean} state True to enable alpha to coverage and false to disable it.
+ */
+ private setAlphaToCoverage(state: boolean): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.GraphicsDevice#setTransformFeedbackBuffer
+ * @description Sets the output vertex buffer. It will be written to by a shader with transform feedback varyings.
+ * @param {pc.VertexBuffer} tf The output vertex buffer
+ */
+ private setTransformFeedbackBuffer(tf: pc.VertexBuffer): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.GraphicsDevice#setRaster
+ * @description Enables or disables rasterization. Useful with transform feedback, when you only need to process the data without drawing.
+ * @param {Boolean} on True to enable rasterization and false to disable it.
+ */
+ private setRaster(on: boolean): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#getBlending
+ * @description Queries whether blending is enabled.
+ * @returns {Boolean} True if blending is enabled and false otherwise.
+ */
+ getBlending(): boolean;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setBlending
+ * @description Enables or disables blending.
+ * @param {Boolean} blending True to enable blending and false to disable it.
+ */
+ setBlending(blending: boolean): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setStencilTest
+ * @description Enables or disables stencil test.
+ * @param {Boolean} enable True to enable stencil test and false to disable it.
+ */
+ setStencilTest(enable: boolean): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setStencilFunc
+ * @description Configures stencil test for both front and back faces.
+ * @param {Number} func A comparison function that decides if the pixel should be written, based on the current stencil buffer value,
+ * reference value, and mask value. Can be:
+ *
+ * - pc.FUNC_NEVER: never pass
+ * - pc.FUNC_LESS: pass if (ref & mask) < (stencil & mask)
+ * - pc.FUNC_EQUAL: pass if (ref & mask) == (stencil & mask)
+ * - pc.FUNC_LESSEQUAL: pass if (ref & mask) <= (stencil & mask)
+ * - pc.FUNC_GREATER: pass if (ref & mask) > (stencil & mask)
+ * - pc.FUNC_NOTEQUAL: pass if (ref & mask) != (stencil & mask)
+ * - pc.FUNC_GREATEREQUAL: pass if (ref & mask) >= (stencil & mask)
+ * - pc.FUNC_ALWAYS: always pass
+ *
+ * @param {Number} ref Reference value used in comparison.
+ * @param {Number} mask Mask applied to stencil buffer value and reference value before comparison.
+ */
+ setStencilFunc(func: number, ref: number, mask: number): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setStencilFuncFront
+ * @description Same as pc.GraphicsDevice#setStencilFunc, but only for front faces.
+ */
+ setStencilFuncFront(func: number, ref: number, mask: number): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setStencilFuncBack
+ * @description Same as pc.GraphicsDevice#setStencilFunc, but only for back faces.
+ */
+ setStencilFuncBack(func: boolean, ref: boolean, mask: boolean): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setStencilOperation
+ * @description Configures how stencil buffer values should be modified based on the result of depth/stencil tests. Works for both front and back faces.
+ * @param {Number} fail Action to take if stencil test is failed
+ * @param {Number} zfail Action to take if depth test is failed
+ * @param {Number} zpass Action to take if both depth and stencil test are passed
+ * All arguments can be:
+ *
+ * - pc.STENCILOP_KEEP: don't change the stencil buffer value
+ * - pc.STENCILOP_ZERO: set value to zero
+ * - pc.STENCILOP_REPLACE: replace value with the reference value (see pc.GraphicsDevice#setStencilFunc)
+ * - pc.STENCILOP_INCREMENT: increment the value
+ * - pc.STENCILOP_INCREMENTWRAP: increment the value, but wrap it to zero when it's larger than a maximum representable value
+ * - pc.STENCILOP_DECREMENT: decrement the value
+ * - pc.STENCILOP_DECREMENTWRAP: decrement the value, but wrap it to a maximum representable value, if the current value is 0
+ * - pc.STENCILOP_INVERT: invert the value bitwise
+ *
+ * @param {Number} writeMask A bit mask applied to the reference value, when written.
+ */
+ setStencilOperation(fail: number, zfail: number, zpass: number, writeMask: number): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setStencilOperationFront
+ * @description Same as pc.GraphicsDevice#setStencilOperation, but only for front faces.
+ */
+ setStencilOperationFront(fail: number, zfail: number, zpass: number, writeMask: number): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setStencilOperationBack
+ * @description Same as pc.GraphicsDevice#setStencilOperation, but only for back faces.
+ */
+ setStencilOperationBack(fail: number, zfail: number, zpass: number, writeMask: number): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setBlendFunction
+ * @description Configures blending operations. Both source and destination
+ * blend modes can take the following values:
+ *
+ * - pc.BLENDMODE_ZERO
+ * - pc.BLENDMODE_ONE
+ * - pc.BLENDMODE_SRC_COLOR
+ * - pc.BLENDMODE_ONE_MINUS_SRC_COLOR
+ * - pc.BLENDMODE_DST_COLOR
+ * - pc.BLENDMODE_ONE_MINUS_DST_COLOR
+ * - pc.BLENDMODE_SRC_ALPHA
+ * - pc.BLENDMODE_SRC_ALPHA_SATURATE
+ * - pc.BLENDMODE_ONE_MINUS_SRC_ALPHA
+ * - pc.BLENDMODE_DST_ALPHA
+ * - pc.BLENDMODE_ONE_MINUS_DST_ALPHA
+ *
+ * @param {Number} blendSrc The source blend function.
+ * @param {Number} blendDst The destination blend function.
+ */
+ setBlendFunction(blendSrc: number, blendDst: number): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setBlendFunctionSeparate
+ * @description Configures blending operations. Both source and destination
+ * blend modes can take the following values:
+ *
+ * - pc.BLENDMODE_ZERO
+ * - pc.BLENDMODE_ONE
+ * - pc.BLENDMODE_SRC_COLOR
+ * - pc.BLENDMODE_ONE_MINUS_SRC_COLOR
+ * - pc.BLENDMODE_DST_COLOR
+ * - pc.BLENDMODE_ONE_MINUS_DST_COLOR
+ * - pc.BLENDMODE_SRC_ALPHA
+ * - pc.BLENDMODE_SRC_ALPHA_SATURATE
+ * - pc.BLENDMODE_ONE_MINUS_SRC_ALPHA
+ * - pc.BLENDMODE_DST_ALPHA
+ * - pc.BLENDMODE_ONE_MINUS_DST_ALPHA
+ *
+ * @param {Number} blendSrc The source blend function.
+ * @param {Number} blendDst The destination blend function.
+ * @param {Number} blendSrcAlpha The separate source blend function for the alpha channel.
+ * @param {Number} blendDstAlpha The separate destination blend function for the alpha channel.
+ */
+ setBlendFunctionSeparate(blendSrc: void, blendDst: void, blendSrcAlpha: void, blendDstAlpha: void): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setBlendEquation
+ * @description Configures the blending equation. The default blend equation is
+ * pc.BLENDEQUATION_ADD.
+ * @param {Number} blendEquation The blend equation. Can be:
+ *
+ * - pc.BLENDEQUATION_ADD
+ * - pc.BLENDEQUATION_SUBTRACT
+ * - pc.BLENDEQUATION_REVERSE_SUBTRACT
+ * - pc.BLENDEQUATION_MIN
+ * - pc.BLENDEQUATION_MAX
+ * Note that MIN and MAX modes require either EXT_blend_minmax or WebGL2 to work (check device.extBlendMinmax).
+ *
+ */
+ setBlendEquation(blendEquation: number): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setBlendEquationSeparate
+ * @description Configures the blending equation. The default blend equation is
+ * pc.BLENDEQUATION_ADD.
+ * @param {Number} blendEquation The blend equation. Can be:
+ *
+ * - pc.BLENDEQUATION_ADD
+ * - pc.BLENDEQUATION_SUBTRACT
+ * - pc.BLENDEQUATION_REVERSE_SUBTRACT
+ * - pc.BLENDEQUATION_MIN
+ * - pc.BLENDEQUATION_MAX
+ * Note that MIN and MAX modes require either EXT_blend_minmax or WebGL2 to work (check device.extBlendMinmax).
+ * @param {Number} blendAlphaEquation A separate blend equation for the alpha channel. Accepts same values as blendEquation.
+ *
+ */
+ setBlendEquationSeparate(blendEquation: number, blendAlphaEquation: number): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setCullMode
+ * @description Controls how triangles are culled based on their face direction.
+ * The default cull mode is pc.CULLFACE_BACK.
+ * @param {Number} cullMode The cull mode to set. Can be:
+ *
+ * - pc.CULLFACE_NONE
+ * - pc.CULLFACE_BACK
+ * - pc.CULLFACE_FRONT
+ * - pc.CULLFACE_FRONTANDBACK
+ *
+ */
+ setCullMode(cullMode: number): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setIndexBuffer
+ * @description Sets the current index buffer on the graphics device. On subsequent
+ * calls to pc.GraphicsDevice#draw, the specified index buffer will be used to provide
+ * index data for any indexed primitives.
+ * @param {pc.IndexBuffer} indexBuffer The index buffer to assign to the device.
+ */
+ setIndexBuffer(indexBuffer: pc.IndexBuffer): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setVertexBuffer
+ * @description Sets the current vertex buffer for a specific stream index on the graphics
+ * device. On subsequent calls to pc.GraphicsDevice#draw, the specified vertex buffer will be
+ * used to provide vertex data for any primitives.
+ * @param {pc.VertexBuffer} vertexBuffer The vertex buffer to assign to the device.
+ * @param {Number} stream The stream index for the vertex buffer, indexed from 0 upwards.
+ */
+ setVertexBuffer(vertexBuffer: pc.VertexBuffer, stream: number, vbOffset?: number): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#setShader
+ * @description Sets the active shader to be used during subsequent draw calls.
+ * @param {pc.Shader} shader The shader to set to assign to the device.
+ */
+ setShader(shader: pc.Shader): void;
+
+ /**
+ * @private
+ * @function
+ * @name pc.GraphicsDevice#getBoneLimit
+ * @description Queries the maximum number of bones that can be referenced by a shader.
+ * The shader generators (pc.programlib) use this number to specify the matrix array
+ * size of the uniform 'matrix_pose[0]'. The value is calculated based on the number of
+ * available uniform vectors available after subtracting the number taken by a typical
+ * heavyweight shader. If a different number is required, it can be tuned via
+ * pc.GraphicsDevice#setBoneLimit.
+ * @returns {Number} The maximum number of bones that can be supported by the host hardware.
+ */
+ private getBoneLimit(): number
+
+ /**
+ * @private
+ * @function
+ * @name pc.GraphicsDevice#setBoneLimit
+ * @description Specifies the maximum number of bones that the device can support on
+ * the current hardware. This function allows the default calculated value based on
+ * available vector uniforms to be overridden.
+ * @param {Number} maxBones The maximum number of bones supported by the host hardware.
+ */
+ private setBoneLimit(maxBones: number): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#resizeCanvas
+ * @description Sets the width and height of the canvas, then fires the 'resizecanvas' event.
+ */
+ resizeCanvas(width: number, height: number): void;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#clearShaderCache
+ * @description Frees memory from all shaders ever allocated with this device
+ */
+ clearShaderCache(): void;
+
+ /**
+ * @readonly
+ * @name pc.GraphicsDevice#width
+ * @type Number
+ * @description Width of the back buffer in pixels.
+ */
+ readonly width: number;
+
+ /**
+ * @readonly
+ * @name pc.GraphicsDevice#height
+ * @type Number
+ * @description Height of the back buffer in pixels.
+ */
+ readonly height: number;
+
+ /**
+ * @readonly
+ * @name pc.GraphicsDevice#maxAnisotropy
+ * @type Number
+ * @description The maximum supported texture anisotropy setting.
+ */
+ readonly maxAnisotropy: number;
+
+
+ // Events
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#on
+ * @description Attach an event handler to an event
+ * @param {String} name Name of the event to bind the callback to
+ * @param {Function} callback Function that is called when event is fired. Note the callback is limited to 8 arguments.
+ * @param {Object} [scope] Object to use as 'this' when the event is fired, defaults to current this
+ * @example
+ * obj.on('test', function (a, b) {
+ * console.log(a + b);
+ * });
+ * obj.fire('test', 1, 2); // prints 3 to the console
+ */
+ on(name: string, callback: (...args: any[]) => void, scope: any): any;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#off
+ * @description Detach an event handler from an event. If callback is not provided then all callbacks are unbound from the event,
+ * if scope is not provided then all events with the callback will be unbound.
+ * @param {String} [name] Name of the event to unbind
+ * @param {Function} [callback] Function to be unbound
+ * @param {Object} [scope] Scope that was used as the this when the event is fired
+ * @example
+ * var handler = function () {
+ * };
+ * obj.on('test', handler);
+ *
+ * obj.off(); // Removes all events
+ * obj.off('test'); // Removes all events called 'test'
+ * obj.off('test', handler); // Removes all handler functions, called 'test'
+ * obj.off('test', handler, this); // Removes all hander functions, called 'test' with scope this
+ */
+ off(name: string, callback: (...args: any[]) => void, scope: any): any;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#fire
+ * @description Fire an event, all additional arguments are passed on to the event listener
+ * @param {Object} name Name of event to fire
+ * @param {*} [...] Arguments that are passed to the event handler
+ * @example
+ * obj.fire('test', 'This is the message');
+ */
+ fire(name: string, arg1: any, arg2?: any, arg3?: any, arg4?: any, arg5?: any, arg6?: any, arg7?: any, arg8?: any): any;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#once
+ * @description Attach an event handler to an event. This handler will be removed after being fired once.
+ * @param {String} name Name of the event to bind the callback to
+ * @param {Function} callback Function that is called when event is fired. Note the callback is limited to 8 arguments.
+ * @param {Object} [scope] Object to use as 'this' when the event is fired, defaults to current this
+ * @example
+ * obj.once('test', function (a, b) {
+ * console.log(a + b);
+ * });
+ * obj.fire('test', 1, 2); // prints 3 to the console
+ * obj.fire('test', 1, 2); // not going to get handled
+ */
+ once(name: string, callback: (...args: any[]) => void, scope: any): any;
+
+ /**
+ * @function
+ * @name pc.GraphicsDevice#hasEvent
+ * @description Test if there are any handlers bound to an event name
+ * @param {String} name The name of the event to test
+ * @example
+ * obj.on('test', function () { }); // bind an event to 'test'
+ * obj.hasEvent('test'); // returns true
+ */
+ hasEvent(name: string): boolean;
+ }
+}
diff --git a/types/playcanvas/engine/graphics/graphics.d.ts b/types/playcanvas/engine/graphics/graphics.d.ts
new file mode 100644
index 0000000000..9c308fa624
--- /dev/null
+++ b/types/playcanvas/engine/graphics/graphics.d.ts
@@ -0,0 +1,757 @@
+declare namespace pc {
+
+ /**
+ * @static
+ * @readonly
+ * @type Number
+ * @name pc.ADDRESS_REPEAT
+ * @description Ignores the integer part of texture coordinates; using only the fractional part.
+ */
+ const ADDRESS_REPEAT = 0;
+ /**
+ * @static
+ * @readonly
+ * @type Number
+ * @name pc.ADDRESS_CLAMP_TO_EDGE
+ * @description Clamps texture coordinate to the range 0 to 1.
+ */
+ const ADDRESS_CLAMP_TO_EDGE = 1;
+ /**
+ * @static
+ * @readonly
+ * @type Number
+ * @name pc.ADDRESS_MIRRORED_REPEAT
+ * @description Texture coordinate to be set to the fractional part if the integer part is even; if the integer part is odd;
+ * then the texture coordinate is set to 1 minus the fractional part.
+ */
+ const ADDRESS_MIRRORED_REPEAT = 2;
+
+ /**
+ * @enum pc.BLENDMODE
+ * @name pc.BLENDMODE_ZERO
+ * @description Multiply all fragment components by zero.
+ */
+ const BLENDMODE_ZERO = 0;
+ /**
+ * @enum pc.BLENDMODE
+ * @name pc.BLENDMODE_ONE
+ * @description Multiply all fragment components by one.
+ */
+ const BLENDMODE_ONE = 1;
+ /**
+ * @enum pc.BLENDMODE
+ * @name pc.BLENDMODE_SRC_COLOR
+ * @description Multiply all fragment components by the components of the source fragment.
+ */
+ const BLENDMODE_SRC_COLOR = 2;
+ /**
+ * @enum pc.BLENDMODE
+ * @name pc.BLENDMODE_ONE_MINUS_SRC_COLOR
+ * @description Multiply all fragment components by one minus the components of the source fragment.
+ */
+ const BLENDMODE_ONE_MINUS_SRC_COLOR = 3;
+ /**
+ * @enum pc.BLENDMODE
+ * @name pc.BLENDMODE_DST_COLOR
+ * @description Multiply all fragment components by the components of the destination fragment.
+ */
+ const BLENDMODE_DST_COLOR = 4;
+ /**
+ * @enum pc.BLENDMODE
+ * @name pc.BLENDMODE_ONE_MINUS_DST_COLOR
+ * @description Multiply all fragment components by one minus the components of the destination fragment.
+ */
+ const BLENDMODE_ONE_MINUS_DST_COLOR = 5;
+ /**
+ * @enum pc.BLENDMODE
+ * @name pc.BLENDMODE_SRC_ALPHA
+ * @description Multiply all fragment components by the alpha value of the source fragment.
+ */
+ const BLENDMODE_SRC_ALPHA = 6;
+ /**
+ * @enum pc.BLENDMODE
+ * @name pc.BLENDMODE_SRC_ALPHA_SATURATE
+ * @description Multiply all fragment components by the alpha value of the source fragment.
+ */
+ const BLENDMODE_SRC_ALPHA_SATURATE = 7;
+ /**
+ * @enum pc.BLENDMODE
+ * @name pc.BLENDMODE_ONE_MINUS_SRC_ALPHA
+ * @description Multiply all fragment components by one minus the alpha value of the source fragment.
+ */
+ const BLENDMODE_ONE_MINUS_SRC_ALPHA = 8;
+ /**
+ * @enum pc.BLENDMODE
+ * @name pc.BLENDMODE_DST_ALPHA
+ * @description Multiply all fragment components by the alpha value of the destination fragment.
+ */
+ const BLENDMODE_DST_ALPHA = 9;
+ /**
+ * @enum pc.BLENDMODE
+ * @name pc.BLENDMODE_ONE_MINUS_DST_ALPHA
+ * @description Multiply all fragment components by one minus the alpha value of the destination fragment.
+ */
+ const BLENDMODE_ONE_MINUS_DST_ALPHA = 10;
+
+ /**
+ * @enum pc.BLENDEQUATION
+ * @name pc.BLENDEQUATION_ADD
+ * @description Add the results of the source and destination fragment multiplies.
+ */
+ const BLENDEQUATION_ADD = 0;
+ /**
+ * @enum pc.BLENDEQUATION
+ * @name pc.BLENDEQUATION_SUBTRACT
+ * @description Subtract the results of the source and destination fragment multiplies.
+ */
+ const BLENDEQUATION_SUBTRACT = 1;
+ /**
+ * @enum pc.BLENDEQUATION
+ * @name pc.BLENDEQUATION_REVERSE_SUBTRACT
+ * @description Reverse and subtract the results of the source and destination fragment multiplies.
+ */
+ const BLENDEQUATION_REVERSE_SUBTRACT = 2;
+
+ /**
+ * @enum pc.BLENDEQUATION
+ * @name pc.BLENDEQUATION_MIN
+ * @description Use the smallest value. Check app.graphicsDevice.extBlendMinmax for support.
+ */
+ const BLENDEQUATION_MIN = 3;
+ /**
+ * @enum pc.BLENDEQUATION
+ * @name pc.BLENDEQUATION_MAX
+ * @description Use the largest value. Check app.graphicsDevice.extBlendMinmax for support.
+ */
+ const BLENDEQUATION_MAX = 4;
+
+ /**
+ * @enum pc.BUFFER
+ * @name pc.BUFFER_STATIC
+ * @description The data store contents will be modified once and used many times.
+ */
+ const BUFFER_STATIC = 0;
+ /**
+ * @enum pc.BUFFER
+ * @name pc.BUFFER_DYNAMIC
+ * @description The data store contents will be modified repeatedly and used many times.
+ */
+ const BUFFER_DYNAMIC = 1;
+ /**
+ * @enum pc.BUFFER
+ * @name pc.BUFFER_STREAM
+ * @description The data store contents will be modified once and used at most a few times.
+ */
+ const BUFFER_STREAM = 2;
+ /**
+ * @enum pc.BUFFER
+ * @name pc.BUFFER_GPUDYNAMIC
+ * @description The data store contents will be modified repeatedly on the GPU and used many times. Optimal for transform feedback usage (WebGL2 only).
+ */
+ const BUFFER_GPUDYNAMIC = 3;
+
+ /**
+ * @enum pc.CLEARFLAG
+ * @name pc.CLEARFLAG_COLOR
+ * @description Clear the color buffer.
+ */
+ const CLEARFLAG_COLOR = 1;
+ /**
+ * @enum pc.CLEARFLAG
+ * @name pc.CLEARFLAG_DEPTH
+ * @description Clear the depth buffer.
+ */
+ const CLEARFLAG_DEPTH = 2;
+ /**
+ * @enum pc.CLEARFLAG
+ * @name pc.CLEARFLAG_STENCIL
+ * @description Clear the stencil buffer.
+ */
+ const CLEARFLAG_STENCIL = 4;
+
+ /**
+ * @enum pc.CUBEFACE
+ * @name pc.CUBEFACE_POSX
+ * @description The positive X face of a cubemap.
+ */
+ const CUBEFACE_POSX = 0;
+ /**
+ * @enum pc.CUBEFACE
+ * @name pc.CUBEFACE_NEGX
+ * @description The negative X face of a cubemap.
+ */
+ const CUBEFACE_NEGX = 1;
+ /**
+ * @enum pc.CUBEFACE
+ * @name pc.CUBEFACE_POSY
+ * @description The positive Y face of a cubemap.
+ */
+ const CUBEFACE_POSY = 2;
+ /**
+ * @enum pc.CUBEFACE
+ * @name pc.CUBEFACE_NEGY
+ * @description The negative Y face of a cubemap.
+ */
+ const CUBEFACE_NEGY = 3;
+ /**
+ * @enum pc.CUBEFACE
+ * @name pc.CUBEFACE_POSZ
+ * @description The positive Z face of a cubemap.
+ */
+ const CUBEFACE_POSZ = 4;
+ /**
+ * @enum pc.CUBEFACE
+ * @name pc.CUBEFACE_NEGZ
+ * @description The negative Z face of a cubemap.
+ */
+ const CUBEFACE_NEGZ = 5;
+
+ /**
+ * @enum pc.CULLFACE
+ * @name pc.CULLFACE_NONE
+ * @description No triangles are culled.
+ */
+ const CULLFACE_NONE = 0;
+ /**
+ * @enum pc.CULLFACE
+ * @name pc.CULLFACE_BACK
+ * @description Triangles facing away from the view direction are culled.
+ */
+ const CULLFACE_BACK = 1;
+ /**
+ * @enum pc.CULLFACE
+ * @name pc.CULLFACE_FRONT
+ * @description Triangles facing the view direction are culled.
+ */
+ const CULLFACE_FRONT = 2;
+ /**
+ * @enum pc.CULLFACE
+ * @name pc.CULLFACE_FRONTANDBACK
+ * @description Triangles are culled regardless of their orientation with respect to the view
+ * direction. Note that point or line primitives are unaffected by this render state.
+ */
+ const CULLFACE_FRONTANDBACK = 3;
+
+ /**
+ * @enum pc.TYPE
+ * @name pc.TYPE_INT8
+ * @description Signed byte vertex element type.
+ */
+ const TYPE_INT8 = 0;
+ /**
+ * @enum pc.TYPE
+ * @name pc.TYPE_UINT8
+ * @description Unsigned byte vertex element type.
+ */
+ const TYPE_UINT8 = 1;
+ /**
+ * @enum pc.TYPE
+ * @name pc.TYPE_INT16
+ * @description Signed short vertex element type.
+ */
+ const TYPE_INT16 = 2;
+ /**
+ * @enum pc.TYPE
+ * @name pc.TYPE_UINT16
+ * @description Unsigned short vertex element type.
+ */
+ const TYPE_UINT16 = 3;
+ /**
+ * @enum pc.TYPE
+ * @name pc.TYPE_INT32
+ * @description Signed integer vertex element type.
+ */
+ const TYPE_INT32 = 4;
+ /**
+ * @enum pc.TYPE
+ * @name pc.TYPE_UINT32
+ * @description Unsigned integer vertex element type.
+ */
+ const TYPE_UINT32 = 5;
+ /**
+ * @enum pc.TYPE
+ * @name pc.TYPE_FLOAT32
+ * @description Floating point vertex element type.
+ */
+ const TYPE_FLOAT32 = 6;
+
+ /**
+ * @enum pc.FILTER
+ * @name pc.FILTER_NEAREST
+ * @description Point sample filtering.
+ */
+ const FILTER_NEAREST = 0;
+ /**
+ * @enum pc.FILTER
+ * @name pc.FILTER_LINEAR
+ * @description Bilinear filtering.
+ */
+ const FILTER_LINEAR = 1;
+ /**
+ * @enum pc.FILTER
+ * @name pc.FILTER_NEAREST_MIPMAP_NEAREST
+ * @description Use the nearest neighbor in the nearest mipmap level.
+ */
+ const FILTER_NEAREST_MIPMAP_NEAREST = 2;
+ /**
+ * @enum pc.FILTER
+ * @name pc.FILTER_NEAREST_MIPMAP_LINEAR
+ * @description Linearly interpolate in the nearest mipmap level.
+ */
+ const FILTER_NEAREST_MIPMAP_LINEAR = 3;
+ /**
+ * @enum pc.FILTER
+ * @name pc.FILTER_LINEAR_MIPMAP_NEAREST
+ * @description Use the nearest neighbor after linearly interpolating between mipmap levels.
+ */
+ const FILTER_LINEAR_MIPMAP_NEAREST = 4;
+ /**
+ * @enum pc.FILTER
+ * @name pc.FILTER_LINEAR_MIPMAP_LINEAR
+ * @description Linearly interpolate both the mipmap levels and between texels.
+ */
+ const FILTER_LINEAR_MIPMAP_LINEAR = 5;
+
+ const FUNC_NEVER = 0;
+ const FUNC_LESS = 1;
+ const FUNC_EQUAL = 2;
+ const FUNC_LESSEQUAL = 3;
+ const FUNC_GREATER = 4;
+ const FUNC_NOTEQUAL = 5;
+ const FUNC_GREATEREQUAL = 6;
+ const FUNC_ALWAYS = 7;
+
+ /**
+ * @enum pc.INDEXFORMAT
+ * @name pc.INDEXFORMAT_UINT8
+ * @description 8-bit unsigned vertex indices.
+ */
+ const INDEXFORMAT_UINT8 = 0;
+ /**
+ * @enum pc.INDEXFORMAT
+ * @name pc.INDEXFORMAT_UINT16
+ * @description 16-bit unsigned vertex indices.
+ */
+ const INDEXFORMAT_UINT16 = 1;
+ /**
+ * @enum pc.INDEXFORMAT
+ * @name pc.INDEXFORMAT_UINT32
+ * @description 32-bit unsigned vertex indices.
+ */
+ const INDEXFORMAT_UINT32 = 2;
+
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_A8
+ * @description 8-bit alpha.
+ */
+ const PIXELFORMAT_A8 = 0;
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_L8
+ * @description 8-bit luminance.
+ */
+ const PIXELFORMAT_L8 = 1;
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_L8_A8
+ * @description 8-bit luminance with 8-bit alpha.
+ */
+ const PIXELFORMAT_L8_A8 = 2;
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_R5_G6_B5
+ * @description 16-bit RGB (5-bits for red channel; 6 for green and 5 for blue).
+ */
+ const PIXELFORMAT_R5_G6_B5 = 3;
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_R5_G5_B5_A1
+ * @description 16-bit RGBA (5-bits for red channel; 5 for green; 5 for blue with 1-bit alpha).
+ */
+ const PIXELFORMAT_R5_G5_B5_A1 = 4;
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_R4_G4_B4_A4
+ * @description 16-bit RGBA (4-bits for red channel; 4 for green; 4 for blue with 4-bit alpha).
+ */
+ const PIXELFORMAT_R4_G4_B4_A4 = 5;
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_R8_G8_B8
+ * @description 24-bit RGB (8-bits for red channel; 8 for green and 8 for blue).
+ */
+ const PIXELFORMAT_R8_G8_B8 = 6;
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_R8_G8_B8_A8
+ * @description 32-bit RGBA (8-bits for red channel; 8 for green; 8 for blue with 8-bit alpha).
+ */
+ const PIXELFORMAT_R8_G8_B8_A8 = 7;
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_DXT1
+ * @description Block compressed format; storing 16 input pixels in 64 bits of output; consisting of two 16-bit RGB 5 =6 =5 color values and a 4x4 two bit lookup table.
+ */
+ const PIXELFORMAT_DXT1 = 8;
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_DXT3
+ * @description Block compressed format; storing 16 input pixels (corresponding to a 4x4 pixel block) into 128 bits of output; consisting of 64 bits of alpha channel data (4 bits for each pixel) followed by 64 bits of color data; encoded the same way as DXT1.
+ */
+ const PIXELFORMAT_DXT3 = 9;
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_DXT5
+ * @description Block compressed format; storing 16 input pixels into 128 bits of output; consisting of 64 bits of alpha channel data (two 8 bit alpha values and a 4x4 3 bit lookup table) followed by 64 bits of color data (encoded the same way as DXT1).
+ */
+ const PIXELFORMAT_DXT5 = 10;
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_RGB16F
+ * @description 16-bit floating point RGB (16-bit float for each red; green and blue channels).
+ */
+ const PIXELFORMAT_RGB16F = 11;
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_RGBA16F
+ * @description 16-bit floating point RGBA (16-bit float for each red; green; blue and alpha channels).
+ */
+ const PIXELFORMAT_RGBA16F = 12;
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_RGB32F
+ * @description 32-bit floating point RGB (32-bit float for each red; green and blue channels).
+ */
+ const PIXELFORMAT_RGB32F = 13;
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_RGBA32F
+ * @description 32-bit floating point RGBA (32-bit float for each red; green; blue and alpha channels).
+ */
+ const PIXELFORMAT_RGBA32F = 14;
+
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_R32F
+ * @description 32-bit floating point single channel format (WebGL2 only).
+ */
+ const PIXELFORMAT_R32F = 15;
+
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_DEPTH
+ * @description A readable depth buffer format
+ */
+ const PIXELFORMAT_DEPTH = 16;
+
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_DEPTHSTENCIL
+ * @description A readable depth/stencil buffer format (WebGL2 only).
+ */
+ const PIXELFORMAT_DEPTHSTENCIL = 17;
+
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_111110F
+ * @description A floating-point color-only format with 11 bits for red and green channels; and 10 bits for the blue channel (WebGL2 only).
+ */
+ const PIXELFORMAT_111110F = 18;
+
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_SRGB
+ * @description Color-only sRGB format (WebGL2 only).
+ */
+ const PIXELFORMAT_SRGB = 19;
+
+ /**
+ * @enum pc.PIXELFORMAT
+ * @name pc.PIXELFORMAT_SRGBA
+ * @description Color sRGB format with additional alpha channel (WebGL2 only).
+ */
+ const PIXELFORMAT_SRGBA = 20;
+
+ const PIXELFORMAT_ETC1 = 21;
+ const PIXELFORMAT_PVRTC_2BPP_RGB_1 = 22;
+ const PIXELFORMAT_PVRTC_2BPP_RGBA_1 = 23;
+ const PIXELFORMAT_PVRTC_4BPP_RGB_1 = 24;
+ const PIXELFORMAT_PVRTC_4BPP_RGBA_1 = 25;
+ // only add compressed formats next
+
+ /**
+ * @enum pc.PRIMITIVE
+ * @name pc.PRIMITIVE_POINTS
+ * @description List of distinct points.
+ */
+ const PRIMITIVE_POINTS = 0;
+ /**
+ * @enum pc.PRIMITIVE
+ * @name pc.PRIMITIVE_LINES
+ * @description Discrete list of line segments.
+ */
+ const PRIMITIVE_LINES = 1;
+ /**
+ * @enum pc.PRIMITIVE
+ * @name pc.PRIMITIVE_LINELOOP
+ * @description List of points that are linked sequentially by line segments; with a closing line segment between the last and first points.
+ */
+ const PRIMITIVE_LINELOOP = 2;
+ /**
+ * @enum pc.PRIMITIVE
+ * @name pc.PRIMITIVE_LINESTRIP
+ * @description List of points that are linked sequentially by line segments.
+ */
+ const PRIMITIVE_LINESTRIP = 3;
+ /**
+ * @enum pc.PRIMITIVE
+ * @name pc.PRIMITIVE_TRIANGLES
+ * @description Discrete list of triangles.
+ */
+ const PRIMITIVE_TRIANGLES = 4;
+ /**
+ * @enum pc.PRIMITIVE
+ * @name pc.PRIMITIVE_TRISTRIP
+ * @description Connected strip of triangles where a specified vertex forms a triangle using the previous two.
+ */
+ const PRIMITIVE_TRISTRIP = 5;
+ /**
+ * @enum pc.PRIMITIVE
+ * @name pc.PRIMITIVE_TRIFAN
+ * @description Connected fan of triangles where the first vertex forms triangles with the following pairs of vertices.
+ */
+ const PRIMITIVE_TRIFAN = 6;
+
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_POSITION
+ * @description Vertex attribute to be treated as a position.
+ */
+ const SEMANTIC_POSITION = "POSITION";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_NORMAL
+ * @description Vertex attribute to be treated as a normal.
+ */
+ const SEMANTIC_NORMAL = "NORMAL";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_TANGENT
+ * @description Vertex attribute to be treated as a tangent.
+ */
+ const SEMANTIC_TANGENT = "TANGENT";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_BLENDWEIGHT
+ * @description Vertex attribute to be treated as skin blend weights.
+ */
+ const SEMANTIC_BLENDWEIGHT = "BLENDWEIGHT";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_BLENDINDICES
+ * @description Vertex attribute to be treated as skin blend indices.
+ */
+ const SEMANTIC_BLENDINDICES = "BLENDINDICES";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_COLOR
+ * @description Vertex attribute to be treated as a color.
+ */
+ const SEMANTIC_COLOR = "COLOR";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_TEXCOORD0
+ * @description Vertex attribute to be treated as a texture coordinate (set 0).
+ */
+ const SEMANTIC_TEXCOORD0 = "TEXCOORD0";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_TEXCOORD1
+ * @description Vertex attribute to be treated as a texture coordinate (set 1).
+ */
+ const SEMANTIC_TEXCOORD1 = "TEXCOORD1";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_TEXCOORD2
+ * @description Vertex attribute to be treated as a texture coordinate (set 2).
+ */
+ const SEMANTIC_TEXCOORD2 = "TEXCOORD2";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_TEXCOORD3
+ * @description Vertex attribute to be treated as a texture coordinate (set 3).
+ */
+ const SEMANTIC_TEXCOORD3 = "TEXCOORD3";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_TEXCOORD4
+ * @description Vertex attribute to be treated as a texture coordinate (set 4).
+ */
+ const SEMANTIC_TEXCOORD4 = "TEXCOORD4";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_TEXCOORD5
+ * @description Vertex attribute to be treated as a texture coordinate (set 5).
+ */
+ const SEMANTIC_TEXCOORD5 = "TEXCOORD5";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_TEXCOORD6
+ * @description Vertex attribute to be treated as a texture coordinate (set 6).
+ */
+ const SEMANTIC_TEXCOORD6 = "TEXCOORD6";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_TEXCOORD7
+ * @description Vertex attribute to be treated as a texture coordinate (set 7).
+ */
+ const SEMANTIC_TEXCOORD7 = "TEXCOORD7";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_ATTR0
+ * @description Vertex attribute with a user defined semantic.
+ */
+ const SEMANTIC_ATTR0 = "ATTR0";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_ATTR1
+ * @description Vertex attribute with a user defined semantic.
+ */
+ const SEMANTIC_ATTR1 = "ATTR1";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_ATTR2
+ * @description Vertex attribute with a user defined semantic.
+ */
+ const SEMANTIC_ATTR2 = "ATTR2";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_ATTR3
+ * @description Vertex attribute with a user defined semantic.
+ */
+ const SEMANTIC_ATTR3 = "ATTR3";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_ATTR4
+ * @description Vertex attribute with a user defined semantic.
+ */
+ const SEMANTIC_ATTR4 = "ATTR4";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_ATTR5
+ * @description Vertex attribute with a user defined semantic.
+ */
+ const SEMANTIC_ATTR5 = "ATTR5";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_ATTR6
+ * @description Vertex attribute with a user defined semantic.
+ */
+ const SEMANTIC_ATTR6 = "ATTR6";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_ATTR7
+ * @description Vertex attribute with a user defined semantic.
+ */
+ const SEMANTIC_ATTR7 = "ATTR7";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_ATTR8
+ * @description Vertex attribute with a user defined semantic.
+ */
+ const SEMANTIC_ATTR8 = "ATTR8";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_ATTR9
+ * @description Vertex attribute with a user defined semantic.
+ */
+ const SEMANTIC_ATTR9 = "ATTR9";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_ATTR10
+ * @description Vertex attribute with a user defined semantic.
+ */
+ const SEMANTIC_ATTR10 = "ATTR10";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_ATTR11
+ * @description Vertex attribute with a user defined semantic.
+ */
+ const SEMANTIC_ATTR11 = "ATTR11";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_ATTR12
+ * @description Vertex attribute with a user defined semantic.
+ */
+ const SEMANTIC_ATTR12 = "ATTR12";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_ATTR13
+ * @description Vertex attribute with a user defined semantic.
+ */
+ const SEMANTIC_ATTR13 = "ATTR13";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_ATTR14
+ * @description Vertex attribute with a user defined semantic.
+ */
+ const SEMANTIC_ATTR14 = "ATTR14";
+ /**
+ * @enum pc.SEMANTIC
+ * @name pc.SEMANTIC_ATTR15
+ * @description Vertex attribute with a user defined semantic.
+ */
+ const SEMANTIC_ATTR15 = "ATTR15";
+
+ const SHADERTAG_MATERIAL = 1;
+
+ const STENCILOP_KEEP = 0;
+ const STENCILOP_ZERO = 1;
+ const STENCILOP_REPLACE = 2;
+ const STENCILOP_INCREMENT = 3;
+ const STENCILOP_INCREMENTWRAP = 4;
+ const STENCILOP_DECREMENT = 5;
+ const STENCILOP_DECREMENTWRAP = 6;
+ const STENCILOP_INVERT = 7;
+
+ /**
+ * @enum pc.TEXTURELOCK
+ * @name pc.TEXTURELOCK_READ
+ * @description Read only. Any changes to the locked mip level's pixels will not update the texture.
+ */
+ const TEXTURELOCK_READ = 1;
+ /**
+ * @enum pc.TEXTURELOCK
+ * @name pc.TEXTURELOCK_WRITE
+ * @description Write only. The contents of the specified mip level will be entirely replaced.
+ */
+ const TEXTURELOCK_WRITE = 2;
+
+ const TEXHINT_NONE = 0;
+ const TEXHINT_SHADOWMAP = 1;
+ const TEXHINT_ASSET = 2;
+ const TEXHINT_LIGHTMAP = 3;
+
+ const UNIFORMTYPE_BOOL = 0;
+ const UNIFORMTYPE_INT = 1;
+ const UNIFORMTYPE_FLOAT = 2;
+ const UNIFORMTYPE_VEC2 = 3;
+ const UNIFORMTYPE_VEC3 = 4;
+ const UNIFORMTYPE_VEC4 = 5;
+ const UNIFORMTYPE_IVEC2 = 6;
+ const UNIFORMTYPE_IVEC3 = 7;
+ const UNIFORMTYPE_IVEC4 = 8;
+ const UNIFORMTYPE_BVEC2 = 9;
+ const UNIFORMTYPE_BVEC3 = 10;
+ const UNIFORMTYPE_BVEC4 = 11;
+ const UNIFORMTYPE_MAT2 = 12;
+ const UNIFORMTYPE_MAT3 = 13;
+ const UNIFORMTYPE_MAT4 = 14;
+ const UNIFORMTYPE_TEXTURE2D = 15;
+ const UNIFORMTYPE_TEXTURECUBE = 16;
+ const UNIFORMTYPE_FLOATARRAY = 17;
+ const UNIFORMTYPE_TEXTURE2D_SHADOW = 18;
+ const UNIFORMTYPE_TEXTURECUBE_SHADOW = 19;
+ const UNIFORMTYPE_TEXTURE3D = 20;
+}
diff --git a/types/playcanvas/engine/graphics/index-buffer.d.ts b/types/playcanvas/engine/graphics/index-buffer.d.ts
new file mode 100644
index 0000000000..12779368e5
--- /dev/null
+++ b/types/playcanvas/engine/graphics/index-buffer.d.ts
@@ -0,0 +1,61 @@
+declare namespace pc {
+
+ /**
+ * @name pc.IndexBuffer
+ * @class An index buffer is the mechanism via which the application specifies primitive
+ * index data to the graphics hardware.
+ * @description Creates a new index buffer.
+ * @example
+ * // Create an index buffer holding 3 16-bit indices
+ * // The buffer is marked as static, hinting that the buffer will never be modified
+ * var indexBuffer = new pc.IndexBuffer(graphicsDevice, pc.INDEXFORMAT_UINT16, 3, pc.BUFFER_STATIC);
+ * @param {pc.GraphicsDevice} graphicsDevice The graphics device used to manage this index buffer.
+ * @param {Number} format The type of each index to be stored in the index buffer (see pc.INDEXFORMAT_*).
+ * @param {Number} numIndices The number of indices to be stored in the index buffer.
+ * @param {Number} [usage] The usage type of the vertex buffer (see pc.BUFFER_*).
+ * @param {ArrayBuffer} [initialData] Initial data.
+ */
+ class IndexBuffer {
+ constructor(graphicsDevice: pc.GraphicsDevice, format: number, numIndices: number, usage?: number, initialData?: any)
+
+ /**
+ * @function
+ * @name pc.IndexBuffer#destroy
+ * @description Frees resources associated with this index buffer.
+ */
+ destroy(): void;
+
+ /**
+ * @function
+ * @name pc.IndexBuffer#getFormat
+ * @description Returns the data format of the specified index buffer.
+ * @returns {Number} The data format of the specified index buffer (see pc.INDEXFORMAT_*).
+ */
+ getFormat(): void;
+
+ /**
+ * @function
+ * @name pc.IndexBuffer#getNumIndices
+ * @description Returns the number of indices stored in the specified index buffer.
+ * @returns {Number} The number of indices stored in the specified index buffer.
+ */
+ getNumIndices(): number;
+
+ /**
+ * @function
+ * @name pc.IndexBuffer#lock
+ * @description Gives access to the block of memory that stores the buffer's indices.
+ * @returns {ArrayBuffer} A contiguous block of memory where index data can be written to.
+ */
+ lock(): ArrayBuffer;
+
+ /**
+ * @function
+ * @name pc.IndexBuffer#unlock
+ * @description Signals that the block of memory returned by a call to the lock function is
+ * ready to be given to the graphics hardware. Only unlocked index buffers can be set on the
+ * currently active device.
+ */
+ unlock(): void;
+ }
+}
diff --git a/types/playcanvas/engine/graphics/post-effect.d.ts b/types/playcanvas/engine/graphics/post-effect.d.ts
new file mode 100644
index 0000000000..7575098503
--- /dev/null
+++ b/types/playcanvas/engine/graphics/post-effect.d.ts
@@ -0,0 +1,25 @@
+declare namespace pc {
+
+ /**
+ * @name pc.PostEffect
+ * @class Base class for all post effects. Post effects take a a render target as input
+ * apply effects to it and then render the result to an output render target or the screen
+ * if no output is specified.
+ * @description Creates new PostEffect
+ * @param {pc.GraphicsDevice} graphicsDevice The graphics device of the application
+ */
+ class PostEffect {
+ constructor(graphicsDevice: pc.GraphicsDevice)
+
+ /**
+ * @function
+ * @name pc.PostEffect#render
+ * @description Render the post effect using the specified inputTarget
+ * to the specified outputTarget.
+ * @param {pc.RenderTarget} inputTarget The input render target
+ * @param {pc.RenderTarget} outputTarget The output render target. If null then this will be the screen.
+ * @param {pc.Vec4} rect (Optional) The rect of the current camera. If not specified then it will default to [0,0,1,1]
+ */
+ render(inputTarget: pc.RenderTarget, outputTarget: pc.RenderTarget, rect: pc.Vec4): void;
+ }
+}
diff --git a/types/playcanvas/engine/graphics/program-library.d.ts b/types/playcanvas/engine/graphics/program-library.d.ts
new file mode 100644
index 0000000000..ef203317b4
--- /dev/null
+++ b/types/playcanvas/engine/graphics/program-library.d.ts
@@ -0,0 +1,18 @@
+declare namespace pc {
+
+ class ProgramLibrary {
+ constructor(device: pc.GraphicsDevice)
+
+ register(name: string, generator: any): void;
+
+ unregister(name: string): void;
+
+ isRegistered(name: string): void;
+
+ getProgram(name: string, options: {}): pc.Shader;
+
+ clearCache(): void;
+
+ removeFromCache(shader: pc.Shader): void;
+ }
+}
\ No newline at end of file
diff --git a/types/playcanvas/engine/graphics/render-target.d.ts b/types/playcanvas/engine/graphics/render-target.d.ts
new file mode 100644
index 0000000000..25e4d6aea7
--- /dev/null
+++ b/types/playcanvas/engine/graphics/render-target.d.ts
@@ -0,0 +1,145 @@
+declare namespace pc {
+
+ /**
+ * @name pc.RenderTarget
+ * @class A render target is a rectangular rendering surface.
+ * @description Creates a new render target. A color buffer or a depth buffer must be set.
+ * @param {Object} options Object for passing optional arguments.
+ * @param {pc.Texture} [options.colorBuffer] The texture that this render target will treat as a rendering surface.
+ * @param {Boolean} [options.depth] If set to true, depth buffer will be created. Defaults to true. Ignored if depthBuffer is defined.
+ * @param {Boolean} [options.stencil] If set to true, depth buffer will include stencil. Defaults to false. Ignored if depthBuffer is defined or depth is false.
+ * @param {pc.Texture} [options.depthBuffer] The texture that this render target will treat as a depth/stencil surface (WebGL2 only). If set, the 'depth' and 'stencil' properties are ignored.
+ * Texture must have pc.PIXELFORMAT_DEPTH or PIXELFORMAT_DEPTHSTENCIL format.
+ * @param {Number} [options.samples] Number of hardware anti-aliasing samples (WebGL2 only). Default is 1.
+ * @param {Boolean} [options.autoResolve] If samples > 1, enables or disables automatic MSAA resolve after rendering to this RT (see pc.RenderTarget#resolve). Defaults to true;
+ * Defaults to true.
+ * @param {Number} [options.face] If the colorBuffer parameter is a cubemap, use this option to specify the
+ * face of the cubemap to render to. Can be:
+ *
+ * - pc.CUBEFACE_POSX
+ * - pc.CUBEFACE_NEGX
+ * - pc.CUBEFACE_POSY
+ * - pc.CUBEFACE_NEGY
+ * - pc.CUBEFACE_POSZ
+ * - pc.CUBEFACE_NEGZ
+ *
+ * Defaults to pc.CUBEFACE_POSX.
+ * @example
+ * // Create a 512x512x24-bit render target with a depth buffer
+ * var colorBuffer = new pc.Texture(graphicsDevice, {
+ * width: 512,
+ * height: 512,
+ * format: pc.PIXELFORMAT_R8_G8_B8
+ * });
+ * var renderTarget = new pc.RenderTarget(graphicsDevice, colorBuffer, {
+ * depth: true
+ * });
+ *
+ * // Set the render target on an entity's camera component
+ * entity.camera.renderTarget = renderTarget;
+ */
+ class RenderTarget {
+ constructor(options: {
+ colorBuffer?: pc.Texture,
+ depth?: boolean,
+ stencil?: boolean,
+ depthBuffer?: pc.Texture,
+ samples?: number,
+ autoResolve?: boolean,
+ face?: number
+ })
+ constructor(options: pc.GraphicsDevice, _arg2: pc.Texture, _arg3: {
+ colorBuffer?: pc.Texture,
+ depth?: boolean,
+ stencil?: boolean,
+ depthBuffer?: pc.Texture,
+ samples?: number,
+ autoResolve?: boolean,
+ face?: number
+ })
+
+ /**
+ * @function
+ * @name pc.RenderTarget#destroy
+ * @description Frees resources associated with this render target.
+ */
+ destroy(): void;
+
+ /**
+ * @function
+ * @name pc.RenderTarget#resolve
+ * @description If samples > 1, resolves the anti-aliased render target (WebGL2 only).
+ * When you're rendering to an anti-aliased render target, pixels aren't written directly to the readable texture.
+ * Instead, they're first written to a MSAA buffer, where each sample for each pixel is stored independently.
+ * In order to read the results, you first need to 'resolve' the buffer - to average all samples and create a simple texture with one color per pixel.
+ * This function performs this averaging and updates the colorBuffer and the depthBuffer.
+ * If autoResolve is set to true, the resolve will happen after every rendering to this render target, otherwise you can do it manually,
+ * during the app update or inside a pc.Command.
+ * @param {Boolean} color Resolve color buffer
+ * @param {Boolean} depth Resolve depth buffer
+ */
+ resolve(color: boolean, depth: boolean): void;
+
+ /**
+ * @function
+ * @name pc.RenderTarget#copy
+ * @description Copies color and/or depth contents of source render target to this one. Formats, sizes and anti-aliasing samples must match.
+ * Depth buffer can only be copied on WebGL 2.0.
+ * @param {pc.RenderTarget} source Source render target to copy from
+ * @param {Boolean} color Copy color buffer
+ * @param {Boolean} depth Copy depth buffer
+ */
+ copy(source: pc.RenderTarget, color: boolean, depth: boolean): pc.RenderTarget;
+
+
+ /**
+ * @readonly
+ * @name pc.RenderTarget#colorBuffer
+ * @type pc.Texture
+ * @description Color buffer set up on the render target.
+ */
+ readonly colorBuffer: pc.Texture;
+
+ /**
+ * @readonly
+ * @name pc.RenderTarget#depthBuffer
+ * @type pc.Texture
+ * @description Depth buffer set up on the render target. Only available, if depthBuffer was set in constructor.
+ * Not available, if depth property was used instead.
+ */
+ readonly depthBuffer: pc.Texture;
+
+ /**
+ * @readonly
+ * @name pc.RenderTarget#face
+ * @type Number
+ * @description If the render target is bound to a cubemap, this property
+ * specifies which face of the cubemap is rendered to. Can be:
+ *
+ * - pc.CUBEFACE_POSX
+ * - pc.CUBEFACE_NEGX
+ * - pc.CUBEFACE_POSY
+ * - pc.CUBEFACE_NEGY
+ * - pc.CUBEFACE_POSZ
+ * - pc.CUBEFACE_NEGZ
+ *
+ */
+ readonly face: number;
+
+ /**
+ * @readonly
+ * @name pc.RenderTarget#width
+ * @type Number
+ * @description Width of the render target in pixels.
+ */
+ readonly width: number
+
+ /**
+ * @readonly
+ * @name pc.RenderTarget#height
+ * @type Number
+ * @description Height of the render target in pixels.
+ */
+ readonly height: number;
+ }
+}
\ No newline at end of file
diff --git a/types/playcanvas/engine/graphics/shader.d.ts b/types/playcanvas/engine/graphics/shader.d.ts
new file mode 100644
index 0000000000..4bea7f366a
--- /dev/null
+++ b/types/playcanvas/engine/graphics/shader.d.ts
@@ -0,0 +1,64 @@
+declare namespace pc {
+
+ /**
+ * @name pc.Shader
+ * @class A shader is a program that is responsible for rendering graphical primitives on a device's
+ * graphics processor. The shader is generated from a shader definition. This shader definition specifies
+ * the code for processing vertices and fragments processed by the GPU. The language of the code is GLSL
+ * (or more specifically ESSL, the OpenGL ES Shading Language). The shader definition also describes how
+ * the PlayCanvas engine should map vertex buffer elements onto the attributes specified in the vertex
+ * shader code.
+ * @description Creates a new shader object.
+ * @param {pc.GraphicsDevice} graphicsDevice The graphics device used to manage this shader.
+ * @param {Object} definition The shader definition from which to build the shader.
+ * @param {Object} definition.attributes Object detailing the mapping of vertex shader attribute names
+ * to semantics (pc.SEMANTIC_*). This enables the engine to match vertex buffer data as inputs to the
+ * shader.
+ * @param {String} definition.vshader Vertex shader source (GLSL code).
+ * @param {String} definition.fshader Fragment shader source (GLSL code).
+ * @param {Boolean} definition.useTransformFeedback Specifies that this shader outputs post-VS data to a buffer
+ * @example
+ * // Create a shader that renders primitives with a solid red color
+ * var shaderDefinition = {
+ * attributes: {
+ * aPosition: pc.SEMANTIC_POSITION
+ * },
+ * vshader: [
+ * "attribute vec3 aPosition;",
+ * "",
+ * "void main(void)",
+ * "{",
+ * " gl_Position = vec4(aPosition, 1.0);",
+ * "}"
+ * ].join("\n"),
+ * fshader: [
+ * "precision " + graphicsDevice.precision + " float;",
+ * "",
+ * "void main(void)",
+ * "{",
+ * " gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);",
+ * "}"
+ * ].join("\n")
+ * };
+ *
+ * shader = new pc.Shader(graphicsDevice, shaderDefinition);
+ * @author Will Eastcott
+ */
+ class Shader {
+ constructor(graphicsDevice: pc.GraphicsDevice, definition: {
+ attributes: {},
+ vshader: string,
+ fshader: string,
+ useTransformFeedback: boolean
+ })
+
+ /**
+ * @function
+ * @name pc.Shader#destroy
+ * @description Frees resources associated with this shader.
+ */
+ destroy(): void;
+
+
+ }
+}
\ No newline at end of file
diff --git a/types/playcanvas/engine/graphics/texture.d.ts b/types/playcanvas/engine/graphics/texture.d.ts
new file mode 100644
index 0000000000..ac637117bf
--- /dev/null
+++ b/types/playcanvas/engine/graphics/texture.d.ts
@@ -0,0 +1,373 @@
+declare namespace pc {
+
+ /**
+ * @name pc.Texture
+ * @class A texture is a container for texel data that can be utilized in a fragment shader.
+ * Typically, the texel data represents an image that is mapped over geometry.
+ * @description Creates a new texture.
+ * @param {pc.GraphicsDevice} graphicsDevice The graphics device used to manage this texture.
+ * @param {Object} options Object for passing optional arguments.
+ * @param {Number} options.width The width of the texture in pixels. Defaults to 4.
+ * @param {Number} options.height The height of the texture in pixels. Defaults to 4.
+ * @param {Number} options.depth The number of depth slices in a 3D texture (WebGL2 only). Defaults to 1 (single 2D image).
+ * @param {Number} options.format The pixel format of the texture. Can be:
+ *
+ * - {@link pc.PIXELFORMAT_A8}
+ * - {@link pc.PIXELFORMAT_L8}
+ * - {@link pc.PIXELFORMAT_L8_A8}
+ * - {@link pc.PIXELFORMAT_R5_G6_B5}
+ * - {@link pc.PIXELFORMAT_R5_G5_B5_A1}
+ * - {@link pc.PIXELFORMAT_R4_G4_B4_A4}
+ * - {@link pc.PIXELFORMAT_R8_G8_B8}
+ * - {@link pc.PIXELFORMAT_R8_G8_B8_A8}
+ * - {@link pc.PIXELFORMAT_DXT1}
+ * - {@link pc.PIXELFORMAT_DXT3}
+ * - {@link pc.PIXELFORMAT_DXT5}
+ * - {@link pc.PIXELFORMAT_RGB16F}
+ * - {@link pc.PIXELFORMAT_RGBA16F}
+ * - {@link pc.PIXELFORMAT_RGB32F}
+ * - {@link pc.PIXELFORMAT_RGBA32F}
+ * - {@link pc.PIXELFORMAT_ETC1}
+ * - {@link pc.PIXELFORMAT_PVRTC_2BPP_RGB_1}
+ * - {@link pc.PIXELFORMAT_PVRTC_2BPP_RGBA_1}
+ * - {@link pc.PIXELFORMAT_PVRTC_4BPP_RGB_1}
+ * - {@link pc.PIXELFORMAT_PVRTC_4BPP_RGBA_1}
+ * - {@link pc.PIXELFORMAT_111110F}
+ *
+ * Defaults to pc.PIXELFORMAT_R8_G8_B8_A8.
+ * @param {Number} options.minFilter The minification filter type to use. Defaults to {@link pc.FILTER_LINEAR_MIPMAP_LINEAR}
+ * @param {Number} options.magFilter The magnification filter type to use. Defaults to {@link pc.FILTER_LINEAR}
+ * @param {Number} options.anisotropy The level of anisotropic filtering to use. Defaults to 1
+ * @param {Number} options.addressU The repeat mode to use in the U direction. Defaults to {@link pc.ADDRESS_REPEAT}
+ * @param {Number} options.addressV The repeat mode to use in the V direction. Defaults to {@link pc.ADDRESS_REPEAT}
+ * @param {Boolean} options.mipmaps When enabled try to generate or use mipmaps for this texture. Default is true
+ * @param {Boolean} options.cubemap Specifies whether the texture is to be a cubemap. Defaults to false.
+ * @param {Boolean} options.volume Specifies whether the texture is to be a 3D volume (WebGL2 only). Defaults to false.
+ * @param {Boolean} options.rgbm Specifies whether the texture contains RGBM-encoded HDR data. Defaults to false.
+ * @param {Boolean} options.fixCubemapSeams Specifies whether this cubemap texture requires special
+ * seam fixing shader code to look right. Defaults to false.
+ * @param {Boolean} options.flipY Specifies whether the texture should be flipped in the Y-direction. Only affects textures
+ * with a source that is an image, canvas or video element. Does not affect cubemaps, compressed textures or textures set from raw
+ * pixel data. Defaults to true.
+ * @param {Boolean} options.compareOnRead When enabled, and if texture format is pc.PIXELFORMAT_DEPTH or pc.PIXELFORMAT_DEPTHSTENCIL,
+ * hardware PCF is enabled for this texture, and you can get filtered results of comparison using texture() in your shader (WebGL2 only).
+ * Defaults to false.
+ * @param {Number} options.compareFunc Comparison function when compareOnRead is enabled (WebGL2 only). Defaults to pc.FUNC_LESS.
+ * Possible values:
+ *
+ * - pc.FUNC_LESS
+ * - pc.FUNC_LESSEQUAL
+ * - pc.FUNC_GREATER
+ * - pc.FUNC_GREATEREQUAL
+ * - pc.FUNC_EQUAL
+ * - pc.FUNC_NOTEQUAL
+ *
+ * @example
+ * // Create a 8x8x24-bit texture
+ * var texture = new pc.Texture(graphicsDevice, {
+ * width: 8,
+ * height: 8,
+ * format: pc.PIXELFORMAT_R8_G8_B8
+ * });
+ *
+ * // Fill the texture with a gradient
+ * var pixels = texture.lock();
+ * var count = 0;
+ * for (var i = 0; i < 8; i++) {
+ * for (var j = 0; j < 8; j++) {
+ * pixels[count++] = i * 32;
+ * pixels[count++] = j * 32;
+ * pixels[count++] = 255;
+ * }
+ * }
+ * texture.unlock();
+ * @property {String} name The name of the texture. Defaults to null.
+ * @author Will Eastcott
+ */
+ class Texture {
+ constructor(graphicsDevice: pc.GraphicsDevice, options: {
+ width: number,
+ height: number,
+ depth: number,
+ format: number,
+ minFilter: number,
+ magFilter: number,
+ anisotropy: number,
+ addressU: number,
+ addressV: number,
+ mipmaps: boolean,
+ cubemap: boolean,
+ volume: boolean,
+ rgbm: boolean,
+ fixCubemapSeams: boolean,
+ flipY: boolean,
+ compareOnRead: boolean,
+ compareFunc: boolean
+ })
+
+ name: string;
+
+ /**
+ * @name pc.Texture#minFilter
+ * @type Number
+ * @description The minification filter to be applied to the texture. Can be:
+ *
+ * - {@link pc.FILTER_NEAREST}
+ * - {@link pc.FILTER_LINEAR}
+ * - {@link pc.FILTER_NEAREST_MIPMAP_NEAREST}
+ * - {@link pc.FILTER_NEAREST_MIPMAP_LINEAR}
+ * - {@link pc.FILTER_LINEAR_MIPMAP_NEAREST}
+ * - {@link pc.FILTER_LINEAR_MIPMAP_LINEAR}
+ *
+ */
+ minFilter: number;
+
+ /**
+ * @name pc.Texture#magFilter
+ * @type Number
+ * @description The magnification filter to be applied to the texture. Can be:
+ *
+ * - {@link pc.FILTER_NEAREST}
+ * - {@link pc.FILTER_LINEAR}
+ *
+ */
+ magFilter: number;
+
+ /**
+ * @name pc.Texture#addressU
+ * @type Number
+ * @description The addressing mode to be applied to the texture horizontally. Can be:
+ *
+ * - {@link pc.ADDRESS_REPEAT}
+ * - {@link pc.ADDRESS_CLAMP_TO_EDGE}
+ * - {@link pc.ADDRESS_MIRRORED_REPEAT}
+ *
+ */
+ addressU: number;
+
+ /**
+ * @name pc.Texture#addressV
+ * @type Number
+ * @description The addressing mode to be applied to the texture vertically. Can be:
+ *
+ * - {@link pc.ADDRESS_REPEAT}
+ * - {@link pc.ADDRESS_CLAMP_TO_EDGE}
+ * - {@link pc.ADDRESS_MIRRORED_REPEAT}
+ *
+ */
+ addressV: number;
+
+ /**
+ * @name pc.Texture#addressW
+ * @type Number
+ * @description The addressing mode to be applied to the 3D texture depth (WebGL2 only). Can be:
+ *
+ * - {@link pc.ADDRESS_REPEAT}
+ * - {@link pc.ADDRESS_CLAMP_TO_EDGE}
+ * - {@link pc.ADDRESS_MIRRORED_REPEAT}
+ *
+ */
+ addressW: number;
+
+ /**
+ * @name pc.Texture#compareOnRead
+ * @type Boolean
+ * @description When enabled, and if texture format is pc.PIXELFORMAT_DEPTH or pc.PIXELFORMAT_DEPTHSTENCIL,
+ * hardware PCF is enabled for this texture, and you can get filtered results of comparison using texture() in your shader (WebGL2 only).
+ */
+ compareOnRead: boolean;
+
+ /**
+ * @name pc.Texture#compareFunc
+ * @type Number
+ * @description Comparison function when compareOnRead is enabled (WebGL2 only).
+ * Possible values:
+ *
+ * - pc.FUNC_LESS
+ * - pc.FUNC_LESSEQUAL
+ * - pc.FUNC_GREATER
+ * - pc.FUNC_GREATEREQUAL
+ * - pc.FUNC_EQUAL
+ * - pc.FUNC_NOTEQUAL
+ *
+ */
+ compareFunc: number;
+
+ /**
+ * @private
+ * @deprecated
+ * @name pc.Texture#autoMipmap
+ * @type Boolean
+ * @description Toggles automatic mipmap generation. Can't be used on non power of two textures.
+ */
+ private autoMipmap: boolean;
+
+ /**
+ * @name pc.Texture#mipmaps
+ * @type Boolean
+ * @description Defines if texture should generate/upload mipmaps if possible.
+ */
+ mipmaps: boolean;
+
+ /**
+ * @name pc.Texture#anisotropy
+ * @type Number
+ * @description Integer value specifying the level of anisotropic to apply to the texture
+ * ranging from 1 (no anisotropic filtering) to the {@link pc.GraphicsDevice} property maxAnisotropy.
+ */
+ anisotropy: number;
+
+ /**
+ * @readonly
+ * @name pc.Texture#width
+ * @type Number
+ * @description The width of the texture in pixels.
+ */
+ readonly width: number;
+
+ /**
+ * @readonly
+ * @name pc.Texture#height
+ * @type Number
+ * @description The height of the texture in pixels.
+ */
+ readonly height: number;
+
+ /**
+ * @readonly
+ * @name pc.Texture#depth
+ * @type Number
+ * @description The number of depth slices in a 3D texture (WebGL2 only).
+ */
+ readonly depth: number;
+
+ /**
+ * @readonly
+ * @name pc.Texture#format
+ * @type Number
+ * @description The pixel format of the texture. Can be:
+ *
+ * - {@link pc.PIXELFORMAT_A8}
+ * - {@link pc.PIXELFORMAT_L8}
+ * - {@link pc.PIXELFORMAT_L8_A8}
+ * - {@link pc.PIXELFORMAT_R5_G6_B5}
+ * - {@link pc.PIXELFORMAT_R5_G5_B5_A1}
+ * - {@link pc.PIXELFORMAT_R4_G4_B4_A4}
+ * - {@link pc.PIXELFORMAT_R8_G8_B8}
+ * - {@link pc.PIXELFORMAT_R8_G8_B8_A8}
+ * - {@link pc.PIXELFORMAT_DXT1}
+ * - {@link pc.PIXELFORMAT_DXT3}
+ * - {@link pc.PIXELFORMAT_DXT5}
+ * - {@link pc.PIXELFORMAT_RGB16F}
+ * - {@link pc.PIXELFORMAT_RGBA16F}
+ * - {@link pc.PIXELFORMAT_RGB32F}
+ * - {@link pc.PIXELFORMAT_RGBA32F}
+ * - {@link pc.PIXELFORMAT_ETC1}
+ * - {@link pc.PIXELFORMAT_PVRTC_2BPP_RGB_1}
+ * - {@link pc.PIXELFORMAT_PVRTC_2BPP_RGBA_1}
+ * - {@link pc.PIXELFORMAT_PVRTC_4BPP_RGB_1}
+ * - {@link pc.PIXELFORMAT_PVRTC_4BPP_RGBA_1}
+ * - {@link pc.PIXELFORMAT_111110F}
+ *
+ */
+ readonly format: number;
+
+ /**
+ * @readonly
+ * @name pc.Texture#cubemap
+ * @type Boolean
+ * @description Returns true if this texture is a cube map and false otherwise.
+ */
+ readonly cubemap: boolean;
+
+ /**
+ * @readonly
+ * @name pc.Texture#volume
+ * @type Boolean
+ * @description Returns true if this texture is a 3D volume and false otherwise.
+ */
+ readonly volume: boolean;
+
+ /**
+ * @name pc.Texture#flipY
+ * @type Boolean
+ * @description Specifies whether the texture should be flipped in the Y-direction. Only affects textures
+ * with a source that is an image, canvas or video element. Does not affect cubemaps, compressed textures
+ * or textures set from raw pixel data. Defaults to true.
+ */
+ flipY: boolean;
+
+ /**
+ * @private
+ * @function
+ * @name pc.Texture#bind
+ * @description Activates the specified texture on the current texture unit.
+ */
+ private bind(): void;
+
+ /**
+ * @function
+ * @name pc.Texture#destroy
+ * @description Forcibly free up the underlying WebGL resource owned by the texture.
+ */
+ destroy(): void;
+
+ /**
+ * @function
+ * @name pc.Texture#lock
+ * @description Locks a miplevel of the texture, returning a typed array to be filled with pixel data.
+ * @param {Object} options Optional options object. Valid properties are as follows:
+ * @param {Number} options.level The mip level to lock with 0 being the top level. Defaults to 0.
+ * @param {Number} options.face If the texture is a cubemap, this is the index of the face to lock.
+ */
+ lock(options: { level: number, face: number }): Uint8Array | Uint16Array | Float32Array;
+
+ /**
+ * @private
+ * @function
+ * @name pc.Texture#recover
+ * @description Restores the texture in the event of the underlying WebGL context being lost and then
+ * restored.
+ */
+ private recover(): void;
+
+ /**
+ * @function
+ * @name pc.Texture#setSource
+ * @description Set the pixel data of the texture from a canvas, image, video DOM element. If the
+ * texture is a cubemap, the supplied source must be an array of 6 canvases, images or videos.
+ * @param {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement|Array} source A canvas, image or video element,
+ * or an array of 6 canvas, image or video elements.
+ */
+ setSource(
+ source: HTMLCanvasElement | HTMLImageElement | HTMLVideoElement |
+ Array
+ ): void;
+
+ /**
+ * @function
+ * @name pc.Texture#getSource
+ * @description Get the pixel data of the texture. If this is a cubemap then an array of 6 images will be returned otherwise
+ * a single image.
+ * @return {HTMLImageElement} The source image of this texture.
+ */
+ getSource(): HTMLImageElement
+
+ /**
+ * @function
+ * @name pc.Texture#unlock
+ * @description Unlocks the currently locked mip level and uploads it to VRAM.
+ */
+ unlock(): void;
+
+ /**
+ * @function
+ * @name pc.Texture#upload
+ * @description Forces a reupload of the textures pixel data to graphics memory. Ordinarily, this function
+ * is called by internally by {@link pc.Texture#setSource} and {@link pc.Texture#unlock}. However, it still needs to
+ * be called explicitly in the case where an HTMLVideoElement is set as the source of the texture. Normally,
+ * this is done once every frame before video textured geometry is rendered.
+ */
+ upload(): void;
+ }
+}
diff --git a/types/playcanvas/engine/graphics/transform-feedback.d.ts b/types/playcanvas/engine/graphics/transform-feedback.d.ts
new file mode 100644
index 0000000000..e7cb87ce53
--- /dev/null
+++ b/types/playcanvas/engine/graphics/transform-feedback.d.ts
@@ -0,0 +1,112 @@
+declare namespace pc {
+
+ /**
+ * @name pc.TransformFeedback
+ * @class Transform feedback helper object
+ * @description This object allows you to configure and use the transform feedback feature (WebGL2 only).
+ * How to use:
+ *
+ * - First, check that you're on WebGL2, by looking at the
app.graphicsDevice.webgl2 value.
+ * - Define the outputs in your vertex shader. The syntax is
out vec3 out_vertex_position, note that there must be out_ in the name. You can then simply assign values to these outputs in VS. The order and size of shader outputs must match the output buffer layout.
+ * - Create the shader using
pc.TransformFeedback.createShader(device, vsCode, yourShaderName).
+ * - Create/acquire the input vertex buffer. Can be any pc.VertexBuffer, either manually created, or from a pc.Mesh.
+ * - Create the pc.TransformFeedback object:
var tf = new pc.TransformFeedback(inputBuffer). This object will internally create an output buffer.
+ * - Run the shader:
tf.process(shader). Shader will take the input buffer, process it and write to the output buffer, then the input/output buffers will be automatically swapped, so you'll immediately see the result.
+ *
+ * @example
+ * // *** shader asset ***
+ * attribute vec3 vertex_position;
+ * attribute vec3 vertex_normal;
+ * attribute vec2 vertex_texCoord0;
+ * attribute vec4 vertex_tangent;
+ * out vec3 out_vertex_position;
+ * out vec3 out_vertex_normal;
+ * out vec2 out_vertex_texCoord0;
+ * out vec4 out_vertex_tangent;
+ * void main(void) {
+ * // read position and normal, write new position (push away)
+ * out_vertex_position = vertex_position + vertex_normal * 0.01;
+ * // pass other attributes unchanged
+ * out_vertex_normal = vertex_normal;
+ * out_vertex_texCoord0 = vertex_texCoord0;
+ * out_vertex_tangent = vertex_tangent;
+ * }
+ * @example
+ * // *** script asset ***
+ * var TransformExample = pc.createScript('transformExample');
+ *
+ * // attribute that references shader asset and material
+ * TransformExample.attributes.add('shaderCode', { type: 'asset', assetType: 'shader' });
+ * TransformExample.attributes.add('material', { type: 'asset', assetType: 'material' });
+ *
+ * TransformExample.prototype.initialize = function() {
+ * var device = this.app.graphicsDevice;
+ * var mesh = pc.createTorus(device, { tubeRadius: 0.01, ringRadius: 3 });
+ * var node = new pc.GraphNode();
+ * var meshInstance = new pc.MeshInstance(node, mesh, this.material.resource);
+ * var model = new pc.Model();
+ * model.graph = node;
+ * model.meshInstances = [ meshInstance ];
+ * this.app.scene.addModel(model);
+ *
+ * // if webgl2 is not supported, TF is not available
+ * if (!device.webgl2) return;
+ * var inputBuffer = mesh.vertexBuffer;
+ * this.tf = new pc.TransformFeedback(inputBuffer);
+ * this.shader = pc.TransformFeedback.createShader(device, this.shaderCode.resource, "tfMoveUp");
+ * };
+ *
+ * TransformExample.prototype.update = function(dt) {
+ * if (!this.app.graphicsDevice.webgl2) return;
+ * this.tf.process(this.shader);
+ * };
+ * @param {pc.VertexBuffer} inputBuffer The input vertex buffer
+ * @param {Number} [usage] The optional usage type of the output vertex buffer (see pc.BUFFER_*). pc.BUFFER_GPUDYNAMIC is recommended for continuous update, and is the default value.
+ */
+ class TransformFeedback {
+ constructor(inputBuffer: pc.VertexBuffer, usage?: number)
+
+ /**
+ * @function
+ * @name pc.TransformFeedback#createShader
+ * @description Creates a transform feedback ready vertex shader from code.
+ * @param {pc.GraphicsDevice} graphicsDevice The graphics device used by the renderer.
+ * @param {String} vsCode Vertex shader code. Should contain output variables starting with "out_".
+ * @param {String} name Unique name for caching the shader.
+ * @returns {pc.Shader} A shader to use in the process() function.
+ */
+ static createShader(device: pc.GraphicsDevice, vsCode: string, name: string): pc.Shader;
+
+ /**
+ * @function
+ * @name pc.TransformFeedback#destroy
+ * @description Destroys the transform feedback helper object
+ */
+ destroy(): void;
+
+ /**
+ * @function
+ * @name pc.TransformFeedback#process
+ * @description Runs the specified shader on the input buffer, writes results into the new buffer, then optionally swaps input/output.
+ * @param {pc.Shader} shader A vertex shader to run. Should be created with pc.TransformFeedback.createShader.
+ * @param {Boolean} [swap] Swap input/output buffer data. Useful for continuous buffer processing. Default is true.
+ */
+ process(shader: pc.Shader, swap?: boolean): void;
+
+ /**
+ * @readonly
+ * @name pc.TransformFeedback#inputBuffer
+ * @type pc.VertexBuffer
+ * @description The current input buffer
+ */
+ readonly inputBuffer: pc.VertexBuffer;
+
+ /**
+ * @readonly
+ * @name pc.TransformFeedback#outputBuffer
+ * @type pc.VertexBuffer
+ * @description The current output buffer
+ */
+ readonly outputBuffer: pc.VertexBuffer;
+ }
+}
diff --git a/types/playcanvas/engine/graphics/vertex-buffer.d.ts b/types/playcanvas/engine/graphics/vertex-buffer.d.ts
new file mode 100644
index 0000000000..1dd408172d
--- /dev/null
+++ b/types/playcanvas/engine/graphics/vertex-buffer.d.ts
@@ -0,0 +1,67 @@
+declare namespace pc {
+
+ /**
+ * @name pc.VertexBuffer
+ * @class A vertex buffer is the mechanism via which the application specifies vertex
+ * data to the graphics hardware.
+ * @description Creates a new vertex buffer object.
+ * @param {pc.GraphicsDevice} graphicsDevice The graphics device used to manage this vertex buffer.
+ * @param {pc.VertexFormat} format The vertex format of this vertex buffer.
+ * @param {Number} numVertices The number of vertices that this vertex buffer will hold.
+ * @param {Number} [usage] The usage type of the vertex buffer (see pc.BUFFER_*).
+ * @param {ArrayBuffer} [initialData] Initial data.
+ */
+ class VertexBuffer {
+ constructor(graphicsDevice: pc.GraphicsDevice, format: pc.VertexFormat, numVertices: number, usage?: number, initialData?: ArrayBuffer)
+
+ /**
+ * @function
+ * @name pc.VertexBuffer#destroy
+ * @description Frees resources associated with this vertex buffer.
+ */
+ destroy(): void;
+
+ /**
+ * @function
+ * @name pc.VertexBuffer#getFormat
+ * @description Returns the data format of the specified vertex buffer.
+ * @returns {pc.VertexFormat} The data format of the specified vertex buffer.
+ */
+ getFormat(): pc.VertexFormat;
+
+ /**
+ * @function
+ * @name pc.VertexBuffer#getUsage
+ * @description Returns the usage type of the specified vertex buffer. This indicates
+ * whether the buffer can be modified once and used many times (pc.BUFFER_STATIC),
+ * modified repeatedly and used many times (pc.BUFFER_DYNAMIC) or modified once
+ * and used at most a few times (pc.BUFFER_STREAM).
+ * @returns {Number} The usage type of the vertex buffer (see pc.BUFFER_*).
+ */
+ getUsage(): number;
+
+ /**
+ * @function
+ * @name pc.VertexBuffer#getNumVertices
+ * @description Returns the number of vertices stored in the specified vertex buffer.
+ * @returns {Number} The number of vertices stored in the vertex buffer.
+ */
+ getNumVertices(): number;
+
+ /**
+ * @function
+ * @name pc.VertexBuffer#lock
+ * @description Returns a mapped memory block representing the content of the vertex buffer.
+ * @returns {ArrayBuffer} An array containing the byte data stored in the vertex buffer.
+ */
+ lock(): ArrayBuffer;
+
+ /**
+ * @function
+ * @name pc.VertexBuffer#unlock
+ * @description Notifies the graphics engine that the client side copy of the vertex buffer's
+ * memory can be returned to the control of the graphics driver.
+ */
+ unlock(): void;
+ }
+}
\ No newline at end of file
diff --git a/types/playcanvas/engine/graphics/vertex-format.d.ts b/types/playcanvas/engine/graphics/vertex-format.d.ts
new file mode 100644
index 0000000000..13052e2a8a
--- /dev/null
+++ b/types/playcanvas/engine/graphics/vertex-format.d.ts
@@ -0,0 +1,67 @@
+declare namespace pc {
+
+ /**
+ * @name pc.VertexFormat
+ * @class A vertex format is a descriptor that defines the layout of vertex data inside
+ * a {@link pc.VertexBuffer}.
+ * @description Returns a new pc.VertexFormat object.
+ * @param {pc.GraphicsDevice} graphicsDevice The graphics device used to manage this vertex format.
+ * @param {Object[]} description An array of vertex attribute descriptions.
+ * @param {Number} description[].semantic The meaning of the vertex element. This is used to link
+ * the vertex data to a shader input. Can be:
+ *
+ * - pc.SEMANTIC_POSITION
+ * - pc.SEMANTIC_NORMAL
+ * - pc.SEMANTIC_TANGENT
+ * - pc.SEMANTIC_BLENDWEIGHT
+ * - pc.SEMANTIC_BLENDINDICES
+ * - pc.SEMANTIC_COLOR
+ * - pc.SEMANTIC_TEXCOORD0
+ * - pc.SEMANTIC_TEXCOORD1
+ * - pc.SEMANTIC_TEXCOORD2
+ * - pc.SEMANTIC_TEXCOORD3
+ * - pc.SEMANTIC_TEXCOORD4
+ * - pc.SEMANTIC_TEXCOORD5
+ * - pc.SEMANTIC_TEXCOORD6
+ * - pc.SEMANTIC_TEXCOORD7
+ *
+ * If vertex data has a meaning other that one of those listed above, use the user-defined
+ * semantics: pc.SEMANTIC_ATTR0 to pc.SEMANTIC_ATTR15.
+ * @param {Number} description[].components The number of components of the vertex attribute.
+ * Can be 1, 2, 3 or 4.
+ * @param {Number} description[].type The data type of the attribute. Can be:
+ *
+ * - pc.TYPE_INT8
+ * - pc.TYPE_UINT8
+ * - pc.TYPE_INT16
+ * - pc.TYPE_UINT16
+ * - pc.TYPE_INT32
+ * - pc.TYPE_UINT32
+ * - pc.TYPE_FLOAT32
+ *
+ * @param {Boolean} description[].normalize If true, vertex attribute data will be mapped from a
+ * 0 to 255 range down to 0 to 1 when fed to a shader. If false, vertex attribute data is left
+ * unchanged. If this property is unspecified, false is assumed.
+ * @example
+ * // Specify 3-component positions (x, y, z)
+ * var vertexFormat = new pc.VertexFormat(graphicsDevice, [
+ * { semantic: pc.SEMANTIC_POSITION, components: 3, type: pc.TYPE_FLOAT32 },
+ * ]);
+ * @example
+ * // Specify 2-component positions (x, y), a texture coordinate (u, v) and a vertex color (r, g, b, a)
+ * var vertexFormat = new pc.VertexFormat(graphicsDevice, [
+ * { semantic: pc.SEMANTIC_POSITION, components: 2, type: pc.TYPE_FLOAT32 },
+ * { semantic: pc.SEMANTIC_TEXCOORD0, components: 2, type: pc.TYPE_FLOAT32 },
+ * { semantic: pc.SEMANTIC_COLOR, components: 4, type: pc.TYPE_UINT8, normalize: true }
+ * ]);
+ * @author Will Eastcott
+ */
+ class VertexFormat {
+ constructor(graphicsDevice: pc.GraphicsDevice, description: {
+ semantic: number,
+ components: number,
+ type: number,
+ normalize: boolean
+ }[])
+ }
+}
\ No newline at end of file
diff --git a/types/playcanvas/engine/graphics/vertex-iterator.d.ts b/types/playcanvas/engine/graphics/vertex-iterator.d.ts
new file mode 100644
index 0000000000..bc9b23d59b
--- /dev/null
+++ b/types/playcanvas/engine/graphics/vertex-iterator.d.ts
@@ -0,0 +1,50 @@
+declare namespace pc {
+
+ /**
+ * @name pc.VertexIterator
+ * @class A vertex iterator simplifies the process of writing vertex data to a vertex buffer.
+ * @description Returns a new pc.VertexIterator object.
+ * @param {pc.VertexBuffer} vertexBuffer The vertex buffer to be iterated.
+ * @author Will Eastcott
+ */
+ class VertexIterator {
+ constructor(vertexBuffer: pc.VertexBuffer)
+
+ /**
+ * @function
+ * @name pc.VertexIterator#next
+ * @description Moves the vertex iterator on to the next vertex.
+ * @example
+ * var iterator = new pc.VertexIterator(vertexBuffer);
+ * iterator.element[pc.SEMANTIC_POSTIION].set(-0.9, -0.9, 0.0);
+ * iterator.element[pc.SEMANTIC_COLOR].set(255, 0, 0, 255);
+ * iterator.next();
+ * iterator.element[pc.SEMANTIC_POSTIION].set(0.9, -0.9, 0.0);
+ * iterator.element[pc.SEMANTIC_COLOR].set(0, 255, 0, 255);
+ * iterator.next();
+ * iterator.element[pc.SEMANTIC_POSTIION].set(0.0, 0.9, 0.0);
+ * iterator.element[pc.SEMANTIC_COLOR].set(0, 0, 255, 255);
+ * iterator.end();
+ */
+ next(): void;
+
+ /**
+ * @function
+ * @name pc.VertexIterator#end
+ * @description Notifies the vertex buffer being iterated that writes are complete. Internally
+ * the vertex buffer is unlocked and vertex data is uploaded to video memory.
+ * @example
+ * var iterator = new pc.VertexIterator(vertexBuffer);
+ * iterator.element[pc.SEMANTIC_POSTIION].set(-0.9, -0.9, 0.0);
+ * iterator.element[pc.SEMANTIC_COLOR].set(255, 0, 0, 255);
+ * iterator.next();
+ * iterator.element[pc.SEMANTIC_POSTIION].set(0.9, -0.9, 0.0);
+ * iterator.element[pc.SEMANTIC_COLOR].set(0, 255, 0, 255);
+ * iterator.next();
+ * iterator.element[pc.SEMANTIC_POSTIION].set(0.0, 0.9, 0.0);
+ * iterator.element[pc.SEMANTIC_COLOR].set(0, 0, 255, 255);
+ * iterator.end();
+ */
+ end(): void;
+ }
+}
diff --git a/types/playcanvas/engine/input/controller.d.ts b/types/playcanvas/engine/input/controller.d.ts
new file mode 100644
index 0000000000..58cbc1153f
--- /dev/null
+++ b/types/playcanvas/engine/input/controller.d.ts
@@ -0,0 +1,115 @@
+declare namespace pc {
+
+ /**
+ * @name pc.Controller
+ * @class A general input handler which handles both mouse and keyboard input assigned to named actions.
+ * This allows you to define input handlers separately to defining keyboard/mouse configurations.
+ * @description Create a new instance of a Controller.
+ * @param {Element} [element] Element to attach Controller to.
+ * @param {Object} [options] Optional arguments.
+ * @param {pc.Keyboard} [options.keyboard] A Keyboard object to use.
+ * @param {pc.Mouse} [options.mouse] A Mouse object to use.
+ * @param {pc.GamePads} [options.gamepads] A Gamepads object to use.
+ * @example
+ * var c = new pc.Controller(document)
+ *
+ * // Register the "fire" action and assign it to both the Enter key and the Spacebar.
+ * c.registerKeys("fire", [pc.KEY_ENTER, pc.KEY_SPACE]);
+ */
+ class Controller {
+ constructor(element?: Element, options?: {
+ keyboard?: pc.Keyboard,
+ mouse?: pc.Mouse,
+ gamepads: pc.GamePads
+ })
+
+ /**
+ * @function
+ * @name pc.Controller#attach
+ * @description Attach Controller to a Element, this is required before you can monitor for key/mouse inputs.
+ * @param {Element} element The element to attach mouse and keyboard event handler too
+ */
+ attach(element: Element): void;
+
+ /**
+ * @function
+ * @name pc.Controller#detach
+ * @description Detach Controller from an Element, this should be done before the Controller is destroyed
+ */
+ detach(): void;
+
+ /**
+ * @function
+ * @name pc.Controller#disableContextMenu
+ * @description Disable the context menu usually activated with the right mouse button.
+ */
+ disableContextMenu(): void;
+
+ /**
+ * @function
+ * @name pc.Controller#enableContextMenu
+ * @description Enable the context menu usually activated with the right mouse button. This is enabled by default.
+ */
+ enableContextMenu(): void;
+
+ /**
+ * @function
+ * @name pc.Controller#update
+ * @description Update the Keyboard and Mouse handlers
+ * @param {Object} dt The time since the last frame
+ */
+ update(dt: number): void;
+
+ /**
+ * @function
+ * @name pc.Controller#registerKeys
+ * @description Create or update a action which is enabled when the supplied keys are pressed.
+ * @param {String} action The name of the action
+ * @param {Number[]} keys A list of keycodes
+ */
+ registerKeys(action: string, keys: number[]): void;
+ /**
+ * @function
+ * @name pc.Controller#registerMouse
+ * @description Create or update an action which is enabled when the supplied mouse button is pressed
+ * @param {String} action The name of the action
+ * @param {Number} button The mouse button
+ */
+ registerMouse(action: string, button: number): void;
+
+ /**
+ * @function
+ * @name pc.Controller#registerPadButton
+ * @description Create or update an action which is enabled when the gamepad button is pressed
+ * @param {String} action The name of the action
+ * @param {Number} pad The index of the pad to register (use pc.PAD_1, etc)
+ * @param {Number} button The pad button
+ */
+ registerPadButton(action: string, pad: number, button: number): void;
+
+ /**
+ * @function
+ * @name pc.Controller#registerAxis
+ * @param {Object} [options]
+ * @param {Object} [options.pad] The index of the game pad to register for (use pc.PAD_1, etc)
+ */
+ registerAxis(options?: { pad?: number }): void;
+
+ /**
+ * @function
+ * @name pc.Controller#isPressed
+ * @description Return true if the current action is enabled
+ * @param {String} action The name of the action
+ */
+ isPressed(actionName: string): boolean;
+
+ /**
+ * @function
+ * @name pc.Controller#wasPressed
+ * @description Returns true if the action was enabled this since the last update
+ * @param {String} action The name of the action
+ * @returns {Boolean} True if the action was enabled this since the last update
+ */
+ wasPressed(actionName: string): boolean;
+ }
+}
diff --git a/types/playcanvas/engine/input/element-input.d.ts b/types/playcanvas/engine/input/element-input.d.ts
new file mode 100644
index 0000000000..509f5be2ae
--- /dev/null
+++ b/types/playcanvas/engine/input/element-input.d.ts
@@ -0,0 +1,117 @@
+declare namespace pc {
+
+ /**
+ * @name pc.ElementInputEvent
+ * @class Represents an input event fired on a {@link pc.ElementComponent}. When an event is raised on an ElementComponent it bubbles up to its parent ElementComponents unless we call stopPropagation().
+ * @description Create an instance of a pc.ElementInputEvent.
+ * @param {MouseEvent|TouchEvent} event The MouseEvent or TouchEvent that was originally raised.
+ * @property {MouseEvent|TouchEvent} event The MouseEvent or TouchEvent that was originally raised.
+ * @property {pc.ElementComponent} element The ElementComponent that this event was originally raised on.
+ */
+ class ElementInputEvent {
+ constructor(event: BrowserMouseEvent | BrowserTouchEvent, element: pc.ElementComponent)
+
+ event: BrowserMouseEvent | BrowserTouchEvent;
+ element: pc.ElementComponent;
+
+ /**
+ * @function
+ * @name pc.ElementInputEvent#stopPropagation
+ * @description Stop propagation of the event to parent {@link pc.ElementComponent}s. This also stops propagation of the event to other event listeners of the original DOM Event.
+ */
+ stopPropagation(): void;
+ }
+
+ /**
+ * @name pc.ElementMouseEvent
+ * @class Represents a Mouse event fired on a {@link pc.ElementComponent}.
+ * @extends pc.ElementInputEvent
+ * @description Create an instance of a pc.ElementMouseEvent.
+ * @param {MouseEvent} event The MouseEvent that was originally raised.
+ * @param {pc.ElementComponent} element The ElementComponent that this event was originally raised on.
+ * @param {Number} x The x coordinate
+ * @param {Number} y The y coordinate
+ * @param {Number} lastX The last x coordinate
+ * @param {Number} lastY The last y coordinate
+ * @property {Boolean} ctrlKey Whether the ctrl key was pressed
+ * @property {Boolean} altKey Whether the alt key was pressed
+ * @property {Boolean} shiftKey Whether the shift key was pressed
+ * @property {Boolean} metaKey Whether the meta key was pressed
+ * @property {Number} button The mouse button
+ * @property {Number} dx The amount of horizontal movement of the cursor
+ * @property {Number} dy The amount of vertical movement of the cursor
+ * @property {Number} wheel The amount of the wheel movement
+ */
+ class ElementMouseEvent extends pc.ElementInputEvent {
+ constructor(event: BrowserMouseEvent, element: pc.ElementComponent, x: number, y: number, lastX: number, lastY: number)
+
+ ctrlKey: boolean;
+ altKey: boolean;
+ shiftKey: boolean;
+ metaKey: boolean;
+ button: number;
+ dx: number;
+ dy: number;
+ wheel: number;
+ }
+
+ /**
+ * @name pc.ElementTouchEvent
+ * @class Represents a TouchEvent fired on a {@link pc.ElementComponent}.
+ * @extends pc.ElementInputEvent
+ * @description Create an instance of a pc.ElementTouchEvent.
+ * @param {TouchEvent} event The TouchEvent that was originally raised.
+ * @param {pc.ElementComponent} element The ElementComponent that this event was originally raised on.
+ * @param {pc.ElementInput} input The pc.ElementInput instance
+ * @property {Touch[]} touches The Touch objects representing all current points of contact with the surface, regardless of target or changed status.
+ * @property {Touch[]} changedTouches The Touch objects representing individual points of contact whose states changed between the previous touch event and this one.
+ */
+ class ElementTouchEvent extends pc.ElementInputEvent {
+ constructor(event: BrowserTouchEvent, element: pc.ElementComponent, input: pc.ElementInput)
+
+ touches: BrowserTouch[];
+ changedTouches: BrowserTouch[];
+ }
+
+ /**
+ * @name pc.ElementInput
+ * @class Handles mouse and touch events for {@link pc.ElementComponent}s. When input events
+ * occur on an ElementComponent this fires the appropriate events on the ElementComponent.
+ * @description Create a new pc.ElementInput instance.
+ * @param {Element} domElement The DOM element
+ */
+ class ElementInput {
+ constructor(domElement: Element)
+
+ /**
+ * @function
+ * @name pc.ElementInput#attach
+ * @description Attach mouse and touch events to a DOM element.
+ * @param {Element} domElement The DOM element
+ */
+ attach(domElement: Element): void;
+
+ /**
+ * @function
+ * @name pc.ElementInput#detach
+ * @description Remove mouse and touch events from the DOM element that it is attached to
+ */
+ detach(): void;
+
+ /**
+ * @function
+ * @name pc.ElementInput#addElement
+ * @description Add a {@link pc.ElementComponent} to the internal list of ElementComponents that are being checked for input.
+ * @param {pc.ElementComponent} element The ElementComponent
+ */
+ addElement(element: pc.ElementComponent): void;
+
+ /**
+ * @function
+ * @name pc.ElementInput#removeElement
+ * @description Remove a {@link pc.ElementComponent} from the internal list of ElementComponents that are being checked for input.
+ * @param {pc.ElementComponent} element The ElementComponent
+ */
+ removeElement(element: pc.ElementComponent): void;
+ }
+}
\ No newline at end of file
diff --git a/types/playcanvas/engine/input/game-pads.d.ts b/types/playcanvas/engine/input/game-pads.d.ts
new file mode 100644
index 0000000000..7b395ccc12
--- /dev/null
+++ b/types/playcanvas/engine/input/game-pads.d.ts
@@ -0,0 +1,57 @@
+declare namespace pc {
+ /**
+ * @name pc.GamePads
+ * @class Input handler for accessing GamePad input
+ */
+ class GamePads {
+ /**
+ * @function
+ * @name pc.GamePads#update
+ * @description Update the current and previous state of the gamepads. This must be called every frame for wasPressed()
+ * to work
+ */
+ update(dt: number): void;
+
+ /**
+ * @function
+ * @name pc.GamePads#poll
+ * @description Poll for the latest data from the gamepad API.
+ * @returns {Object[]} An array of gamepads and mappings for the model of gamepad that is attached
+ * @example
+ * var gamepads = new pc.GamePads();
+ * var pads = gamepads.poll();
+ * // pads[0] = { map: