LocalStorage。
*/
static support: boolean;
/**
* 数据列表。
*/
static items: any;
constructor();
static __init__(): void;
/**
* 存储指定键名和键值，字符串类型。
* @param key 键名。
* @param value 键值。
*/
static setItem(key: string, value: any): void;
/**
* 获取指定键名的值。
* @param key 键名。
* @return 字符串型值。
*/
static getItem(key: string): string;
/**
* 存储指定键名及其对应的 Object 类型值。
* @param key 键名。
* @param value 键值。是 Object 类型，此致会被转化为 JSON 字符串存储。
*/
static setJSON(key: string, value: any): void;
/**
* 获取指定键名对应的 Object 类型值。
* @param key 键名。
* @return Object 类型值
*/
static getJSON(key: string): any;
/**
* 删除指定键名的信息。
* @param key 键名。
*/
static removeItem(key: string): void;
/**
* 清除本地存储信息。
*/
static clear(): void;
/**同步获取当前storage的相关信息**/
static getStorageInfoSync(): any;
}
}
declare module laya.wx.mini {
class MiniInput {
constructor();
static wxinputFocus(e: any): void;
static inputEnter(): void;
static wxinputblur(): void;
static hideKeyboard(): void;
}
}
declare module laya.wx.mini {
class MiniImage {
protected _loadImage(url: string): void;
}
}
declare module laya.wx.mini {
import Handler = laya.utils.Handler;
class MiniFileMgr {
static filesListObj: any;
static fileNativeDir: string;
static fileListName: string;
static ziyuFileData: any;
/**子域图片磁盘缓存路径存储对象**/
static ziyuFileTextureData: any;
/**加载路径设定(相当于URL.rootPath)**/
static loadPath: string;
static DESCENDING: number;
static NUMERIC: number;
/**
* @private
* 是否是本地4M包文件
* @param url
* @return
*/
static isLocalNativeFile(url: string): boolean;
/**
* @private
* 判断缓存里是否存在文件
* @param fileUrl
* @return
*/
static getFileInfo(fileUrl: string): any;
/**
* @private
* 本地读取
* @param filePath 文件磁盘路径
* @param encoding 文件读取的编码格式
* @param callBack 回调处理
* @param readyUrl 文件请求加载地址
* @param isSaveFile 是否自动缓存下载的文件,只有在开发者自己单独加载时生效
* @param fileType 文件类型
*/
static read(filePath: string, encoding?: string, callBack?: Handler, readyUrl?: string, isSaveFile?: boolean, fileType?: string): void;
/**
* @private
* 下载远端文件(非图片跟声音文件)
* @param fileUrl 文件远端下载地址
* @param encode 文件编码
* @param callBack 完成回调
* @param readyUrl 文件真实下载地址
* @param isSaveFile 是否自动缓存下载的文件,只有在开发者自己单独加载时生效
* @param fileType 文件类型
*/
static downFiles(fileUrl: string, encoding?: string, callBack?: Handler, readyUrl?: string, isSaveFile?: boolean, fileType?: string, isAutoClear?: boolean): void;
/**
* @private
* 本地本地磁盘文件读取
* @param filePath 文件磁盘临时地址
* @param encoding 文件设定读取的编码格式
* @param callBack 完成回调
* @param readyUrl 真实的下载地址
* @param isSaveFile 是否自动缓存下载的文件,只有在开发者自己单独加载时生效
* @param fileType 文件类型
*/
static readFile(filePath: string, encoding?: string, callBack?: Handler, readyUrl?: string, isSaveFile?: boolean, fileType?: string, isAutoClear?: boolean): void;
/**
* @private
* 下载远端文件(图片跟声音文件)
* @param fileUrl 文件远端下载地址
* @param encode 文件编码
* @param callBack 完成回调
* @param readyUrl 文件真实下载地址
* @param isSaveFile 是否自动缓存下载的文件,只有在开发者自己单独加载时生效
*/
static downOtherFiles(fileUrl: string, callBack?: Handler, readyUrl?: string, isSaveFile?: boolean, isAutoClear?: boolean): void;
/**
* @private
* 下载文件
* @param fileUrl 文件远端地址
* @param fileType 文件类型(image、text、json、xml、arraybuffer、sound、atlas、font)
* @param callBack 文件加载回调,回调内容[errorCode码(0成功,1失败,2加载进度)
* @param encoding 文件编码默认 ascill，非图片文件加载需要设置相应的编码，二进制编码为空字符串
*/
static downLoadFile(fileUrl: string, fileType?: string, callBack?: Handler, encoding?: string): void;
/**
* @private
* 数组排序
* @param array
* @param name
* @param options
* @return
*/
static sortOn(array: ArrayShaderCompile 类用于实现Shader编译。
*/
class ShaderCompile {
static IFDEF_NO: number;
static IFDEF_YES: number;
static IFDEF_ELSE: number;
static IFDEF_PARENT: number;
static _removeAnnotation: RegExp;
static _reg: RegExp;
static _splitToWordExps: RegExp;
static includes: any;
static shaderParamsMap: any;
protected _VS: ShaderNode;
protected _PS: ShaderNode;
static addInclude(fileName: string, txt: string): void;
static preGetParams(vs: string, ps: string): any;
static splitToWords(str: string, block: ShaderNode): ArrayUtils 是工具类。
*/
class Utils {
protected static _extReg: RegExp;
/**
* 角度转弧度。
* @param angle 角度值。
* @return 返回弧度值。
*/
static toRadian(angle: number): number;
/**
* 弧度转换为角度。
* @param radian 弧度值。
* @return 返回角度值。
*/
static toAngle(radian: number): number;
/**
* 将传入的 uint 类型颜色值转换为字符串型颜色值。
* @param color 颜色值。
* @return 字符串型颜色值。
*/
static toHexColor(color: number): string;
/**获取一个全局唯一ID。*/
static getGID(): number;
/**
* 将字符串解析成 XML 对象。
* @param value 需要解析的字符串。
* @return js原生的XML对象。
*/
static parseXMLFromString: Function;
/**
* @private
* 连接数组。和array的concat相比，此方法不创建新对象
* 注意：若 参数 a 不为空，则会改变参数 source 的值为连接后的数组。 * @param source 待连接的数组目标对象。 * @param array 待连接的数组对象。 * @return 连接后的数组。 */ static concatArray(source: ArraySprite 和此显示对象上的 两个点，返回此对象上的两个点在舞台坐标系上组成的最小的矩形区域对象。
* @param sprite 显示对象 Sprite。
* @param x0 点一的 X 轴坐标点。
* @param y0 点一的 Y 轴坐标点。
* @param x1 点二的 X 轴坐标点。
* @param y1 点二的 Y 轴坐标点。
* @return 两个点在舞台坐标系组成的矩形对象 Rectangle。
*/
static getGlobalRecByPoints(sprite: Sprite, x0: number, y0: number, x1: number, y1: number): Rectangle;
/**
* 计算传入的显示对象 Sprite 的全局坐标系的坐标和缩放值，返回 Rectangle 对象存放计算出的坐标X值、Y值、ScaleX值、ScaleY值。
* @param sprite Sprite 对象。
* @return 矩形对象 Rectangle
*/
static getGlobalPosAndScale(sprite: Sprite): Rectangle;
/**
* 给传入的函数绑定作用域，返回绑定后的函数。
* @param fun 函数对象。
* @param scope 函数作用域。
* @return 绑定后的函数。
*/
static bind(fun: Function, scope: any): Function;
/**
* 测量文本在指定样式下的宽度、高度信息。
* @param txt 文本内容。
* @param font 文本字体样式。
* @return 文本的宽高信息对象。如：
*/
static measureText(txt: string, font: string): any;
/**
* @private
* 对传入的数组列表，根据子项的属性 Z 值进行重新排序。返回是否已重新排序的 Boolean 值。
* @param array 子对象数组。
* @return Boolean 值，表示是否已重新排序。
*/
static updateOrder(array: ArrayTween 是一个缓动类。使用此类能够实现对目标对象属性的渐变。
*/
class Tween {
gid: number;
/**更新回调，缓动数值发生变化时，回调变化的值*/
update: Handler;
/**重播次数，如果repeat=0，则表示无限循环播放*/
repeat: number;
/**
* 缓动对象的props属性到目标值。
* @param target 目标对象(即将更改属性值的对象)。
* @param props 变化的属性列表，比如
* @param duration 花费的时间，单位毫秒。
* @param ease 缓动类型，默认为匀速运动。
* @param complete 结束回调函数。
* @param delay 延迟执行时间。
* @param coverBefore 是否覆盖之前的缓动。
* @param autoRecover 是否自动回收，默认为true，缓动结束之后自动回收到对象池。
* @return 返回Tween对象。
*/
static to(target: any, props: any, duration: number, ease?: Function, complete?: Handler, delay?: number, coverBefore?: boolean, autoRecover?: boolean): Tween;
/**
* 从props属性，缓动到当前状态。
* @param target 目标对象(即将更改属性值的对象)。
* @param props 变化的属性列表，比如
* @param duration 花费的时间，单位毫秒。
* @param ease 缓动类型，默认为匀速运动。
* @param complete 结束回调函数。
* @param delay 延迟执行时间。
* @param coverBefore 是否覆盖之前的缓动。
* @param autoRecover 是否自动回收，默认为true，缓动结束之后自动回收到对象池。
* @return 返回Tween对象。
*/
static from(target: any, props: any, duration: number, ease?: Function, complete?: Handler, delay?: number, coverBefore?: boolean, autoRecover?: boolean): Tween;
/**
* 缓动对象的props属性到目标值。
* @param target 目标对象(即将更改属性值的对象)。
* @param props 变化的属性列表，比如
* @param duration 花费的时间，单位毫秒。
* @param ease 缓动类型，默认为匀速运动。
* @param complete 结束回调函数。
* @param delay 延迟执行时间。
* @param coverBefore 是否覆盖之前的缓动。
* @return 返回Tween对象。
*/
to(target: any, props: any, duration: number, ease?: Function, complete?: Handler, delay?: number, coverBefore?: boolean): Tween;
/**
* 从props属性，缓动到当前状态。
* @param target 目标对象(即将更改属性值的对象)。
* @param props 变化的属性列表，比如
* @param duration 花费的时间，单位毫秒。
* @param ease 缓动类型，默认为匀速运动。
* @param complete 结束回调函数。
* @param delay 延迟执行时间。
* @param coverBefore 是否覆盖之前的缓动。
* @return 返回Tween对象。
*/
from(target: any, props: any, duration: number, ease?: Function, complete?: Handler, delay?: number, coverBefore?: boolean): Tween;
_create(target: any, props: any, duration: number, ease: Function, complete: Handler, delay: number, coverBefore: boolean, isTo: boolean, usePool: boolean, runNow: boolean): Tween;
_updateEase(time: number): void;
/**设置当前执行比例**/
progress: number;
/**
* 立即结束缓动并到终点。
*/
complete(): void;
/**
* 暂停缓动，可以通过resume或restart重新开始。
*/
pause(): void;
/**
* 设置开始时间。
* @param startTime 开始时间。
*/
setStartTime(startTime: number): void;
/**
* 清理指定目标对象上的所有缓动。
* @param target 目标对象。
*/
static clearAll(target: any): void;
/**
* 清理某个缓动。
* @param tween 缓动对象。
*/
static clear(tween: Tween): void;
static clearTween(target: any): void;
/**
* 停止并清理当前缓动。
*/
clear(): void;
/**
* @private
*/
_clear(): void;
/** 回收到对象池。*/
recover(): void;
/**
* 重新开始暂停的缓动。
*/
restart(): void;
/**
* 恢复暂停的缓动。
*/
resume(): void;
}
}
declare module laya.utils {
/**
* Timer 是时钟管理类。它是一个单例，不要手动实例化此类，应该通过 Laya.timer 访问。
*/
class Timer {
static _mid: number;
/** 时针缩放。*/
scale: number;
/** 当前帧开始的时间。*/
currTimer: number;
/** 当前的帧数。*/
currFrame: number;
_delta: number;
_lastTimer: number;
/**
* 创建 Timer 类的一个实例。
*/
constructor(autoActive?: boolean);
/**两帧之间的时间间隔,单位毫秒。*/
readonly delta: number;
/**
* @private
* 帧循环处理函数。
*/
_update(): void;
_create(useFrame: boolean, repeat: boolean, delay: number, caller: any, method: Function, args: ArrayStringKey 类用于存取字符串对应的数字。
*/
class StringKey {
add(str: string): number;
getID(str: string): number;
getName(id: number): string;
}
}
declare module laya.utils {
import Sprite = laya.display.Sprite;
/**
* Stat 是一个性能统计面板，可以实时更新相关的性能参数。
参与统计的性能参数如下（所有参数都是每大约1秒进行更新）：
* FPS(Canvas)/FPS(WebGL)：Canvas 模式或者 WebGL 模式下的帧频，也就是每秒显示的帧数，值越高、越稳定，感觉越流畅；
* Sprite：统计所有渲染节点（包括容器）数量，它的大小会影响引擎进行节点遍历、数据组织和渲染的效率。其值越小，游戏运行效率越高；
* DrawCall：此值是决定性能的重要指标，其值越小，游戏运行效率越高。Canvas模式下表示每大约1秒的图像绘制次数；WebGL模式下表示每大约1秒的渲染提交批次，每次准备数据并通知GPU渲染绘制的过程称为1次DrawCall，在每次DrawCall中除了在通知GPU的渲染上比较耗时之外，切换材质与shader也是非常耗时的操作；
* CurMem：Canvas模式下，表示内存占用大小，值越小越好，过高会导致游戏闪退；WebGL模式下，表示内存与显存的占用，值越小越好；
* Shader：是 WebGL 模式独有的性能指标，表示每大约1秒 Shader 提交次数，值越小越好；
* Canvas：由三个数值组成，只有设置 CacheAs 后才会有值，默认为0/0/0。从左到右数值的意义分别为：每帧重绘的画布数量 / 缓存类型为"normal"类型的画布数量 / 缓存类型为"bitmap"类型的画布数量。
Stage 渲染次数计数。 */
static loopCount: number;
/** 着色器请求次数。*/
static shaderCall: number;
/** 描绘次数。*/
static renderBatch: number;
/** 三角形面数。*/
static trianglesFaces: number;
/** 精灵Sprite 的数量。*/
static spriteCount: number;
/** 精灵渲染使用缓存Sprite 的数量。*/
static spriteRenderUseCacheCount: number;
/** 八叉树节点检测次数。*/
static treeNodeCollision: number;
/** 八叉树精灵碰撞检测次数。*/
static treeSpriteCollision: number;
/** 画布 canvas 使用标准渲染的次数。*/
static canvasNormal: number;
/** 画布 canvas 使用位图渲染的次数。*/
static canvasBitmap: number;
/** 画布 canvas 缓冲区重绘次数。*/
static canvasReCache: number;
/** 表示当前使用的是否为慢渲染模式。*/
static renderSlow: boolean;
/** 资源管理器所管理资源的累计内存,以字节为单位。*/
static gpuMemory: number;
static cpuMemory: number;
static _sp: Sprite;
static _titleSp: Sprite;
static _bgSp: Sprite;
static _show: boolean;
static _useCanvas: boolean;
/**
* 显示性能统计信息。
* @param x X轴显示位置。
* @param y Y轴显示位置。
*/
static show(x?: number, y?: number): void;
/**激活性能统计*/
static enable(): void;
/**
* 隐藏性能统计信息。
*/
static hide(): void;
/**
* @private
* 清零性能统计计算相关的数据。
*/
static clear(): void;
/**
* 点击性能统计显示区域的处理函数。
*/
static onclick: Function;
/**
* @private
* 性能统计参数计算循环处理函数。
*/
static loop(): void;
}
}
declare module laya.utils {
/**
* @private 场景辅助类
*/
class SceneUtils {
static _sheet: any;
static getBindFun(value: string): Function;
static createByData(root: any, uiView: any): any;
static createInitTool(): InitTool;
/**
* 根据UI数据实例化组件。
* @param uiView UI数据。
* @param comp 组件本体，如果为空，会新创建一个。
* @param view 组件所在的视图实例，用来注册var全局变量，如果值为空则不注册。
* @return 一个 Component 对象。
*/
static createComp(uiView: any, comp?: any, view?: any, dataMap?: Array Pool 是对象池类，用于对象的存储、重复使用。
合理使用对象池，可以有效减少对象创建的开销，避免频繁的垃圾回收，从而优化游戏流畅度。
*/ class Pool { /** * 根据对象类型标识字符，获取对象池。 * @param sign 对象类型标识字符。 * @return 对象池。 */ static getPoolBySign(sign: string): Array根据传入的对象类型标识字符，获取对象池中此类型标识的一个对象实例。
*当对象池中无此类型标识的对象时，则根据传入的类型，创建一个新的对象返回。
* @param sign 对象类型标识字符。 * @param cls 用于创建该类型对象的类。 * @return 此类型标识的一个对象。 */ static getItemByClass(sign: string, cls: any): any; /** *根据传入的对象类型标识字符，获取对象池中此类型标识的一个对象实例。
*当对象池中无此类型标识的对象时，则使用传入的创建此类型对象的函数，新建一个对象返回。
* @param sign 对象类型标识字符。 * @param createFun 用于创建该类型对象的方法。 * @param caller this对象 * @return 此类型标识的一个对象。 */ static getItemByCreateFun(sign: string, createFun: Function, caller?: any): any; /** * 根据传入的对象类型标识字符，获取对象池中已存储的此类型的一个对象，如果对象池中无此类型的对象，则返回 null 。 * @param sign 对象类型标识字符。 * @return 对象池中此类型的一个对象，如果对象池中无此类型的对象，则返回 null 。 */ static getItem(sign: string): any; } } declare module laya.utils { class PerfData { id: number; name: string; color: number; scale: number; datas: ArrayMouse 类用于控制鼠标光标样式。
*/
class Mouse {
/**
* 设置鼠标样式
* @param cursorStr
* 例如auto move no-drop col-resize
* all-scroll pointer not-allowed row-resize
* crosshair progress e-resize ne-resize
* default text n-resize nw-resize
* help vertical-text s-resize se-resize
* inherit wait w-resize sw-resize
*/
static cursor: string;
/**
* 隐藏鼠标
*/
static hide(): void;
/**
* 显示鼠标
*/
static show(): void;
}
}
declare module laya.utils {
/**
* Log 类用于在界面内显示日志记录信息。
* 注意：在加速器内不可使用
*/
class Log {
/**最大打印数量，超过这个数量，则自动清理一次，默认为50次*/
static maxCount: number;
/**是否自动滚动到底部，默认为true*/
static autoScrollToBottom: boolean;
/**
* 激活Log系统，使用方法Laya.init(800,600,Laya.Log);
*/
static enable(): void;
/**隐藏/显示日志面板*/
static toggle(): void;
/**
* 增加日志内容。
* @param value 需要增加的日志内容。
*/
static print(value: string): void;
/**
* 清理日志
*/
static clear(): void;
}
}
declare module laya.utils {
/**
* @private
* HTMLChar 是一个 HTML 字符类。
*/
class HTMLChar {
/** x坐标*/
x: number;
/** y坐标*/
y: number;
/** 宽*/
width: number;
/** 高*/
height: number;
/** 表示是否是正常单词(英文|.|数字)。*/
isWord: boolean;
/** 字符。*/
char: string;
/** 字符数量。*/
charNum: number;
/** CSS 样式。*/
style: any;
/**
* 创建实例
*/
constructor();
/**
* 根据指定的字符、宽高、样式，创建一个 HTMLChar 类的实例。
* @param char 字符。
* @param w 宽度。
* @param h 高度。
* @param style CSS 样式。
*/
setData(char: string, w: number, h: number, style: any): HTMLChar;
/**
* 重置
*/
reset(): HTMLChar;
recover(): void;
/**
* 创建
*/
static create(): HTMLChar;
_isChar(): boolean;
_getCSSStyle(): any;
}
}
declare module laya.utils {
import Graphics = laya.display.Graphics;
/**
* 鼠标点击区域，可以设置绘制一系列矢量图作为点击区域和非点击区域（目前只支持圆形，矩形，多边形）
*
*/
class HitArea {
/**
* 检测对象是否包含指定的点。
* @param x 点的 X 轴坐标值（水平位置）。
* @param y 点的 Y 轴坐标值（垂直位置）。
* @return 如果包含指定的点，则值为 true；否则为 false。
*/
contains(x: number, y: number): boolean;
/**
* @private
* 是否击中Graphic
*/
static _isHitGraphic(x: number, y: number, graphic: Graphics): boolean;
/**
* @private
* 是否击中绘图指令
*/
static _isHitCmd(x: number, y: number, cmd: any): boolean;
/**
* @private
* 坐标是否在多边形内
*/
static _ptInPolygon(x: number, y: number, areaPoints: ArrayHandler 是事件处理器类。
推荐使用 Handler.create() 方法从对象池创建，减少对象创建消耗。创建的 Handler 对象不再使用后，可以使用 Handler.recover() 将其回收到对象池，回收后不要再使用此对象，否则会导致不可预料的错误。
*注意：由于鼠标事件也用本对象池，不正确的回收及调用，可能会影响鼠标事件的执行。
*/ class Handler { /** 执行域(this)。*/ caller: any; /** 处理方法。*/ method: Function; /** 参数。*/ args: ArrayHandler 类的实例。
* @param caller 执行域。
* @param method 处理函数。
* @param args 函数参数。
* @param once 是否只执行一次。
*/
constructor(caller?: any, method?: Function, args?: ArrayEase 类定义了缓动函数，以便实现 Tween 动画的缓动效果。
*/
class Ease {
/**
* 定义无加速持续运动。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static linearNone(t: number, b: number, c: number, d: number): number;
/**
* 定义无加速持续运动。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static linearIn(t: number, b: number, c: number, d: number): number;
/**
* 定义无加速持续运动。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static linearInOut(t: number, b: number, c: number, d: number): number;
/**
* 定义无加速持续运动。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static linearOut(t: number, b: number, c: number, d: number): number;
/**
* 方法以零速率开始运动，然后在执行时加快运动速度。
* 它的运动是类似一个球落向地板又弹起后，几次逐渐减小的回弹运动。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static bounceIn(t: number, b: number, c: number, d: number): number;
/**
* 开始运动时速率为零，先对运动进行加速，再减速直到速率为零。
* 它的运动是类似一个球落向地板又弹起后，几次逐渐减小的回弹运动。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static bounceInOut(t: number, b: number, c: number, d: number): number;
/**
* 以较快速度开始运动，然后在执行时减慢运动速度，直至速率为零。
* 它的运动是类似一个球落向地板又弹起后，几次逐渐减小的回弹运动。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static bounceOut(t: number, b: number, c: number, d: number): number;
/**
* 开始时往后运动，然后反向朝目标移动。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @param s 指定过冲量，此处数值越大，过冲越大。
* @return 指定时间的插补属性的值。
*/
static backIn(t: number, b: number, c: number, d: number, s?: number): number;
/**
* 开始运动时是向后跟踪，再倒转方向并朝目标移动，稍微过冲目标，然后再次倒转方向，回来朝目标移动。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @param s 指定过冲量，此处数值越大，过冲越大。
* @return 指定时间的插补属性的值。
*/
static backInOut(t: number, b: number, c: number, d: number, s?: number): number;
/**
* 开始运动时是朝目标移动，稍微过冲，再倒转方向回来朝着目标。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @param s 指定过冲量，此处数值越大，过冲越大。
* @return 指定时间的插补属性的值。
*/
static backOut(t: number, b: number, c: number, d: number, s?: number): number;
/**
* 方法以零速率开始运动，然后在执行时加快运动速度。
* 其中的运动由按照指数方式衰减的正弦波来定义。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @param a 指定正弦波的幅度。
* @param p 指定正弦波的周期。
* @return 指定时间的插补属性的值。
*/
static elasticIn(t: number, b: number, c: number, d: number, a?: number, p?: number): number;
/**
* 开始运动时速率为零，先对运动进行加速，再减速直到速率为零。
* 其中的运动由按照指数方式衰减的正弦波来定义。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @param a 指定正弦波的幅度。
* @param p 指定正弦波的周期。
* @return 指定时间的插补属性的值。
*/
static elasticInOut(t: number, b: number, c: number, d: number, a?: number, p?: number): number;
/**
* 以较快速度开始运动，然后在执行时减慢运动速度，直至速率为零。
* 其中的运动由按照指数方式衰减的正弦波来定义。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @param a 指定正弦波的幅度。
* @param p 指定正弦波的周期。
* @return 指定时间的插补属性的值。
*/
static elasticOut(t: number, b: number, c: number, d: number, a?: number, p?: number): number;
/**
* 以零速率开始运动，然后在执行时加快运动速度。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static strongIn(t: number, b: number, c: number, d: number): number;
/**
* 开始运动时速率为零，先对运动进行加速，再减速直到速率为零。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static strongInOut(t: number, b: number, c: number, d: number): number;
/**
* 以较快速度开始运动，然后在执行时减慢运动速度，直至速率为零。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static strongOut(t: number, b: number, c: number, d: number): number;
/**
* 开始运动时速率为零，先对运动进行加速，再减速直到速率为零。
* Sine 缓动方程中的运动加速度小于 Quad 方程中的运动加速度。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static sineInOut(t: number, b: number, c: number, d: number): number;
/**
* 以零速率开始运动，然后在执行时加快运动速度。
* Sine 缓动方程中的运动加速度小于 Quad 方程中的运动加速度。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static sineIn(t: number, b: number, c: number, d: number): number;
/**
* 以较快速度开始运动，然后在执行时减慢运动速度，直至速率为零。
* Sine 缓动方程中的运动加速度小于 Quad 方程中的运动加速度。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static sineOut(t: number, b: number, c: number, d: number): number;
/**
* 以零速率开始运动，然后在执行时加快运动速度。
* Quint 缓动方程的运动加速大于 Quart 缓动方程。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static quintIn(t: number, b: number, c: number, d: number): number;
/**
* 开始运动时速率为零，先对运动进行加速，再减速直到速率为零。
* Quint 缓动方程的运动加速大于 Quart 缓动方程。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static quintInOut(t: number, b: number, c: number, d: number): number;
/**
* 以较快速度开始运动，然后在执行时减慢运动速度，直至速率为零。
* Quint 缓动方程的运动加速大于 Quart 缓动方程。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static quintOut(t: number, b: number, c: number, d: number): number;
/**
* 方法以零速率开始运动，然后在执行时加快运动速度。
* Quart 缓动方程的运动加速大于 Cubic 缓动方程。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static quartIn(t: number, b: number, c: number, d: number): number;
/**
* 开始运动时速率为零，先对运动进行加速，再减速直到速率为零。
* Quart 缓动方程的运动加速大于 Cubic 缓动方程。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static quartInOut(t: number, b: number, c: number, d: number): number;
/**
* 以较快速度开始运动，然后在执行时减慢运动速度，直至速率为零。
* Quart 缓动方程的运动加速大于 Cubic 缓动方程。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static quartOut(t: number, b: number, c: number, d: number): number;
/**
* 方法以零速率开始运动，然后在执行时加快运动速度。
* Cubic 缓动方程的运动加速大于 Quad 缓动方程。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static cubicIn(t: number, b: number, c: number, d: number): number;
/**
* 开始运动时速率为零，先对运动进行加速，再减速直到速率为零。
* Cubic 缓动方程的运动加速大于 Quad 缓动方程。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static cubicInOut(t: number, b: number, c: number, d: number): number;
/**
* 以较快速度开始运动，然后在执行时减慢运动速度，直至速率为零。
* Cubic 缓动方程的运动加速大于 Quad 缓动方程。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static cubicOut(t: number, b: number, c: number, d: number): number;
/**
* 方法以零速率开始运动，然后在执行时加快运动速度。
* Quad 缓动方程中的运动加速度等于 100% 缓动的时间轴补间的运动加速度，并且显著小于 Cubic 缓动方程中的运动加速度。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static quadIn(t: number, b: number, c: number, d: number): number;
/**
* 开始运动时速率为零，先对运动进行加速，再减速直到速率为零。
* Quad 缓动方程中的运动加速度等于 100% 缓动的时间轴补间的运动加速度，并且显著小于 Cubic 缓动方程中的运动加速度。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static quadInOut(t: number, b: number, c: number, d: number): number;
/**
* 以较快速度开始运动，然后在执行时减慢运动速度，直至速率为零。
* Quad 缓动方程中的运动加速度等于 100% 缓动的时间轴补间的运动加速度，并且显著小于 Cubic 缓动方程中的运动加速度。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static quadOut(t: number, b: number, c: number, d: number): number;
/**
* 方法以零速率开始运动，然后在执行时加快运动速度。
* 其中每个时间间隔是剩余距离减去一个固定比例部分。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static expoIn(t: number, b: number, c: number, d: number): number;
/**
* 开始运动时速率为零，先对运动进行加速，再减速直到速率为零。
* 其中每个时间间隔是剩余距离减去一个固定比例部分。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static expoInOut(t: number, b: number, c: number, d: number): number;
/**
* 以较快速度开始运动，然后在执行时减慢运动速度，直至速率为零。
* 其中每个时间间隔是剩余距离减去一个固定比例部分。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static expoOut(t: number, b: number, c: number, d: number): number;
/**
* 方法以零速率开始运动，然后在执行时加快运动速度。
* 缓动方程的运动加速会产生突然的速率变化。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static circIn(t: number, b: number, c: number, d: number): number;
/**
* 开始运动时速率为零，先对运动进行加速，再减速直到速率为零。
* 缓动方程的运动加速会产生突然的速率变化。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static circInOut(t: number, b: number, c: number, d: number): number;
/**
* 以较快速度开始运动，然后在执行时减慢运动速度，直至速率为零。
* 缓动方程的运动加速会产生突然的速率变化。
* @param t 指定当前时间，介于 0 和持续时间之间（包括二者）。
* @param b 指定动画属性的初始值。
* @param c 指定动画属性的更改总计。
* @param d 指定运动的持续时间。
* @return 指定时间的插补属性的值。
*/
static circOut(t: number, b: number, c: number, d: number): number;
}
}
declare module laya.utils {
import Sprite = laya.display.Sprite;
import Rectangle = laya.maths.Rectangle;
/**
* @private
* Dragging 类是触摸滑动控件。
*/
class Dragging {
/** 被拖动的对象。*/
target: Sprite;
/** 缓动衰减系数。*/
ratio: number;
/** 单帧最大偏移量。*/
maxOffset: number;
/** 滑动范围。*/
area: Rectangle;
/** 表示拖动是否有惯性。*/
hasInertia: boolean;
/** 橡皮筋最大值。*/
elasticDistance: number;
/** 橡皮筋回弹时间，单位为毫秒。*/
elasticBackTime: number;
/** 事件携带数据。*/
data: any;
/**
* 开始拖拽。
* @param target 待拖拽的 Sprite 对象。
* @param area 滑动范围。
* @param hasInertia 拖动是否有惯性。
* @param elasticDistance 橡皮筋最大值。
* @param elasticBackTime 橡皮筋回弹时间，单位为毫秒。
* @param data 事件携带数据。
* @param disableMouseEvent 鼠标事件是否有效。
* @param ratio 惯性阻尼系数
*/
start(target: Sprite, area: Rectangle, hasInertia: boolean, elasticDistance: number, elasticBackTime: number, data: any, disableMouseEvent: boolean, ratio?: number): void;
/**
* 停止拖拽。
*/
stop(): void;
}
}
declare module laya.utils {
/**
* @private
* ColorUtils 是一个颜色值处理类。
*/
class ColorUtils {
static _SAVE: any;
static _SAVE_SIZE: number;
arrColor: ArrayColor 类的实例。
* @param value 颜色值，可以是字符串："#ff0000"或者16进制颜色 0xff0000。
*/
constructor(value: any);
static _initDefault(): any;
static _initSaveMap(): void;
/**
* 根据指定的属性值，创建并返回一个 Color 类的实例。
* @param value 颜色值，可以是字符串："#ff0000"或者16进制颜色 0xff0000。
* @return 一个 Color 类的实例。
*/
static create(value: any): ColorUtils;
}
}
declare module laya.utils {
import Node = laya.display.Node;
import Sprite = laya.display.Sprite;
/**
* ClassUtils 是一个类工具类。
*/
class ClassUtils {
/**
* 注册 Class 映射，方便在class反射时获取。
* @param className 映射的名字或者别名。
* @param classDef 类的全名或者类的引用，全名比如:"laya.display.Sprite"。
*/
static regClass(className: string, classDef: any): void;
/**
* 根据类名短名字注册类，比如传入[Sprite]，功能同regClass("Sprite",Sprite);
* @param classes 类数组
*/
static regShortClassName(classes: Array Byte 类提供用于优化读取、写入以及处理二进制数据的方法和属性。
Byte 类适用于需要在字节层访问数据的高级开发人员。
主机字节序，是 CPU 存放数据的两种不同顺序，包括小端字节序和大端字节序。通过 getSystemEndian 可以获取当前系统的字节序。
BIG_ENDIAN ：大端字节序，地址低位存储值的高位，地址高位存储值的低位。有时也称之为网络字节序。
* LITTLE_ENDIAN ：小端字节序，地址低位存储值的低位，地址高位存储值的高位。
主机字节序，是 CPU 存放数据的两种不同顺序，包括小端字节序和大端字节序。通过 getSystemEndian 可以获取当前系统的字节序。
LITTLE_ENDIAN ：小端字节序，地址低位存储值的低位，地址高位存储值的高位。
* BIG_ENDIAN ：大端字节序，地址低位存储值的高位，地址高位存储值的低位。有时也称之为网络字节序。
获取当前主机的字节序。
*主机字节序，是 CPU 存放数据的两种不同顺序，包括小端字节序和大端字节序。
* BIG_ENDIAN ：大端字节序，地址低位存储值的高位，地址高位存储值的低位。有时也称之为网络字节序。
* LITTLE_ENDIAN ：小端字节序，地址低位存储值的低位，地址高位存储值的高位。
Byte 类的实例。
* @param data 用于指定初始化的元素数目，或者用于初始化的TypedArray对象、ArrayBuffer对象。如果为 null ，则预分配一定的内存空间，当可用空间不足时，优先使用这部分内存，如果还不够，则重新分配所需内存。
*/
constructor(data?: any);
/**
* 获取此对象的 ArrayBuffer 数据，数据只包含有效数据部分。
*/
readonly buffer: ArrayBuffer;
/**
* Byte 实例的字节序。取值为：BIG_ENDIAN 或 BIG_ENDIAN 。
主机字节序，是 CPU 存放数据的两种不同顺序，包括小端字节序和大端字节序。通过 getSystemEndian 可以获取当前系统的字节序。
BIG_ENDIAN ：大端字节序，地址低位存储值的高位，地址高位存储值的低位。有时也称之为网络字节序。
* LITTLE_ENDIAN ：小端字节序，地址低位存储值的低位，地址高位存储值的高位。
Byte 对象的长度（以字节为单位）。
如果将长度设置为大于当前长度的值，则用零填充字节数组的右侧；如果将长度设置为小于当前长度的值，将会截断该字节数组。
*如果要设置的长度大于当前已分配的内存空间的字节长度，则重新分配内存空间，大小为以下两者较大者：要设置的长度、当前已分配的长度的2倍，并将原有数据拷贝到新的内存空间中；如果要设置的长度小于当前已分配的内存空间的字节长度，也会重新分配内存空间，大小为要设置的长度，并将原有数据从头截断为要设置的长度存入新的内存空间中。
*/ length: number; /** * @private *常用于解析固定格式的字节流。
*先从字节流的当前字节偏移位置处读取一个 Uint16 值，然后以此值为长度，读取此长度的字符串。
常用于解析固定格式的字节流。
*先从字节流的当前字节偏移位置处读取一个 Uint16 值，然后以此值为长度，读取此长度的字符串。
从字节流中 start 参数指定的位置开始，读取 len 参数指定的字节数的数据，用于创建一个 Float32Array 对象并返回此对象。
注意：返回的 Float32Array 对象，在 JavaScript 环境下，是原生的 HTML5 Float32Array 对象，对此对象的读取操作都是基于运行此程序的当前主机字节序，此顺序可能与实际数据的字节序不同，如果使用此对象进行读取，需要用户知晓实际数据的字节序和当前主机字节序，如果相同，可正常读取，否则需要用户对实际数据(Float32Array.buffer)包装一层 DataView ，使用 DataView 对象可按照指定的字节序进行读取。
* @param start 开始位置。 * @param len 需要读取的字节长度。如果要读取的长度超过可读取范围，则只返回可读范围内的值。 * @return 读取的 Float32Array 对象。 */ getFloat32Array(start: number, len: number): any; /** * 从字节流中start 参数指定的位置开始，读取 len 参数指定的字节数的数据，用于创建一个 Float32Array 对象并返回此对象。
* @param start 开始位置。
* @param len 需要读取的字节长度。如果要读取的长度超过可读取范围，则只返回可读范围内的值。
* @return 读取的 Float32Array 对象。
*/
readFloat32Array(start: number, len: number): any;
/**
* @private
* 从字节流中 start 参数指定的位置开始，读取 len 参数指定的字节数的数据，用于创建一个 Uint8Array 对象并返回此对象。
* @param start 开始位置。
* @param len 需要读取的字节长度。如果要读取的长度超过可读取范围，则只返回可读范围内的值。
* @return 读取的 Uint8Array 对象。
*/
getUint8Array(start: number, len: number): Uint8Array;
/**
* 从字节流中 start 参数指定的位置开始，读取 len 参数指定的字节数的数据，用于创建一个 Uint8Array 对象并返回此对象。
* @param start 开始位置。
* @param len 需要读取的字节长度。如果要读取的长度超过可读取范围，则只返回可读范围内的值。
* @return 读取的 Uint8Array 对象。
*/
readUint8Array(start: number, len: number): Uint8Array;
/**
* @private
* 从字节流中 start 参数指定的位置开始，读取 len 参数指定的字节数的数据，用于创建一个 Int16Array 对象并返回此对象。
注意：返回的 Int16Array 对象，在 JavaScript 环境下，是原生的 HTML5 Int16Array 对象，对此对象的读取操作都是基于运行此程序的当前主机字节序，此顺序可能与实际数据的字节序不同，如果使用此对象进行读取，需要用户知晓实际数据的字节序和当前主机字节序，如果相同，可正常读取，否则需要用户对实际数据(Int16Array.buffer)包装一层 DataView ，使用 DataView 对象可按照指定的字节序进行读取。
* @param start 开始读取的字节偏移量位置。 * @param len 需要读取的字节长度。如果要读取的长度超过可读取范围，则只返回可读范围内的值。 * @return 读取的 Int16Array 对象。 */ getInt16Array(start: number, len: number): any; /** * 从字节流中start 参数指定的位置开始，读取 len 参数指定的字节数的数据，用于创建一个 Int16Array 对象并返回此对象。
* @param start 开始读取的字节偏移量位置。
* @param len 需要读取的字节长度。如果要读取的长度超过可读取范围，则只返回可读范围内的值。
* @return 读取的 Uint8Array 对象。
*/
readInt16Array(start: number, len: number): any;
/**
* @private
* 从字节流的当前字节偏移位置处读取一个 IEEE 754 单精度（32 位）浮点数。
* @return 单精度（32 位）浮点数。
*/
getFloat32(): number;
/**
* 从字节流的当前字节偏移位置处读取一个 IEEE 754 单精度（32 位）浮点数。
* @return 单精度（32 位）浮点数。
*/
readFloat32(): number;
/**
* @private
* 从字节流的当前字节偏移量位置处读取一个 IEEE 754 双精度（64 位）浮点数。
* @return 双精度（64 位）浮点数。
*/
getFloat64(): number;
/**
* 从字节流的当前字节偏移量位置处读取一个 IEEE 754 双精度（64 位）浮点数。
* @return 双精度（64 位）浮点数。
*/
readFloat64(): number;
/**
* 在字节流的当前字节偏移量位置处写入一个 IEEE 754 单精度（32 位）浮点数。
* @param value 单精度（32 位）浮点数。
*/
writeFloat32(value: number): void;
/**
* 在字节流的当前字节偏移量位置处写入一个 IEEE 754 双精度（64 位）浮点数。
* @param value 双精度（64 位）浮点数。
*/
writeFloat64(value: number): void;
/**
* @private
* 从字节流的当前字节偏移量位置处读取一个 Int32 值。
* @return Int32 值。
*/
getInt32(): number;
/**
* 从字节流的当前字节偏移量位置处读取一个 Int32 值。
* @return Int32 值。
*/
readInt32(): number;
/**
* @private
* 从字节流的当前字节偏移量位置处读取一个 Uint32 值。
* @return Uint32 值。
*/
getUint32(): number;
/**
* 从字节流的当前字节偏移量位置处读取一个 Uint32 值。
* @return Uint32 值。
*/
readUint32(): number;
/**
* 在字节流的当前字节偏移量位置处写入指定的 Int32 值。
* @param value 需要写入的 Int32 值。
*/
writeInt32(value: number): void;
/**
* 在字节流的当前字节偏移量位置处写入 Uint32 值。
* @param value 需要写入的 Uint32 值。
*/
writeUint32(value: number): void;
/**
* @private
* 从字节流的当前字节偏移量位置处读取一个 Int16 值。
* @return Int16 值。
*/
getInt16(): number;
/**
* 从字节流的当前字节偏移量位置处读取一个 Int16 值。
* @return Int16 值。
*/
readInt16(): number;
/**
* @private
* 从字节流的当前字节偏移量位置处读取一个 Uint16 值。
* @return Uint16 值。
*/
getUint16(): number;
/**
* 从字节流的当前字节偏移量位置处读取一个 Uint16 值。
* @return Uint16 值。
*/
readUint16(): number;
/**
* 在字节流的当前字节偏移量位置处写入指定的 Uint16 值。
* @param value 需要写入的Uint16 值。
*/
writeUint16(value: number): void;
/**
* 在字节流的当前字节偏移量位置处写入指定的 Int16 值。
* @param value 需要写入的 Int16 值。
*/
writeInt16(value: number): void;
/**
* @private
* 从字节流的当前字节偏移量位置处读取一个 Uint8 值。
* @return Uint8 值。
*/
getUint8(): number;
/**
* 从字节流的当前字节偏移量位置处读取一个 Uint8 值。
* @return Uint8 值。
*/
readUint8(): number;
/**
* 在字节流的当前字节偏移量位置处写入指定的 Uint8 值。
* @param value 需要写入的 Uint8 值。
*/
writeUint8(value: number): void;
_getUInt8(pos: number): number;
_readUInt8(pos: number): number;
_getUint16(pos: number): number;
_readUint16(pos: number): number;
_getMatrix(): Matrix;
_readMatrix(): Matrix;
getCustomString(len: number): string;
readCustomString(len: number): string;
/**
* 移动或返回 Byte 对象的读写指针的当前位置（以字节为单位）。下一次调用读取方法时将在此位置开始读取，或者下一次调用写入方法时将在此位置开始写入。
*/
pos: number;
/**
* 可从字节流的当前位置到末尾读取的数据的字节数。
*/
readonly bytesAvailable: number;
/**
* 清除字节数组的内容，并将 length 和 pos 属性重置为 0。调用此方法将释放 Byte 实例占用的内存。
*/
clear(): void;
/**
* @private
* 获取此对象的 ArrayBuffer 引用。
* @return
*/
__getBuffer(): ArrayBuffer;
/**
* 将 UTF-8 字符串写入字节流。类似于 writeUTF() 方法，但 writeUTFBytes() 不使用 16 位长度的字为字符串添加前缀。
*对应的读取方法为： getUTFBytes 。
* @param value 要写入的字符串。 */ writeUTFBytes(value: string): void; /** *将 UTF-8 字符串写入字节流。先写入以字节表示的 UTF-8 字符串长度（作为 16 位整数），然后写入表示字符串字符的字节。
*对应的读取方法为： getUTFString 。
* @param value 要写入的字符串值。 */ writeUTFString(value: string): void; /** * @private * 读取 UTF-8 字符串。 * @return 读取的字符串。 */ readUTFString(): string; /** *从字节流中读取一个 UTF-8 字符串。假定字符串的前缀是一个无符号的短整型（以此字节表示要读取的长度）。
*对应的写入方法为： writeUTFString 。
* @return 读取的字符串。 */ getUTFString(): string; /** * @private * 读字符串，必须是 writeUTFBytes 方法写入的字符串。 * @param len 要读的buffer长度，默认将读取缓冲区全部数据。 * @return 读取的字符串。 */ readUTFBytes(len?: number): string; /** *从字节流中读取一个由 length 参数指定的长度的 UTF-8 字节序列，并返回一个字符串。
*一般读取的是由 writeUTFBytes 方法写入的字符串。
* @param len 要读的buffer长度，默认将读取缓冲区全部数据。 * @return 读取的字符串。 */ getUTFBytes(len?: number): string; /** *在字节流中写入一个字节。
*使用参数的低 8 位。忽略高 24 位。
* @param value */ writeByte(value: number): void; /** *从字节流中读取带符号的字节。
*返回值的范围是从 -128 到 127。
* @return 介于 -128 和 127 之间的整数。 */ readByte(): number; /** * @private * 从字节流中读取带符号的字节。 */ getByte(): number; /** * @private *保证该字节流的可用长度不小于 lengthToEnsure 参数指定的值。
将指定 arraybuffer 对象中的以 offset 为起始偏移量， length 为长度的字节序列写入字节流。
*如果省略 length 参数，则使用默认长度 0，该方法将从 offset 开始写入整个缓冲区；如果还省略了 offset 参数，则写入整个缓冲区。
*如果 offset 或 length 小于0，本函数将抛出异常。
* @param arraybuffer 需要写入的 Arraybuffer 对象。 * @param offset Arraybuffer 对象的索引的偏移量（以字节为单位） * @param length 从 Arraybuffer 对象写入到 Byte 对象的长度（以字节为单位） */ writeArrayBuffer(arraybuffer: any, offset?: number, length?: number): void; /** * 读取ArrayBuffer数据 * @param length * @return */ readArrayBuffer(length: number): ArrayBuffer; } } declare module laya.utils { import Context = laya.resource.Context; import HTMLCanvas = laya.resource.HTMLCanvas; /** *Browser 是浏览器代理类。封装浏览器及原生 js 提供的一些功能。
*/
class Browser {
/** 浏览器代理信息。*/
static userAgent: string;
/** 表示是否在移动设备，包括IOS和安卓等设备内。*/
static onMobile: boolean;
/** 表示是否在 IOS 设备内。*/
static onIOS: boolean;
/** 表示是否在 Mac 设备。*/
static onMac: boolean;
/** 表示是否在 IPhone 设备内。*/
static onIPhone: boolean;
/** 表示是否在 IPad 设备内。*/
static onIPad: boolean;
/** 表示是否在 Android 设备内。*/
static onAndroid: boolean;
/** 表示是否在 Windows Phone 设备内。*/
static onWP: boolean;
/** 表示是否在 QQ 浏览器内。*/
static onQQBrowser: boolean;
/** 表示是否在移动端 QQ 或 QQ 浏览器内。*/
static onMQQBrowser: boolean;
/** 表示是否在 Safari 内。*/
static onSafari: boolean;
/** 表示是否在 IE 浏览器内*/
static onIE: boolean;
/** 表示是否在 微信 内*/
static onWeiXin: boolean;
/** 表示是否在 PC 端。*/
static onPC: boolean;
static onMiniGame: boolean;
static onBDMiniGame: boolean;
static onLimixiu: boolean;
static onFirefox: boolean;
static onEdge: boolean;
/** 表示是否支持WebAudio*/
static supportWebAudio: boolean;
/** 表示是否支持LocalStorage*/
static supportLocalStorage: boolean;
/** 全局离线画布（非主画布）。主要用来测量字体、获取image数据。*/
static canvas: HTMLCanvas;
/** 全局离线画布上绘图的环境（非主画布）。 */
static context: Context;
static _supportWebGL: boolean;
static __init__(): any;
/**
* 创建浏览器原生节点。
* @param type 节点类型。
* @return 创建的节点对象的引用。
*/
static createElement(type: string): any;
/**
* 返回 Document 对象中拥有指定 id 的第一个对象的引用。
* @param type 节点id。
* @return 节点对象。
*/
static getElementById(type: string): any;
/**
* 移除指定的浏览器原生节点对象。
* @param type 节点对象。
*/
static removeElement(ele: any): void;
/**
* 获取浏览器当前时间戳，单位为毫秒。
*/
static now(): number;
/**
* 浏览器窗口可视宽度。
* 通过分析浏览器信息获得。浏览器多个属性值优先级为：window.innerWidth(包含滚动条宽度) > document.body.clientWidth(不包含滚动条宽度)，如果前者为0或为空，则选择后者。
*/
static readonly clientWidth: number;
/**
* 浏览器窗口可视高度。
* 通过分析浏览器信息获得。浏览器多个属性值优先级为：window.innerHeight(包含滚动条高度) > document.body.clientHeight(不包含滚动条高度) > document.documentElement.clientHeight(不包含滚动条高度)，如果前者为0或为空，则选择后者。
*/
static readonly clientHeight: number;
/** 浏览器窗口物理宽度。考虑了设备像素比。*/
static readonly width: number;
/** 浏览器窗口物理高度。考虑了设备像素比。*/
static readonly height: number;
/** 获得设备像素比。*/
static readonly pixelRatio: number;
/**画布容器，用来盛放画布的容器。方便对画布进行控制*/
static container: any;
/**浏览器原生 window 对象的引用。*/
static readonly window: any;
/**浏览器原生 document 对象的引用。*/
static readonly document: any;
}
}
declare module laya.ui {
import Sprite = laya.display.Sprite;
import IFilter = laya.filters.IFilter;
/**
* UIUtils 是文本工具集。
*/
class UIUtils {
/**
* 需要替换的转义字符表
*/
static escapeSequence: any;
/**
* 用字符串填充数组，并返回数组副本。
* @param arr 源数组对象。
* @param str 用逗号连接的字符串。如"p1,p2,p3,p4"。
* @param type 如果值不为null，则填充的是新增值得类型。
* @return 填充后的数组。
*/
static fillArray(arr: ArrayStyles 定义了组件常用的样式属性。
*/
class Styles {
/**
* 默认九宫格信息。
* @see laya.ui.AutoBitmap#sizeGrid
*/
static defaultSizeGrid: Array格式：[上边距，右边距，下边距，左边距]。
*/ static labelPadding: Array格式：[上边距，右边距，下边距，左边距]。
*/ static inputLabelPadding: Array格式：[upColor,overColor,downColor,disableColor]。
*/ static buttonLabelColors: Array格式：[overBgColor,overLabelColor,outLabelColor,borderColor,bgColor]。
*/ static comboBoxItemColors: ArrayISelect 接口，实现对象的 selected 属性和 clickHandler 选择回调函数处理器。
*/
interface ISelect {
}
}
declare module laya.ui {
/**
* IRender 接口，实现设置项的渲染类型。
*/
interface IRender {
}
}
declare module laya.ui {
/**
* Item接口。
*/
interface IItem {
/**
* 初始化列表项。
*/
initItems(): void;
}
}
declare module laya.ui {
/**容器接口，实现了编辑器容器类型。*/
interface IBox {
}
}
declare module laya.system {
/**
* @private
*/
class System {
static changeDefinition(name: string, classObj: any): void;
/**
* @private
* 初始化。
*/
static __init__(): void;
}
}
declare module laya.runtime {
/**
* @private
* @author hugao
*/
interface IPlatform {
/**
* 调用方法
* @param methodName 方法名
* @param ...args 参数
* @return 返回值 目前只用android能直接返回
*/
call(methodName: string, ...args: any[]): any;
/**
* 调用方法通过回调接收返回值
* @param callback 回调方法 参数为返回值
* @param methodName 方法名
* @param ...args 参数
*/
callWithBack(callback: Function, methodName: string, ...args: any[]): void;
}
}
declare module laya.runtime {
/**
* @private
*/
interface IMarket {
/**
* 登录
* @param jsonParm
* @param callback
*/
login(jsonParm: string, callback: Function): void;
/**
* 登出
* @param jsonParm
* @param callback
*/
logout(jsonParm: string, callback: Function): void;
/**
* 授权
* @param jsonParm
* @param callback
*/
authorize(jsonParm: string, callback: Function): void;
/**
* 进入论坛
* @param jsonParm
* @param callback
*/
enterBBS(jsonParm: string, callback: Function): void;
/**
* 刷新票据
* @param jsonParm
* @param callback
*/
refreshToken(jsonParm: string, callback: Function): void;
/**
* 支付
* @param jsonParm
* @param callback
*/
recharge(jsonParm: string, callback: Function): void;
/**
* 分享
* @param jsonParm
* @param callback
*/
enterShareAndFeed(jsonParm: string, callback: Function): void;
/**
* 邀请
* @param jsonParm
* @param callback
*/
enterInvite(jsonParm: string, callback: Function): void;
/**
* 获取游戏好友
* @param jsonParm
* @param callback
*/
getGameFriends(jsonParm: string, callback: Function): void;
/**
* 发送到桌面
* @param jsonParm
* @param callback
*/
sendToDesktop(jsonParm: string, callback: Function): void;
/**
* 发送自定义消息
* @param jsonParm
* @param callback
*/
sendMessageToPlatform(jsonParm: string, callback: Function): void;
/**
* 获取用户信息
* @param jsonParm
* @param callback
*/
getUserInfo(jsonParm: string, callback: Function): void;
/**
* 返回Market名称
*/
getMarketName(): string;
/**
* 返回支付类型 自定义
*/
getPayType(): number;
/**
* 返回登录类型 自定义
*/
getLoginType(): number;
/**
*
*/
getChargeType(): number;
}
}
declare module laya.runtime {
/**
* @private
* @author hugao
*/
interface ICPlatformClass {
/**
* 创建平台类
* @param clsName 类全名
* @return 创建的类
*/
createClass(clsName: string): IPlatformClass;
}
}
declare module laya.runtime {
/**
* @private
* @author hugao
*/
interface IConchRenderObject {
drawSubmesh(submesh: any, drawType: number, renderMode: number, offset: number, count: number): void;
matrix(matrix: Float32Array): void;
boundingBox(min: Float32Array, max: Float32Array): void;
}
}
declare module laya.resource {
/**
* @private
* IList 可加入队列接口。
*/
interface ISingletonElement {
_getIndexInList(): number;
_setIndexInList(index: number): void;
}
}
declare module laya.resource {
/**
* @private
* IDispose 是资源销毁的接口。
*/
interface IDispose {
dispose(): void;
}
}
declare module laya.resource {
/**
* @private
* IDestroy 是对象销毁的接口。
*/
interface IDestroy {
destroy(): void;
}
}
declare module laya.resource {
/**
* @private
* ICreateResource 对象创建接口。
*/
interface ICreateResource {
_setCreateURL(url: string): void;
}
}
declare module laya.resource {
import ColorFilter = laya.filters.ColorFilter;
import Matrix = laya.maths.Matrix;
import Point = laya.maths.Point;
/**
* @private
* Context扩展类
*/
class Context {
_canvas: HTMLCanvas;
static ENUM_TEXTALIGN_DEFAULT: number;
static ENUM_TEXTALIGN_CENTER: number;
static ENUM_TEXTALIGN_RIGHT: number;
static __init__(to?: any): void;
font: string;
textBaseline: string;
fillStyle: any;
translate(x: number, y: number): void;
scale(scaleX: number, scaleY: number): void;
drawImage(...args: any[]): void;
getImageData(...args: any[]): any;
measureText(text: string): any;
setTransform(...args: any[]): void;
beginPath(convex?: boolean): void;
strokeStyle: any;
globalCompositeOperation: string;
/**获取canvas */
readonly canvas: HTMLCanvas;
rect(x: number, y: number, width: number, height: number): void;
stroke(): void;
$transform(a: number, b: number, c: number, d: number, tx: number, ty: number): void;
save(): void;
restore(): void;
clip(): void;
arcTo(x1: number, y1: number, x2: number, y2: number, r: number): void;
quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
lineJoin: string;
lineCap: string;
miterLimit: string;
globalAlpha: number;
clearRect(x: number, y: number, width: number, height: number): void;
moveTo(x: number, y: number): void;
lineTo(x: number, y: number): void;
closePath(): void;
drawCanvas(canvas: HTMLCanvas, x: number, y: number, width: number, height: number): void;
_drawRect(x: number, y: number, width: number, height: number, style: any): void;
drawText(text: any, x: number, y: number, font: string, color: string, textAlign: string): void;
fillBorderText(text: any, x: number, y: number, font: string, fillColor: string, borderColor: string, lineWidth: number, textAlign: string): void;
fillWords(words: ArrayRender 是渲染管理类。它是一个单例，可以使用 Laya.render 访问。
*/
class Render {
static _context: Context;
static _mainCanvas: HTMLCanvas;
/**是否是加速器 只读*/
static isConchApp: boolean;
/**是否是WebGL模式*/
static isWebGL: boolean;
/** 表示是否是 3D 模式。*/
static is3DMode: boolean;
/**
* 初始化引擎。
* @param width 游戏窗口宽度。
* @param height 游戏窗口高度。
*/
constructor(width: number, height: number);
/** 目前使用的渲染器。*/
static readonly context: Context;
/** 渲染使用的原生画布引用。 */
static readonly canvas: any;
}
}
declare module laya.renders {
import Sprite = laya.display.Sprite;
import Context = laya.resource.Context;
/**
* @private
* 快速节点命令执行器
* 多个指令组合才有意义，单个指令没必要在下面加
*/
class LayaGLQuickRunner {
static map: any;
static __init__(): void;
static transform_drawTexture(sprite: Sprite, context: Context, x: number, y: number): void;
static alpha_drawTexture(sprite: Sprite, context: Context, x: number, y: number): void;
static alpha_transform_drawTexture(sprite: Sprite, context: Context, x: number, y: number): void;
static alpha_transform_drawLayaGL(sprite: Sprite, context: Context, x: number, y: number): void;
static alpha_drawLayaGL(sprite: Sprite, context: Context, x: number, y: number): void;
static transform_drawLayaGL(sprite: Sprite, context: Context, x: number, y: number): void;
static transform_drawNodes(sprite: Sprite, context: Context, x: number, y: number): void;
static drawLayaGL_drawNodes(sprite: Sprite, context: Context, x: number, y: number): void;
}
}
declare module laya.particle.particleUtils {
class PicTool {
static getCanvasPic(img: any, color: number): any;
static getRGBPic(img: any): ArrayParticleTemplateBase 类是粒子模板基类
*
*/
class ParticleTemplateBase {
/**
* 粒子配置数据
*/
settings: ParticleSetting;
protected texture: Texture;
/**
* 创建一个新的 ParticleTemplateBase 类实例。
*
*/
constructor();
/**
* 添加一个粒子
* @param position 粒子位置
* @param velocity 粒子速度
*
*/
addParticleArray(position: Float32Array, velocity: Float32Array): void;
}
}
declare module laya.particle {
/**
* ParticleSettings 类是粒子配置数据类
*/
class ParticleSetting {
/**贴图*/
textureName: string;
/**贴图个数,默认为1可不设置*/
textureCount: number;
/**由于循环队列判断算法，最大饱和粒子数为maxPartices-1*/
maxPartices: number;
/**粒子持续时间(单位:秒）*/
duration: number;
/**如果大于0，某些粒子的持续时间会小于其他粒子,并具有随机性(单位:无）*/
ageAddScale: number;
/**粒子受发射器速度的敏感度（需在自定义发射器中编码设置）*/
emitterVelocitySensitivity: number;
/**最小开始尺寸（单位：2D像素、3D坐标）*/
minStartSize: number;
/**最大开始尺寸（单位：2D像素、3D坐标）*/
maxStartSize: number;
/**最小结束尺寸（单位：2D像素、3D坐标）*/
minEndSize: number;
/**最大结束尺寸（单位：2D像素、3D坐标）*/
maxEndSize: number;
/**最小水平速度（单位：2D像素、3D坐标）*/
minHorizontalVelocity: number;
/**最大水平速度（单位：2D像素、3D坐标）*/
maxHorizontalVelocity: number;
/**最小垂直速度（单位：2D像素、3D坐标）*/
minVerticalVelocity: number;
/**最大垂直速度（单位：2D像素、3D坐标）*/
maxVerticalVelocity: number;
/**等于1时粒子从出生到消亡保持一致的速度，等于0时粒子消亡时速度为0，大于1时粒子会保持加速（单位：无）*/
endVelocity: number;
/**（单位：2D像素、3D坐标）*/
gravity: Float32Array;
/**最小旋转速度（单位：2D弧度/秒、3D弧度/秒）*/
minRotateSpeed: number;
/**最大旋转速度（单位：2D弧度/秒、3D弧度/秒）*/
maxRotateSpeed: number;
/**最小开始半径（单位：2D像素、3D坐标）*/
minStartRadius: number;
/**最大开始半径（单位：2D像素、3D坐标）*/
maxStartRadius: number;
/**最小结束半径（单位：2D像素、3D坐标）*/
minEndRadius: number;
/**最大结束半径（单位：2D像素、3D坐标）*/
maxEndRadius: number;
/**最小水平开始弧度（单位：2D弧度、3D弧度）*/
minHorizontalStartRadian: number;
/**最大水平开始弧度（单位：2D弧度、3D弧度）*/
maxHorizontalStartRadian: number;
/**最小垂直开始弧度（单位：2D弧度、3D弧度）*/
minVerticalStartRadian: number;
/**最大垂直开始弧度（单位：2D弧度、3D弧度）*/
maxVerticalStartRadian: number;
/**是否使用结束弧度,false为结束时与起始弧度保持一致,true为根据minHorizontalEndRadian、maxHorizontalEndRadian、minVerticalEndRadian、maxVerticalEndRadian计算结束弧度。*/
useEndRadian: boolean;
/**最小水平结束弧度（单位：2D弧度、3D弧度）*/
minHorizontalEndRadian: number;
/**最大水平结束弧度（单位：2D弧度、3D弧度）*/
maxHorizontalEndRadian: number;
/**最小垂直结束弧度（单位：2D弧度、3D弧度）*/
minVerticalEndRadian: number;
/**最大垂直结束弧度（单位：2D弧度、3D弧度）*/
maxVerticalEndRadian: number;
/**最小开始颜色*/
minStartColor: Float32Array;
/**最大开始颜色*/
maxStartColor: Float32Array;
/**最小结束颜色*/
minEndColor: Float32Array;
/**最大结束颜色*/
maxEndColor: Float32Array;
/**false代表RGBA整体插值，true代表RGBA逐分量插值*/
colorComponentInter: boolean;
/**false代表使用参数颜色数据，true代表使用原图颜色数据*/
disableColor: boolean;
/**混合模式，待调整，引擎中暂无BlendState抽象*/
blendState: number;
/**发射器类型,"point","box","sphere","ring"*/
emitterType: string;
/**发射器发射速率*/
emissionRate: number;
/**点发射器位置*/
pointEmitterPosition: Float32Array;
/**点发射器位置随机值*/
pointEmitterPositionVariance: Float32Array;
/**点发射器速度*/
pointEmitterVelocity: Float32Array;
/**点发射器速度随机值*/
pointEmitterVelocityAddVariance: Float32Array;
/**盒发射器中心位置*/
boxEmitterCenterPosition: Float32Array;
/**盒发射器尺寸*/
boxEmitterSize: Float32Array;
/**盒发射器速度*/
boxEmitterVelocity: Float32Array;
/**盒发射器速度随机值*/
boxEmitterVelocityAddVariance: Float32Array;
/**球发射器中心位置*/
sphereEmitterCenterPosition: Float32Array;
/**球发射器半径*/
sphereEmitterRadius: number;
/**球发射器速度*/
sphereEmitterVelocity: number;
/**球发射器速度随机值*/
sphereEmitterVelocityAddVariance: number;
/**环发射器中心位置*/
ringEmitterCenterPosition: Float32Array;
/**环发射器半径*/
ringEmitterRadius: number;
/**环发射器速度*/
ringEmitterVelocity: number;
/**环发射器速度随机值*/
ringEmitterVelocityAddVariance: number;
/**环发射器up向量，0代表X轴,1代表Y轴,2代表Z轴*/
ringEmitterUp: number;
/**发射器位置随机值,2D使用*/
positionVariance: Float32Array;
/**
* 创建一个新的 ParticleSettings 类实例。
*
*/
constructor();
static checkSetting(setting: any): void;
}
}
declare module laya.particle {
/**
* @private
*/
class ParticleEmitter {
constructor(templet: ParticleTemplateBase, particlesPerSecond: number, initialPosition: Float32Array);
update(elapsedTime: number, newPosition: Float32Array): void;
}
}
declare module laya.particle {
/**
* @private
*/
class ParticleData {
position: Float32Array;
velocity: Float32Array;
startColor: Float32Array;
endColor: Float32Array;
sizeRotation: Float32Array;
radius: Float32Array;
radian: Float32Array;
durationAddScale: number;
time: number;
constructor();
static Create(settings: ParticleSetting, position: Float32Array, velocity: Float32Array, time: number): ParticleData;
}
}
declare module laya.particle.emitter {
import ParticleTemplateBase = laya.particle.ParticleTemplateBase;
/**
* EmitterBase 类是粒子发射器类
*/
class EmitterBase {
protected _frameTime: number;
protected _emissionRate: number;
protected _emissionTime: number;
/**
* 发射粒子最小时间间隔
*/
minEmissionTime: number;
_particleTemplate: ParticleTemplateBase;
/**
* 设置粒子粒子模板
* @param particleTemplate 粒子模板
*
*/
particleTemplate: ParticleTemplateBase;
/**
* 获取粒子发射速率
* @return 发射速率 粒子发射速率 (个/秒)
*/
/**
* 设置粒子发射速率
* @param emissionRate 粒子发射速率 (个/秒)
*/
emissionRate: number;
/**
* 开始发射粒子
* @param duration 发射持续的时间(秒)
*/
start(duration?: number): void;
/**
* 停止发射粒子
* @param clearParticles 是否清理当前的粒子
*/
stop(): void;
/**
* 清理当前的活跃粒子
* @param clearTexture 是否清理贴图数据,若清除贴图数据将无法再播放
*/
clear(): void;
/**
* 发射一个粒子
*
*/
emit(): void;
/**
* 时钟前进
* @param passedTime 前进时间
*
*/
advanceTime(passedTime?: number): void;
}
}
declare module laya.net {
/**
* URL 提供URL格式化，URL版本管理的类。
引擎加载资源的时候，会自动调用formatURL函数格式化URL路径
*通过basePath属性可以设置网络基础路径
*通过设置customFormat函数，可以自定义URL格式化的方式
*除了默认的通过增加后缀的格式化外，通过VersionManager类，可以开启IDE提供的，基于目录的管理方式来替代 "?v=" 的管理方式
* @see laya.net.VersionManager */ class URL { /**URL地址版本映射表，比如"aaa/bb.png":99,"aaa/bb.png":12}，默认情况下，通过formatURL格式化后，会自动生成为"aaa/bb.png?v=99"的一个地址*/ static version: any; /**兼容微信不支持加载scene后缀场景，设置为true，则会把scene加载替换为json*/ static exportSceneToJson: boolean; /**创建一个新的URL 实例。*/
constructor(url: string);
/**格式化后的地址。*/
readonly url: string;
/**地址的文件夹路径（不包括文件名）。*/
readonly path: string;
/**基础路径。如果不设置，默认为当前网页的路径。最终地址将被格式化为 basePath+相对URL地址，*/
static basePath: string;
/**root路径。只针对'~'类型的url路径有效*/
static rootPath: string;
/** 自定义URL格式化的方式。例如： customFormat=function(url:string):string} */
static customFormat: Function;
/**
* 格式化指定的地址并返回。
* @param url 地址。
* @param base 基础路径，如果没有，则使用basePath。
* @return 格式化处理后的地址。
*/
static formatURL(url: string): string;
/**
* @private
* 格式化相对路径。
*/
static _formatRelativePath(value: string): string;
/**
* 获取指定 URL 的文件夹路径（不包括文件名）。
* 注意：末尾有斜杠（/）。
* @param url url地址。 * @return 返回文件夹路径。 */ static getPath(url: string): string; /** * 获取指定 URL 的文件名。 * @param url 地址。 * @return 返回文件名。 */ static getFileName(url: string): string; /** * @private 兼容微信 */ static getAdptedFilePath(url: string): string; } } declare module laya.net { import Handler = laya.utils.Handler; /** * @private */ class TTFLoader { fontName: string; complete: Handler; err: Handler; load(fontPath: string): void; } } declare module laya.net { import Handler = laya.utils.Handler; /** *资源版本的生成由layacmd或IDE完成，使用 ResourceVersion 简化使用过程。
调用 enable 启用资源版本管理。
启用资源版本管理。
*由于只有发布版本需要资源管理。因此没有资源管理文件时，可以设置manifestFile为null或者不存在的路径。
* @param manifestFile 清单（json）文件的路径。 * @param callback 清单（json）文件加载完成后执行。 * @param type FOLDER_VERSION为基于文件夹管理方式（老版本IDE默认类型），FILENAME_VERSION为基于文件名映射管理（新版本IDE默认类型 */ static enable(manifestFile: string, callback: Handler, type?: number): void; /** * 为加载路径添加版本前缀。 * @param originURL 源路径。 * @return 格式化后的新路径。 */ static addVersionPrefix(originURL: string): string; } } declare module laya.net { /** * LocalStorage 类用于没有时间限制的数据存储。
LocalStorage。
*/
static support: boolean;
static __init__(): boolean;
/**
* 存储指定键名和键值，字符串类型。
* @param key 键名。
* @param value 键值。
*/
static setItem(key: string, value: string): void;
/**
* 获取指定键名的值。
* @param key 键名。
* @return 字符串型值。
*/
static getItem(key: string): string;
/**
* 存储指定键名及其对应的 Object 类型值。
* @param key 键名。
* @param value 键值。是 Object 类型，此致会被转化为 JSON 字符串存储。
*/
static setJSON(key: string, value: any): void;
/**
* 获取指定键名对应的 Object 类型值。
* @param key 键名。
* @return Object 类型值
*/
static getJSON(key: string): any;
/**
* 删除指定键名的信息。
* @param key 键名。
*/
static removeItem(key: string): void;
/**
* 清除本地存储信息。
*/
static clear(): void;
}
class Storage {
/**
* 数据列表。
*/
static items: any;
/**
* 表示是否支持 LocalStorage。
*/
static support: boolean;
static init(): void;
/**
* 存储指定键名和键值，字符串类型。
* @param key 键名。
* @param value 键值。
*/
static setItem(key: string, value: string): void;
/**
* 获取指定键名的值。
* @param key 键名。
* @return 字符串型值。
*/
static getItem(key: string): string;
/**
* 存储指定键名和它的 Object 类型值。
* @param key 键名。
* @param value 键值。是 Object 类型，此致会被转化为 JSON 字符串存储。
*/
static setJSON(key: string, value: any): void;
/**
* 获取指定键名的 Object 类型值。
* @param key 键名。
* @return Object 类型值
*/
static getJSON(key: string): any;
/**
* 删除指定键名的信息。
* @param key 键名。
*/
static removeItem(key: string): void;
/**
* 清除本地存储信息。
*/
static clear(): void;
}
}
declare module laya.net {
import Handler = laya.utils.Handler;
/**
* @private
*/
class AtlasInfoManager {
static enable(infoFile: string, callback?: Handler): void;
static getFileLoadPath(file: string): string;
}
}
declare module laya.media {
import Handler = laya.utils.Handler;
/**
* SoundManager 是一个声音管理类。提供了对背景音乐、音效的播放控制方法。
* 引擎默认有两套声音方案：WebAudio和H5Audio
* 播放音效，优先使用WebAudio播放声音，如果WebAudio不可用，则用H5Audio播放，H5Audio在部分机器上有兼容问题（比如不能混音，播放有延迟等）。
* 播放背景音乐，则使用H5Audio播放（使用WebAudio会增加特别大的内存，并且要等加载完毕后才能播放，有延迟）
* 建议背景音乐用mp3类型，音效用wav或者mp3类型（如果打包为app，音效只能用wav格式）。
* 详细教程及声音格式请参考：http://ldc2.layabox.com/doc/?nav=ch-as-1-7-0
*/
class SoundManager {
/**
* 背景音乐音量。
* @default 1
*/
static musicVolume: number;
/**
* 音效音量。
* @default 1
*/
static soundVolume: number;
/**
* 声音播放速率。
* @default 1
*/
static playbackRate: number;
static _bgMusic: string;
static _soundClass: any;
static _musicClass: any;
static __init__(): boolean;
/**
* 音效播放后自动删除。
* @default true
*/
static autoReleaseSound: boolean;
/**
* 添加播放的声音实例。
* @param channel SoundChannel 对象。
*/
static addChannel(channel: SoundChannel): void;
/**
* 移除播放的声音实例。
* @param channel SoundChannel 对象。
*/
static removeChannel(channel: SoundChannel): void;
static disposeSoundLater(url: string): void;
static disposeSoundIfNotUsed(url: string): void;
/**
* 失去焦点后是否自动停止背景音乐。
*/
/**
* 失去焦点后是否自动停止背景音乐。
* @param v Boolean 失去焦点后是否自动停止背景音乐。
*
*/
static autoStopMusic: boolean;
/**
* 背景音乐和所有音效是否静音。
*/
static muted: boolean;
/**
* 所有音效（不包括背景音乐）是否静音。
*/
static soundMuted: boolean;
/**
* 背景音乐（不包括音效）是否静音。
*/
static musicMuted: boolean;
static useAudioMusic: boolean;
/**
* 播放音效。音效可以同时播放多个。
* @param url 声音文件地址。
* @param loops 循环次数,0表示无限循环。
* @param complete 声音播放完成回调 Handler对象。
* @param soundClass 使用哪个声音类进行播放，null表示自动选择。
* @param startTime 声音播放起始时间。
* @return SoundChannel对象，通过此对象可以对声音进行控制，以及获取声音信息。
*/
static playSound(url: string, loops?: number, complete?: Handler, soundClass?: any, startTime?: number): SoundChannel;
/**
* 释放声音资源。
* @param url 声音播放地址。
*/
static destroySound(url: string): void;
/**
* 播放背景音乐。背景音乐同时只能播放一个，如果在播放背景音乐时再次调用本方法，会先停止之前的背景音乐，再播发当前的背景音乐。
* @param url 声音文件地址。
* @param loops 循环次数,0表示无限循环。
* @param complete 声音播放完成回调。
* @param startTime 声音播放起始时间。
* @return SoundChannel对象，通过此对象可以对声音进行控制，以及获取声音信息。
*/
static playMusic(url: string, loops?: number, complete?: Handler, startTime?: number): SoundChannel;
/**
* 停止声音播放。此方法能够停止任意声音的播放（包括背景音乐和音效），只需传入对应的声音播放地址。
* @param url 声音文件地址。
*/
static stopSound(url: string): void;
/**
* 停止播放所有声音（包括背景音乐和音效）。
*/
static stopAll(): void;
/**
* 停止播放所有音效（不包括背景音乐）。
*/
static stopAllSound(): void;
/**
* 停止播放背景音乐（不包括音效）。
* @param url 声音文件地址。
*/
static stopMusic(): void;
/**
* 设置声音音量。根据参数不同，可以分别设置指定声音（背景音乐或音效）音量或者所有音效（不包括背景音乐）音量。
* @param volume 音量。初始值为1。音量范围从 0（静音）至 1（最大音量）。
* @param url (default = null)声音播放地址。默认为null。为空表示设置所有音效（不包括背景音乐）的音量，不为空表示设置指定声音（背景音乐或音效）的音量。
*/
static setSoundVolume(volume: number, url?: string): void;
/**
* 设置背景音乐音量。音量范围从 0（静音）至 1（最大音量）。
* @param volume 音量。初始值为1。音量范围从 0（静音）至 1（最大音量）。
*/
static setMusicVolume(volume: number): void;
}
}
declare module laya.maths {
/**
* Rectangle 对象是按其位置（由它左上角的点 (x, y) 确定）以及宽度和高度定义的区域。
Rectangle 类的 x、y、width 和 height 属性相互独立；更改一个属性的值不会影响其他属性。
*/ class Rectangle { static EMPTY: Rectangle; /**全局临时的矩形区域，此对象用于全局复用，以减少对象创建*/ static TEMP: Rectangle; /** 矩形左上角的 X 轴坐标。*/ x: number; /** 矩形左上角的 Y 轴坐标。*/ y: number; /** 矩形的宽度。*/ width: number; /** 矩形的高度。*/ height: number; /** * 创建一个Rectangle 对象。
* @param x 矩形左上角的 X 轴坐标。
* @param y 矩形左上角的 Y 轴坐标。
* @param width 矩形的宽度。
* @param height 矩形的高度。
*/
constructor(x?: number, y?: number, width?: number, height?: number);
/** 此矩形右侧的 X 轴坐标。 x 和 width 属性的和。*/
readonly right: number;
/** 此矩形底端的 Y 轴坐标。y 和 height 属性的和。*/
readonly bottom: number;
/**
* 将 Rectangle 的属性设置为指定值。
* @param x x 矩形左上角的 X 轴坐标。
* @param y x 矩形左上角的 Y 轴坐标。
* @param width 矩形的宽度。
* @param height 矩形的高。
* @return 返回属性值修改后的矩形对象本身。
*/
setTo(x: number, y: number, width: number, height: number): Rectangle;
/**
* 重置
*/
reset(): Rectangle;
/**
* 回收
*/
recover(): void;
/**
* 创建
*/
static create(): Rectangle;
/**
* 复制 source 对象的属性值到此矩形对象中。
* @param sourceRect 源 Rectangle 对象。
* @return 返回属性值修改后的矩形对象本身。
*/
copyFrom(source: Rectangle): Rectangle;
/**
* 确定由此 Rectangle 对象定义的矩形区域内是否包含指定的点。
* @param x 点的 X 轴坐标值（水平位置）。
* @param y 点的 Y 轴坐标值（垂直位置）。
* @return 如果 Rectangle 对象包含指定的点，则值为 true；否则为 false。
*/
contains(x: number, y: number): boolean;
/**
* 确定在 rect 参数中指定的对象是否与此 Rectangle 对象相交。此方法检查指定的 Rectangle 对象的 x、y、width 和 height 属性，以查看它是否与此 Rectangle 对象相交。
* @param rect Rectangle 对象。
* @return 如果传入的矩形对象与此对象相交，则返回 true 值，否则返回 false。
*/
intersects(rect: Rectangle): boolean;
/**
* 如果在 rect 参数中指定的 Rectangle 对象与此 Rectangle 对象相交，则返回交集区域作为 Rectangle 对象。如果矩形不相交，则此方法返回null。
* @param rect 待比较的矩形区域。
* @param out （可选）待输出的矩形区域。如果为空则创建一个新的。建议：尽量复用对象，减少对象创建消耗。
* @return 返回相交的矩形区域对象。
*/
intersection(rect: Rectangle, out?: Rectangle): Rectangle;
/**
* 矩形联合，通过填充两个矩形之间的水平和垂直空间，将这两个矩形组合在一起以创建一个新的 Rectangle 对象。
*注意：union() 方法忽略高度或宽度值为 0 的矩形，如：var rect2:Rectangle = new Rectangle(300,300,50,0);
* @param 要添加到此 Rectangle 对象的 Rectangle 对象。 * @param out 用于存储输出结果的矩形对象。如果为空，则创建一个新的。建议：尽量复用对象，减少对象创建消耗。Rectangle.TEMP对象用于对象复用。 * @return 充当两个矩形的联合的新 Rectangle 对象。 */ union(source: Rectangle, out?: Rectangle): Rectangle; /** * 返回一个 Rectangle 对象，其 x、y、width 和 height 属性的值与当前 Rectangle 对象的对应值相同。 * @param out （可选）用于存储结果的矩形对象。如果为空，则创建一个新的。建议：尽量复用对象，减少对象创建消耗。。Rectangle.TEMP对象用于对象复用。 * @return Rectangle 对象，其 x、y、width 和 height 属性的值与当前 Rectangle 对象的对应值相同。 */ clone(out?: Rectangle): Rectangle; /** * 当前 Rectangle 对象的水平位置 x 和垂直位置 y 以及高度 width 和宽度 height 以逗号连接成的字符串。 */ toString(): string; /** * 检测传入的 Rectangle 对象的属性是否与当前 Rectangle 对象的属性 x、y、width、height 属性值都相等。 * @param rect 待比较的 Rectangle 对象。 * @return 如果判断的属性都相等，则返回 true ,否则返回 false。 */ equals(rect: Rectangle): boolean; /** *为当前矩形对象加一个点，以使当前矩形扩展为包含当前矩形和此点的最小矩形。
*此方法会修改本对象。
* @param x 点的 X 坐标。 * @param y 点的 Y 坐标。 * @return 返回此 Rectangle 对象。 */ addPoint(x: number, y: number): Rectangle; /** * @private * 返回代表当前矩形的顶点数据。 * @return 顶点数据。 */ _getBoundPoints(): ArrayPoint 对象表示二维坐标系统中的某个位置，其中 x 表示水平轴，y 表示垂直轴。
*/
class Point {
/**临时使用的公用对象。*/
static TEMP: Point;
static EMPTY: Point;
/**该点的水平坐标。*/
x: number;
/**该点的垂直坐标。*/
y: number;
/**
* 根据指定坐标，创建一个新的 Point 对象。
* @param x （可选）水平坐标。
* @param y （可选）垂直坐标。
*/
constructor(x?: number, y?: number);
/**
* 从对象池创建
*/
static create(): Point;
/**
* 将 Point 的成员设置为指定值。
* @param x 水平坐标。
* @param y 垂直坐标。
* @return 当前 Point 对象。
*/
setTo(x: number, y: number): Point;
/**
* 重置
*/
reset(): Point;
/**
* 回收到对象池，方便复用
*/
recover(): void;
/**
* 计算当前点和目标点(x，y)的距离。
* @param x 水平坐标。
* @param y 垂直坐标。
* @return 返回当前点和目标点之间的距离。
*/
distance(x: number, y: number): number;
/**返回包含 x 和 y 坐标的值的字符串。*/
toString(): string;
/**
* 标准化向量。
*/
normalize(): void;
/**
* copy point坐标
* @param point 需要被copy的point
*/
copy(point: Point): Point;
}
}
declare module laya.maths {
/**
* Matrix 类表示一个转换矩阵，它确定如何将点从一个坐标空间映射到另一个坐标空间。
您可以对一个显示对象执行不同的图形转换，方法是设置 Matrix 对象的属性，将该 Matrix 对象应用于 Transform 对象的 matrix 属性，然后应用该 Transform 对象作为显示对象的 transform 属性。这些转换函数包括平移（x 和 y 重新定位）、旋转、缩放和倾斜。
*/ class Matrix { static EMPTY: Matrix; /**用于中转使用的Matrix 对象。*/
static TEMP: Matrix;
static _createFun: Function;
/**缩放或旋转图像时影响像素沿 x 轴定位的值。*/
a: number;
/**旋转或倾斜图像时影响像素沿 y 轴定位的值。*/
b: number;
/**旋转或倾斜图像时影响像素沿 x 轴定位的值。*/
c: number;
/**缩放或旋转图像时影响像素沿 y 轴定位的值。*/
d: number;
/**沿 x 轴平移每个点的距离。*/
tx: number;
/**沿 y 轴平移每个点的距离。*/
ty: number;
_bTransform: boolean;
/**
* 使用指定参数创建新的 Matrix 对象。
* @param a （可选）缩放或旋转图像时影响像素沿 x 轴定位的值。
* @param b （可选）旋转或倾斜图像时影响像素沿 y 轴定位的值。
* @param c （可选）旋转或倾斜图像时影响像素沿 x 轴定位的值。
* @param d （可选）缩放或旋转图像时影响像素沿 y 轴定位的值。
* @param tx （可选）沿 x 轴平移每个点的距离。
* @param ty （可选）沿 y 轴平移每个点的距离。
*/
constructor(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number, nums?: number);
/**
* 将本矩阵设置为单位矩阵。
* @return 返回当前矩形。
*/
identity(): Matrix;
_checkTransform(): boolean;
/**
* 设置沿 x 、y 轴平移每个点的距离。
* @param x 沿 x 轴平移每个点的距离。
* @param y 沿 y 轴平移每个点的距离。
* @return 返回对象本身
*/
setTranslate(x: number, y: number): Matrix;
/**
* 沿 x 和 y 轴平移矩阵，平移的变化量由 x 和 y 参数指定。
* @param x 沿 x 轴向右移动的量（以像素为单位）。
* @param y 沿 y 轴向下移动的量（以像素为单位）。
* @return 返回此矩形对象。
*/
translate(x: number, y: number): Matrix;
/**
* 对矩阵应用缩放转换。
* @param x 用于沿 x 轴缩放对象的乘数。
* @param y 用于沿 y 轴缩放对象的乘数。
* @return 返回矩阵对象本身
*/
scale(x: number, y: number): Matrix;
/**
* 对 Matrix 对象应用旋转转换。
* @param angle 以弧度为单位的旋转角度。
* @return 返回矩阵对象本身
*/
rotate(angle: number): Matrix;
/**
* 对 Matrix 对象应用倾斜转换。
* @param x 沿着 X 轴的 2D 倾斜弧度。
* @param y 沿着 Y 轴的 2D 倾斜弧度。
* @return 当前 Matrix 对象。
*/
skew(x: number, y: number): Matrix;
/**
* 对指定的点应用当前矩阵的逆转化并返回此点。
* @param out 待转化的点 Point 对象。
* @return 返回out
*/
invertTransformPoint(out: Point): Point;
/**
* 将 Matrix 对象表示的几何转换应用于指定点。
* @param out 用来设定输出结果的点。
* @return 返回out
*/
transformPoint(out: Point): Point;
/**
* 将 Matrix 对象表示的几何转换应用于指定点，忽略tx、ty。
* @param out 用来设定输出结果的点。
* @return 返回out
*/
transformPointN(out: Point): Point;
/**
* 获取 X 轴缩放值。
* @return X 轴缩放值。
*/
getScaleX(): number;
/**
* 获取 Y 轴缩放值。
* @return Y 轴缩放值。
*/
getScaleY(): number;
/**
* 执行原始矩阵的逆转换。
* @return 当前矩阵对象。
*/
invert(): Matrix;
/**
* 将 Matrix 的成员设置为指定值。
* @param a 缩放或旋转图像时影响像素沿 x 轴定位的值。
* @param b 旋转或倾斜图像时影响像素沿 y 轴定位的值。
* @param c 旋转或倾斜图像时影响像素沿 x 轴定位的值。
* @param d 缩放或旋转图像时影响像素沿 y 轴定位的值。
* @param tx 沿 x 轴平移每个点的距离。
* @param ty 沿 y 轴平移每个点的距离。
* @return 当前矩阵对象。
*/
setTo(a: number, b: number, c: number, d: number, tx: number, ty: number): Matrix;
/**
* 将指定矩阵与当前矩阵连接，从而将这两个矩阵的几何效果有效地结合在一起。
* @param matrix 要连接到源矩阵的矩阵。
* @return 当前矩阵。
*/
concat(matrix: Matrix): Matrix;
/**
* 将指定的两个矩阵相乘后的结果赋值给指定的输出对象。
* @param m1 矩阵一。
* @param m2 矩阵二。
* @param out 输出对象。
* @return 结果输出对象 out。
*/
static mul(m1: Matrix, m2: Matrix, out: Matrix): Matrix;
/**
* 将指定的两个矩阵相乘，结果赋值给指定的输出数组，长度为16。
* @param m1 矩阵一。
* @param m2 矩阵二。
* @param out 输出对象Array。
* @return 结果输出对象 out。
*/
static mul16(m1: Matrix, m2: Matrix, out: ArrayMatrix 对象。
* @return Matrix 对象。
*/
static create(): Matrix;
}
}
declare module laya.maths {
/**
* @private
* MathUtil 是一个数据处理工具类。
*/
class MathUtil {
static subtractVector3(l: Float32Array, r: Float32Array, o: Float32Array): void;
static lerp(left: number, right: number, amount: number): number;
static scaleVector3(f: Float32Array, b: number, e: Float32Array): void;
static lerpVector3(l: Float32Array, r: Float32Array, t: number, o: Float32Array): void;
static lerpVector4(l: Float32Array, r: Float32Array, t: number, o: Float32Array): void;
static slerpQuaternionArray(a: Float32Array, Offset1: number, b: Float32Array, Offset2: number, t: number, out: Float32Array, Offset3: number): Float32Array;
/**
* 获取指定的两个点组成的线段的弧度值。
* @param x0 点一的 X 轴坐标值。
* @param y0 点一的 Y 轴坐标值。
* @param x1 点二的 X 轴坐标值。
* @param y1 点二的 Y 轴坐标值。
* @return 弧度值。
*/
static getRotation(x0: number, y0: number, x1: number, y1: number): number;
/**
* 一个用来确定数组元素排序顺序的比较函数。
* @param a 待比较数字。
* @param b 待比较数字。
* @return 如果a等于b 则值为0；如果b>a则值为1；如果b<则值为-1。
*/
static sortBigFirst(a: number, b: number): number;
/**
* 一个用来确定数组元素排序顺序的比较函数。
* @param a 待比较数字。
* @param b 待比较数字。
* @return 如果a等于b 则值为0；如果b>a则值为-1；如果b<则值为1。
*/
static sortSmallFirst(a: number, b: number): number;
/**
* 将指定的元素转为数字进行比较。
* @param a 待比较元素。
* @param b 待比较元素。
* @return b、a转化成数字的差值 (b-a)。
*/
static sortNumBigFirst(a: any, b: any): number;
/**
* 将指定的元素转为数字进行比较。
* @param a 待比较元素。
* @param b 待比较元素。
* @return a、b转化成数字的差值 (a-b)。
*/
static sortNumSmallFirst(a: any, b: any): number;
/**
* 返回根据对象指定的属性进行排序的比较函数。
* @param key 排序要依据的元素属性名。
* @param bigFirst 如果值为true，则按照由大到小的顺序进行排序，否则按照由小到大的顺序进行排序。
* @param forceNum 如果值为true，则将排序的元素转为数字进行比较。
* @return 排序函数。
*/
static sortByKey(key: string, bigFirst?: boolean, forceNum?: boolean): Function;
}
}
declare module laya.maths {
/**
* @private
* 凸包算法。
*/
class GrahamScan {
static multiply(p1: Point, p2: Point, p0: Point): number;
/**
* 计算两个点的距离。
* @param p1
* @param p2
* @return
*/
static dis(p1: Point, p2: Point): number;
/**
* 将数组 src 从索引0位置 依次取 cout 个项添加至 tst 数组的尾部。
* @param rst 原始数组，用于添加新的子元素。
* @param src 用于取子元素的数组。
* @param count 需要取得子元素个数。
* @return 添加完子元素的 rst 对象。
*/
static getFrom(rst: Array Matrix 类表示一个转换矩阵，它确定如何将点从一个坐标空间映射到另一个坐标空间。
您可以对一个显示对象执行不同的图形转换，方法是设置 Matrix 对象的属性，将该 Matrix 对象应用于 Transform 对象的 matrix 属性，然后应用该 Transform 对象作为显示对象的 transform 属性。这些转换函数包括平移（x 和 y 重新定位）、旋转、缩放和倾斜。
*/ class MatrixConch { static A: number; static B: number; static C: number; static D: number; static TX: number; static TY: number; static EMPTY: MatrixConch; /**用于中转使用的Matrix 对象。*/
static TEMP: MatrixConch;
_nums: Float32Array;
_bTransform: boolean;
/**
* 使用指定参数创建新的 Matrix 对象。
* @param a （可选）缩放或旋转图像时影响像素沿 x 轴定位的值。
* @param b （可选）旋转或倾斜图像时影响像素沿 y 轴定位的值。
* @param c （可选）旋转或倾斜图像时影响像素沿 x 轴定位的值。
* @param d （可选）缩放或旋转图像时影响像素沿 y 轴定位的值。
* @param tx （可选）沿 x 轴平移每个点的距离。
* @param ty （可选）沿 y 轴平移每个点的距离。
*/
constructor(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number, nums?: Float32Array);
/**缩放或旋转图像时影响像素沿 x 轴定位的值。*/
a: number;
/**旋转或倾斜图像时影响像素沿 y 轴定位的值。*/
b: number;
/**旋转或倾斜图像时影响像素沿 x 轴定位的值。*/
c: number;
/**缩放或旋转图像时影响像素沿 y 轴定位的值。*/
d: number;
/**沿 x 轴平移每个点的距离。*/
tx: number;
/**沿 y 轴平移每个点的距离。*/
ty: number;
/**
* 将本矩阵设置为单位矩阵。
* @return 返回矩阵对象本身
*/
identity(): MatrixConch;
_checkTransform(): boolean;
/**
* 设置沿 x 、y 轴平移每个点的距离。
* @param x 沿 x 轴平移每个点的距离。
* @param y 沿 y 轴平移每个点的距离。
* @return 返回矩阵对象本身
*/
setTranslate(x: number, y: number): MatrixConch;
/**
* 沿 x 和 y 轴平移矩阵，平移的变化量由 x 和 y 参数指定。
* @param x 沿 x 轴向右移动的量（以像素为单位）。
* @param y 沿 y 轴向下移动的量（以像素为单位）。
* @return 返回矩阵对象本身
*/
translate(x: number, y: number): MatrixConch;
/**
* 对矩阵应用缩放转换。
* @param x 用于沿 x 轴缩放对象的乘数。
* @param y 用于沿 y 轴缩放对象的乘数。
* @return 返回矩阵对象本身
*/
scale(x: number, y: number): MatrixConch;
/**
* 对 Matrix 对象应用旋转转换。
* @param angle 以弧度为单位的旋转角度。
* @return 返回矩阵对象本身
*/
rotate(angle: number): MatrixConch;
/**
* 对 Matrix 对象应用倾斜转换。
* @param x 沿着 X 轴的 2D 倾斜弧度。
* @param y 沿着 Y 轴的 2D 倾斜弧度。
* @return 返回矩阵对象本身
*/
skew(x: number, y: number): MatrixConch;
/**
* 对指定的点应用当前矩阵的逆转化并返回此点。
* @param out 待转化的点 Point 对象。
* @return 返回out
*/
invertTransformPoint(out: Point): Point;
/**
* 将 Matrix 对象表示的几何转换应用于指定点。
* @param out 用来设定输出结果的点。
* @return 返回out
*/
transformPoint(out: Point): Point;
/**
* 将 Matrix 对象表示的几何转换应用于指定点，忽略tx、ty。
* @param out 用来设定输出结果的点。
* @return 返回out
*/
transformPointN(out: Point): Point;
/**
* 获取 X 轴缩放值。
* @return X 轴缩放值。
*/
getScaleX(): number;
/**
* 获取 Y 轴缩放值。
* @return Y 轴缩放值。
*/
getScaleY(): number;
/**
* 执行原始矩阵的逆转换。
* @return 返回矩阵对象本身
*/
invert(): MatrixConch;
/**
* 将 Matrix 的成员设置为指定值。
* @param a 缩放或旋转图像时影响像素沿 x 轴定位的值。
* @param b 旋转或倾斜图像时影响像素沿 y 轴定位的值。
* @param c 旋转或倾斜图像时影响像素沿 x 轴定位的值。
* @param d 缩放或旋转图像时影响像素沿 y 轴定位的值。
* @param tx 沿 x 轴平移每个点的距离。
* @param ty 沿 y 轴平移每个点的距离。
* @return 返回矩阵对象本身
*/
setTo(a: number, b: number, c: number, d: number, tx: number, ty: number): MatrixConch;
/**
* 将指定矩阵与当前矩阵连接，从而将这两个矩阵的几何效果有效地结合在一起。
* @param matrix 要连接到源矩阵的矩阵。
* @return 当前矩阵。
*/
concat(matrix: MatrixConch): MatrixConch;
/**
* 将指定的两个矩阵相乘后的结果赋值给指定的输出对象。
* @param m1 矩阵一。
* @param m2 矩阵二。
* @param out 输出对象。
* @return 结果输出对象 out。
*/
static mul(m1: MatrixConch, m2: MatrixConch, out: MatrixConch): MatrixConch;
/**
* 将指定的两个矩阵相乘，结果赋值给指定的输出数组，长度为16。
* @param m1 矩阵一。
* @param m2 矩阵二。
* @param out 输出对象Array。
* @return 结果输出对象 out。
*/
static mul16(m1: MatrixConch, m2: MatrixConch, out: ArrayMatrix 对象。
* @return Matrix 对象。
*/
static create(nums?: Float32Array): MatrixConch;
}
}
declare module laya.layagl {
/**
* ...
* @author James
*/
class LayaNative2D {
static _SIMPLE_TEXTURE_CMDENCODER_: any;
static _SIMPLE_RECT_CMDENCODER_: any;
static _RECT_BORDER_CMD_ENCODER_: any;
static PROGRAMEX_DRAWTEXTURE: number;
static PROGRAMEX_DRAWVG: number;
static PROGRAMEX_DRAWRECT: number;
static PROGRAMEX_DRAWPARTICLE: number;
static VDO_MESHQUADTEXTURE: number;
static VDO_MESHVG: number;
static VDO_MESHPARTICLE: number;
static GLOBALVALUE_VIEWS: number;
static GLOBALVALUE_MATRIX32: number;
static GLOBALVALUE_DRAWTEXTURE_COLOR: number;
static GLOBALVALUE_ITALICDEG: number;
static GLOBALVALUE_CLIP_MAT_DIR: number;
static GLOBALVALUE_CLIP_MAT_POS: number;
static GLOBALVALUE_BLENDFUNC_SRC: number;
static GLOBALVALUE_BLENDFUNC_DEST: number;
static GLOBALVALUE_COLORFILTER_COLOR: number;
static GLOBALVALUE_COLORFILTER_ALPHA: number;
static GLOBALVALUE_BLURFILTER_STRENGTH: number;
static GLOBALVALUE_BLURFILTER_BLURINFO: number;
static SHADER_MACRO_COLOR_FILTER: number;
static SHADER_MACRO_BLUR_FILTER: number;
static SHADER_MACRO_GLOW_FILTER: number;
static GLOBALVALUE_GLOWFILTER_COLOR: number;
static GLOBALVALUE_GLOWFILTER_BLURINFO1: number;
static GLOBALVALUE_GLOWFILTER_BLURINFO2: number;
constructor();
static _init_simple_texture_cmdEncoder_(): void;
static _init_simple_rect_cmdEncoder_(): void;
static _init_rect_border_cmdEncoder_(): void;
static __init__(): void;
}
}
declare module laya.layagl {
/**
* @private
* 命令模板，用来优化合并命令执行
*/
class LayaGLTemplate {
static GLS: ArrayILayout 类是显示对象的布局接口。
*/
interface ILayout {
_isChar(): boolean;
_getCSSStyle(): HTMLStyle;
}
}
declare module laya.html.utils {
import HTMLElement = laya.html.dom.HTMLElement;
import URL = laya.net.URL;
/**
* @private
*/
class HTMLStyle {
/**水平居左对齐方式。 */
static ALIGN_LEFT: string;
/**水平居中对齐方式。 */
static ALIGN_CENTER: string;
/**水平居右对齐方式。 */
static ALIGN_RIGHT: string;
/**垂直居中对齐方式。 */
static VALIGN_TOP: string;
/**垂直居中对齐方式。 */
static VALIGN_MIDDLE: string;
/**垂直居底部对齐方式。 */
static VALIGN_BOTTOM: string;
/** 样式表信息。*/
static styleSheets: any;
/**添加布局。 */
static ADDLAYOUTED: number;
_type: number;
fontSize: number;
family: string;
color: string;
ower: HTMLElement;
textDecoration: string;
/**
* 文本背景颜色，以字符串表示。
*/
bgColor: string;
/**
* 文本边框背景颜色，以字符串表示。
*/
borderColor: string;
/**
* 边距信息。
*/
padding: Array描边宽度（以像素为单位）。
* 默认值0，表示不描边。 * @default 0 */ stroke: number; /** *描边颜色，以字符串表示。
* @default "#000000"; */ strokeColor: string; /** *垂直行间距（以像素为单位）
*/ leading: number; /**行高。 */ lineHeight: number; /** *表示使用此文本格式的文本段落的水平对齐方式。
* @default "left" */ align: string; /** *表示使用此文本格式的文本段落的水平对齐方式。
* @default "left" */ valign: string; /** * 字体样式字符串。 */ font: string; /**表示元素是否显示为块级元素。*/ /** * 是否显示为块级元素。 */ block: boolean; /** * 重置，方便下次复用 */ reset(): HTMLStyle; recover(): void; /** * 从对象池中创建 */ static create(): HTMLStyle; /** * 复制传入的 CSSStyle 属性值。 * @param src 待复制的 CSSStyle 对象。 */ inherit(src: HTMLStyle): void; /** * 表示是否换行。 */ wordWrap: boolean; /**是否为粗体*/ bold: boolean; /** * 表示使用此文本格式的文本是否为斜体。 * @default false */ italic: boolean; _widthAuto(): boolean; /**@inheritDoc */ widthed(sprite: any): boolean; /** * 设置如何处理元素内的空白。 */ whiteSpace: string; _calculation(type: string, value: string): boolean; /** * 宽度。 */ width: any; /** * 高度。 */ height: any; /** * 是否已设置高度。 * @param sprite 显示对象 Sprite。 * @return 一个Boolean 表示是否已设置高度。 */ heighted(sprite: any): boolean; /** * 设置宽高。 * @param w 宽度。 * @param h 高度。 */ size(w: number, h: number): void; /** * 是否是行元素。 */ getLineElement(): boolean; setLineElement(value: boolean): void; _enableLayout(): boolean; /** * 间距。 */ letterSpacing: number; /** * 设置 CSS 样式字符串。 * @param text CSS样式字符串。 */ cssText(text: string): void; /** * 根据传入的属性名、属性值列表，设置此对象的属性值。 * @param attrs 属性名与属性值列表。 */ attrs(attrs: Array描边宽度（以像素为单位）。
* 默认值0，表示不描边。 * @default 0 */ stroke: number; /** *描边颜色，以字符串表示。
* @default "#000000"; */ strokeColor: string; /** *垂直行间距（以像素为单位）
*/ leading: number; /**行高。 */ lineHeight: number; letterSpacing: number; href: string; constructor(); reset(): HTMLExtendStyle; recover(): void; static create(): HTMLExtendStyle; } } declare module laya.html.dom { import Rectangle = laya.maths.Rectangle; /** * @private */ class HTMLHitRect { rec: Rectangle; href: string; constructor(); reset(): HTMLHitRect; recover(): void; static create(): HTMLHitRect; } } declare module laya.html.dom { import Graphics = laya.display.Graphics; import HTMLStyle = laya.html.utils.HTMLStyle; import ILayout = laya.html.utils.ILayout; import URL = laya.net.URL; import HTMLChar = laya.utils.HTMLChar; /** * @private */ class HTMLElement { URI: URL; parent: HTMLElement; _style: HTMLStyle; protected _text: any; protected _children: Array销毁此对象。destroy对象默认会把自己从父节点移除，并且清理自身引用关系，等待js自动垃圾回收机制回收。destroy后不能再使用。
*destroy时会移除自身的事情监听，自身的timer监听，移除子对象及从父节点移除自己。
* @param destroyChild （可选）是否同时销毁子节点，若值为true,则销毁子节点，否则不销毁子节点。 */ destroy(): void; /** * 销毁所有子对象，不销毁自己本身。 */ destroyChildren(): void; readonly style: HTMLStyle; _getWords(): ArrayFilter 是滤镜基类。
*/
class Filter implements IFilter {
static BLUR: number;
static COLOR: number;
static GLOW: number;
static _filter: any;
_action: any;
/** @private*/
_glRender: any;
/**
* 创建一个 Filter 实例。
* */
constructor();
readonly type: number;
static _recycleScope: any;
}
}
declare module laya.filters {
/**
* @private
* ColorFilterAction 是一个颜色滤镜应用类。
*/
class ColorFilterAction {
data: ColorFilter;
/**
* 给指定的对象应用颜色滤镜。
* @param srcCanvas 需要应用画布对象。
* @return 应用了滤镜后的画布对象。
*/
apply(srcCanvas: any): any;
}
}
declare module laya.filters {
import WebGLContext2D = laya.webgl.canvas.WebGLContext2D;
import RenderTexture2D = laya.webgl.resource.RenderTexture2D;
import Value2D = laya.webgl.shader.d2.value.Value2D;
/**
* @private
*/
class BlurFilterGLRender {
render(rt: RenderTexture2D, ctx: WebGLContext2D, width: number, height: number, filter: BlurFilter): void;
setShaderInfo(shader: Value2D, filter: BlurFilter, w: number, h: number): void;
}
}
declare module laya.events {
/**
* @private
* Touch事件管理类，处理多点触控下的鼠标事件
*/
class TouchManager {
static I: TouchManager;
/**
* 是否启用
*/
enable: boolean;
/**
* 用于派发事件用的Event对象
*/
_event: Event;
/**
* 处理touchStart
* @param ele 根节点
* @param touchID touchID
* @param isLeft （可选）是否为左键
*/
onMouseDown(ele: any, touchID: number, isLeft?: boolean): void;
/**
* 处理TouchMove事件
* @param ele 根节点
* @param touchID touchID
*
*/
onMouseMove(ele: any, touchID: number): void;
getLastOvers(): ArrayMouseManager 是鼠标、触摸交互管理器。
鼠标事件流包括捕获阶段、目标阶段、冒泡阶段。
* 捕获阶段：此阶段引擎会从stage开始递归检测stage及其子对象，直到找到命中的目标对象或者未命中任何对象；
* 目标阶段：找到命中的目标对象；
* 冒泡阶段：事件离开目标对象，按节点层级向上逐层通知，直到到达舞台的过程。
KeyLocation 类包含表示在键盘或类似键盘的输入设备上按键位置的常量。
KeyLocation 常数用在键盘事件对象的 keyLocation 属性中。
表示激活的键位于数字键盘或者是使用对应于数字键盘的虚拟键激活的。
*注意：此属性只在flash模式下有效。
* */ static NUM_PAD: number; } } declare module laya.events { /** *KeyBoardManager 是键盘事件管理类。该类从浏览器中接收键盘事件，并派发该事件。
派发事件时若 Stage.focus 为空则只从 Stage 上派发该事件，否则将从 Stage.focus 对象开始一直冒泡派发该事件。所以在 Laya.stage 上监听键盘事件一定能够收到，如果在其他地方监听，则必须处在Stage.focus的冒泡链上才能收到该事件。
*用户可以通过代码 Laya.stage.focus=someNode 的方式来设置focus对象。
*用户可统一的根据事件对象中 e.keyCode 来判断按键类型，该属性兼容了不同浏览器的实现。
*/ class KeyBoardManager { /**是否开启键盘事件，默认为true*/ static enabled: boolean; static _event: Event; static __init__(): void; /** * 返回指定键是否被按下。 * @param key 键值。 * @return 是否被按下。 */ static hasKeyDown(key: number): boolean; } } declare module laya.events { /** *Keyboard 类的属性是一些常数，这些常数表示控制游戏时最常用的键。
*/
class Keyboard {
/** 与 0 的键控代码值(48)关联的常数。*/
static NUMBER_0: number;
/** 与 1 的键控代码值(49)关联的常数。*/
static NUMBER_1: number;
/** 与 2 的键控代码值(50)关联的常数。*/
static NUMBER_2: number;
/** 与 3 的键控代码值(51)关联的常数。*/
static NUMBER_3: number;
/** 与 4 的键控代码值(52)关联的常数。*/
static NUMBER_4: number;
/** 与 5 的键控代码值(53)关联的常数。*/
static NUMBER_5: number;
/** 与 6 的键控代码值(54)关联的常数。*/
static NUMBER_6: number;
/** 与 7 的键控代码值(55)关联的常数。*/
static NUMBER_7: number;
/** 与 8 的键控代码值(56)关联的常数。*/
static NUMBER_8: number;
/** 与 9 的键控代码值(57)关联的常数。*/
static NUMBER_9: number;
/** 与 A 键的键控代码值(65)关联的常数。*/
static A: number;
/** 与 B 键的键控代码值(66)关联的常数。*/
static B: number;
/** 与 C 键的键控代码值(67)关联的常数。*/
static C: number;
/** 与 D 键的键控代码值(68)关联的常数。*/
static D: number;
/** 与 E 键的键控代码值(69)关联的常数。*/
static E: number;
/** 与 F 键的键控代码值(70)关联的常数。*/
static F: number;
/** 与 G 键的键控代码值(71)关联的常数。*/
static G: number;
/** 与 H 键的键控代码值(72)关联的常数。*/
static H: number;
/** 与 I 键的键控代码值(73)关联的常数。*/
static I: number;
/** 与 J 键的键控代码值(74)关联的常数。*/
static J: number;
/** 与 K 键的键控代码值(75)关联的常数。*/
static K: number;
/** 与 L 键的键控代码值(76)关联的常数。*/
static L: number;
/** 与 M 键的键控代码值(77)关联的常数。*/
static M: number;
/** 与 N 键的键控代码值(78)关联的常数。*/
static N: number;
/** 与 O 键的键控代码值(79)关联的常数。*/
static O: number;
/** 与 P 键的键控代码值(80)关联的常数。*/
static P: number;
/** 与 Q 键的键控代码值(81)关联的常数。*/
static Q: number;
/** 与 R 键的键控代码值(82)关联的常数。*/
static R: number;
/** 与 S 键的键控代码值(83)关联的常数。*/
static S: number;
/** 与 T 键的键控代码值(84)关联的常数。*/
static T: number;
/** 与 U 键的键控代码值(85)关联的常数。*/
static U: number;
/** 与 V 键的键控代码值(86)关联的常数。*/
static V: number;
/** 与 W 键的键控代码值(87)关联的常数。*/
static W: number;
/** 与 X 键的键控代码值(88)关联的常数。*/
static X: number;
/** 与 Y 键的键控代码值(89)关联的常数。*/
static Y: number;
/** 与 Z 键的键控代码值(90)关联的常数。*/
static Z: number;
/** 与 F1 的键控代码值(112)关联的常数。*/
static F1: number;
/** 与 F2 的键控代码值(113)关联的常数。*/
static F2: number;
/** 与 F3 的键控代码值(114)关联的常数。*/
static F3: number;
/** 与 F4 的键控代码值(115)关联的常数。*/
static F4: number;
/** 与 F5 的键控代码值(116)关联的常数。*/
static F5: number;
/** 与 F6 的键控代码值(117)关联的常数。*/
static F6: number;
/** 与 F7 的键控代码值(118)关联的常数。*/
static F7: number;
/** 与 F8 的键控代码值(119)关联的常数。*/
static F8: number;
/** 与 F9 的键控代码值(120)关联的常数。*/
static F9: number;
/** 与 F10 的键控代码值(121)关联的常数。*/
static F10: number;
/** 与 F11 的键控代码值(122)关联的常数。*/
static F11: number;
/** 与 F12 的键控代码值(123)关联的常数。*/
static F12: number;
/** 与 F13 的键控代码值(124)关联的常数。*/
static F13: number;
/** 与 F14 的键控代码值(125)关联的常数。*/
static F14: number;
/** 与 F15 的键控代码值(126)关联的常数。*/
static F15: number;
/** 与数字键盘的伪键控代码(21)关联的常数。*/
static NUMPAD: number;
/** 与数字键盘上的数字 0 的键控代码值(96)关联的常数。*/
static NUMPAD_0: number;
/** 与数字键盘上的数字 1 的键控代码值(97)关联的常数。*/
static NUMPAD_1: number;
/** 与数字键盘上的数字 2 的键控代码值(98)关联的常数。*/
static NUMPAD_2: number;
/** 与数字键盘上的数字 3 的键控代码值(99)关联的常数。*/
static NUMPAD_3: number;
/** 与数字键盘上的数字 4 的键控代码值(100)关联的常数。*/
static NUMPAD_4: number;
/** 与数字键盘上的数字 5 的键控代码值(101)关联的常数。*/
static NUMPAD_5: number;
/** 与数字键盘上的数字 6 的键控代码值(102)关联的常数。*/
static NUMPAD_6: number;
/** 与数字键盘上的数字 7 的键控代码值(103)关联的常数。*/
static NUMPAD_7: number;
/** 与数字键盘上的数字 8 的键控代码值(104)关联的常数。*/
static NUMPAD_8: number;
/** 与数字键盘上的数字 9 的键控代码值(105)关联的常数。*/
static NUMPAD_9: number;
/** 与数字键盘上的加号(+)的键控代码值(107)关联的常数。*/
static NUMPAD_ADD: number;
/** 与数字键盘上的小数点(.)的键控代码值(110)关联的常数。*/
static NUMPAD_DECIMAL: number;
/** 与数字键盘上的除号(/)的键控代码值(111)关联的常数。*/
static NUMPAD_DIVIDE: number;
/** 与数字键盘上的 Enter 的键控代码值(108)关联的常数。*/
static NUMPAD_ENTER: number;
/** 与数字键盘上的乘号(*)的键控代码值(106)关联的常数。*/
static NUMPAD_MULTIPLY: number;
/** 与数字键盘上的减号(-)的键控代码值(109)关联的常数。*/
static NUMPAD_SUBTRACT: number;
/** 与 ; 键的键控代码值(186)关联的常数。*/
static SEMICOLON: number;
/** 与=键的键控代码值(187)关联的常数。*/
static EQUAL: number;
/** 与 F15 的键控代码值(188)关联的常数。*/
static COMMA: number;
/** 与 - 键的键控代码值(189)关联的常数。*/
static MINUS: number;
/** 与 . 键的键控代码值(190)关联的常数。*/
static PERIOD: number;
/** 与 / 键的键控代码值(191)关联的常数。*/
static SLASH: number;
/** 与 ` 键的键控代码值(192)关联的常数。*/
static BACKQUOTE: number;
/** 与 [ 键的键控代码值(219)关联的常数。*/
static LEFTBRACKET: number;
/** 与 \ 键的键控代码值(220)关联的常数。*/
static BACKSLASH: number;
/** 与 ] 键的键控代码值(221)关联的常数。*/
static RIGHTBRACKET: number;
/** 与 ' 键的键控代码值(222)关联的常数。*/
static QUOTE: number;
/** 与 Alternate(Option)键的键控代码值(18)关联的常数。*/
static ALTERNATE: number;
/** 与 Backspace 的键控代码值(8)关联的常数。*/
static BACKSPACE: number;
/** 与 Caps Lock 的键控代码值(20)关联的常数。*/
static CAPS_LOCK: number;
/** 与 Mac 命令键(15)关联的常数。*/
static COMMAND: number;
/** 与 Ctrl 的键控代码值(17)关联的常数。*/
static CONTROL: number;
/** 与 Delete 的键控代码值(46)关联的常数。*/
static DELETE: number;
/** 与 Enter 的键控代码值(13)关联的常数。*/
static ENTER: number;
/** 与 Esc 的键控代码值(27)关联的常数。*/
static ESCAPE: number;
/** 与 Page Up 的键控代码值(33)关联的常数。*/
static PAGE_UP: number;
/** 与 Page Down 的键控代码值(34)关联的常数。*/
static PAGE_DOWN: number;
/** 与 End 的键控代码值(35)关联的常数。*/
static END: number;
/** 与 Home 的键控代码值(36)关联的常数。*/
static HOME: number;
/** 与向左箭头键的键控代码值(37)关联的常数。*/
static LEFT: number;
/** 与向上箭头键的键控代码值(38)关联的常数。*/
static UP: number;
/** 与向右箭头键的键控代码值(39)关联的常数。*/
static RIGHT: number;
/** 与向下箭头键的键控代码值(40)关联的常数。*/
static DOWN: number;
/** 与 Shift 的键控代码值(16)关联的常数。*/
static SHIFT: number;
/** 与空格键的键控代码值(32)关联的常数。*/
static SPACE: number;
/** 与 Tab 的键控代码值(9)关联的常数。*/
static TAB: number;
/** 与 Insert 的键控代码值(45)关联的常数。*/
static INSERT: number;
}
}
declare module laya.events {
import Handler = laya.utils.Handler;
/**
* EventDispatcher 类是可调度事件的所有类的基类。
*/
class EventDispatcher {
static MOUSE_EVENTS: any;
/**
* 检查 EventDispatcher 对象是否为特定事件类型注册了任何侦听器。
* @param type 事件的类型。
* @return 如果指定类型的侦听器已注册，则值为 true；否则，值为 false。
*/
hasListener(type: string): boolean;
/**
* 派发事件。
* @param type 事件类型。
* @param data （可选）回调数据。注意：如果是需要传递多个参数 p1,p2,p3,...可以使用数组结构如：[p1,p2,p3,...] ；如果需要回调单个参数 p ，且 p 是一个数组，则需要使用结构如：[p]，其他的单个参数 p ，可以直接传入参数 p。
* @return 此事件类型是否有侦听者，如果有侦听者则值为 true，否则值为 false。
*/
event(type: string, data?: any): boolean;
/**
* 使用 EventDispatcher 对象注册指定类型的事件侦听器对象，以使侦听器能够接收事件通知。
* @param type 事件的类型。
* @param caller 事件侦听函数的执行域。
* @param listener 事件侦听函数。
* @param args （可选）事件侦听函数的回调参数。
* @return 此 EventDispatcher 对象。
*/
on(type: string, caller: any, listener: Function, args?: ArrayEvent 是事件类型的集合。一般当发生事件时，Event 对象将作为参数传递给事件侦听器。
*/
class Event {
/** 一个空的 Event 对象。用于事件派发中转使用。*/
static EMPTY: Event;
/** 定义 mousedown 事件对象的 type 属性值。*/
static MOUSE_DOWN: string;
/** 定义 mouseup 事件对象的 type 属性值。*/
static MOUSE_UP: string;
/** 定义 click 事件对象的 type 属性值。*/
static CLICK: string;
/** 定义 rightmousedown 事件对象的 type 属性值。*/
static RIGHT_MOUSE_DOWN: string;
/** 定义 rightmouseup 事件对象的 type 属性值。*/
static RIGHT_MOUSE_UP: string;
/** 定义 rightclick 事件对象的 type 属性值。*/
static RIGHT_CLICK: string;
/** 定义 mousemove 事件对象的 type 属性值。*/
static MOUSE_MOVE: string;
/** 定义 mouseover 事件对象的 type 属性值。*/
static MOUSE_OVER: string;
/** 定义 mouseout 事件对象的 type 属性值。*/
static MOUSE_OUT: string;
/** 定义 mousewheel 事件对象的 type 属性值。*/
static MOUSE_WHEEL: string;
/** 定义 mouseover 事件对象的 type 属性值。*/
static ROLL_OVER: string;
/** 定义 mouseout 事件对象的 type 属性值。*/
static ROLL_OUT: string;
/** 定义 doubleclick 事件对象的 type 属性值。*/
static DOUBLE_CLICK: string;
/** 定义 change 事件对象的 type 属性值。*/
static CHANGE: string;
/** 定义 changed 事件对象的 type 属性值。*/
static CHANGED: string;
/** 定义 resize 事件对象的 type 属性值。*/
static RESIZE: string;
/** 定义 added 事件对象的 type 属性值。*/
static ADDED: string;
/** 定义 removed 事件对象的 type 属性值。*/
static REMOVED: string;
/** 定义 display 事件对象的 type 属性值。*/
static DISPLAY: string;
/** 定义 undisplay 事件对象的 type 属性值。*/
static UNDISPLAY: string;
/** 定义 error 事件对象的 type 属性值。*/
static ERROR: string;
/** 定义 complete 事件对象的 type 属性值。*/
static COMPLETE: string;
/** 定义 loaded 事件对象的 type 属性值。*/
static LOADED: string;
/** 定义 loaded 事件对象的 type 属性值。*/
static READY: string;
/** 定义 progress 事件对象的 type 属性值。*/
static PROGRESS: string;
/** 定义 input 事件对象的 type 属性值。*/
static INPUT: string;
/** 定义 render 事件对象的 type 属性值。*/
static RENDER: string;
/** 定义 open 事件对象的 type 属性值。*/
static OPEN: string;
/** 定义 message 事件对象的 type 属性值。*/
static MESSAGE: string;
/** 定义 close 事件对象的 type 属性值。*/
static CLOSE: string;
/** 定义 keydown 事件对象的 type 属性值。*/
static KEY_DOWN: string;
/** 定义 keypress 事件对象的 type 属性值。*/
static KEY_PRESS: string;
/** 定义 keyup 事件对象的 type 属性值。*/
static KEY_UP: string;
/** 定义 frame 事件对象的 type 属性值。*/
static FRAME: string;
/** 定义 dragstart 事件对象的 type 属性值。*/
static DRAG_START: string;
/** 定义 dragmove 事件对象的 type 属性值。*/
static DRAG_MOVE: string;
/** 定义 dragend 事件对象的 type 属性值。*/
static DRAG_END: string;
/** 定义 enter 事件对象的 type 属性值。*/
static ENTER: string;
/** 定义 select 事件对象的 type 属性值。*/
static SELECT: string;
/** 定义 blur 事件对象的 type 属性值。*/
static BLUR: string;
/** 定义 focus 事件对象的 type 属性值。*/
static FOCUS: string;
/** 定义 visibilitychange 事件对象的 type 属性值。*/
static VISIBILITY_CHANGE: string;
/** 定义 focuschange 事件对象的 type 属性值。*/
static FOCUS_CHANGE: string;
/** 定义 played 事件对象的 type 属性值。*/
static PLAYED: string;
/** 定义 paused 事件对象的 type 属性值。*/
static PAUSED: string;
/** 定义 stopped 事件对象的 type 属性值。*/
static STOPPED: string;
/** 定义 start 事件对象的 type 属性值。*/
static START: string;
/** 定义 end 事件对象的 type 属性值。*/
static END: string;
/** 定义 componentadded 事件对象的 type 属性值。*/
static COMPONENT_ADDED: string;
/** 定义 componentremoved 事件对象的 type 属性值。*/
static COMPONENT_REMOVED: string;
/** 定义 released 事件对象的 type 属性值。*/
static RELEASED: string;
/** 定义 link 事件对象的 type 属性值。*/
static LINK: string;
/** 定义 label 事件对象的 type 属性值。*/
static LABEL: string;
/**浏览器全屏更改时触发*/
static FULL_SCREEN_CHANGE: string;
/**显卡设备丢失时触发*/
static DEVICE_LOST: string;
/**世界矩阵更新时触发。*/
static TRANSFORM_CHANGED: string;
/**更换动作时触发。*/
static ANIMATION_CHANGED: string;
/**拖尾渲染节点改变时触发。*/
static TRAIL_FILTER_CHANGE: string;
/**物理碰撞开始*/
static TRIGGER_ENTER: string;
/**物理碰撞持续*/
static TRIGGER_STAY: string;
/**物理碰撞结束*/
static TRIGGER_EXIT: string;
/** 事件类型。*/
type: string;
/** 原生浏览器事件。*/
nativeEvent: any;
/** 事件目标触发对象。*/
target: Sprite;
/** 事件当前冒泡对象。*/
currentTarget: Sprite;
_stoped: boolean;
/** 分配给触摸点的唯一标识号（作为 int）。*/
touchId: number;
/**键盘值*/
keyCode: number;
/**滚轮滑动增量*/
delta: number;
/**
* 设置事件数据。
* @param type 事件类型。
* @param currentTarget 事件目标触发对象。
* @param target 事件当前冒泡对象。
* @return 返回当前 Event 对象。
*/
setTo(type: string, currentTarget: Sprite, target: Sprite): Event;
/**
* 阻止对事件流中当前节点的后续节点中的所有事件侦听器进行处理。此方法不会影响当前节点 (currentTarget) 中的任何事件侦听器。
*/
stopPropagation(): void;
/**
* 触摸点列表。
*/
readonly touches: ArrayGraphics 类用于创建绘图显示对象。Graphics可以同时绘制多个位图或者矢量图，还可以结合save，restore，transform，scale，rotate，translate，alpha等指令对绘图效果进行变化。
* Graphics以命令流方式存储，可以通过cmds属性访问所有命令流。Graphics是比Sprite更轻量级的对象，合理使用能提高应用性能(比如把大量的节点绘图改为一个节点的Graphics命令集合，能减少大量节点创建消耗)。
* @see laya.display.Sprite#graphics
*/
class Graphics {
_sp: Sprite;
_one: any;
_render: Function;
protected _vectorgraphArray: Array销毁此对象。
*/ destroy(): void; /** *清空绘制命令。
* @param recoverCmds 是否回收绘图指令数组，设置为true，则对指令数组进行回收以节省内存开销，建议设置为true进行回收，但如果手动引用了数组，不建议回收 */ clear(recoverCmds?: boolean): void; /** * @private * 重绘此对象。 */ _repaint(): void; _isOnlyOne(): boolean; /** * @private * 命令流。存储了所有绘制命令。 */ cmds: ArrayBitmapFont 是位图字体类，用于定义位图字体信息。
* 字体制作及使用方法，请参考文章
* @see http://ldc2.layabox.com/doc/?nav=ch-js-1-2-5
*/
class BitmapFont {
/**当前位图字体字号，使用时，如果字号和设置不同，并且autoScaleSize=true，则按照设置字号比率进行缩放显示。*/
fontSize: number;
/**表示是否根据实际使用的字体大小缩放位图字体大小。*/
autoScaleSize: boolean;
/**字符间距（以像素为单位）。*/
letterSpacing: number;
/**
* 通过指定位图字体文件路径，加载位图字体文件，加载完成后会自动解析。
* @param path 位图字体文件的路径。
* @param complete 加载并解析完成的回调。
*/
loadFont(path: string, complete: Handler): void;
/**
* 解析字体文件。
* @param xml 字体文件XML。
* @param texture 字体的纹理。
*/
parseFont(xml: any, texture: Texture): void;
/**
* 解析字体文件。
* @param xml 字体文件XML。
* @param texture 字体的纹理。
*/
parseFont2(xml: any, texture: Texture): void;
/**
* 获取指定字符的字体纹理对象。
* @param char 字符。
* @return 指定的字体纹理对象。
*/
getCharTexture(char: string): Texture;
/**
* 销毁位图字体，调用Text.unregisterBitmapFont 时，默认会销毁。
*/
destroy(): void;
/**
* 设置空格的宽（如果字体库有空格，这里就可以不用设置了）。
* @param spaceWidth 宽度，单位为像素。
*/
setSpaceWidth(spaceWidth: number): void;
/**
* 获取指定字符的宽度。
* @param char 字符。
* @return 宽度。
*/
getCharWidth(char: string): number;
/**
* 获取指定文本内容的宽度。
* @param text 文本内容。
* @return 宽度。
*/
getTextWidth(text: string): number;
/**
* 获取最大字符宽度。
*/
getMaxWidth(): number;
/**
* 获取最大字符高度。
*/
getMaxHeight(): number;
/**
* @private
* 将指定的文本绘制到指定的显示对象上。
*/
_drawText(text: string, sprite: Sprite, drawX: number, drawY: number, align: string, width: number): void;
}
}
declare module laya.device.motion {
/**
* 保存旋转信息的类。请勿修改本类的属性。
* @author Survivor
*/
class RotationInfo {
/**
* * 指示设备是否可以提供绝对方位数据（指向地球坐标系），或者设备决定的任意坐标系。 * 关于坐标系参见https://developer.mozilla.org/en-US/docs/Web/Guide/Events/Orientation_and_motion_data_explained。 *
* 需要注意的是，IOS环境下，该值始终为false。即使如此，你依旧可以从alpha中取得正确的值。
*/
absolute: boolean;
/**
* Z轴旋转角度，其值范围从0至360。
* 若absolute为true或者在IOS中，alpha值是从北方到当前设备方向的角度值。
*/
alpha: number;
/**
* X轴旋转角度, 其值范围从-180至180。代表设备从前至后的运动。
*/
beta: number;
/**
* Y轴旋转角度，其值范围从-90至90。代表设备从左至右的运动。
*/
gamma: number;
/**
* 罗盘数据的精确度（角度）。仅IOS可用。
*/
compassAccuracy: number;
constructor();
}
}
declare module laya.device.motion {
/**
* 加速度x/y/z的单位均为m/s²。
* 在硬件（陀螺仪）不支持的情况下，alpha、beta和gamma值为null。
*
* @author Survivor
*/
class AccelerationInfo {
/**
* x轴上的加速度值。
*/
x: number;
/**
* y轴上的加速度值。
*/
y: number;
/**
* z轴上的加速度值。
*/
z: number;
constructor();
}
}
declare module laya.device.media {
import Handler = laya.utils.Handler;
/**
* Media用于捕捉摄像头和麦克风。可以捕捉任意之一，或者同时捕捉两者。getCamera前可以使用supported()检查当前浏览器是否支持。
* NOTE:
* 目前Media在移动平台只支持Android，不支持IOS。只可在FireFox完整地使用，Chrome测试时无法捕捉视频。
*/ class Media { constructor(); /** * 检查浏览器兼容性。 */ static supported(): boolean; /** * 获取用户媒体。 * @param options 简单的可选项可以使
* @param onSuccess 获取成功的处理器，唯一参数返回媒体的Blob地址，可以将其传给Video。
* @param onError 获取失败的处理器，唯一参数是Error。
*/
static getMedia(options: any, onSuccess: Handler, onError: Handler): void;
}
}
declare module laya.device.geolocation {
class GeolocationInfo {
setPosition(pos: any): void;
readonly latitude: number;
readonly longitude: number;
readonly altitude: number;
readonly accuracy: number;
readonly altitudeAccuracy: number;
readonly heading: number;
readonly speed: number;
readonly timestamp: number;
}
}
declare module laya.device.geolocation {
import Handler = laya.utils.Handler;
/**
* 使用前可用supported查看浏览器支持。
*/
class Geolocation {
/**
* 由于权限被拒绝造成的地理信息获取失败。
*/
static PERMISSION_DENIED: number;
/**
* 由于内部位置源返回了内部错误导致地理信息获取失败。
*/
static POSITION_UNAVAILABLE: number;
/**
* 信息获取所用时长超出timeout所设置时长。
*/
static TIMEOUT: number;
/**
* 是否支持。
*/
static supported: boolean;
/**
* 如果enableHighAccuracy为true，并且设备能够提供一个更精确的位置，则会获取最佳可能的结果。
* 请注意,这可能会导致较慢的响应时间或增加电量消耗（如使用GPS）。
* 另一方面，如果设置为false，将会得到更快速的响应和更少的电量消耗。
* 默认值为false。
*/
static enableHighAccuracy: boolean;
static timeout: number;
/**
* 表示可被返回的缓存位置信息的最大时限。
* 如果设置为0，意味着设备不使用缓存位置，并且尝试获取实时位置。
* 如果设置为Infinity，设备必须返回缓存位置而无论其时限。
*/
static maximumAge: number;
constructor();
/**
* 获取设备当前位置。
* @param onSuccess 带有唯一Position参数的回调处理器。
* @param onError 可选的。带有错误信息的回调处理器。错误代码为Geolocation.PERMISSION_DENIED、Geolocation.POSITION_UNAVAILABLE和Geolocation.TIMEOUT之一。
*/
static getCurrentPosition(onSuccess: Handler, onError?: Handler): void;
/**
* 监视设备当前位置。回调处理器在设备位置改变时被执行。
* @param onSuccess 带有唯一Position参数的回调处理器。
* @param onError 可选的。带有错误信息的回调处理器。错误代码为Geolocation.PERMISSION_DENIED、Geolocation.POSITION_UNAVAILABLE和Geolocation.TIMEOUT之一。
*/
static watchPosition(onSuccess: Handler, onError: Handler): number;
/**
* 移除watchPosition安装的指定处理器。
* @param id
*/
static clearWatch(id: number): void;
}
}
declare module laya.d3.utils {
import RenderableSprite3D = laya.d3.core.RenderableSprite3D;
import Scene3D = laya.d3.core.scene.Scene3D;
import Matrix4x4 = laya.d3.math.Matrix4x4;
import Quaternion = laya.d3.math.Quaternion;
import Vector3 = laya.d3.math.Vector3;
import Vector4 = laya.d3.math.Vector4;
import Node = laya.display.Node;
import Texture2D = laya.webgl.resource.Texture2D;
/**
* Utils3D 类用于创建3D工具。
*/
class Utils3D {
/**
* @private
*/
static _convertToLayaVec3(bVector: any, out: Vector3, inverseX: boolean): void;
/**
* @private
*/
static _convertToBulletVec3(lVector: Vector3, out: any, inverseX: boolean): void;
/**
* @private
*/
static _compIdToNode: any;
/**
* @private
*/
static _createSceneByJsonForMaker(nodeData: any, outBatchSprites: Array, initTool?: any): Scene3D;
/**
* @private
*/
static _createNodeByJsonForMaker(nodeData: any, outBatchSprites: Array, initTool?: any): Node;
/**
* @private
*/
static _addComponentByJsonForMaker(nodeData: any, outBatchSprites: Array, initTool?: any): void;
/**
* @private
*/
static _createNodeByJson(nodeData: any, outBatchSprites: Array