2019年5月

微信setLocalStorage存数组 不能只改单个索引的值 需要重新给  数组赋值一个新的数组 数组复制可以使用concat

Laya.loader  提供附加类型 可以正确解析 相关类型  如 atlas,json

wx.setUserCloudStorage

wx.setUserCloudStorage(
    KVDataList: [{ key: "key1", value: "value1" }],
    success: (res)=>{
        console.log("success");
        console.log(res);
    },  fail: (res) => {
        console.log("fail");
        console.log(res);
    }, complete: (res) => {
        console.log("complete");
        console.log(res);
    }
});

成功返回:

　　开发工具环境下　success complete　{errMsg: "setUserCloudStorage:ok"}

　　Ios, Android　success complete　　{errMsg: "setUserCloudStorage:ok"}

断网返回:

　　开发工具环境下 fail complete　　{errMsg: "setUserCloudStorage:ok"}

　　Android  fail complete　　{errMsg: "setUserCloudStorage:fail:"}　　

　　Ios  fail complete　　{errMsg: "setUserCloudStorage:fail data no response", err_code: "0"}

　　开发工具环境下, 下次联网时, 会继续发送上次断网时的请求. 手机环境下不会

wx.setKeepScreenOn

Axure RP 8

Licensee：zdfans

Key：fZw2VoYzXakllUuLVdTH13QYWnjD6NZrxgubQkaRyxD5+HNMqdr+WZKkaa6IoE5N

Cocos Creator 

　　版本信息: https://www.cocos.com/creator

　　用户手册 https://docs.cocos.com/creator/manual/zh/

　　API参考 https://docs.cocos.com/creator/api/zh/

Cocos2dx 版本信息

　　版本信息 https://www.cocos.com/cocos2dx

　　用户手册 https://docs.cocos.com/cocos2d-x/manual/zh/

　　API参考 https://docs.cocos2d-x.org/api-ref/index.html

LayaNative release-v2.1.0

Chrome浏览器调试App

chrome-devtools://devtools/bundled/inspector.html?experiments=true&v8only=true&ws=192.168.1.102:5959

app构建 单机包 要先发布  在资源路径里选择这个路径

APK-update https://ldc2.layabox.com/doc/?nav=zh-ts-6-2-7

<activity android:screenOrientation="sensorPortrait/portrait"

(function(exports,global,require,__dirname,__filename){"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
window._conchInfo = { version: '2.1.3.1' };
var _inline = !conchConfig.localizable;
console.log('======================================================  ');
console.log('             LAYA CONCH            ');
console.log('     runtimeversion:' + conchConfig.getRuntimeVersion());
console.log('          jsversion:' + window._conchInfo.version);
console.log('             isplug:' + conchConfig.getIsPlug());
console.log('======================================================');
function log(m) {
    console.log(m);
}
if (conchConfig.getOS() == "Conch-ios") {
    require('promise');
}
function loadLib(url) {
    var script = document.createElement("script");
    if (url.indexOf("laya.physics3D.js") >= 0) {
        url = url.replace("laya.physics3D.js", "laya.physics3D.runtime.js");
    }
    script.src = url;
    script.onerror = function () {
        if (window["onLayaInitError"]) {
            window["onLayaInitError"]("Load script error");
        }
    };
    document.head.appendChild(script);
}
window['loadLib'] = loadLib;
const asyncs = require("async");
function initFreeType() {
    return __awaiter(this, void 0, void 0, function* () {
        var sOS = conchConfig.getOS();
        var bRet = false;
        var sTempFontPath = conch.getCachePath() + "/runtimeFont/";
        if (!fs_exists(sTempFontPath)) {
            fs_mkdir(sTempFontPath);
        }
        sTempFontPath += "layabox.ttf";
        bRet = conchTextCanvas.initFreeTypeDefaultFontFromFile(sTempFontPath);
        if (bRet == false) {
            var assetFontData = conch.readFileFromAsset('font/layabox.ttf', 'raw');
            if (assetFontData) {
                fs_writeFileSync(sTempFontPath, assetFontData);
                bRet = conchTextCanvas.initFreeTypeDefaultFontFromFile(sTempFontPath);
            }
        }
        if (!bRet) {
            if (sOS == "Conch-window") {
                bRet = conchTextCanvas.initFreeTypeDefaultFontFromFile("C:/Windows/Fonts/simhei.ttf");
            }
            else if (sOS == "Conch-android") {
                var fSystemVersion = navigator.sv;
                if (fSystemVersion >= 2.0 && fSystemVersion < 5.0) {
                    bRet = conchTextCanvas.initFreeTypeDefaultFontFromFile("/system/fonts/DFHEIA5A.ttf");
                    if (bRet == false) {
                        bRet = conchTextCanvas.initFreeTypeDefaultFontFromFile("/system/fonts/DroidSansFallback.ttf");
                    }
                }
                else if (fSystemVersion >= 5.0 && fSystemVersion < 6.0) {
                    var vDefaultStrings = [];
                    vDefaultStrings.push("/system/fonts/NotoSansHans-Regular.otf");
                    vDefaultStrings.push("/system/fonts/Roboto-Regular.ttf");
                    bRet = conchTextCanvas.initFreeTypeDefaultFontFromFile(vDefaultStrings.join('|'));
                }
                else if (fSystemVersion >= 6.0 && fSystemVersion < 7.0) {
                    var vDefaultStrings = [];
                    vDefaultStrings.push("/system/fonts/NotoSansSC-Regular.otf");
                    vDefaultStrings.push("/system/fonts/Roboto-Regular.ttf");
                    bRet = conchTextCanvas.initFreeTypeDefaultFontFromFile(vDefaultStrings.join('|'));
                }
                else if (fSystemVersion >= 7.0 && fSystemVersion < 8.0) {
                    bRet = false;
                }
            }
            else if (sOS == "Conch-ios") {
                bRet = conchTextCanvas.initFreeTypeDefaultFontFromFile("");
            }
        }
        if (bRet == false) {
            log('字体初始化失败，从网络下载字体...');
            var data = (yield asyncs.downloadSync(location.fullpath + '/font/simhei.ttf', true, null));
            if (!data) {
                data = (yield asyncs.downloadSync('http://runtime.layabox.com/font/simhei.ttf', true, null));
            }
            if (!data) {
                alert('下载字体失败。 ');
                return;
            }
            fs_writeFileSync(sTempFontPath, data);
            bRet = conchTextCanvas.initFreeTypeDefaultFontFromFile(sTempFontPath);
        }
        if (!bRet) {
            log('字体初始化失败。');
        }
    });
}
function setOrientation(s) {
    var nameToVal = {
        landscape: 0, portrait: 1, user: 2, behind: 3, sensor: 4, nosensor: 5, sensor_landscape: 6, sensorLandscape: 6,
        sensor_portrait: 7, sensorPortrait: 7, reverse_landscape: 8, reverseLandscape: 8, reverse_portrait: 9, reversePortrait: 9, full_sensor: 10, fullSensor: 10,
    };
    var nOri = (function (name) {
        try {
            var n = nameToVal[name];
            return n || 0;
        }
        catch (e) {
            return 0;
        }
    })(s);
    conchConfig.setScreenOrientation(nOri);
    ;
}
Object.defineProperty(window, 'screenOrientation', {
    get: function () {
        return window.___screenOri;
    },
    set: function (v) {
        window.___screenOri = v;
        setOrientation(v);
    }
});
function startApp(data) {
    var jsonobj = null;
    try {
        jsonobj = JSON.parse(data);
    }
    catch (e) {
        console.log("Error:start page parse error! 
 " + data);
        return;
    }
    jsonobj.scripts.forEach((v) => {
        var t = document.createElement("script");
        t["src"] = v;
        t.onerror = function () {
            if (window["onLayaInitError"]) {
                window["onLayaInitError"]("Load script error");
            }
        };
        document.head.appendChild(t);
    });
    if (jsonobj.screenOrientation)
        setOrientation(jsonobj.screenOrientation);
    else if (jsonobj.screenorientation)
        setOrientation(jsonobj.screenorientation);
    else
        setOrientation("sensor_landscape");
    document.createElement("script").text = "window.onload&&window.onload()";
}
function loadApp(url) {
    return __awaiter(this, void 0, void 0, function* () {
        var urllen = url.length;
        if (urllen < 2)
            return;
        url = url.trim();
        if (url.substring(urllen - 1) === '/')
            url = url + 'runtime.json';
        url = url.replace(/.html$/i, '.json');
        if (url.indexOf('http://stand.alone.version') == 0)
            _inline = false;
        if (!_inline) {
            url = 'http://stand.alone.version/index.js';
        }
        console.log("loadApp:" + url);
        if (history.length <= 0) {
            history._push(url);
        }
        if (url.length < 2)
            return;
        location.setHref(url);
        var urlpath = location.fullpath + '/';
        var cache = window.appcache = new AppCache(urlpath);
        document.loadCookie();
        yield initFreeType();
        try {
            require("config");
        }
        catch (e) {
        }
        var isDccOk = true;
        function updateDcc() {
            return __awaiter(this, void 0, void 0, function* () {
                cache.setResourceID('appurl', urlpath);
                var curassets = cache.getResourceID('netassetsid');
                var assetsidStr = (yield asyncs.downloadSync(urlpath + 'update/assetsid.txt?rand=' + Math.random() * Date.now(), false, null));
                console.log("assetsid old:" + curassets + "  new:" + assetsidStr);
                if (!assetsidStr) {
                    if (curassets && curassets != "") {
                        if (window["onLayaInitError"]) {
                            isDccOk = false;
                            window["onLayaInitError"]("Update DCC get assetsid error");
                        }
                    }
                }
                else {
                    if (curassets != assetsidStr) {
                        log('need update;');
                        var txtdcc = '';
                        var bindcc = yield asyncs.downloadSync(urlpath + 'update/filetable.bin?' + assetsidStr, true, null);
                        if (!bindcc || !(bindcc instanceof ArrayBuffer)) {
                            txtdcc = (yield asyncs.downloadSync(urlpath + 'update/filetable.txt?' + assetsidStr, false, null));
                        }
                        else {
                            if (bindcc.byteLength % 8 != 0) {
                                log('下载的的filetable.bin的长度不对。是不是错了。');
                            }
                            else {
                                var v = new Uint32Array(bindcc);
                                if (v[0] != 0xffeeddcc || v[1] != 1) {
                                    log('dcc.bin file err!');
                                }
                                else {
                                    if (v[2] == 0x00ffffff) {
                                        var stp = (4 + 8) / 2;
                                        var md5int = v.slice(4, 12);
                                        var md5char = new Uint8Array(md5int.buffer);
                                        var so = String.fromCharCode.apply(null, md5char);
                                        console.log('--------------------------------------------');
                                        console.log('so=' + so);
                                        console.log('netid=' + assetsidStr);
                                        if (so == assetsidStr) {
                                            for (var ii = stp, isz = v.length / 2; ii < isz; ii++)
                                                txtdcc += v[ii * 2].toString(16) + ' ' + v[ii * 2 + 1].toString(16) + '
';
                                        }
                                    }
                                    else {
                                        console.log('----------------old format');
                                        for (var ii = 1, isz = v.length / 2; ii < isz; ii++)
                                            txtdcc += v[ii * 2].toString(16) + ' ' + v[ii * 2 + 1].toString(16) + '
';
                                    }
                                }
                            }
                        }
                        if (txtdcc && txtdcc.length > 0) {
                            cache.saveFileTable(txtdcc);
                            window.appcache = cache = new AppCache(urlpath);
                            cache.setResourceID('netassetsid', assetsidStr);
                        }
                        else {
                            if (window["onLayaInitError"]) {
                                isDccOk = false;
                                window["onLayaInitError"]("Update DCC get filetable error");
                            }
                        }
                    }
                }
            });
        }
        if (_inline) {
            yield updateDcc();
            if (!isDccOk) {
                console.log("init dcc fail");
                return;
            }
        }
        var data = yield asyncs.loadText(url);
        for (var n = 0; n < 3 && !data; n++) {
            data = yield asyncs.loadText(url);
        }
        if (!data) {
            if (window["loadingView"]) {
                window["loadingView"].setFontColor("#FF0000");
                window["loadingView"].setTips(['网络异常，请检查您的网络或与开发商联系。']);
            }
            data = cache.loadCachedURL(url);
            if (!data || data.length <= 0)
                if (window["onLayaInitError"]) {
                    window["onLayaInitError"]("Load start url error");
                }
            return;
        }
        console.log("");
        var qpos = url.indexOf('?');
        if (qpos < 0)
            qpos = url.length;
        if (url.substr(qpos - 3, 3) === '.js') {
            window.eval(data + `
        //@ sourceURL=${url}
        `);
            document.createElement("script").text = "window.onload&&window.onload()";
        }
        else {
            startApp(data);
        }
        if (window["loadingView"] && window["loadingView"].loadingAutoClose) {
            window["loadingView"].hideLoadingView();
        }
    });
}
window.document.addEventListener('keydown', function (e) {
    switch (e.keyCode) {
        case 116:
            reloadJS(true);
            break;
        case 117:
            history.back();
            break;
        case 118:
            break;
        case 119:
            break;
        case 120:
            gc();
            break;
    }
});
window.loadConchUrl = loadApp;
window['updateByZip'] = function (url, onEvent, onEnd) {
    let cachePath = conch.getCachePath();
    let localfile = cachePath + url.substr(url.lastIndexOf('/'));
    downloadBigFile(url, localfile, (total, now, speed) => {
        onEvent('downloading', Math.floor((now / total) * 100), null);
        return false;
    }, (curlret, httpret) => {
        if (curlret != 0 || httpret < 200 || httpret >= 300) {
            onEvent('downloadError');
        }
        else {
            onEvent('downloadOK');
            let zip = new ZipFile();
            if (zip.setSrc(localfile)) {
                zip.forEach((id, name, dir, sz) => {
                    if (!dir) {
                        let buf = zip.readFile(id);
                        let fid = window.appcache.hashstr('/' + name);
                        if (window.appcache.updateFile(fid, 0, buf, false)) {
                            onEvent('updating', null, name);
                        }
                        else {
                            onEvent("updateError", null, name);
                        }
                    }
                });
                zip.close();
                if (onEnd)
                    onEnd(localfile);
            }
            else {
                console.log("set zip src error!");
                onEvent('unknownError');
            }
        }
    }, 10, 100000000);
};
loadApp(conch.presetUrl || "http://nativetest.layabox.com/layaplayer2.0.1/index.js");
;
return exports;})

(function(exports,global,require,__dirname,__filename){class loadingView
{
    constructor() 
    {
        this.sOS = conchConfig.getOS();
        if (this.sOS == "Conch-ios")
        {
            this.bridge = PlatformClass.createClass("JSBridge");
        }
        else if (this.sOS == "Conch-android")
        {
            this.bridge = PlatformClass.createClass("layaair.game.browser.JSBridge");
        }
    }
    set loadingAutoClose(value) 
    {
        this._loadingAutoClose = value;
    }
    get loadingAutoClose()
    {
        return this._loadingAutoClose;
    }
    set showTextInfo(value) 
    {
        this._showTextInfo = value;
        if(this.bridge)
        {
            if (this.sOS == "Conch-ios")
            {
                this.bridge.call("showTextInfo:",value);
            }
            else if(this.sOS == "Conch-android")
            {
                this.bridge.call("showTextInfo",value);
            }
        }
    }
    get showTextInfo()
    {
        return this._showTextInfo;
    }
    bgColor(value)
    {
        if(this.bridge)
        {
            if (this.sOS == "Conch-ios")
            {
                this.bridge.call("bgColor:",value);
            }
            else if(this.sOS == "Conch-android")
            {
                this.bridge.call("bgColor",value);
            }
        }
    }
    setFontColor(value)
    {
        if(this.bridge)
        {
            if (this.sOS == "Conch-ios")
            {
                this.bridge.call("setFontColor:",value);
            }
            else if(this.sOS == "Conch-android")
            {
                this.bridge.call("setFontColor",value);
            }
        }
    }
    setTips(value)
    {
        if(this.bridge)
        {
            if (this.sOS == "Conch-ios")
            {
                this.bridge.call("setTips:",value);
            }
            else if(this.sOS == "Conch-android")
            {
                this.bridge.call("setTips",value);
            }
        }
    }
    loading(value)
    {
        if(this.bridge)
        {
            if (this.sOS == "Conch-ios")
            {
                this.bridge.call("loading:",value);
            }
            else if(this.sOS == "Conch-android")
            {
                this.bridge.call("loading",value);
            }
        }
    }
    hideLoadingView()
    {
        this.bridge.call("hideSplash");
    }
}
window.loadingView = new loadingView();
if(window.loadingView)
{
    window.loadingView.loadingAutoClose=true;//true代表当动画播放完毕，自动进入游戏。false为开发者手动控制
    window.loadingView.bgColor("#000000");//设置背景颜色
    window.loadingView.setFontColor("#ffffff");//设置字体颜色
    window.loadingView.setTips(["新世界的大门即将打开","敌军还有30秒抵达战场","妈妈说，心急吃不了热豆腐"]);//设置tips数组，会随机出现
}
window.onLayaInitError=function(e)
{
    console.log("onLayaInitError error=" + e);
    alert("加载游戏失败，可能由于您的网络不稳定，请退出重进");
};
return exports;})

(function(exports,global,require,__dirname,__filename){function async(gen) {
    "use strict";
    var log = console.log;
    var g = gen();
    let nr = null;
    function cast(value) {
        return value instanceof Promise && value.constructor === Promise ? value : new Promise(function () { });
    }
    function thennext(v) {
        nr = g.next(v);
        var p = nr.value;
        nr.done ? (0) : cast(p).then(thennext, function (e) { console.log('async reject:' + e); thennext(null); }).catch(function (r) { 
            alert(`${r}
                ${r.stack}`); 
        });
    }
    thennext(void 0);
}
exports.async = async;
//延时
function delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}
exports.delay = delay;
//下载图片
function loadImage(src) {
    return new Promise((resolve, reject) => {
        var img = new Image();
        img.src = src;
        img.onload = () => { resolve(img); };
        img.onerror = () => {
            //reject('file load err:' + src);
            resolve(null);
        };
    });
}
exports.loadImage = loadImage;
//下载文本文件
function loadText(src) {
    return new Promise((resolve, reject) => {
        var xhr = new XMLHttpRequest();
        xhr.open('GET', src);
        xhr.onload = () => { resolve(xhr.responseText); };
        xhr.onerror = (e) => { 
            //if (reject)
            //    reject('download xhr error:' + src + '. e=' + e); 
            resolve(null);
        };
        xhr.send();
    });
}
exports.loadText = loadText;
function downloadSync(url, bin, onprog) {
    return new Promise(function (resolve, reject) {
        var f = new conch_File(url);
        var fr = new conch_FileReader();
        fr.setIgnoreError(true);
        fr.onload = () => {
            console.log('download end');
            resolve(fr.result);
        };
        fr.onerror = (e) => { console.log('onerror ' + e); 
            //if (reject)
            //    reject(e); 
            resolve(null);
        };
        fr.onprogress = onprog;
        if (bin)
            fr.readAsArrayBuffer(f);
        else
            fr.readAsText(f);
    });
}
exports.downloadSync = downloadSync;
//直到func返回true,tm是间隔
function check(func, tm) {
    return new Promise(function (resolve, reject) {
        function checkFunc() {
            if (func()) {
                clearInterval(chker);
                resolve(1);
            }
        }
        var chker = setInterval(checkFunc, tm);
    });
}
function regGlobal(window) {
}
exports.regGlobal = regGlobal;
window['async'] = async;
window['delay'] = delay;
window['downloadSync'] = downloadSync;
window['asynccheck'] = check;
;
return exports;})

(function(window){
'use strict'
'use strict';
conch["platCallBack"] = function (ret) {
    var objid, m, rs, c, rJSON;
    if (ret == null)
        return;
    objid = ret.objId;
    m = ret.mName;
    c = ret.cName;
    rs = ret.v;
    var platC;
    if (objid != -1) {
        platC = PlatformObj.objMap[objid];
    }
    else {
        platC = PlatformClass.clsMap[c];
    }
    if (platC) {
        var callback = platC.callBackList[m];
        callback && callback(rs);
    }
};
class PlatformBase {
    call(methodName, p1, p2, p3, p4, p5, p6, p7, p8, p9) {
        var a = Array.prototype.slice.call(arguments);
        a.shift();
        try {
            var rs = JSON.parse(conch.callMethod(this.objid, true, this.className, methodName, JSON.stringify(a)) || "{}");
            return rs.v;
        }
        catch (e) {
            return null;
        }
    }
    callWithBack(callback, methodName, p1, p2, p3, p4, p5, p6, p7, p8, p9) {
        this.callBackList[methodName] = callback;
        var a = Array.prototype.slice.call(arguments);
        a.splice(0, 2);
        try {
            var rs = JSON.parse(conch.callMethod(this.objid, false, this.className, methodName, JSON.stringify(a)) || "{}");
            return rs.v;
        }
        catch (e) {
            return null;
        }
    }
}
class PlatformClass extends PlatformBase {
    constructor(clsName) {
        super();
        this.objid = -1;
        this.className = clsName;
        this.callBackList = {};
        PlatformClass.clsMap[clsName] = this;
    }
    static createClass(clsName) {
        return PlatformClass.clsMap[clsName] || new PlatformClass(clsName);
    }
    newObject(p1, p2, p3, p4, p5, p6, p7, p8, p9) {
        var a = Array.prototype.slice.call(arguments);
        a.splice(0, 0, "<init>");
        var rs = new PlatformObj(this);
        rs.init.apply(rs, a);
        return rs;
    }
}
PlatformClass.clsMap = {};
class PlatformObj extends PlatformBase {
    constructor(cls) {
        super();
        this.cls = cls;
        this.className = cls.className;
        this.callBackList = {};
    }
    init() {
        this.objid = PlatformObj.objNum++;
        this.call.apply(this, arguments) || -1;
        PlatformObj.objMap[this.objid] = this;
    }
}
PlatformObj.objMap = {};
PlatformObj.objNum = 0;
window["PlatformClass"] = PlatformClass;
window["PlatformObj"] = PlatformObj;
function loadRawCache(cache, relUrl, encode) {
    var cpath = cache.getCachePath();
    var relFile = relUrl;
    var id = new Uint32Array([cache.hashstr(relFile)])[0].toString(16);
    var fn = cpath + '/files/' + id.substr(0, 2) + '/' + id.substr(2);
    var ab = fs_readFileSync(fn);
    if (ab) {
        var content = new Uint8Array(ab, 48);
        if (encode === 'utf8') {
            var strCont = String.fromCharCode.apply(null, content);
            return strCont;
        }
        else
            return content.buffer;
    }
    return null;
}
class conchFloatArrayKeyframe {
    constructor() {
        this._nativeObj = new _conchFloatArrayKeyframe();
    }
    set time(value) {
        this._nativeObj.setTime(value);
    }
    get time() {
        return this._nativeObj.getTime();
    }
    set data(value) {
        this._data = value;
        this._nativeObj.setData(value);
    }
    get data() {
        return this._data;
    }
    set inTangent(value) {
        this._inTangent = value;
        this._nativeObj.setInTangent(this._inTangent);
    }
    get inTangent() {
        return this._inTangent;
    }
    set outTangent(value) {
        this._outTangent = value;
        this._nativeObj.setOutTangent(this._outTangent);
    }
    get outTangent() {
        return this._outTangent;
    }
    set value(v) {
        this._value = v;
        this._nativeObj.setValue(this._value);
    }
    get value() {
        return this._value;
    }
    clone() {
        let pDestObj = new conchFloatArrayKeyframe();
        this.cloneTo(pDestObj);
        return pDestObj;
    }
    cloneTo(destObj) {
        destObj.inTangent = this._inTangent.slice();
        destObj.outTangent = this._outTangent.slice();
        destObj.value = this._value.slice();
        destObj.data = this._data.slice();
    }
}
window["conchFloatArrayKeyframe"] = conchFloatArrayKeyframe;
class conchKeyframeNode {
    constructor() {
        this._keyFrameArray = [];
        this._type = 0;
        this._setKeyframeByIndex = function (index, keyframe) {
            this._keyFrameArray[index] = keyframe;
            if (keyframe instanceof (conchFloatArrayKeyframe)) {
                this._nativeObj._setKeyframeByIndex1(index, keyframe._nativeObj);
            }
            else {
                this._nativeObj._setKeyframeByIndex0(index, keyframe);
            }
        };
        this._nativeObj = new _conchKeyframeNode();
    }
    set data(value) {
        this._data = value;
        this._nativeObj.setFloat32ArrayData(this._data.elements);
    }
    get data() {
        return this._type == 0 ? this._nativeObj.getFloatData() : this._data;
    }
    get indexInList() {
        return this._nativeObj._indexInList;
    }
    set indexInList(value) {
        this._nativeObj._indexInList = value;
    }
    get type() {
        return this._type;
    }
    set type(type) {
        this._type = type;
        this._nativeObj.type = type;
    }
    get fullPath() {
        return this._nativeObj.fullPath;
    }
    set fullPath(path) {
        this._nativeObj.fullPath = path;
    }
    get propertyOwner() {
        return this._nativeObj.propertyOwner;
    }
    set propertyOwner(value) {
        this._nativeObj.propertyOwner = value;
    }
    get ownerPathCount() {
        return this._nativeObj.ownerPathCount;
    }
    set ownerPathCount(value) {
        this._nativeObj.ownerPathCount = value;
    }
    get propertyCount() {
        return this._nativeObj.propertyCount;
    }
    set propertyCount(value) {
        this._nativeObj.propertyCount = value;
    }
    get keyFramesCount() {
        return this._keyFrameArray.length;
    }
    set keyFramesCount(value) {
        this._keyFrameArray.length = value;
        this._nativeObj.keyFramesCount = value;
    }
    getOwnerPathCount() {
        return this._nativeObj.getOwnerPathCount();
    }
    _setOwnerPathCount(value) {
        this._nativeObj._setOwnerPathCount(value);
    }
    getPropertyCount() {
        return this._nativeObj.getPropertyCount();
    }
    _setPropertyCount(value) {
        this._nativeObj._setPropertyCount(value);
    }
    getKeyFramesCount() {
        return this._keyFrameArray.length;
    }
    _setKeyframeCount(value) {
        this._keyFrameArray.length = value;
        this._nativeObj._setKeyframeCount(value);
    }
    getOwnerPathByIndex(index) {
        return this._nativeObj.getOwnerPathByIndex(index);
    }
    _setOwnerPathByIndex(index, value) {
        this._nativeObj._setOwnerPathByIndex(index, value);
    }
    getPropertyByIndex(index) {
        return this._nativeObj.getPropertyByIndex(index);
    }
    _setPropertyByIndex(index, value) {
        this._nativeObj._setPropertyByIndex(index, value);
    }
    getKeyframeByIndex(index) {
        return this._nativeObj.getKeyframeByIndex(index);
    }
    _joinOwnerPath(sep) {
        return this._nativeObj._joinOwnerPath(sep);
    }
    _joinProperty(sep) {
        return this._nativeObj._joinProperty(sep);
    }
}
window["conchKeyframeNode"] = conchKeyframeNode;
class conchKeyframeNodeList {
    constructor() {
        this._nodes = [];
        this._nativeObj = new _conchKeyframeNodeList();
    }
    set count(value) {
        this._nodes.length = value;
        this._nativeObj.setCount(value);
    }
    get count() {
        return this._nodes.length;
    }
    getNodeByIndex(index) {
        return this._nodes[index];
    }
    setNodeByIndex(index, node) {
        this._nodes[index] = node;
        this._nativeObj.setNodeByIndex(index, node._nativeObj);
    }
}
window["conchKeyframeNodeList"] = conchKeyframeNodeList;
class textBitmap {
    constructor(obj) {
        this._nativeObj = obj;
        this._data = null;
    }
    get width() {
        return this._nativeObj.width;
    }
    get height() {
        return this._nativeObj.height;
    }
    get data() {
        return this._data;
    }
    set data(value) {
        this._data = value;
    }
}
window["textBitmap"] = textBitmap;
conchTextCanvas["getTextBitmapData"] = function (sText, nColor, nBorderSize, nBorderColor) {
    var nativeObj = this._getTextBitmapData(sText, nColor, nBorderSize, nBorderColor);
    var pTextBitmap = new textBitmap(nativeObj);
    pTextBitmap.data = nativeObj.data;
    return pTextBitmap;
};
class WindowBase64 {
    constructor() {
        this.atob = function () { return null; };
        this.btoa = function () { return null; };
    }
}
window["WindowBase64"] = WindowBase64;
function _process() {
    this.pid = 0;
    this.cwd = function () {
        return 'd:/temp';
    };
    this.mainModule = 'index.js';
    this.argv = ['conch.exe', 'index.js'];
    this.version = '1.3.1';
    this._require = function (f) { console.log('process require(' + f + ')'); return function nop() { }; };
    this._debugObject = {};
}
window.process = new _process();
class SubtleCrypto {
    decrypt(algorithm, key, data) {
    }
    deriveBits(algorithm, baseKey, length) {
    }
    deriveKey(algorithm, baseKey, derivedKeyType, extractable, keyUsages) {
    }
    digest(algorithm, data) {
    }
    encrypt(algorithm, key, data) {
    }
    exportKey(format, key) {
    }
    generateKey(algorithm, extractable, keyUsages) {
    }
    importKey(format, keyData, algorithm, extractable, keyUsages) {
    }
    sign(algorithm, key, data) {
    }
    unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages) {
    }
    verify(algorithm, key, signature, data) {
    }
    wrapKey(format, key, wrappingKey, wrapAlgorithm) {
    }
}
class Crypto {
    constructor() {
        this.subtle = new SubtleCrypto();
    }
    getRandomValues(array) {
        return null;
    }
}
var LogLevel;
(function (LogLevel) {
    LogLevel[LogLevel["Warn"] = 0] = "Warn";
    LogLevel[LogLevel["Error"] = 1] = "Error";
    LogLevel[LogLevel["Debug"] = 2] = "Debug";
    LogLevel[LogLevel["Info"] = 3] = "Info";
    LogLevel[LogLevel["Runtime"] = 4] = "Runtime";
})(LogLevel || (LogLevel = {}));
class Console {
    constructor() {
    }
    assert(test, message) {
        var c = _console;
        if (test) {
            c.log(3, message);
        }
        ;
    }
    clear() { }
    count(countTitle) {
    }
    debug(message) {
        var c = _console;
        c.log(LogLevel.Debug, message);
    }
    dir(value) {
    }
    dirxml(value) {
    }
    error(message) {
        var c = _console;
        c.log(LogLevel.Error, message);
    }
    group(groupTitle) { }
    groupCollapsed(groupTitle) { }
    groupEnd() { }
    info(message) {
        var c = _console;
        c.log(LogLevel.Info, message);
    }
    log(message) {
        var c = _console;
        c.log(LogLevel.Info, message);
    }
    profile(reportName) {
    }
    profileEnd() { }
    select(element) { }
    time(timerName) { }
    timeEnd(timerName) { }
    trace(message) {
    }
    warn(message) {
        var c = _console;
        c.log(LogLevel.Warn, message);
    }
}
class GlobalEventHandlers {
    constructor() {
    }
    onpointercancel(ev) {
        return null;
    }
    onpointerdown(ev) {
        return null;
    }
    onpointerenter(ev) {
        return null;
    }
    onpointerleave(ev) {
        return null;
    }
    onpointermove(ev) {
        return null;
    }
    onpointerout(ev) {
        return null;
    }
    onpointerover(ev) {
        return null;
    }
    onpointerup(ev) {
        return null;
    }
}
class ErrorEvent {
    constructor() {
    }
    initErrorEvent(typeArg, canBubbleArg, cancelableArg, messageArg, filenameArg, linenoArg) {
    }
}
class Event {
    constructor(type, eventInitDict) {
        this._propagationStopped = false;
        this.type = type;
        this.timeStamp = Date.now();
        this.bubbles = false;
        this.cancelable = false;
        this.eventPhase = Event.AT_TARGET;
        if (eventInitDict) {
            this.bubbles = eventInitDict.bubbles;
            this.cancelable = eventInitDict.cancelable;
        }
    }
    initEvent(eventTypeArg, canBubbleArg, cancelableArg) {
        this.type = eventTypeArg;
        this.bubbles = canBubbleArg;
        this.cancelable = cancelableArg;
    }
    preventDefault() {
        if (!this.cancelable)
            return;
        this.defaultPrevented = true;
    }
    stopImmediatePropagation() {
    }
    stopPropagation() {
        this._propagationStopped = true;
    }
}
Event.AT_TARGET = 2;
Event.BUBBLING_PHASE = 3;
Event.CAPTURING_PHASE = 1;
var _lbEvent = window['Event'] = Event;
var _lbMap = Map;
class EventTarget {
    constructor() {
        this._evtMaps = new _lbMap();
        this.removeEventListener = (type, listener, useCapture) => {
            var listeners = this._evtMaps.get(type);
            if (!listeners)
                return;
            var newlisteners = [];
            for (var i = 0, sz = listeners.length; i < sz; i++) {
                if (listeners[i].listener != listener || listeners[i].useCapture != useCapture) {
                    newlisteners.push(listeners[i]);
                }
            }
            this._evtMaps.set(type, newlisteners);
        };
        this.dispatchEvent = this._dispatchEvent.bind(this);
        this.fireEventListeners = this._fireEventListeners.bind(this);
    }
    addEventListener(type, listener, useCapture) {
        var listeners = this._evtMaps.get(type) || [];
        listeners.push({ obj: this, listener: listener, useCapture: useCapture });
        this._evtMaps.set(type, listeners);
    }
    _dispatchEvent(evt) {
        this.fireEventListeners(evt);
        return !evt.defaultPrevented;
    }
    _fireEventListeners(evt) {
        var listeners = this._evtMaps.get(evt.type);
        if (listeners) {
            listeners.forEach(function (listener) {
                switch (evt.eventPhase) {
                    case Event.CAPTURING_PHASE:
                        if (listener.useCapture && listener.listener)
                            listener.listener.call(listener.obj, evt);
                        break;
                    case Event.AT_TARGET:
                        if (listener.listener)
                            listener.listener.call(listener.obj, evt);
                        break;
                    case Event.BUBBLING_PHASE:
                        if (!listener.useCapture && listener.listener)
                            listener.listener.call(listener.obj, evt);
                        break;
                }
            });
        }
    }
}
class UIEvent extends Event {
    constructor(type, eventInitDict) {
        super(type);
        this.bubbles = true;
        if (eventInitDict) {
            this.initUIEvent(type, eventInitDict.bubbles, eventInitDict.cancelable, eventInitDict.view, eventInitDict.detail);
        }
    }
    initUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg) {
        this.type = typeArg;
        this.cancelable = canBubbleArg;
        this.cancelable = cancelableArg;
        this.view = viewArg;
        this.detail = detailArg;
    }
}
class PointerEvent {
    constructor(typeArg, eventInitDict) {
    }
}
class MouseEvent extends UIEvent {
    constructor(typeArg, eventInitDict) {
        super(typeArg, eventInitDict);
        if (eventInitDict) {
            for (var v in eventInitDict) {
                this[v] = eventInitDict[v];
            }
        }
    }
    getModifierState(keyArg) {
        return false;
    }
    initMouseEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg, screenXArg, screenYArg, clientXArg, clientYArg, ctrlKeyArg, altKeyArg, shiftKeyArg, metaKeyArg, buttonArg, relatedTargetArg) {
        var args = arguments;
        ['type', 'bubbles', 'cancelable', 'view', 'detail', 'screenX', 'screenY', 'clientX', 'clientY', 'ctrlKey', 'altKey', 'shiftKey', 'metaKey', 'button', 'relatedTarget'].forEach((v, i, a) => {
            this[v] = args[i];
        });
    }
}
var _lbMouseEvent = window['MouseEvent'] = MouseEvent;
class MouseWheelEvent extends MouseEvent {
    initMouseWheelEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg, screenXArg, screenYArg, clientXArg, clientYArg, buttonArg, relatedTargetArg, modifiersListArg, wheelDeltaArg) {
    }
    constructor() {
        super("mousewheel");
    }
}
class WheelEvent extends MouseEvent {
    constructor(typeArg, eventInitDict) {
        super(typeArg, eventInitDict);
        if (eventInitDict) {
            this.deltaMode = eventInitDict.deltaMode;
            this.deltaX = eventInitDict.deltaX;
            this.deltaY = eventInitDict.deltaY;
            this.deltaZ = eventInitDict.deltaZ;
        }
    }
    getCurrentPoint(element) {
    }
    initWheelEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg, screenXArg, screenYArg, clientXArg, clientYArg, buttonArg, relatedTargetArg, modifiersListArg, deltaXArg, deltaYArg, deltaZArg, deltaMode) {
    }
}
WheelEvent.DOM_DELTA_LINE = 1;
WheelEvent.DOM_DELTA_PAGE = 2;
WheelEvent.DOM_DELTA_PIXEL = 0;
class Touch {
    constructor() {
    }
}
class TouchList extends Array {
    item(index) {
        return this[index];
    }
}
class DeviceMotionEvent extends Event {
    constructor() {
        super('devicemotion');
    }
    initDeviceMotionEvent(type, bubbles, cancelable, acceleration, accelerationIncludingGravity, rotationRate, interval) {
    }
}
window["DeviceMotionEvent"] = DeviceMotionEvent;
class DeviceOrientationEvent extends Event {
    constructor() {
        super('deviceorientation');
    }
    initDeviceOrientationEvent(type, bubbles, cancelable, alpha, beta, gamma, absolute) {
    }
}
window["DeviceOrientationEvent"] = DeviceOrientationEvent;
class DocumentEvent {
    constructor() {
    }
    createEvent(eventInterface) {
        return null;
    }
}
class ProgressEvent extends Event {
    constructor(type) {
        super(type);
    }
    initProgressEvent(typeArg, canBubbleArg, cancelableArg, lengthComputableArg, loadedArg, totalArg) {
        this.type = typeArg;
        this.cancelBubble = canBubbleArg;
        this.cancelable = cancelableArg;
        this.lengthComputable = lengthComputableArg;
        this.loaded = loadedArg;
        this.total = totalArg;
    }
}
var _lbProgressEvent = window["ProgressEvent"] = ProgressEvent;
var VendorIDSource;
(function (VendorIDSource) {
    VendorIDSource[VendorIDSource["bluetooth"] = 0] = "bluetooth";
    VendorIDSource[VendorIDSource["usb"] = 1] = "usb";
})(VendorIDSource || (VendorIDSource = {}));
;
class BluetoothDevice {
    connectGATT() {
        return null;
    }
}
class Bluetooth extends EventTarget {
    requestDevice(options) {
        return null;
    }
}
class Gamepad {
}
class GamepadEvent extends Event {
}
class Storage {
    constructor() {
        this.storagePath = conchConfig.getStoragePath();
        this.filename = '';
        this.db = {};
        this._len = 0;
    }
    get length() {
        return this._len;
    }
    getItem(key) {
        return this.db[key] || null;
    }
    key(index) {
        var keys = Object.keys(this.db);
        keys.sort();
        return keys[index] || null;
    }
    removeItem(key) {
        if (this.db[key])
            this._len--;
        delete this.db[key];
        this.savedb();
    }
    _setItem(key, data) {
        if (this.db[key] == null)
            this._len++;
        this.db[key] = data;
    }
    setItem(key, data) {
        this._setItem(key, data);
        this.savedb();
    }
    create(url) {
        url = location.fullpath;
        if (location.protocol == "file:") {
            this.filename = url.substring(8).replace(/:/g, '_').replace(/[\/]/g, '__');
            this.fileNamePre = this.storagePath + '/' + this.filename;
        }
        else {
            this.fileNamePre = this.storagePath + '/' + url.split('/')[2].replace(':', '_');
        }
        this.filename = this.fileNamePre + '.txt';
        var strdb = readFileSync(this.filename, 'utf8') || '{}';
        var db = JSON.parse(strdb);
        for (var v in db) {
            this._setItem(v, db[v]);
        }
        return this;
    }
    onChange(changes) {
        if (changes && changes.length) {
        }
    }
    clear() {
        this.db = {};
        this.savedb();
    }
    savedb() {
        writeStrFileSync(this.filename, JSON.stringify(this.db));
    }
}
window["Storage"] = Storage;
class WindowLocalStorage {
    constructor() {
        this.localStorage = new Storage();
    }
}
class WindowSessionStorage {
    getItem(i) {
        return this[i] || null;
    }
    setItem(i, b) {
        this[i] = b;
    }
}
window.loadLocalStorage = function (url) {
    return new Storage().create(url);
};
class _Cookie {
    constructor() {
        this.domain = "";
    }
    static addCookie(s) {
        var result = _Cookie.sreg.exec(s);
        if (result == null) {
            console.warn("设置cookie无效");
            return null;
        }
        else {
            var temp = new _Cookie();
            temp.key = result[1];
            temp.value = result[2];
            if (result[4]) {
                temp.expires = new Date(result[4]);
            }
            return temp;
        }
    }
    static pushCookie(c) {
        if (!c.isValid())
            return false;
        for (var i = 0, len = _Cookie.cookies.length; i < len; i++) {
            var temp = _Cookie.cookies[i];
            if (temp.key == c.key) {
                _Cookie.cookies[i] = c;
                return true;
            }
        }
        _Cookie.cookies.push(c);
        return true;
    }
    static flush() {
        writeStrFileSync(document._cookiePath, _Cookie.getString("in", """));
    }
    static getString(type, joinstr) {
        var a = [];
        for (var i = 0, len = _Cookie.cookies.length; i < len; i++) {
            var temp = _Cookie.cookies[i];
            if (temp.isValid()) {
                a.push(temp.toLocalString(type));
            }
            else {
                _Cookie.cookies.slice(i, 1);
                i--;
                len--;
            }
        }
        return a.join(joinstr);
    }
    static toLocalString() {
        return _Cookie.getString("out", "; ");
    }
    isValid() {
        if (this.expires && (this.expires.getTime() < Date.now())) {
            return false;
        }
        return true;
    }
    static init(s) {
        if (s) {
            var temp = s.split(""");
            for (var i = 0, len = temp.length; i < len; i++) {
                var t = _Cookie.addCookie(temp[i]);
                console.warn(">>>>>>>>>>addCookie" + temp[i]);
                if (t) {
                    t.value = decodeURIComponent(t.value);
                    t.domain = decodeURIComponent(t.domain);
                }
                _Cookie.pushCookie(t);
            }
        }
    }
    toLocalString(type) {
        switch (type) {
            case "in":
                return this.key + "=" + encodeURIComponent(this.value) + "; expires=" + this.expires.toGMTString() + "; domain=" + encodeURIComponent(this.domain);
            case "out":
                return this.key + "=" + this.value;
            default:
                return null;
        }
    }
}
_Cookie.cookies = [];
_Cookie.sreg = new RegExp("([^=]*)\s*=\s*([^;]*)\s*;\s*(expires\s*=\s*(.{23,26}GMT)|)");
class KeyboardEvent extends UIEvent {
    constructor(typeArg, eventInitDict) {
        super(typeArg);
        if (eventInitDict) {
            var ini = eventInitDict;
            this.altKey = eventInitDict.altKey;
            this.initKeyboardEvent(typeArg, ini.bubbles, ini.cancelable, ini.view, ini.key, ini.location, null, ini.repeat, null);
        }
    }
    initKeyboardEvent(typeArg, canBubbleArg, cancelableArg, viewArg, keyArg, locationArg, modifiersListArg, repeat, locale) {
        this.type = typeArg;
        this.cancelable = canBubbleArg;
        this.cancelable = cancelableArg;
        this.key = keyArg;
        this.location = locationArg;
        this.locale = locale;
    }
}
KeyboardEvent.DOM_KEY_LOCATION_LEFT = 1;
KeyboardEvent.DOM_KEY_LOCATION_NUMPAD = 3;
KeyboardEvent.DOM_KEY_LOCATION_RIGHT = 2;
KeyboardEvent.DOM_KEY_LOCATION_STANDARD = 0;
var _lbKeyboardEvent = window["KeyboardEvent"] = KeyboardEvent;
(function (layaDoc) {
    'use strict';
    var APP_TOUCH_DOWN = 0;
    var APP_TOUCH_UP = 1;
    var APP_TOUCH_MOV = 2;
    var APP_TOUCH_PT_DOWN = 5;
    var APP_TOUCH_PT_UP = 6;
    var m_vTouchs = [];
    class touchEvt extends UIEvent {
        constructor(type, id, name, x, y) {
            super('');
            this.changedTouches = [];
            this.touches = [];
            this.targetTouches = this.changedTouches;
            var touch = new Touch();
            touch.identifier = id;
            touch.pageX = touch.screenX = touch.clientX = x;
            touch.pageY = touch.screenY = touch.clientY = y;
            this.changedTouches.push(touch);
            switch (type) {
                case APP_TOUCH_DOWN:
                case APP_TOUCH_PT_DOWN:
                    m_vTouchs.push(touch);
                    break;
                case APP_TOUCH_PT_UP:
                    {
                        var epos = 0;
                        var tnum = m_vTouchs.length;
                        while (epos < tnum) {
                            var ce = m_vTouchs[epos];
                            if (ce.identifier == id) {
                                break;
                            }
                            epos++;
                        }
                        if (epos >= tnum) {
                        }
                        else {
                            m_vTouchs.splice(epos, 1);
                        }
                    }
                    break;
                case APP_TOUCH_MOV:
                    {
                        var tnum = m_vTouchs.length;
                        var ti = 0;
                        while (ti < tnum) {
                            var ce = m_vTouchs[ti];
                            if (ce.identifier == id) {
                                m_vTouchs[ti] = touch;
                                break;
                            }
                            ti++;
                        }
                    }
                    break;
                case APP_TOUCH_UP:
                    m_vTouchs = [];
                    break;
            }
            this.touches = m_vTouchs;
            switch (type) {
                case 0:
                case 5:
                    this.type = "touchstart";
                    break;
                case 1:
                case 6:
                    this.type = "touchend";
                    break;
                case 2:
                    this.type = "touchmove";
                    break;
            }
        }
    }
    var joystickEvt = function (TL_xOffset, TL_yOffset, TR_xOffset, TR_yOffset, LT_Offset, RT_Offset) {
        this.THUMBL_xOffset = TL_xOffset;
        this.THUMBL_yOffset = TL_yOffset;
        this.THUMBR_xOffset = TR_xOffset;
        this.THUMBR_yOffset = TR_yOffset;
        this.LT_Offset = LT_Offset;
        this.RT_Offset = RT_Offset;
    };
    var keyEvt = function (name, code, keychar, flag) { this.type = name; this.keyCode = code; this.keyChar = keychar; this.altKey = flag & 0x1; this.shiftKey = (flag & 0x2) != 0; this.ctrlKey = (flag & 0x4) != 0; this.preventDefault = function () { }; };
    conch.setTouchEvtFunction((touchtype, id, etype, x, y) => {
        if (conch.disableMultiTouch && id != 0)
            return;
        var doc = window.document;
        if (!doc) {
            console.log('touch event cant dispatch!');
            return;
        }
        var evt = new touchEvt(touchtype, id, etype, x, y);
        evt.target = doc.pickElement(x, y);
        doc.dispatchEvent(evt);
    });
    function keyEventHandle() {
        var ke = new _lbKeyboardEvent('');
        return function (type, keycode, keychar, AltShiftCtrl) {
            var doc = window.document;
            if (!doc)
                return;
            var keyinit = {};
            var kc = String.fromCharCode(keycode);
            ke.defaultPrevented = false;
            ke._propagationStopped = false;
            ke.type = type;
            ke.key = kc;
            ke.keyCode = keycode;
            ke.altKey = (AltShiftCtrl & 0x4) != 0;
            ke.shiftKey = (AltShiftCtrl & 0x2) != 0;
            ke.ctrlKey = (AltShiftCtrl & 0x1) != 0;
            ke.target = doc._topElement;
            doc.dispatchEvent(ke);
            if (!ke.defaultPrevented) {
                var f = doc['on' + type];
                if (f) {
                    f.call(doc, ke);
                }
            }
        };
    }
    conch.setKeyEvtFunction(keyEventHandle());
    conch.setMouseEvtFunction(function (touchtype, type, x, y, wheel) {
        var doc = window.document;
        if (!doc) {
            console.log('mouse event cant dispatch!');
            return;
        }
        var target = doc.pickElement(x, y);
        if (wheel != 0) {
            var evt1 = new MouseWheelEvent();
            evt1.clientX = evt1.pageX = evt1.screenX = x;
            evt1.clientY = evt1.pageY = evt1.screenY = y;
            evt1.target = target;
            evt1.wheelDelta = wheel;
            doc.dispatchEvent(evt1);
        }
        else {
            var evt;
            switch (touchtype) {
                case 10:
                    evt = new _lbMouseEvent("mousedown");
                    evt.button = 1;
                    break;
                case 11:
                    evt = new _lbMouseEvent("mouseup");
                    evt.button = 1;
                    break;
                default:
                    evt = new _lbMouseEvent(type);
                    evt.button = 0;
                    break;
            }
            evt.clientX = evt.pageX = evt.screenX = x;
            evt.clientY = evt.pageY = evt.screenY = y;
            evt.target = target;
            doc.dispatchEvent(evt);
        }
    });
    conch.otherBuffer = new ArrayBuffer(40);
    conch.otherDataView = new DataView(conch.otherBuffer);
    conch.setBuffer(conch.otherBuffer);
    conch.setDeviceMotionEvtFunction(function (type, ra, rb, rg) {
        if ((typeof ra) != "undefined") {
            var e = new DeviceOrientationEvent();
            e.alpha = ra;
            e.beta = rb;
            e.gamma = rg;
            window.dispatchEvent(e);
        }
        else {
            var d = conch.otherDataView;
            var evt = new DeviceMotionEvent();
            evt.acceleration = { x: d.getFloat32(0, true), y: d.getFloat32(4, true), z: d.getFloat32(8, true) };
            evt.accelerationIncludingGravity = { x: d.getFloat32(12, true), y: d.getFloat32(16, true), z: d.getFloat32(20, true) };
            evt.rotationRate = { alpha: d.getFloat32(24, true), beta: d.getFloat32(28, true), gamma: d.getFloat32(32, true) };
            evt.interval = d.getFloat32(36, true);
            window.dispatchEvent(evt);
        }
    });
    setJoystickEvtFunction(function (type, thumbL_xoff, thumbL_yoff, thumbR_xoff, thumbR_yoff, LT_offset, RT_offset) {
    });
    conch.setNetworkEvtFunction(function (type) {
        var event = new Event("network");
        event["code"] = type;
        document.dispatchEvent(event);
    });
})(window.document);
class Navigator {
    get appName() { return 'Netscape'; }
    get appVersion() { return this.userAgent; }
    ;
    get platform() { return window.layabox.devinfo.os; }
    ;
    get userAgent() {
        var os = window.layabox.devinfo.os;
        if (os == "ios")
            return "LayaBox(iPhone; CPU iPhone OS Mac OS X)";
        else if (os == "android")
            return "LayaBox Android";
        else
            return 'LayaBox/2.1';
    }
    ;
    get sv() {
        var v = window.layabox.devinfo.osversion;
        var t = parseFloat(v);
        if (isNaN(t)) {
            t = v.charCodeAt(0) - 71;
        }
        return t;
    }
    ;
    get appCodeName() { return 'Mozilla'; }
    get language() { return 'zh-CN'; }
    ;
    get userLanguage() { return 'zh-CN'; }
    constructor() {
    }
    getGamepads() {
        return null;
    }
    javaEnabled() { return false; }
    vibrate(pattern) {
        return false;
    }
    addEventListener(type, listener, useCapture) {
    }
}
class Node extends EventTarget {
    constructor() {
        super();
        this._childs = [];
        this._zip = 0;
        this._z = 0;
        this.nodeType = 1;
        this._zip = Node._nodeid++;
    }
    get firstChild() {
        return this._childs ? this._childs[0] : null;
    }
    set firstChild(node) {
    }
    get childNodes() {
        return this._childs;
    }
    set childNodes(nodes) {
    }
    insertBefore(newChild, oldChild) {
        this.appendChild(newChild);
    }
    appendChild(newChild) {
        if (newChild == null)
            return null;
        if (newChild == this)
            return;
        if (this._childs.indexOf(newChild) < 0) {
            this._childs.push(newChild);
        }
        newChild.parentNode = this;
        newChild._z = this._z + 1;
        var doc = newChild.ownerDocument || this.ownerDocument;
        if (doc && newChild._z >= doc._topElement._z && newChild instanceof HTMLCanvasElement && !(window.document._topElement instanceof HTMLCanvasElement)) {
            var ele = newChild;
            if (ele.__visible) {
                window.document._topElement = newChild;
            }
        }
        return newChild;
    }
    cloneNode(deep) {
        if (deep) {
            deep = false;
        }
        function clone(obj) {
            if (typeof (obj) != 'object' || obj == null)
                return obj;
            var newObj = Object.create(obj.__proto__);
            for (var i in obj) {
                if (!deep)
                    newObj[i] = obj[i];
                else
                    newObj[i] = clone(obj[i]);
            }
            return newObj;
        }
        return clone(this);
    }
    removeChild(oldChild) {
        var p = this._childs.indexOf(oldChild);
        if (p >= 0) {
            this._childs.splice(p, 1);
            if (window.document._topElement == oldChild)
                window.document._topElement = oldChild.parentElement;
            oldChild.parentNode = null;
            oldChild.parentElement = null;
            return oldChild;
        }
        else
            return null;
    }
    getAncestorsNode() {
        var ret = new Array();
        var obj = this;
        while (obj.parentNode) {
            ret.push(obj.parentNode);
            obj = obj.parentNode;
        }
        return ret;
    }
}
Node._nodeid = 0;
class NodeSelector {
    querySelector(selectors) {
        return null;
    }
    querySelectorAll(selectors) {
        return [];
    }
}
class ChildNode {
    constructor() { }
    remove() {
    }
}
class ElementTraversal {
    constructor() {
    }
}
class Element extends Node {
    constructor() {
        super();
        this.__visible = true;
    }
    set id(s) {
        this._id = s;
        document.all.push(this);
    }
    get id() {
        return this._id;
    }
    setAttribute(name, value) {
        if (!this._attribs)
            this._attribs = [];
        this._attribs[name] = value;
    }
    getAttribute(name) {
        return this._attribs ? this._attribs[name] : null;
    }
}
applyMixins(Element, [Node, GlobalEventHandlers, ElementTraversal, NodeSelector, ChildNode]);
var ns_Timer;
(function (ns_Timer) {
    class timerobj {
        constructor(curtm, interval, obj, func, args, num) {
            this.del = false;
            this.interval = (interval < 18) ? -1 : interval;
            if (Math.abs(conch.maxInterval - interval) < 1)
                this.interval = -1;
            this.tm = curtm + interval;
            this.obj = obj;
            this.func = func;
            this.args = args;
            this.num = num;
        }
    }
    var timerqueue = function () {
        this.AniFrame = [];
        this.tmq = new Array();
        this.addTimer = function (tm, obj, func, args, num) {
            var tmobj = new timerobj(Date.now(), tm, obj, func, args, num);
            this.tmq.push(tmobj);
            return tmobj;
        };
        this.delTimer = function (obj) {
            for (var i = 0, sz = this.tmq.length; i < sz; i++) {
                if (this.tmq[i] === obj) {
                    this.tmq[i].del = true;
                    break;
                }
            }
        };
        this.update = function () {
            this.curtm = Date.now();
            var i = 0;
            var btmq = [];
            for (var sz = this.tmq.length; i < sz; i++) {
                var ctm = this.tmq[i];
                if (ctm.del)
                    continue;
                var dt = ctm.tm - this.curtm;
                if (dt < 0 || ctm.interval < 0 || Math.abs(conch.maxInterval - ctm.interval) < 1) {
                    if (typeof (ctm.func) === 'function') {
                        ctm.func.apply(null, ctm.obj);
                    }
                    else {
                        eval(ctm.func);
                    }
                    if (ctm.num < 0 || --ctm.num > 0) {
                        if (dt < 0)
                            dt = 0;
                        ctm.tm = dt + this.curtm + ctm.interval;
                        btmq.push(ctm);
                    }
                }
                else {
                    btmq.push(ctm);
                }
            }
            this.tmq.splice(0, sz);
            this.tmq = this.tmq.concat(btmq);
        };
    };
    var gTimerQueue = new timerqueue();
    class _WindowTimersExtension {
        clearImmediate(handle) {
        }
        setImmediate(expression) {
            return 0;
        }
    }
    ns_Timer._WindowTimersExtension = _WindowTimersExtension;
    class _WindowTimers extends _WindowTimersExtension {
        constructor() {
            super();
        }
        clearInterval(handle) {
            gTimerQueue.delTimer(handle);
        }
        clearTimeout(handle) {
            gTimerQueue.delTimer(handle);
        }
        setInterval(handler, timeout, parm) {
            var b = _WindowTimers.ET;
            if (arguments.length > 2) {
                b = Array.prototype.slice.call(arguments);
                b.splice(0, 2);
                handler.arg = b;
            }
            return gTimerQueue.addTimer(timeout, b, handler, null, -1);
        }
        setTimeout(handler, timeout, parm) {
            if (!timeout)
                timeout = 0;
            var b = _WindowTimers.ET;
            if (arguments.length > 2) {
                b = Array.prototype.slice.call(arguments);
                b.splice(0, 2);
                handler.arg = b;
            }
            return gTimerQueue.addTimer(timeout, b, handler, null, 1);
        }
    }
    _WindowTimers.ET = [];
    ns_Timer._WindowTimers = _WindowTimers;
    var animfrm = 0;
    function requestAnimationFrame(callback) {
        var id = animfrm++;
        gTimerQueue.AniFrame.push({ id: id, func: callback });
        if (!gTimerQueue.AniFrameStTm)
            gTimerQueue.AniFrameStTm = Date.now();
        return id;
    }
    ns_Timer.requestAnimationFrame = requestAnimationFrame;
    function cancelAnimationFrame(handle) {
    }
    ns_Timer.cancelAnimationFrame = cancelAnimationFrame;
    var framCount = 0;
    var fpsTimeout = 0;
    conch.setOnFrame(function () {
        if (framCount % 30 == 0) {
            var cur = Date.now();
            var space = (cur - fpsTimeout) / 30;
            fpsTimeout = cur;
            window["conchFps"] && window["conchFps"].render(Math.round(1000 / space));
        }
        framCount++;
        gTimerQueue.update();
        if (document)
            document.onframeend();
    });
    conch.setOnDraw((vsync) => {
        var curAnimFrms = gTimerQueue.AniFrame;
        gTimerQueue.AniFrame = [];
        curAnimFrms.forEach(function (af) {
            if (af.del)
                return;
            af.func(vsync);
        });
    });
})(ns_Timer || (ns_Timer = {}));
var WindowTimers = ns_Timer._WindowTimers;
var requestAnimationFrame = ns_Timer.requestAnimationFrame;
var cancelAnimationFrame = ns_Timer.cancelAnimationFrame;
class Location {
    constructor() {
        this._nativeObj = conch;
        this.setHref = (url) => {
            if (!url || url.length < 8) {
                alert("您的地址不符合要求");
                return;
            }
            var s = new RegExp("(http|file|https)://([^/:]*)(:(\d+)|)([^?]+)(.*|)", "g");
            var result;
            if ((result = s.exec(url)) != null) {
                this._href = result[0];
                this._hostname = result[2];
                this._host = result[2] + result[3];
                this._pathname = result[5];
                this._port = result[4];
                this._search = result[6];
                this._protocol = result[1] + ":";
                this._origin = this._protocol + "//" + this._host;
                var i = this._pathname ? this._pathname.lastIndexOf("/") : -1;
                if (i != -1) {
                    var temp = this._pathname.substring(0, i);
                    this._fullpath = this._origin + temp;
                }
                else {
                    this._fullpath = this._origin + this._pathname;
                }
            }
            else {
                alert("您的地址不符合要求");
            }
            this.bk_setHref(url);
            window.localStorage.create(this._fullpath + '/');
        };
        this.bk_setHref = this._nativeObj.setHref.bind(this._nativeObj);
    }
    get hostname() {
        return this._hostname;
    }
    get host() {
        return this._host;
    }
    get fullpath() {
        return this._fullpath;
    }
    get pathname() {
        return this._pathname;
    }
    get protocol() {
        return this._protocol;
    }
    get search() {
        return this._search;
    }
    get port() {
        return this._port;
    }
    get origin() {
        return this._origin;
    }
    get href() {
        return this._href;
    }
    set href(url) {
        url = this.normalizeUrl(url);
        var oldhref = this._href;
        if (url != oldhref) {
            this.setHref(url);
            if (this._href != oldhref)
                reloadJS(true);
        }
    }
    setBaseHref(basehref) {
    }
    getBaseHref() {
        return "";
    }
    assign(url) {
    }
    reload(forcedReload) {
        reloadJS(forcedReload);
    }
    replace(url) {
    }
    toString() {
        return this._href;
    }
    normalizeUrl(url) {
        url = url.replace(/\/g, '/');
        if (url[0] === '/')
            url = 'file://' + url;
        else if (url[1] === ':')
            url = 'file:///' + url;
        return url.trim();
    }
    parseQuery(url) {
        var ret = {};
        var p1 = url.indexOf('?');
        if (p1 < 0)
            return null;
        var q = url.substr(p1 + 1);
        q && q.split('&').forEach((v, i, a) => {
            var kv = v.split('=');
            if (kv.length === 2) {
                ret[kv[0].trim()] = kv[1].trim();
            }
        });
        return ret;
    }
    resolve(fileName) {
        var urlcache = Location.__urlCache__[fileName];
        if (urlcache != null)
            return urlcache;
        if (fileName == null) {
            return "";
        }
        if (fileName.indexOf("//") == 0) {
            return this.protocol + fileName;
        }
        if (fileName.indexOf("file:///") == 0 || fileName.indexOf("http://") == 0 || fileName.indexOf("https://") == 0)
            return fileName;
        if ((fileName.charAt(1) == ':' && fileName.charAt(2) == '/'))
            fileName = "file://" + fileName;
        if (fileName.charAt(0) == "/") {
            return this._origin + fileName;
        }
        var basePath = this._fullpath;
        var urlfull = basePath + "/" + fileName;
        urlcache = Location.__urlCache__[urlfull];
        if (urlcache != null)
            return urlcache;
        if (fileName.indexOf("://") < 0)
            fileName = basePath + "/" + fileName;
        var urls = fileName.split("/");
        urls[1] = "";
        var str, i = 2, size = urls.length;
        while (i < size) {
            str = urls[i];
            if (str == null)
                break;
            if (str == '' || str == '.') {
                urls.splice(i, 1);
                continue;
            }
            if (str == "..") {
                if (i <= 3 && this._protocol != "file:") {
                    urls.splice(i, 1);
                }
                else {
                    urls.splice(i - 1, 2);
                    i -= 1;
                }
                continue;
            }
            i += 1;
        }
        fileName = urls.join("/");
        Location.__urlCache__[fileName] = fileName;
        Location.__urlCache__[urlfull] = fileName;
        return fileName;
    }
}
Location.__urlCache__ = {};
function applyMixins(derivedCtor, baseCtors) {
    baseCtors.forEach(baseCtor => {
        Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
            if (name !== 'constructor') {
                derivedCtor.prototype[name] = baseCtor.prototype[name];
            }
        });
    });
}
class IDBEnvironment {
}
class _Window extends EventTarget {
    constructor() {
        super();
        this.timer = new WindowTimers();
        this.clearInterval = this.timer.clearInterval;
        this.clearTimeout = this.timer.clearTimeout;
        this.setInterval = this.timer.setInterval;
        this.setTimeout = this.timer.setTimeout;
        this._removeEventListener = this.removeEventListener;
        this.removeEventListener = this.removeEventListenernew;
    }
    addEventListener(type, listener, useCapture) {
        if (type == "devicemotion" || type == "deviceorientation") {
            conch.setSensorAble(true);
        }
        super.addEventListener(type, listener, useCapture);
    }
    removeEventListenernew(type, listener, useCapture) {
        this._removeEventListener(type, listener, useCapture);
        if (type == "devicemotion" || type == "deviceorientation") {
            var de = this._evtMaps.get("devicemotion");
            var deo = this._evtMaps.get("deviceorientation");
            if ((!de || de.length == 0) && (!deo || deo.length == 0)) {
                conch.setSensorAble(false);
            }
        }
    }
}
class XMLHttpRequest extends EventTarget {
    constructor() {
        super();
        this._hasReqHeader = false;
        this.withCredentials = false;
        this.setResponseHeader = function (name, value) {
            this._head = value;
        };
        this.xhr = new _XMLHttpRequest();
        this._readyState = 0;
        this._responseText = this._response = this._responseType = this._url = "";
        this._responseType = "text";
        this._method = "GET";
        this.xhr._t = this;
        this.xhr.set_onreadystatechange(function (r) {
            var _t = this._t;
            if (r == 1) {
                _t._readyState = 1;
            }
            if (_t._onrchgcb) {
                var e = new _lbEvent("readystatechange");
                e.target = _t;
                _t._onrchgcb(e);
            }
            var ev;
            if (_t._status == 200) {
                ev = new _lbEvent("load");
                ev.target = _t;
                _t.dispatchEvent(ev);
            }
            else if (_t._status == 404) {
                ev = new _lbEvent("error");
                ev.target = _t;
                _t.dispatchEvent(ev);
            }
        });
    }
    setRequestHeader(name, value) {
        this.xhr.setRequestHeader(name, value);
        this._hasReqHeader = true;
    }
    getAllResponseHeaders() {
        return this._head;
    }
    get responseText() {
        return this._responseText;
    }
    get response() {
        return this._response;
    }
    get responseType() {
        return this._responseType;
    }
    set responseType(type) {
        this._responseType = type;
        if (type == 'blob') {
            this.xhr.responseTypeCode = 4;
        }
        else if (type == 'arraybuffer') {
            this.xhr.responseTypeCode = 5;
        }
        else {
            this.xhr.responseTypeCode = 1;
        }
    }
    get url() {
        return this._url;
    }
    get async() {
        return this._async;
    }
    get readyState() {
        return this._readyState;
    }
    get status() {
        return this._status;
    }
    _loadsus() {
        var e = new _lbEvent("load");
        e.target = this;
        this._onloadcb(e);
    }
    set onreadystatechange(listen) {
        this._onrchgcb = listen;
        if (listen == null)
            return;
        if (this._readyState != 0) {
            var e = new _lbEvent("readystatechange");
            e.target = this;
            this._onrchgcb(e);
        }
    }
    get onreadystatechange() {
        return this._onrchgcb;
    }
    set onload(listen) {
        this._onloadcb = listen;
        if (listen == null)
            return;
        if (this._readyState == 4 && this._status == 200) {
            this._loadsus();
        }
    }
    get onload() {
        return this._onloadcb;
    }
    getResponseHeader() {
        return this._head;
    }
    open(type, url, async) {
        console.log('xhr.' + type + ' url=' + url);
        if (!url)
            return;
        type = type.toUpperCase();
        async = true;
        url = location.resolve(url);
        this._method = (type === 'POST' ? 'POST' : 'GET');
        this._url = url;
        this._async = (async == null || async == undefined || async == true) ? true : false;
        this.xhr._open(this._method, this._url, this._async);
    }
    overrideMimeType(mime) {
        if (this._responseType == "text" || this._responseText == "")
            this._responseType = "arraybuffer";
        this.xhr.mimeType = "1";
    }
    send(body) {
        if (body) {
            if (body instanceof ArrayBuffer || ArrayBuffer.isView(body) || body instanceof DataView)
                this._responseType = 'arraybuffer';
            else if (body instanceof Object) {
                body = JSON.stringify(body);
            }
        }
        this.xhr._t = this;
        var onPostLoad = function (buf, strbuf) {
            var _t = this._t;
            if (_t.responseType == 'arraybuffer') {
                _t._response = buf;
                _t._responseText = strbuf;
            }
            else {
                _t._response = _t._responseText = buf;
            }
            _t._readyState = 4;
            _t._status = 200;
            _t.xhr._changeState(4);
            if (_t._onloadcb) {
                _t._loadsus();
            }
            onPostLoad.ref = onPostError.ref = null;
        };
        var onPostError = function (e1, e2) {
            var _t = this._t;
            _t._readyState = 4;
            _t._status = 404;
            _t.xhr._changeState(4);
            if (_t.onerror) {
                var ev = new _lbEvent("error");
                ev.target = _t;
                ev['ecode1'] = e1;
                ev['ecode2'] = e2;
                _t.onerror(ev);
            }
            onPostLoad.ref = onPostError.ref = null;
        };
        if (this._method == 'POST' && body) {
            onPostLoad.ref = onPostError.ref = this.xhr;
            this.xhr.setPostCB(onPostLoad, onPostError);
            this.xhr.postData(this.url, body);
        }
        else if (this._hasReqHeader) {
            onPostLoad.ref = onPostError.ref = this.xhr;
            this.xhr.setPostCB(onPostLoad, onPostError);
            this.xhr.getData(this.url);
        }
        else {
            var file = new conch_File(this.url);
            var fileRead = new FileReader();
            fileRead.sync = !this.async;
            if (this._responseType == "text" || this._responseType == "TEXT") {
                fileRead.responseType = 0;
            }
            else if (this._responseType == "arraybuffer") {
                fileRead.responseType = 1;
            }
            else {
                console.log("XMLhttpRequest 暂不支持的类型 responseType=" + this.responseType);
            }
            fileRead._t = this;
            fileRead.onload = function () {
                var _t = this._t;
                if (_t._responseType == "arraybuffer") {
                    _t._response = this.result;
                }
                else {
                    _t._response = _t._responseText = this.result;
                    if (_t._responseType == "json") {
                        _t._response = JSON.parse(this.result);
                    }
                }
                if (_t.xhr.mimeType) {
                    var u8arr = new Uint8Array(_t._response);
                    var strret = "";
                    u8arr.forEach((v, i, arr) => {
                        if (v >= 0x80) {
                            strret += String.fromCharCode(0xf700 | v);
                        }
                        else if (v == 0) {
                            strret += '';
                        }
                        else {
                            strret += String.fromCharCode(v);
                        }
                    });
                    _t._responseText = strret;
                }
                _t._readyState = 4;
                _t._status = 200;
                _t.xhr._changeState(4);
                if (_t._onloadcb) {
                    _t._loadsus();
                }
                fileRead.onload = null;
                fileRead.onerror = null;
            };
            fileRead.onerror = function () {
                var _t = this._t;
                _t._readyState = 4;
                _t._status = 404;
                _t.xhr._changeState(4);
                if (_t.onerror) {
                    var ev = new _lbEvent("error");
                    ev.target = _t;
                    _t.onerror(ev);
                }
                fileRead.onload = null;
                fileRead.onerror = null;
            };
            if (this.onerror) {
                fileRead.setIgnoreError(true);
            }
            if (this.responseType == "arraybuffer")
                fileRead.readAsArrayBuffer(file);
            else
                fileRead.readAsText(file);
        }
    }
}
window.XMLHttpRequest = XMLHttpRequest;
class CanvasRenderingContext {
    constructor(c) {
        this.canvas = c;
        this.gl = LayaGLContext.instance;
    }
    setSize(w, h) {
        if (this._width != w || this._height != h) {
            this._width = w;
            this._height = h;
            if (this.canvas._isFirst) {
                this.gl.setMainContextSize(this._width, this._height);
            }
        }
    }
    clear() {
        this.gl.clearColor(0, 0, 0, 0);
        this.gl.clear(this.gl.COLOR_BUFFER_BIT | this.gl.DEPTH_BUFFER_BIT | this.gl.STENCIL_BUFFER_BIT);
    }
    toBase64(type, encoderOptions, callback) {
    }
    getImageData(x, y, w, h, callBack) {
    }
    drawImage(...args) {
    }
    destroy() {
        this.canvas = null;
        this.gl = null;
    }
}
window["CanvasRenderingContext"] = CanvasRenderingContext;
class ColorUtil {
    static getColorNum(str) {
        if (!str)
            return 0;
        if (typeof (str) == "number") {
            if (str >= 0xFFFFFF)
                return str;
            return str | 0xFF000000;
        }
        var len;
        if (str[0] == "#") {
            var r = ColorUtil.getRGBByRGBStr(str);
            if (r) {
                return parseInt(r, 16);
            }
            else
                return NaN;
        }
        else if (str.indexOf("rgb") != -1) {
            return ColorUtil.getColNum(str, true);
        }
        else if (str.indexOf("hsl") != -1) {
            return ColorUtil.getColNum(str, false);
        }
        else {
            var c = ColorUtil._COLOR_MAP[str];
            return c ? ColorUtil.getColorNum(c) : NaN;
        }
    }
    static getColNum(c, isRgb) {
        var temp, i, s, result = [], st;
        var t = isRgb ? ColorUtil.RGBReg.exec(c) : ColorUtil.HSLReg.exec(c);
        if (t) {
            var r = t[2].split(",");
            i = 0;
            s = r.length;
            while (i < s) {
                result[i] = parseFloat(r[i]);
                i++;
            }
            var ta = result;
            if (!isRgb) {
                ta = ColorUtil.hsl2rgb(result[0] / 360, result[1] / 100, result[2] / 100);
            }
            if (i == 3 && !t[1]) {
                return 0xff000000 + (ta[0] << 16) + (ta[1] << 8) + ta[2];
            }
            else if (i == 4 && t[1]) {
                return parseInt(Math.floor(0xff * result[3]).toString(16) + "000000", 16) + (ta[0] << 16) + (ta[1] << 8) + ta[2];
            }
            return NaN;
        }
        else
            return NaN;
    }
    static getRGBByRGBStr(str) {
        str = str.substr(1);
        var i, len = str.length, result;
        switch (len) {
            case 3:
                result = "ff";
                for (i = 0; i < len; i++) {
                    result += str[i] + str[i];
                }
                break;
            case 6:
                result = "ff" + str;
            default:
                break;
        }
        return result;
    }
    static toHexColor(color) {
        if (color < 0 || isNaN(color))
            return null;
        if (color > 0xff000000) {
            color -= 0xff000000;
        }
        else {
            return "rgba(" + (color >> 16 & 0xff) + "," + (color >> 8 & 0xff) + "," + (color & 0xff) + "," + ((color >> 24 & 0xff) / 0xff) + ")";
        }
        var str = color.toString(16);
        while (str.length < 6)
            str = "0" + str;
        return "#" + str;
    }
    static hsl2rgb(h, s, l) {
        var r, g, b;
        if (s == 0) {
            r = g = b = l;
        }
        else {
            function hue2rgb(p, q, t) {
                if (t < 0)
                    t += 1;
                if (t > 1)
                    t -= 1;
                if (t < 1 / 6)
                    return p + (q - p) * 6 * t;
                if (t < 1 / 2)
                    return q;
                if (t < 2 / 3)
                    return p + (q - p) * (2 / 3 - t) * 6;
                return p;
            }
            var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
            var p = 2 * l - q;
            r = hue2rgb(p, q, h + 1 / 3);
            g = hue2rgb(p, q, h);
            b = hue2rgb(p, q, h - 1 / 3);
        }
        return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
    }
}
ColorUtil._COLOR_MAP = { "white": '#FFFFFF', "red": '#FF0000', "green": '#00FF00', "blue": '#0000FF', "black": '#000000', "yellow": '#FFFF00', 'gray': '#AAAAAA' };
ColorUtil.RGBReg = new RegExp("rgb([a]{0,1})\s*[(]([\d,.\s-]*)?[)]");
ColorUtil.HSLReg = new RegExp("hsl([a]{0,1})\s*[(]([\d,.\s-%]*)?[)]");
class ParamData {
    constructor(sz, bSyncRenderThread, bOnly16) {
        bOnly16 = bOnly16 ? bOnly16 : false;
        this._data = new ArrayBuffer(sz);
        if (!bOnly16) {
            this._int32Data = new Int32Array(this._data);
            this._float32Data = new Float32Array(this._data);
            this._int8Data = new Uint8Array(this._data);
        }
        this._int16Data = new Int16Array(this._data);
        LayaGLContext.createArrayBufferRef(this._data, LayaGLContext.ARRAY_BUFFER_TYPE_DATA, bSyncRenderThread);
    }
    getPtrID() {
        return this._data["_ptrID"];
    }
    getByteLength() {
        return this._data.byteLength;
    }
}
class ProgramLocationTable {
    constructor() {
        this._fakeLocationNum = 0;
        this._map = {};
    }
    getFakeLocation(fakeProgramID, name) {
        var key = fakeProgramID + "-" + name;
        var fakeID = this._map[key];
        if (!fakeID) {
            fakeID = this._fakeLocationNum++;
            this._map[key] = fakeID;
        }
        return fakeID;
    }
}
var FUNCTION_ID;
(function (FUNCTION_ID) {
    FUNCTION_ID[FUNCTION_ID["UNIFORMMATRIX2FVEX"] = 0] = "UNIFORMMATRIX2FVEX";
    FUNCTION_ID[FUNCTION_ID["UNIFORMMATRIX3FVEX"] = 1] = "UNIFORMMATRIX3FVEX";
    FUNCTION_ID[FUNCTION_ID["UNIFORMMATRIX4FVEX"] = 2] = "UNIFORMMATRIX4FVEX";
    FUNCTION_ID[FUNCTION_ID["ADDSHADERUNIFORM"] = 3] = "ADDSHADERUNIFORM";
    FUNCTION_ID[FUNCTION_ID["UPLOADSHADERUNIFORMS"] = 4] = "UPLOADSHADERUNIFORMS";
    FUNCTION_ID[FUNCTION_ID["UPLOADSHADERUNIFORMS_BUFFER"] = 5] = "UPLOADSHADERUNIFORMS_BUFFER";
    FUNCTION_ID[FUNCTION_ID["USECOMMANDENCODER"] = 6] = "USECOMMANDENCODER";
    FUNCTION_ID[FUNCTION_ID["LOADDATATOREG"] = 7] = "LOADDATATOREG";
    FUNCTION_ID[FUNCTION_ID["LOADDATATOREGEX"] = 8] = "LOADDATATOREGEX";
    FUNCTION_ID[FUNCTION_ID["IFLESS0"] = 9] = "IFLESS0";
    FUNCTION_ID[FUNCTION_ID["IFEQUAL0"] = 10] = "IFEQUAL0";
    FUNCTION_ID[FUNCTION_ID["IFGREATER0"] = 11] = "IFGREATER0";
    FUNCTION_ID[FUNCTION_ID["IFLEQUAL0"] = 12] = "IFLEQUAL0";
    FUNCTION_ID[FUNCTION_ID["IFGEQUAL0"] = 13] = "IFGEQUAL0";
    FUNCTION_ID[FUNCTION_ID["IFGNOTEQUAL0"] = 14] = "IFGNOTEQUAL0";
    FUNCTION_ID[FUNCTION_ID["OPERATEREG"] = 15] = "OPERATEREG";
    FUNCTION_ID[FUNCTION_ID["STORE"] = 16] = "STORE";
    FUNCTION_ID[FUNCTION_ID["CREATEIMAGEONRENDERTHREAD"] = 64] = "CREATEIMAGEONRENDERTHREAD";
    FUNCTION_ID[FUNCTION_ID["DELETE_IMAGE_ON_RENDER_THREAD"] = 65] = "DELETE_IMAGE_ON_RENDER_THREAD";
    FUNCTION_ID[FUNCTION_ID["RELEASE_IMAGE_ON_RENDER_THREAD"] = 66] = "RELEASE_IMAGE_ON_RENDER_THREAD";
    FUNCTION_ID[FUNCTION_ID["SET_IMAGE_RELEASE_SPACE_TIME"] = 67] = "SET_IMAGE_RELEASE_SPACE_TIME";
    FUNCTION_ID[FUNCTION_ID["SET_PREMULTIPLY_ALPHA"] = 68] = "SET_PREMULTIPLY_ALPHA";
    FUNCTION_ID[FUNCTION_ID["PERFADDDATA"] = 69] = "PERFADDDATA";
    FUNCTION_ID[FUNCTION_ID["PERFUPDATEDT"] = 70] = "PERFUPDATEDT";
    FUNCTION_ID[FUNCTION_ID["SET_MAIN_CONTEXT_SIZE"] = 71] = "SET_MAIN_CONTEXT_SIZE";
    FUNCTION_ID[FUNCTION_ID["GETCONTEXTATTRIBUTES"] = 128] = "GETCONTEXTATTRIBUTES";
    FUNCTION_ID[FUNCTION_ID["ISCONTEXTLOST"] = 129] = "ISCONTEXTLOST";
    FUNCTION_ID[FUNCTION_ID["GETSUPPORTEDEXTENSIONS"] = 130] = "GETSUPPORTEDEXTENSIONS";
    FUNCTION_ID[FUNCTION_ID["GETEXTENSION"] = 131] = "GETEXTENSION";
    FUNCTION_ID[FUNCTION_ID["ACTIVETEXTURE"] = 132] = "ACTIVETEXTURE";
    FUNCTION_ID[FUNCTION_ID["ATTACHSHADER"] = 133] = "ATTACHSHADER";
    FUNCTION_ID[FUNCTION_ID["BINDATTRIBLOCATION"] = 134] = "BINDATTRIBLOCATION";
    FUNCTION_ID[FUNCTION_ID["BINDBUFFER"] = 135] = "BINDBUFFER";
    FUNCTION_ID[FUNCTION_ID["BINDFRAMEBUFFER"] = 136] = "BINDFRAMEBUFFER";
    FUNCTION_ID[FUNCTION_ID["BINDRENDERBUFFER"] = 137] = "BINDRENDERBUFFER";
    FUNCTION_ID[FUNCTION_ID["BINDTEXTURE"] = 138] = "BINDTEXTURE";
    FUNCTION_ID[FUNCTION_ID["USETEXTURE"] = 139] = "USETEXTURE";
    FUNCTION_ID[FUNCTION_ID["BLENDCOLOR"] = 140] = "BLENDCOLOR";
    FUNCTION_ID[FUNCTION_ID["BLENDEQUATION"] = 141] = "BLENDEQUATION";
    FUNCTION_ID[FUNCTION_ID["BLENDEQUATIONSEPARATE"] = 142] = "BLENDEQUATIONSEPARATE";
    FUNCTION_ID[FUNCTION_ID["BLENDFUNC"] = 143] = "BLENDFUNC";
    FUNCTION_ID[FUNCTION_ID["BLENDFUNCSEPARATE"] = 144] = "BLENDFUNCSEPARATE";
    FUNCTION_ID[FUNCTION_ID["BUFFERDATA_SIZE"] = 145] = "BUFFERDATA_SIZE";
    FUNCTION_ID[FUNCTION_ID["BUFFERDATA_ARRAYBUFFER"] = 146] = "BUFFERDATA_ARRAYBUFFER";
    FUNCTION_ID[FUNCTION_ID["BUFFERSUBDATA"] = 147] = "BUFFERSUBDATA";
    FUNCTION_ID[FUNCTION_ID["CHECKFRAMEBUFFERSTATUS"] = 148] = "CHECKFRAMEBUFFERSTATUS";
    FUNCTION_ID[FUNCTION_ID["CLEAR"] = 149] = "CLEAR";
    FUNCTION_ID[FUNCTION_ID["CLEARCOLOR"] = 150] = "CLEARCOLOR";
    FUNCTION_ID[FUNCTION_ID["CLEARDEPTH"] = 151] = "CLEARDEPTH";
    FUNCTION_ID[FUNCTION_ID["CLEARSTENCIL"] = 152] = "CLEARSTENCIL";
    FUNCTION_ID[FUNCTION_ID["COLORMASK"] = 153] = "COLORMASK";
    FUNCTION_ID[FUNCTION_ID["COMPILESHADER"] = 154] = "COMPILESHADER";
    FUNCTION_ID[FUNCTION_ID["COPYTEXIMAGE2D"] = 155] = "COPYTEXIMAGE2D";
    FUNCTION_ID[FUNCTION_ID["COPYTEXSUBIMAGE2D"] = 156] = "COPYTEXSUBIMAGE2D";
    FUNCTION_ID[FUNCTION_ID["CREATEBUFFER"] = 157] = "CREATEBUFFER";
    FUNCTION_ID[FUNCTION_ID["CREATEFRAMEBUFFER"] = 158] = "CREATEFRAMEBUFFER";
    FUNCTION_ID[FUNCTION_ID["CREATEPROGRAM"] = 159] = "CREATEPROGRAM";
    FUNCTION_ID[FUNCTION_ID["CREATERENDERBUFFER"] = 160] = "CREATERENDERBUFFER";
    FUNCTION_ID[FUNCTION_ID["CREATESHADER"] = 161] = "CREATESHADER";
    FUNCTION_ID[FUNCTION_ID["CREATETEXTURE"] = 162] = "CREATETEXTURE";
    FUNCTION_ID[FUNCTION_ID["CULLFACE"] = 163] = "CULLFACE";
    FUNCTION_ID[FUNCTION_ID["DELETEBUFFER"] = 164] = "DELETEBUFFER";
    FUNCTION_ID[FUNCTION_ID["DELETEFRAMEBUFFER"] = 165] = "DELETEFRAMEBUFFER";
    FUNCTION_ID[FUNCTION_ID["DELETEPROGRAM"] = 166] = "DELETEPROGRAM";
    FUNCTION_ID[FUNCTION_ID["DELETERENDERBUFFER"] = 167] = "DELETERENDERBUFFER";
    FUNCTION_ID[FUNCTION_ID["DELETESHADER"] = 168] = "DELETESHADER";
    FUNCTION_ID[FUNCTION_ID["DELETETEXTURE"] = 169] = "DELETETEXTURE";
    FUNCTION_ID[FUNCTION_ID["DEPTHFUNC"] = 170] = "DEPTHFUNC";
    FUNCTION_ID[FUNCTION_ID["DEPTHMASK"] = 171] = "DEPTHMASK";
    FUNCTION_ID[FUNCTION_ID["DEPTHRANGE"] = 172] = "DEPTHRANGE";
    FUNCTION_ID[FUNCTION_ID["DETACHSHADER"] = 173] = "DETACHSHADER";
    FUNCTION_ID[FUNCTION_ID["DISABLE"] = 174] = "DISABLE";
    FUNCTION_ID[FUNCTION_ID["DISABLEVERTEXATTRIBARRAY"] = 175] = "DISABLEVERTEXATTRIBARRAY";
    FUNCTION_ID[FUNCTION_ID["DRAWARRAYS"] = 176] = "DRAWARRAYS";
    FUNCTION_ID[FUNCTION_ID["DRAWELEMENTS"] = 177] = "DRAWELEMENTS";
    FUNCTION_ID[FUNCTION_ID["ENABLE"] = 178] = "ENABLE";
    FUNCTION_ID[FUNCTION_ID["ENABLEVERTEXATTRIBARRAY"] = 179] = "ENABLEVERTEXATTRIBARRAY";
    FUNCTION_ID[FUNCTION_ID["FINISH"] = 180] = "FINISH";
    FUNCTION_ID[FUNCTION_ID["FLUSH"] = 181] = "FLUSH";
    FUNCTION_ID[FUNCTION_ID["FRAMEBUFFERRENDERBUFFER"] = 182] = "FRAMEBUFFERRENDERBUFFER";
    FUNCTION_ID[FUNCTION_ID["FRAMEBUFFERTEXTURE2D"] = 183] = "FRAMEBUFFERTEXTURE2D";
    FUNCTION_ID[FUNCTION_ID["FRONTFACE"] = 184] = "FRONTFACE";
    FUNCTION_ID[FUNCTION_ID["GENERATEMIPMAP"] = 185] = "GENERATEMIPMAP";
    FUNCTION_ID[FUNCTION_ID["GETACTIVEATTRIB"] = 186] = "GETACTIVEATTRIB";
    FUNCTION_ID[FUNCTION_ID["GETACTIVEUNIFORM"] = 187] = "GETACTIVEUNIFORM";
    FUNCTION_ID[FUNCTION_ID["GETATTRIBLOCATION"] = 188] = "GETATTRIBLOCATION";
    FUNCTION_ID[FUNCTION_ID["GETPARAMETER"] = 189] = "GETPARAMETER";
    FUNCTION_ID[FUNCTION_ID["GETBUFFERPARAMETER"] = 190] = "GETBUFFERPARAMETER";
    FUNCTION_ID[FUNCTION_ID["GETERROR"] = 191] = "GETERROR";
    FUNCTION_ID[FUNCTION_ID["GETFRAMEBUFFERATTACHMENTPARAMETER"] = 192] = "GETFRAMEBUFFERATTACHMENTPARAMETER";
    FUNCTION_ID[FUNCTION_ID["GETPROGRAMPARAMETER"] = 193] = "GETPROGRAMPARAMETER";
    FUNCTION_ID[FUNCTION_ID["GETPROGRAMINFOLOG"] = 194] = "GETPROGRAMINFOLOG";
    FUNCTION_ID[FUNCTION_ID["GETRENDERBUFFERPARAMETER"] = 195] = "GETRENDERBUFFERPARAMETER";
    FUNCTION_ID[FUNCTION_ID["GETSHADERPRECISIONFORMAT"] = 196] = "GETSHADERPRECISIONFORMAT";
    FUNCTION_ID[FUNCTION_ID["GETSHADERPARAMETER"] = 197] = "GETSHADERPARAMETER";
    FUNCTION_ID[FUNCTION_ID["GETSHADERINFOLOG"] = 198] = "GETSHADERINFOLOG";
    FUNCTION_ID[FUNCTION_ID["GETSHADERSOURCE"] = 199] = "GETSHADERSOURCE";
    FUNCTION_ID[FUNCTION_ID["GETTEXPARAMETER"] = 200] = "GETTEXPARAMETER";
    FUNCTION_ID[FUNCTION_ID["GETUNIFORM"] = 201] = "GETUNIFORM";
    FUNCTION_ID[FUNCTION_ID["GETUNIFORMLOCATION"] = 202] = "GETUNIFORMLOCATION";
    FUNCTION_ID[FUNCTION_ID["GETVERTEXATTRIB"] = 203] = "GETVERTEXATTRIB";
    FUNCTION_ID[FUNCTION_ID["GETVERTEXATTRIBOFFSET"] = 204] = "GETVERTEXATTRIBOFFSET";
    FUNCTION_ID[FUNCTION_ID["HINT"] = 205] = "HINT";
    FUNCTION_ID[FUNCTION_ID["ISBUFFER"] = 206] = "ISBUFFER";
    FUNCTION_ID[FUNCTION_ID["ISENABLED"] = 207] = "ISENABLED";
    FUNCTION_ID[FUNCTION_ID["ISFRAMEBUFFER"] = 208] = "ISFRAMEBUFFER";
    FUNCTION_ID[FUNCTION_ID["ISPROGRAM"] = 209] = "ISPROGRAM";
    FUNCTION_ID[FUNCTION_ID["ISRENDERBUFFER"] = 210] = "ISRENDERBUFFER";
    FUNCTION_ID[FUNCTION_ID["ISSHADER"] = 211] = "ISSHADER";
    FUNCTION_ID[FUNCTION_ID["ISTEXTURE"] = 212] = "ISTEXTURE";
    FUNCTION_ID[FUNCTION_ID["LINEWIDTH"] = 213] = "LINEWIDTH";
    FUNCTION_ID[FUNCTION_ID["LINKPROGRAM"] = 214] = "LINKPROGRAM";
    FUNCTION_ID[FUNCTION_ID["PIXELSTOREI"] = 215] = "PIXELSTOREI";
    FUNCTION_ID[FUNCTION_ID["POLYGONOFFSET"] = 216] = "POLYGONOFFSET";
    FUNCTION_ID[FUNCTION_ID["READPIXELS"] = 217] = "READPIXELS";
    FUNCTION_ID[FUNCTION_ID["RENDERBUFFERSTORAGE"] = 218] = "RENDERBUFFERSTORAGE";
    FUNCTION_ID[FUNCTION_ID["SAMPLECOVERAGE"] = 219] = "SAMPLECOVERAGE";
    FUNCTION_ID[FUNCTION_ID["SCISSOR"] = 220] = "SCISSOR";
    FUNCTION_ID[FUNCTION_ID["SHADERSOURCE"] = 221] = "SHADERSOURCE";
    FUNCTION_ID[FUNCTION_ID["STENCILFUNC"] = 222] = "STENCILFUNC";
    FUNCTION_ID[FUNCTION_ID["STENCILFUNCSEPARATE"] = 223] = "STENCILFUNCSEPARATE";
    FUNCTION_ID[FUNCTION_ID["STENCILMASK"] = 224] = "STENCILMASK";
    FUNCTION_ID[FUNCTION_ID["STENCILMASKSEPARATE"] = 225] = "STENCILMASKSEPARATE";
    FUNCTION_ID[FUNCTION_ID["STENCILOP"] = 226] = "STENCILOP";
    FUNCTION_ID[FUNCTION_ID["STENCILOPSEPARATE"] = 227] = "STENCILOPSEPARATE";
    FUNCTION_ID[FUNCTION_ID["TEXIMAGE2D"] = 228] = "TEXIMAGE2D";
    FUNCTION_ID[FUNCTION_ID["TEXPARAMETERF"] = 229] = "TEXPARAMETERF";
    FUNCTION_ID[FUNCTION_ID["TEXPARAMETERI"] = 230] = "TEXPARAMETERI";
    FUNCTION_ID[FUNCTION_ID["TEXSUBIMAGE2D"] = 231] = "TEXSUBIMAGE2D";
    FUNCTION_ID[FUNCTION_ID["UNIFORM1F"] = 232] = "UNIFORM1F";
    FUNCTION_ID[FUNCTION_ID["UNIFORM1FV"] = 233] = "UNIFORM1FV";
    FUNCTION_ID[FUNCTION_ID["UNIFORM1I"] = 234] = "UNIFORM1I";
    FUNCTION_ID[FUNCTION_ID["UNIFORM1IV"] = 235] = "UNIFORM1IV";
    FUNCTION_ID[FUNCTION_ID["UNIFORM2F"] = 236] = "UNIFORM2F";
    FUNCTION_ID[FUNCTION_ID["UNIFORM2FV"] = 237] = "UNIFORM2FV";
    FUNCTION_ID[FUNCTION_ID["UNIFORM2I"] = 238] = "UNIFORM2I";
    FUNCTION_ID[FUNCTION_ID["UNIFORM2IV"] = 239] = "UNIFORM2IV";
    FUNCTION_ID[FUNCTION_ID["UNIFORM3F"] = 240] = "UNIFORM3F";
    FUNCTION_ID[FUNCTION_ID["UNIFORM3FV"] = 241] = "UNIFORM3FV";
    FUNCTION_ID[FUNCTION_ID["UNIFORM3I"] = 242] = "UNIFORM3I";
    FUNCTION_ID[FUNCTION_ID["UNIFORM3IV"] = 243] = "UNIFORM3IV";
    FUNCTION_ID[FUNCTION_ID["UNIFORM4F"] = 244] = "UNIFORM4F";
    FUNCTION_ID[FUNCTION_ID["UNIFORM4FV"] = 245] = "UNIFORM4FV";
    FUNCTION_ID[FUNCTION_ID["UNIFORM4I"] = 246] = "UNIFORM4I";
    FUNCTION_ID[FUNCTION_ID["UNIFORM4IV"] = 247] = "UNIFORM4IV";
    FUNCTION_ID[FUNCTION_ID["UNIFORMMATRIX2FV"] = 248] = "UNIFORMMATRIX2FV";
    FUNCTION_ID[FUNCTION_ID["UNIFORMMATRIX3FV"] = 249] = "UNIFORMMATRIX3FV";
    FUNCTION_ID[FUNCTION_ID["UNIFORMMATRIX4FV"] = 250] = "UNIFORMMATRIX4FV";
    FUNCTION_ID[FUNCTION_ID["USEPROGRAM"] = 251] = "USEPROGRAM";
    FUNCTION_ID[FUNCTION_ID["VALIDATEPROGRAM"] = 252] = "VALIDATEPROGRAM";
    FUNCTION_ID[FUNCTION_ID["VERTEXATTRIB1F"] = 253] = "VERTEXATTRIB1F";
    FUNCTION_ID[FUNCTION_ID["VERTEXATTRIB1FV"] = 254] = "VERTEXATTRIB1FV";
    FUNCTION_ID[FUNCTION_ID["VERTEXATTRIB2F"] = 255] = "VERTEXATTRIB2F";
    FUNCTION_ID[FUNCTION_ID["VERTEXATTRIB2FV"] = 256] = "VERTEXATTRIB2FV";
    FUNCTION_ID[FUNCTION_ID["VERTEXATTRIB3F"] = 257] = "VERTEXATTRIB3F";
    FUNCTION_ID[FUNCTION_ID["VERTEXATTRIB3FV"] = 258] = "VERTEXATTRIB3FV";
    FUNCTION_ID[FUNCTION_ID["VERTEXATTRIB4F"] = 259] = "VERTEXATTRIB4F";
    FUNCTION_ID[FUNCTION_ID["VERTEXATTRIB4FV"] = 260] = "VERTEXATTRIB4FV";
    FUNCTION_ID[FUNCTION_ID["VERTEXATTRIBPOINTER"] = 261] = "VERTEXATTRIBPOINTER";
    FUNCTION_ID[FUNCTION_ID["VIEWPORT"] = 262] = "VIEWPORT";
    FUNCTION_ID[FUNCTION_ID["CONFIGUREBACKBUFFER"] = 263] = "CONFIGUREBACKBUFFER";
    FUNCTION_ID[FUNCTION_ID["COMPRESSEDTEXIMAGE2D"] = 264] = "COMPRESSEDTEXIMAGE2D";
    FUNCTION_ID[FUNCTION_ID["TEXIMAGE2D_PIXEL"] = 265] = "TEXIMAGE2D_PIXEL";
    FUNCTION_ID[FUNCTION_ID["TEXSUBIMAGE2D_PIXEL"] = 266] = "TEXSUBIMAGE2D_PIXEL";
    FUNCTION_ID[FUNCTION_ID["CREATEVERTEXARRAY"] = 267] = "CREATEVERTEXARRAY";
    FUNCTION_ID[FUNCTION_ID["BINDVERTEXARRAY"] = 268] = "BINDVERTEXARRAY";
    FUNCTION_ID[FUNCTION_ID["DELETEVERTEXARRAYS"] = 269] = "DELETEVERTEXARRAYS";
    FUNCTION_ID[FUNCTION_ID["READPIXELS_ASYNC"] = 270] = "READPIXELS_ASYNC";
    FUNCTION_ID[FUNCTION_ID["COMPRESSEDTEXSUBIMAGE2D"] = 271] = "COMPRESSEDTEXSUBIMAGE2D";
    FUNCTION_ID[FUNCTION_ID["VERTEXATTRIBDIVISOR"] = 272] = "VERTEXATTRIBDIVISOR";
    FUNCTION_ID[FUNCTION_ID["DRAWARRAYSINSTANCED"] = 273] = "DRAWARRAYSINSTANCED";
    FUNCTION_ID[FUNCTION_ID["DRAWELEMENTSINSTANCED"] = 274] = "DRAWELEMENTSINSTANCED";
    FUNCTION_ID[FUNCTION_ID["TEXIMAGE2DCANVAS"] = 275] = "TEXIMAGE2DCANVAS";
})(FUNCTION_ID || (FUNCTION_ID = {}));
var UNIFORM_TYPE;
(function (UNIFORM_TYPE) {
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORM1F"] = 0] = "INTERIOR_UNIFORM1F";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORM1FV"] = 1] = "INTERIOR_UNIFORM1FV";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORM1I"] = 2] = "INTERIOR_UNIFORM1I";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORM1IV"] = 3] = "INTERIOR_UNIFORM1IV";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORM2F"] = 4] = "INTERIOR_UNIFORM2F";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORM2FV"] = 5] = "INTERIOR_UNIFORM2FV";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORM2I"] = 6] = "INTERIOR_UNIFORM2I";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORM2IV"] = 7] = "INTERIOR_UNIFORM2IV";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORM3F"] = 8] = "INTERIOR_UNIFORM3F";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORM3FV"] = 9] = "INTERIOR_UNIFORM3FV";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORM3I"] = 10] = "INTERIOR_UNIFORM3I";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORM3IV"] = 11] = "INTERIOR_UNIFORM3IV";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORM4F"] = 12] = "INTERIOR_UNIFORM4F";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORM4FV"] = 13] = "INTERIOR_UNIFORM4FV";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORM4I"] = 14] = "INTERIOR_UNIFORM4I";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORM4IV"] = 15] = "INTERIOR_UNIFORM4IV";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORMMATRIX2FV"] = 16] = "INTERIOR_UNIFORMMATRIX2FV";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORMMATRIX3FV"] = 17] = "INTERIOR_UNIFORMMATRIX3FV";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORMMATRIX4FV"] = 18] = "INTERIOR_UNIFORMMATRIX4FV";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORMSAMPLER_2D"] = 19] = "INTERIOR_UNIFORMSAMPLER_2D";
    UNIFORM_TYPE[UNIFORM_TYPE["INTERIOR_UNIFORMSAMPLER_CUBE"] = 20] = "INTERIOR_UNIFORMSAMPLER_CUBE";
})(UNIFORM_TYPE || (UNIFORM_TYPE = {}));
class BindInfo {
    constructor() {
        this.m_bindMap = {};
    }
    setBind(pname, buffer) {
        this.m_bindMap[pname] = buffer;
    }
    getBind(pname) {
        var buffer = this.m_bindMap[pname];
        if (!buffer)
            return null;
        if (buffer.id == -1) {
            this.m_bindMap[pname] = null;
            return null;
        }
        return buffer;
    }
}
class ANGLEInstancedArrays {
    constructor(encoder) {
        this.encoder = encoder;
    }
    vertexAttribDivisorANGLE(index, divisor) {
        this.encoder.vertexAttribDivisor(index, divisor);
    }
    drawArraysInstancedANGLE(mode, first, count, instanceCount) {
        this.encoder.drawArraysInstanced(mode, first, count, instanceCount);
    }
    drawElementsInstancedANGLE(mode, count, type, offset, instanceCount) {
        this.encoder.drawElementsInstanced(mode, count, type, offset, instanceCount);
    }
}
class WebGLBuffer {
    constructor(id) {
        this.id = id;
    }
}
class WebGLFrameBuffer {
    constructor(id) {
        this.id = id;
        this.m_bindInfo = new BindInfo();
    }
    setBind(pname, buffer) {
        this.m_bindInfo.setBind(pname, buffer);
    }
    getBind(pname) {
        return this.m_bindInfo.getBind(pname);
    }
}
class WebGLRenderBuffer {
    constructor(id) {
        this.id = id;
    }
}
class WebGLShader {
    constructor(id, type) {
        this.id = id;
        this.type = type;
        this.compileStatus = 0;
        this.src = "";
    }
}
class WebGLProgram {
    constructor(id) {
        this.id = id;
        this.linkStatus = 0;
        this.vsShader = null;
        this.psShader = null;
        this.attachedShaderCount = 0;
        this.m_localMap = {};
    }
    addLocationPair(fakeLoc, name) {
        this.m_localMap[fakeLoc] = name;
    }
    getLocationName(fakeLoc) {
        return this.m_localMap[fakeLoc];
    }
}
class WebGLTexture {
    constructor(id) {
        this.id = id;
    }
}
class WebGLVertextArray {
    constructor(id) {
        this.id = id;
    }
}
class CallbackFuncObj {
    constructor() {
        this._vFunc = new Map();
        this.id = CallbackFuncObj.s_nID++;
        this._nativeObj = new _callbackFuncObj(this.id);
    }
    addCallbackFunc(index, func) {
        this._vFunc[index] = func;
        this._nativeObj.addCallbackFunc(index, func);
    }
}
CallbackFuncObj.s_nID = 0;
class fakeIDObj {
    constructor(id = 0, frame = 0) {
        this.id = id;
        this.frameCount = frame;
    }
}
class GLCommandEncoder {
    constructor(layagl, reserveSize, adjustSize, isSyncToRenderThread) {
        this._adjustSize = 0;
        this._byteLen = 0;
        this._isSyncToRenderThread = false;
        this._readPixelsAsyncCallbackFuncObj = new CallbackFuncObj();
        this._isSyncToRenderThread = isSyncToRenderThread;
        this._layagl = layagl;
        this._byteLen = reserveSize;
        this._adjustSize = adjustSize;
        this._init(isSyncToRenderThread);
    }
    _init(isSyncToRenderThread) {
        this._buffer = new ArrayBuffer(this._byteLen);
        this._idata = new Int32Array(this._buffer);
        this._fdata = new Float32Array(this._buffer);
        this._byteArray = new Uint8Array(this._buffer);
        LayaGLContext.createArrayBufferRef(this._buffer, LayaGLContext.ARRAY_BUFFER_TYPE_CMD, isSyncToRenderThread);
        this._idata[0] = 1;
    }
    getPtrID() {
        return this._buffer["_ptrID"];
    }
    beginEncoding() {
        this._layagl.beginCommandEncoding(this);
    }
    endEncoding() {
        this._layagl.endCommandEncoding();
    }
    clearEncoding() {
        this._idata[0] = 1;
    }
    getCount() {
        return this._idata[0];
    }
    _need(sz) {
        if ((this._byteLen - (this._idata[0] << 2)) >= sz)
            return;
        this._byteLen += (sz > this._adjustSize) ? sz : this._adjustSize;
        var pre = this._idata;
        var preConchRef = this._buffer["conchRef"];
        var prePtrID = this._buffer["_ptrID"];
        this._buffer = new ArrayBuffer(this._byteLen);
        this._idata = new Int32Array(this._buffer);
        this._fdata = new Float32Array(this._buffer);
        this._byteArray = new Uint8Array(this._buffer);
        this._buffer["conchRef"] = preConchRef;
        this._buffer["_ptrID"] = prePtrID;
        pre && this._idata.set(pre, 0);
        conch.updateArrayBufferRef(this._buffer["_ptrID"], preConchRef.isSyncToRender(), this._buffer);
    }
    add_i(i) {
        this._need(4);
        this._idata[this._idata[0]++] = i;
    }
    add_f(a) {
        this._need(4);
        this._fdata[this._idata[0]++] = a;
    }
    add_ff(a, b) {
        this._need(8);
        var i = this._idata[0];
        this._fdata[i++] = a;
        this._fdata[i++] = b;
        this._idata[0] = i;
    }
    add_fff(a, b, c) {
        this._need(12);
        var i = this._idata[0];
        this._fdata[i++] = a;
        this._fdata[i++] = b;
        this._fdata[i++] = c;
        this._idata[0] = i;
    }
    add_ii(a, b) {
        this._need(8);
        var i = this._idata[0];
        this._idata[i++] = a;
        this._idata[i++] = b;
        this._idata[0] = i;
    }
    add_if(a, b) {
        this._need(8);
        var i = this._idata[0];
        this._idata[i++] = a;
        this._fdata[i++] = b;
        this._idata[0] = i;
    }
    add_iii(a, b, c) {
        this._need(12);
        var idata = this._idata;
        var i = this._idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        this._idata[0] = i;
    }
    add_iif(a, b, c) {
        this._need(12);
        var idata = this._idata;
        var i = this._idata[0];
        idata[i++] = a;
        idata[i++] = b;
        this._fdata[i++] = c;
        this._idata[0] = i;
    }
    add_ifi(a, b, c) {
        this._need(12);
        var idata = this._idata;
        var i = this._idata[0];
        idata[i++] = a;
        this._fdata[i++] = b;
        idata[i++] = c;
        this._idata[0] = i;
    }
    add_iifi(a, b, c, d) {
        this._need(16);
        var idata = this._idata;
        var i = this._idata[0];
        idata[i++] = a;
        idata[i++] = b;
        this._fdata[i++] = c;
        idata[i++] = d;
        this._idata[0] = i;
    }
    add_iiii(a, b, c, d) {
        this._need(16);
        var idata = this._idata;
        var i = this._idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        idata[i++] = d;
        idata[0] = i;
    }
    add_iiif(a, b, c, d) {
        this._need(16);
        var idata = this._idata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        this._fdata[i++] = d;
        idata[0] = i;
    }
    add_iiiif(a, b, c, d, e) {
        this._need(20);
        var idata = this._idata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        idata[i++] = d;
        this._fdata[i++] = e;
        idata[0] = i;
    }
    add_iiiff(a, b, c, d, e) {
        this._need(20);
        var idata = this._idata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        this._fdata[i++] = d;
        this._fdata[i++] = e;
        idata[0] = i;
    }
    add_iiiiff(a, b, c, d, e, f) {
        this._need(24);
        var idata = this._idata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        idata[i++] = d;
        this._fdata[i++] = e;
        this._fdata[i++] = f;
        idata[0] = i;
    }
    add_iiifff(a, b, c, d, e, f) {
        this._need(24);
        var idata = this._idata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        this._fdata[i++] = d;
        this._fdata[i++] = e;
        this._fdata[i++] = f;
        idata[0] = i;
    }
    add_iiiifff(a, b, c, d, e, f, g) {
        this._need(28);
        var idata = this._idata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        idata[i++] = d;
        this._fdata[i++] = e;
        this._fdata[i++] = f;
        this._fdata[i++] = g;
        idata[0] = i;
    }
    add_iiiffff(a, b, c, d, e, f, g) {
        this._need(28);
        var idata = this._idata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        this._fdata[i++] = d;
        this._fdata[i++] = e;
        this._fdata[i++] = f;
        this._fdata[i++] = g;
        idata[0] = i;
    }
    add_iiiiffff(a, b, c, d, e, f, g, h) {
        this._need(32);
        var idata = this._idata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        idata[i++] = d;
        this._fdata[i++] = e;
        this._fdata[i++] = f;
        this._fdata[i++] = g;
        this._fdata[i++] = h;
        idata[0] = i;
    }
    add_iiff(a, b, c, d) {
        this._need(16);
        var idata = this._idata;
        var fdata = this._fdata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        fdata[i++] = c;
        fdata[i++] = d;
        idata[0] = i;
    }
    add_iifff(a, b, c, d, e) {
        this._need(20);
        var idata = this._idata;
        var fdata = this._fdata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        fdata[i++] = c;
        fdata[i++] = d;
        fdata[i++] = e;
        idata[0] = i;
    }
    add_iiffff(a, b, c, d, e, f) {
        this._need(24);
        var idata = this._idata;
        var fdata = this._fdata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        fdata[i++] = c;
        fdata[i++] = d;
        fdata[i++] = e;
        fdata[i++] = f;
        idata[0] = i;
    }
    add_iiiii(a, b, c, d, e) {
        this._need(20);
        var idata = this._idata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        idata[i++] = d;
        idata[i++] = e;
        idata[0] = i;
    }
    add_iiiiii(a, b, c, d, e, f) {
        this._need(24);
        var idata = this._idata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        idata[i++] = d;
        idata[i++] = e;
        idata[i++] = f;
        idata[0] = i;
    }
    add_iiiiiii(a, b, c, d, e, f, g) {
        this._need(28);
        var idata = this._idata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        idata[i++] = d;
        idata[i++] = e;
        idata[i++] = f;
        idata[i++] = g;
        idata[0] = i;
    }
    add_iiiiiiiiiiii(a, b, c, d, e, f, g, h, j, k, l, m) {
        this._need(48);
        var idata = this._idata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        idata[i++] = d;
        idata[i++] = e;
        idata[i++] = f;
        idata[i++] = g;
        idata[i++] = h;
        idata[i++] = j;
        idata[i++] = k;
        idata[i++] = l;
        idata[i++] = m;
        idata[0] = i;
    }
    add_iiiiiiiiiiiii(a, b, c, d, e, f, g, h, j, k, l, m, n) {
        this._need(52);
        var idata = this._idata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        idata[i++] = d;
        idata[i++] = e;
        idata[i++] = f;
        idata[i++] = g;
        idata[i++] = h;
        idata[i++] = j;
        idata[i++] = k;
        idata[i++] = l;
        idata[i++] = m;
        idata[i++] = n;
        idata[0] = i;
    }
    add_iff(a, b, c) {
        this._need(12);
        var i = this._idata[0];
        this._idata[i++] = a;
        this._fdata[i++] = b;
        this._fdata[i++] = c;
        this._idata[0] = i;
    }
    add_iffi(a, b, c, d) {
        this._need(16);
        var i = this._idata[0];
        this._idata[i++] = a;
        this._fdata[i++] = b;
        this._fdata[i++] = c;
        this._idata[i++] = d;
        this._idata[0] = i;
    }
    add_ifffi(a, b, c, d, e) {
        this._need(20);
        var i = this._idata[0];
        this._idata[i++] = a;
        this._fdata[i++] = b;
        this._fdata[i++] = c;
        this._fdata[i++] = d;
        this._idata[i++] = e;
        this._idata[0] = i;
    }
    add_iffff(a, b, c, d, e) {
        this._need(20);
        var i = this._idata[0];
        var fdata = this._fdata;
        this._idata[i++] = a;
        fdata[i++] = b;
        fdata[i++] = c;
        fdata[i++] = d;
        fdata[i++] = e;
        this._idata[0] = i;
    }
    add_iffffi(a, b, c, d, e, f) {
        this._need(24);
        var i = this._idata[0];
        var fdata = this._fdata;
        this._idata[i++] = a;
        fdata[i++] = b;
        fdata[i++] = c;
        fdata[i++] = d;
        fdata[i++] = e;
        this._idata[i++] = f;
        this._idata[0] = i;
    }
    add_ifffffi(a, b, c, d, e, f, g) {
        this._need(28);
        var i = this._idata[0];
        var fdata = this._fdata;
        this._idata[i++] = a;
        fdata[i++] = b;
        fdata[i++] = c;
        fdata[i++] = d;
        fdata[i++] = e;
        fdata[i++] = f;
        this._idata[i++] = g;
        this._idata[0] = i;
    }
    add_iffffiif(a, b, c, d, e, f, g, h) {
        this._need(28);
        var i = this._idata[0];
        var fdata = this._fdata;
        this._idata[i++] = a;
        fdata[i++] = b;
        fdata[i++] = c;
        fdata[i++] = d;
        fdata[i++] = e;
        this._idata[i++] = f;
        this._idata[i++] = g;
        fdata[i++] = h;
        this._idata[0] = i;
    }
    add_iffffiii(a, b, c, d, e, f, g, h) {
        this._need(32);
        var i = this._idata[0];
        var fdata = this._fdata;
        this._idata[i++] = a;
        fdata[i++] = b;
        fdata[i++] = c;
        fdata[i++] = d;
        fdata[i++] = e;
        this._idata[i++] = f;
        this._idata[i++] = g;
        this._idata[i++] = h;
        this._idata[0] = i;
    }
    add_iiiiiiii(a, b, c, d, e, f, g, h) {
        this._need(32);
        var i = this._idata[0];
        var idata = this._idata;
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        idata[i++] = d;
        idata[i++] = e;
        idata[i++] = f;
        idata[i++] = g;
        idata[i++] = h;
        idata[0] = i;
    }
    add_iiiiiiiii(a, b, c, d, e, f, g, h, j) {
        this._need(36);
        var idata = this._idata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        idata[i++] = d;
        idata[i++] = e;
        idata[i++] = f;
        idata[i++] = g;
        idata[i++] = h;
        idata[i++] = j;
        idata[0] = i;
    }
    add_iiiiiiiiii(a, b, c, d, e, f, g, h, j, k) {
        this._need(40);
        var idata = this._idata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        idata[i++] = d;
        idata[i++] = e;
        idata[i++] = f;
        idata[i++] = g;
        idata[i++] = h;
        idata[i++] = j;
        idata[i++] = k;
        idata[0] = i;
    }
    add_iiiiiiiiiii(a, b, c, d, e, f, g, h, j, k, l) {
        this._need(44);
        var idata = this._idata;
        var i = idata[0];
        idata[i++] = a;
        idata[i++] = b;
        idata[i++] = c;
        idata[i++] = d;
        idata[i++] = e;
        idata[i++] = f;
        idata[i++] = g;
        idata[i++] = h;
        idata[i++] = j;
        idata[i++] = k;
        idata[i++] = l;
        idata[0] = i;
    }
    add_String(str, len) {
        var ab = conch.strTobufer(str);
        this._need(len + 4);
        this._idata[this._idata[0]++] = len;
        if (len == 0)
            return;
        var uint8array = new Uint8Array(ab);
        this._byteArray.set(uint8array, this._idata[0] * 4);
        this._idata[0] += len / 4;
    }
    add_blockStart(len, a, data) {
        this._need(12);
        var idata = this._idata;
        idata[idata[0]++] = len;
        idata[idata[0]++] = a;
        idata[idata[0]++] = data._data["_ptrID"];
    }
    add_blockEnd(len, a, data) {
        this._need(12);
        var idata = this._idata;
        idata[idata[0]++] = len;
        idata[idata[0]++] = a;
        idata[idata[0]++] = data._data["_ptrID"];
    }
    wab(arraybuffer, length, nAlignLength, offset) {
        offset = offset ? offset : 0;
        this._need(nAlignLength + 4);
        this._idata[this._idata[0]++] = length;
        var uint8array = null;
        if (arraybuffer instanceof Float32Array && offset == 0) {
            this._fdata.set(arraybuffer, this._idata[0]);
        }
        else {
            if (arraybuffer instanceof ArrayBuffer) {
                uint8array = new Uint8Array(arraybuffer, offset, length);
            }
            else if (arraybuffer.buffer) {
                uint8array = new Uint8Array(arraybuffer.buffer, offset + arraybuffer.byteOffset, length);
            }
            else {
                console.log("not arraybuffer/dataview");
                return;
            }
            this._byteArray.set(uint8array, this._idata[0] * 4);
        }
        this._idata[0] += nAlignLength / 4;
    }
    copyBuffer(arraybuffer, length, offset) {
        offset = offset ? offset : 0;
        this._need(length);
        var ab = null;
        if (arraybuffer instanceof ArrayBuffer) {
            ab = arraybuffer;
        }
        else if (arraybuffer.buffer) {
            ab = arraybuffer.buffer;
        }
        else {
            console.log("not arraybuffer/dataview ");
            return;
        }
        var uint8array = new Uint8Array(ab, offset, length);
        this._byteArray.set(uint8array, this._idata[0] * 4);
        this._idata[0] += length / 4;
    }
    getContextAttributes() {
        return { alpha: false, antialias: false, depth: true, failIfMajorPerformanceCaveat: false, premultipliedAlpha: true, preserveDrawingBuffer: false, stencil: false };
    }
    isContextLost() {
        console.log("isContextLost can't support");
        return false;
    }
    getSupportedExtensions() {
        let extentions = this._layagl._nativeObj.getStringEx(0x1F03).split(' ');
        let version = this._layagl._nativeObj.getStringEx(0x1F02);
        function supports(extention) {
            for (let ext of extentions) {
                if (ext === extention) {
                    return true;
                }
            }
            return false;
        }
        let result = [];
        if (supports("GL_EXT_blend_minmax"))
            result.push("EXT_blend_minmax");
        if (supports("GL_EXT_sRGB"))
            result.push("EXT_sRGB");
        if (supports("GL_EXT_frag_depth"))
            result.push("EXT_frag_depth");
        if (supports("GL_OES_texture_float"))
            result.push("OES_texture_float");
        if (supports("GL_OES_texture_float_linear"))
            result.push("OES_texture_float_linear");
        if (supports("GL_OES_texture_half_float"))
            result.push("OES_texture_half_float");
        if (supports("GL_OES_texture_half_float_linear"))
            result.push("OES_texture_half_float_linear");
        if (supports("GL_OES_standard_derivatives"))
            result.push("OES_standard_derivatives");
        if (supports("GL_EXT_shader_texture_lod") || supports("GL_ARB_shader_texture_lod"))
            result.push("EXT_shader_texture_lod");
        if (supports("GL_EXT_texture_filter_anisotropic"))
            result.push("EXT_texture_filter_anisotropic");
        if (supports("GL_OES_vertex_array_object"))
            result.push("OES_vertex_array_object");
        if (supports("GL_OES_element_index_uint"))
            result.push("OES_element_index_uint");
        if (supports("GL_ANGLE_translated_shader_source"))
            result.push("WEBGL_debug_shaders");
        if (supports("GL_AMD_compressed_ATC_texture"))
            result.push("WEBGL_compressed_texture_atc");
        if (supports("GL_IMG_texture_compression_pvrtc"))
            result.push("WEBGL_compressed_texture_pvrtc");
        if (supports("GL_EXT_texture_compression_s3tc") || supports("GL_EXT_texture_compression_dxt1"))
            result.push("WEBGL_compressed_texture_s3tc");
        if (supports("GL_OES_depth_texture") || supports("GL_ARB_depth_texture"))
            result.push("WEBGL_depth_texture");
        if (version.indexOf("OpenGL ES 3.")) {
            result.push("WEBGL_compressed_texture_etc");
        }
        if (supports("ANGLE_instanced_arrays"))
            result.push("ANGLE_instanced_arrays");
        if (supports("GL_EXT_color_buffer_float"))
            result.push("EXT_color_buffer_float");
        if (supports("GL_EXT_color_buffer_half_float"))
            result.push("EXT_color_buffer_half_float");
        if (supports("GL_EXT_disjoint_timer_query"))
            result.push("EXT_disjoint_timer_query");
        if (supports("GL_OES_compressed_ETC1_RGB8_texture"))
            result.push("WEBGL_compressed_texture_etc1");
        if (supports("GL_EXT_texture_compression_s3tc"))
            result.push("WEBGL_compressed_texture_s3tc");
        if (supports("GL_EXT_texture_compression_s3tc_srgb"))
            result.push("WEBGL_compressed_texture_s3tc_srgb");
        result.push("WEBGL_debug_renderer_info");
        result.push("WEBGL_lose_context");
        return result;
    }
    getExtension(name) {
        var extention = this._layagl._nativeObj.getStringEx(0x1F03);
        let extentions = extention.split(' ');
        function supports(extention) {
            for (let ext of extentions) {
                if (ext === extention) {
                    return true;
                }
            }
            return false;
        }
        if (name === 'EXT_blend_minmax' && extention.indexOf('GL_EXT_blend_minmax') != -1) {
            return {
                MAX_EXT: 32776,
                MIN_EXT: 32775,
            };
        }
        else if (name === 'EXT_color_buffer_float' && extention.indexOf('GL_EXT_color_buffer_float') != -1) {
            return {};
        }
        else if (name === 'EXT_color_buffer_half_float' && extention.indexOf('GL_EXT_color_buffer_half_float') != -1) {
            return {};
        }
        else if (name === 'EXT_shader_texture_lod' &&
            (extention.indexOf('GL_EXT_shader_texture_lod') != -1 || extention.indexOf('GL_ARB_shader_texture_lod') != -1)) {
            return {};
        }
        else if (name === 'OES_element_index_uint' && extention.indexOf('GL_OES_element_index_uint') != -1) {
            return {};
        }
        else if (name === 'EXT_sRGB' && extention.indexOf('GL_EXT_sRGB') != -1) {
            return {
                SRGB_EXT: 0x8C40,
                SRGB_ALPHA_EXT: 0x8C42,
                SRGB8_ALPHA8_EXT: 0x8C43,
                FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: 0x8210
            };
        }
        else if (name === 'WEBGL_compressed_texture_pvrtc'
            && extention.indexOf('GL_IMG_texture_compression_pvrtc') != -1) {
            return {
                COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 35843,
                COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 35842,
                COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 35841,
                COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 35840,
            };
        }
        else if (name === 'WEBGL_compressed_texture_etc1'
            && extention.indexOf('GL_OES_compressed_ETC1_RGB8_texture') != -1) {
            return { COMPRESSED_RGB_ETC1_WEBGL: 36196 };
        }
        else if (name === 'WEBGL_compressed_texture_s3tc'
            && supports('GL_EXT_texture_compression_s3tc')) {
            return {
                COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777,
                COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778,
                COMPRESSED_RGBA_S3TC_DXT5_EXT: 33779,
                COMPRESSED_RGB_S3TC_DXT1_EXT: 33776,
            };
        }
        else if (name === 'WEBGL_compressed_texture_s3tc_srgb'
            && extention.indexOf('GL_EXT_texture_compression_s3tc_srgb') != -1) {
            return {
                COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 35917,
                COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 35918,
                COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 35919,
                COMPRESSED_SRGB_S3TC_DXT1_EXT: 35916,
            };
        }
        else if (name === 'WEBGL_debug_renderer_info') {
            return {
                UNMASKED_RENDERER_WEBGL: 37446,
                UNMASKED_VENDOR_WEBGL: 37445,
            };
        }
        else if (name === 'EXT_texture_filter_anisotropic'
            && extention.indexOf('GL_EXT_texture_filter_anisotropic') != -1) {
            return {
                MAX_TEXTURE_MAX_ANISOTROPY_EXT: 34047,
                TEXTURE_MAX_ANISOTROPY_EXT: 34046,
            };
        }
        else if (name.indexOf('ANGLE_instanced_arrays') != -1 && (conchConfig.glCaps & GL_CAPS.INSTANCEING)) {
            return new ANGLEInstancedArrays(this);
        }
        else {
            console.log("getExtension " + name + " 尚未支持");
        }
        return null;
    }
    activeTexture(texture) {
        this.add_iii(8, FUNCTION_ID.ACTIVETEXTURE, texture);
    }
    attachShader(program, shader) {
        if (shader.type == this._layagl.VERTEX_SHADER) {
            if (program.vsShader)
                return;
            program.vsShader = shader;
            program.attachedShaderCount++;
        }
        else if (shader.type == this._layagl.FRAGMENT_SHADER) {
            if (program.psShader)
                return;
            program.psShader = shader;
            program.attachedShaderCount++;
        }
        this.add_iiii(12, FUNCTION_ID.ATTACHSHADER, program.id, shader.id);
    }
    bindAttribLocation(program, index, name) {
        var strLen = this.getStrLength(name);
        this.add_iiii(16 + strLen, FUNCTION_ID.BINDATTRIBLOCATION, program.id, index);
        this.add_String(name, strLen);
    }
    bindBuffer(target, buffer) {
        this.add_iiii(12, FUNCTION_ID.BINDBUFFER, target, buffer ? buffer.id : 0);
    }
    bindFramebuffer(target, framebuffer) {
        this.add_iiii(12, FUNCTION_ID.BINDFRAMEBUFFER, target, framebuffer ? framebuffer.id : 0);
    }
    bindRenderbuffer(target, renderbuffer) {
        this.add_iiii(12, FUNCTION_ID.BINDRENDERBUFFER, target, renderbuffer ? renderbuffer.id : 0);
    }
    bindTexture(target, texture) {
        this.add_iiii(12, FUNCTION_ID.BINDTEXTURE, target, texture ? texture.id : 0);
    }
    useTexture(texture) {
        this.add_iii(8, FUNCTION_ID.USETEXTURE, texture ? texture.id : 0);
    }
    blendColor(red, green, blue, alpha) {
        this.add_iiffff(20, FUNCTION_ID.BLENDCOLOR, red, green, blue, alpha);
    }
    blendEquation(mode) {
        this.add_iii(8, FUNCTION_ID.BLENDEQUATION, mode);
    }
    blendEquationSeparate(modeRGB, modeAlpha) {
        this.add_iiii(12, FUNCTION_ID.BLENDEQUATIONSEPARATE, modeRGB, modeAlpha);
    }
    blendFunc(sfactor, dfactor) {
        this.add_iiii(12, FUNCTION_ID.BLENDFUNC, sfactor, dfactor);
    }
    blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha) {
        this.add_iiiiii(20, FUNCTION_ID.BLENDFUNCSEPARATE, srcRGB, dstRGB, srcAlpha, dstAlpha);
    }
    bufferData(target, sizeOrArray, usage) {
        if (ArrayBuffer.isView(sizeOrArray) || (sizeOrArray instanceof ArrayBuffer)) {
            var nAlignLength = this.getAlignLength(sizeOrArray);
            this.add_iiii(16 + nAlignLength, FUNCTION_ID.BUFFERDATA_ARRAYBUFFER, target, usage);
            this.wab(sizeOrArray, sizeOrArray.byteLength, nAlignLength);
        }
        else {
            var size = sizeOrArray;
            this.add_iiiii(16, FUNCTION_ID.BUFFERDATA_SIZE, target, size, usage);
        }
    }
    bufferSubData(target, offset, data) {
        var nAlignLength = this.getAlignLength(data);
        this.add_iiii(16 + nAlignLength, FUNCTION_ID.BUFFERSUBDATA, target, offset);
        this.wab(data, data.byteLength, nAlignLength);
    }
    checkFramebufferStatus(target) {
        return this._layagl._nativeObj.checkFramebufferStatusEx(target);
    }
    clear(mask) {
        this.add_iii(8, FUNCTION_ID.CLEAR, mask);
    }
    clearColor(red, green, blue, alpha) {
        this.add_iiffff(20, FUNCTION_ID.CLEARCOLOR, red, green, blue, alpha);
    }
    clearDepth(depth) {
        this.add_iif(8, FUNCTION_ID.CLEARDEPTH, depth);
    }
    clearStencil(s) {
        this.add_iii(8, FUNCTION_ID.CLEARSTENCIL, s);
    }
    colorMask(red, green, blue, alpha) {
        this.add_iiiiii(20, FUNCTION_ID.COLORMASK, red, green, blue, alpha);
    }
    compileShader(shader) {
        this.add_iii(8, FUNCTION_ID.COMPILESHADER, shader.id);
        shader.compileStatus = this._layagl._nativeObj.getShaderParameter(shader.src, shader.type, this._layagl.COMPILE_STATUS);
    }
    copyTexImage2D(target, level, internalformat, x, y, width, height, border) {
        this.add_iiiiiiiiii(36, FUNCTION_ID.COPYTEXIMAGE2D, target, level, internalformat, x, y, width, height, border);
    }
    copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height) {
        this.add_iiiiiiiiii(36, FUNCTION_ID.COPYTEXSUBIMAGE2D, target, level, xoffset, yoffset, x, y, width, height);
    }
    createBuffer() {
        var fakeID = this.createFakeID();
        this.add_iii(8, FUNCTION_ID.CREATEBUFFER, fakeID);
        return new WebGLBuffer(fakeID);
    }
    createFramebuffer() {
        var fakeID = this.createFakeID();
        this.add_iii(8, FUNCTION_ID.CREATEFRAMEBUFFER, fakeID);
        return new WebGLFrameBuffer(fakeID);
    }
    createProgram() {
        var fakeID = this.createFakeID();
        this.add_iii(8, FUNCTION_ID.CREATEPROGRAM, fakeID);
        return new WebGLProgram(fakeID);
    }
    createRenderbuffer() {
        var fakeID = this.createFakeID();
        this.add_iii(8, FUNCTION_ID.CREATERENDERBUFFER, fakeID);
        return new WebGLRenderBuffer(fakeID);
    }
    createShader(type) {
        var fakeID = this.createFakeID();
        this.add_iiii(12, FUNCTION_ID.CREATESHADER, fakeID, type);
        return new WebGLShader(fakeID, type);
    }
    createTexture() {
        var fakeID = this.createFakeID();
        this.add_iii(8, FUNCTION_ID.CREATETEXTURE, fakeID);
        return new WebGLTexture(fakeID);
    }
    cullFace(mode) {
        this.add_iii(8, FUNCTION_ID.CULLFACE, mode);
    }
    deleteBuffer(buffer) {
        this.deleteFakeID(buffer.id);
        this.add_iii(8, FUNCTION_ID.DELETEBUFFER, buffer.id);
    }
    deleteFramebuffer(framebuffer) {
        this.deleteFakeID(framebuffer.id);
        this.add_iii(8, FUNCTION_ID.DELETEFRAMEBUFFER, framebuffer.id);
    }
    deleteProgram(program) {
        this.deleteFakeID(program.id);
        this.add_iii(8, FUNCTION_ID.DELETEPROGRAM, program.id);
    }
    deleteRenderbuffer(renderbuffer) {
        this.deleteFakeID(renderbuffer.id);
        this.add_iii(8, FUNCTION_ID.DELETERENDERBUFFER, renderbuffer.id);
    }
    deleteShader(shader) {
        this.deleteFakeID(shader.id);
        this.add_iii(8, FUNCTION_ID.DELETESHADER, shader.id);
    }
    deleteTexture(texture) {
        this.deleteFakeID(texture.id);
        this.add_iii(8, FUNCTION_ID.DELETETEXTURE, texture.id);
    }
    depthFunc(func) {
        this.add_iii(8, FUNCTION_ID.DEPTHFUNC, func);
    }
    depthMask(flag) {
        this.add_iii(8, FUNCTION_ID.DEPTHMASK, flag);
    }
    depthRange(zNear, zFar) {
        this.add_iiff(12, FUNCTION_ID.DEPTHRANGE, zNear, zFar);
    }
    detachShader(program, shader) {
        let shaderid = -1;
        if (program.vsShader && program.vsShader.id === shader.id) {
            shaderid = program.vsShader.id;
            program.vsShader = null;
        }
        else if (program.psShader && program.psShader.id === shader.id) {
            shaderid = program.psShader.id;
            program.psShader = null;
        }
        if (shaderid > 0) {
            program.attachedShaderCount--;
            this.add_iiii(12, FUNCTION_ID.DETACHSHADER, program.id, shaderid);
        }
    }
    disable(cap) {
        this.add_iii(8, FUNCTION_ID.DISABLE, cap);
    }
    disableVertexAttribArray(index) {
        this.add_iii(8, FUNCTION_ID.DISABLEVERTEXATTRIBARRAY, index);
    }
    drawArrays(mode, first, count) {
        this.add_iiiii(16, FUNCTION_ID.DRAWARRAYS, mode, first, count);
    }
    drawElements(mode, count, type, offset) {
        this.add_iiiiii(20, FUNCTION_ID.DRAWELEMENTS, mode, count, type, offset);
    }
    enable(cap) {
        this.add_iii(8, FUNCTION_ID.ENABLE, cap);
    }
    enableVertexAttribArray(index) {
        this.add_iii(8, FUNCTION_ID.ENABLEVERTEXATTRIBARRAY, index);
    }
    finish() {
        this.add_ii(4, FUNCTION_ID.FINISH);
    }
    flush() {
        this.add_ii(4, FUNCTION_ID.FLUSH);
    }
    framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) {
        this.add_iiiiii(20, FUNCTION_ID.FRAMEBUFFERRENDERBUFFER, target, attachment, renderbuffertarget, renderbuffer ? renderbuffer.id : 0);
    }
    framebufferTexture2D(target, attachment, textarget, texture, level) {
        this.add_iiiiiii(24, FUNCTION_ID.FRAMEBUFFERTEXTURE2D, target, attachment, textarget, texture ? texture.id : 0, level);
    }
    frontFace(mode) {
        this.add_iii(8, FUNCTION_ID.FRONTFACE, mode);
    }
    generateMipmap(target) {
        this.add_iii(8, FUNCTION_ID.GENERATEMIPMAP, target);
    }
    getActiveAttrib(program, index) {
        return this._layagl._nativeObj.getActiveAttribEx(program.linkedVSSource, program.linkedPSSource, "", index);
    }
    getActiveUniform(program, index) {
        return this._layagl._nativeObj.getActiveUniformEx(program.linkedVSSource, program.linkedPSSource, "", index);
    }
    getAttribLocation(program, name) {
        return this._layagl._nativeObj.getAttribLocationEx(program.linkedVSSource, program.linkedPSSource, "", name);
    }
    getParameter(pname) {
        var gl = this._layagl;
        var result = 0;
        switch (pname) {
            case gl.ACTIVE_TEXTURE:
            case gl.ALPHA_BITS:
            case gl.BLEND_DST_ALPHA:
            case gl.BLEND_DST_RGB:
            case gl.BLEND_EQUATION:
            case gl.BLEND_EQUATION_ALPHA:
            case gl.BLEND_EQUATION_RGB:
            case gl.BLEND_SRC_ALPHA:
            case gl.BLEND_SRC_RGB:
            case gl.BLUE_BITS:
            case gl.CULL_FACE_MODE:
            case gl.DEPTH_BITS:
            case gl.DEPTH_FUNC:
            case gl.FRONT_FACE:
            case gl.GENERATE_MIPMAP_HINT:
            case gl.GREEN_BITS:
            case gl.IMPLEMENTATION_COLOR_READ_FORMAT:
            case gl.IMPLEMENTATION_COLOR_READ_TYPE:
            case gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS:
            case gl.MAX_CUBE_MAP_TEXTURE_SIZE:
            case gl.MAX_FRAGMENT_UNIFORM_VECTORS:
            case gl.MAX_RENDERBUFFER_SIZE:
            case gl.MAX_TEXTURE_IMAGE_UNITS:
            case gl.MAX_TEXTURE_SIZE:
            case gl.MAX_VARYING_VECTORS:
            case gl.MAX_VERTEX_ATTRIBS:
            case gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS:
            case gl.MAX_VERTEX_UNIFORM_VECTORS:
            case gl.SAMPLE_BUFFERS:
            case gl.SAMPLES:
            case gl.STENCIL_BACK_FAIL:
            case gl.STENCIL_BACK_FUNC:
            case gl.STENCIL_BACK_PASS_DEPTH_FAIL:
            case gl.STENCIL_BACK_PASS_DEPTH_PASS:
            case gl.STENCIL_BACK_REF:
            case gl.STENCIL_BACK_VALUE_MASK:
            case gl.STENCIL_BACK_WRITEMASK:
            case gl.STENCIL_BITS:
            case gl.STENCIL_CLEAR_VALUE:
            case gl.STENCIL_FAIL:
            case gl.STENCIL_FUNC:
            case gl.STENCIL_PASS_DEPTH_FAIL:
            case gl.STENCIL_PASS_DEPTH_PASS:
            case gl.STENCIL_REF:
            case gl.STENCIL_VALUE_MASK:
            case gl.STENCIL_WRITEMASK:
            case gl.SUBPIXEL_BITS:
            case gl.UNPACK_ALIGNMENT:
                result = gl._nativeObj.getIntegerv(pname);
                break;
            case gl.CURRENT_PROGRAM:
                gl._nativeObj.flushCommand();
                result = this._layagl.getBind(pname);
                break;
            case gl.ARRAY_BUFFER_BINDING:
                gl._nativeObj.flushCommand();
                result = this._layagl.getBind(gl.ARRAY_BUFFER);
                break;
            case gl.ELEMENT_ARRAY_BUFFER_BINDING:
                gl._nativeObj.flushCommand();
                result = this._layagl.getBind(gl.ELEMENT_ARRAY_BUFFER);
                break;
            case gl.RENDERBUFFER_BINDING:
                gl._nativeObj.flushCommand();
                result = this._layagl.getBind(gl.RENDERBUFFER);
                break;
            case gl.TEXTURE_BINDING_2D:
                gl._nativeObj.flushCommand();
                result = this._layagl.getBind(gl.TEXTURE_2D);
                break;
            case gl.TEXTURE_BINDING_CUBE_MAP:
                gl._nativeObj.flushCommand();
                result = this._layagl.getBind(gl.TEXTURE_CUBE_MAP);
                break;
            case gl.BLEND:
            case gl.CULL_FACE:
            case gl.DEPTH_TEST:
            case gl.DEPTH_WRITEMASK:
            case gl.DITHER:
            case gl.SAMPLE_COVERAGE_INVERT:
            case gl.SCISSOR_TEST:
            case gl.STENCIL_TEST:
                var ret = gl._nativeObj.getBooleanv(pname);
                if (!ret)
                    result = false;
                else
                    result = true;
                break;
            case gl.DEPTH_CLEAR_VALUE:
            case gl.LINE_WIDTH:
            case gl.SAMPLE_COVERAGE_VALUE:
                result = gl._nativeObj.getFloatv(pname);
                break;
            case gl.ALIASED_LINE_WIDTH_RANGE:
            case gl.ALIASED_POINT_SIZE_RANGE:
            case gl.BLEND_COLOR:
            case gl.COLOR_CLEAR_VALUE:
            case gl.DEPTH_RANGE:
                result = gl._nativeObj.getFloatArrayv(pname);
                break;
            case gl.MAX_VIEWPORT_DIMS:
            case gl.SCISSOR_BOX:
            case gl.VIEWPORT:
                result = gl._nativeObj.getIntegerArrayv(pname);
                break;
            case gl.RENDERER:
            case gl.SHADING_LANGUAGE_VERSION:
            case gl.VENDOR:
            case gl.VERSION:
                result = gl._nativeObj.getStringEx(pname);
                break;
            case gl.MAX_TEXTURE_MAX_ANISOTROPY_EXT:
            case gl.TEXTURE_MAX_ANISOTROPY_EXT:
                result = gl._nativeObj.getParameter(pname);
                break;
            default:
                alert("getParameter 尚未支持");
                break;
        }
        return result;
    }
    getBufferParameter(target, pname) {
        return this._layagl._nativeObj.getBufferParameterEx(target, pname);
    }
    getError() {
        this.add_ii(4, FUNCTION_ID.GETERROR);
        return 0;
    }
    getFramebufferAttachmentParameter(target, attachment, pname) {
        var gl = this._layagl;
        var result = null;
        switch (pname) {
            case gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
                var frameBuffer = gl.getBind(target);
                if (frameBuffer) {
                    var attachBuffer = frameBuffer.getBind(attachment);
                    if (!attachBuffer)
                        result = gl.NONE;
                    else if (attachBuffer instanceof WebGLTexture)
                        result = gl.TEXTURE;
                    else if (attachBuffer instanceof WebGLRenderBuffer)
                        result = gl.RENDERBUFFER;
                }
                break;
            case gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
                var frameBuffer = gl.getBind(target);
                if (frameBuffer) {
                    return frameBuffer.getBind(attachment);
                }
                break;
            case gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
            case gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
                result = gl._nativeObj.getFramebufferAttachmentParameter(target, attachment, pname);
                break;
            default:
                break;
        }
        return result;
    }
    getProgramParameter(program, pname) {
        let ret;
        var gl = this._layagl;
        if (pname == gl.ATTACHED_SHADERS)
            return program.attachedShaderCount;
        if (program.linkStatus == 0 || program.id == -1) {
            if (program.id == -1) {
                if (pname == gl.DELETE_STATUS || pname == gl.LINK_STATUS ||
                    pname == gl.VALIDATE_STATUS) {
                    return null;
                }
            }
            else if (program.linkStatus == 0) {
                if (pname == gl.DELETE_STATUS || pname == gl.LINK_STATUS ||
                    pname == gl.VALIDATE_STATUS) {
                    return false;
                }
            }
            return 0;
        }
        else {
            ret = this._layagl._nativeObj.getProgramParameterEx(program.linkedVSSource, program.linkedPSSource, "", pname);
            if (pname == gl.DELETE_STATUS || pname == gl.LINK_STATUS ||
                pname == gl.VALIDATE_STATUS) {
                return ret == 1 ? true : false;
            }
            else {
                return ret;
            }
        }
    }
    getProgramInfoLog(program) {
        if (program.id == -1)
            return null;
        if (program.linkStatus)
            return "";
        if (program.attachedShaderCount < 2) {
            return "missing shaders" + String.fromCharCode(0);
        }
        var ret = this._layagl._nativeObj.getProgramInfoLogEx(program.vsShader.src, program.psShader.src, "");
        if (ret === "invalid shaders") {
            ret = ret + String.fromCharCode(0);
        }
        return ret;
    }
    getRenderbufferParameter(target, pname) {
        return this._layagl._nativeObj.getRenderbufferParameterEx(target, pname);
    }
    getShaderPrecisionFormat(shaderType, precisionType) {
        return this._layagl._nativeObj.getShaderPrecisionFormat(shaderType, precisionType);
    }
    getShaderParameter(shader, pname) {
        if (shader && shader.id == -1)
            return null;
        if (pname == this._layagl.COMPILE_STATUS) {
            return shader.compileStatus === 0 ? false : true;
        }
        return this._layagl._nativeObj.getShaderParameter(shader.src, shader.type, pname);
    }
    getShaderInfoLog(shader) {
        if (!shader.compileStatus)
            return "";
        return this._layagl._nativeObj.getShaderInfoLogEx(shader.src, shader.type);
    }
    getShaderSource(shader) {
        if (!(shader instanceof WebGLShader))
            throw new TypeError("parameter 1 is not of type 'WebGLShader'");
        if (shader && shader.id !== -1)
            return shader.src;
        return null;
    }
    getTexParameter(target, pname) {
        return this._layagl._nativeObj.getTexParameterEx(target, pname);
    }
    getUniform(program, location) {
        if (!program.linkStatus || program.id == -1)
            return null;
        var gl = this._layagl;
        var curProgram = gl.getBind(gl.CURRENT_PROGRAM);
        var result = null;
        this.useProgram(program);
        gl._nativeObj.flushCommand();
        var locationName = program.getLocationName(location);
        var result = this._layagl._nativeObj.getUniformEx(locationName);
        var type = result[0];
        result.splice(0, 1);
        if (type == gl.BOOL) {
            for (var i = 0; i < result.length; i++) {
                if (result[i] === 0)
                    result[i] = false;
                else
                    result[i] = true;
            }
        }
        if (curProgram) {
            this.useProgram(curProgram);
            gl._nativeObj.flushCommand();
        }
        if (result.length == 1) {
            return result[0];
        }
        else {
            if (type == gl.BOOL)
                return result;
            else if (type == gl.FLOAT)
                return new Float32Array(result);
            else if (type == gl.INT)
                return new Int32Array(result);
        }
        return null;
    }
    getUniformMutiThread(program, location) {
        console.log("getUniformMutiThread can't support");
        return null;
    }
    getUniformLocation(program, name) {
        var fakeLoc = GLCommandEncoder._locTable.getFakeLocation(program.id, name);
        var strLen = this.getStrLength(name);
        this.add_iiii(16 + strLen, FUNCTION_ID.GETUNIFORMLOCATION, program.id, fakeLoc);
        this.add_String(name, strLen);
        program.addLocationPair(fakeLoc, name);
        return fakeLoc;
    }
    getVertexAttrib(index, pname) {
        var gl = this._layagl;
        var result = 0;
        switch (pname) {
            case gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
                gl._nativeObj.flushCommand();
                result = gl.getBind(gl.ARRAY_BUFFER);
                break;
            case gl.VERTEX_ATTRIB_ARRAY_ENABLED:
            case gl.VERTEX_ATTRIB_ARRAY_NORMALIZED:
                var ret = gl._nativeObj.getVertexAttribEx(index, pname);
                if (ret === 0)
                    result = false;
                else
                    result = true;
                break;
            case gl.VERTEX_ATTRIB_ARRAY_SIZE:
            case gl.VERTEX_ATTRIB_ARRAY_STRIDE:
            case gl.VERTEX_ATTRIB_ARRAY_TYPE:
                result = gl._nativeObj.getVertexAttribEx(index, pname);
                break;
            case gl.CURRENT_VERTEX_ATTRIB:
                result = gl._nativeObj.getVertexAttribExfv(index, pname);
                break;
            default:
                result = 0;
                break;
        }
        return result;
    }
    getVertexAttribOffset(index, pname) {
        return this._layagl._nativeObj.getVertexAttribOffset(index, pname);
    }
    hint(target, mode) {
        this.add_iiii(12, FUNCTION_ID.HINT, target, mode);
    }
    isBuffer(buffer) {
        return (buffer instanceof WebGLBuffer);
    }
    isEnabled(cap) {
        var ret = this._layagl._nativeObj.isEnabled(cap);
        if (!ret)
            return false;
        return true;
    }
    isFramebuffer(framebuffer) {
        return (framebuffer instanceof WebGLFrameBuffer);
    }
    isProgram(program) {
        return (program instanceof WebGLProgram);
    }
    isRenderbuffer(renderbuffer) {
        return (renderbuffer instanceof WebGLRenderBuffer);
    }
    isShader(shader) {
        return (shader instanceof WebGLShader);
    }
    isTexture(texture) {
        return (texture instanceof WebGLTexture);
    }
    lineWidth(width) {
        this.add_iif(8, FUNCTION_ID.LINEWIDTH, width);
    }
    linkProgram(program) {
        this.add_iii(8, FUNCTION_ID.LINKPROGRAM, program.id);
        if (program.attachedShaderCount >= 2) {
            var gl = this._layagl;
            program.linkStatus = gl._nativeObj.getProgramParameterEx(program.vsShader.src, program.psShader.src, "", gl.LINK_STATUS);
            if (program.linkStatus) {
                program.linkedVSSource = program.vsShader.src;
                program.linkedPSSource = program.psShader.src;
            }
        }
    }
    pixelStorei(pname, param) {
        this.add_iiii(12, FUNCTION_ID.PIXELSTOREI, pname, param);
    }
    polygonOffset(factor, units) {
        this.add_iiff(12, FUNCTION_ID.POLYGONOFFSET, factor, units);
    }
    readPixels(x, y, width, height, format, type, pixels) {
        if (!pixels && !(pixels instanceof Uint8Array) && !(pixels instanceof Uint16Array) &&
            !(pixels instanceof Float32Array))
            return;
        var ret = this._layagl._nativeObj.readPixels(x, y, width, height, format, type);
        pixels.set(new Uint8Array(ret));
    }
    readPixelsAsync(x, y, w, h, format, type, callBack) {
        var fakeID = this.createFakeID();
        this._readPixelsAsyncCallbackFuncObj.addCallbackFunc(fakeID, callBack);
        this.add_iiiiiiiiii(36, FUNCTION_ID.READPIXELS_ASYNC, x, y, w, h, format, type, this._readPixelsAsyncCallbackFuncObj.id, fakeID);
    }
    renderbufferStorage(target, internalformat, width, height) {
        this.add_iiiiii(20, FUNCTION_ID.RENDERBUFFERSTORAGE, target, internalformat, width, height);
    }
    sampleCoverage(value, invert) {
        this.add_iifi(12, FUNCTION_ID.SAMPLECOVERAGE, value, invert);
    }
    scissor(x, y, width, height) {
        this.add_iiiiii(20, FUNCTION_ID.SCISSOR, x, y, width, height);
    }
    shaderSource(shader, source) {
        shader.src = source;
        var strLen = this.getStrLength(source);
        this.add_iii(12 + strLen, FUNCTION_ID.SHADERSOURCE, shader.id);
        this.add_String(source, strLen);
    }
    stencilFunc(func, ref, mask) {
        this.add_iiiii(16, FUNCTION_ID.STENCILFUNC, func, ref, mask);
    }
    stencilFuncSeparate(face, func, ref, mask) {
        this.add_iiiiii(20, FUNCTION_ID.STENCILFUNCSEPARATE, face, func, ref, mask);
    }
    stencilMask(mask) {
        this.add_iii(8, FUNCTION_ID.STENCILMASK, mask);
    }
    stencilMaskSeparate(face, mask) {
        this.add_iiii(12, FUNCTION_ID.STENCILMASKSEPARATE, face, mask);
    }
    stencilOp(fail, zfail, zpass) {
        this.add_iiiii(16, FUNCTION_ID.STENCILOP, fail, zfail, zpass);
    }
    stencilOpSeparate(face, fail, zfail, zpass) {
        this.add_iiiiii(20, FUNCTION_ID.STENCILOPSEPARATE, face, fail, zfail, zpass);
    }
    texImage2D(_args) {
        var args = arguments;
        if (args.length == 6) {
            if (args[5]._nativeObj) {
                this.add_iiiiiiii(28, FUNCTION_ID.TEXIMAGE2D, args[0], args[1], args[2], args[3], args[4], args[5]._nativeObj.conchImgId);
            }
            else {
                this.add_iiiiiiiiii(40, FUNCTION_ID.TEXIMAGE2DCANVAS, args[0], args[1], args[2], args[3], args[4], args[5]._ctx._targets._glTexture.id, args[5].width, args[5].height);
            }
        }
        else if (args.length == 9) {
            if (args[8] == null) {
                this.add_iiiiiiiiiii(40, FUNCTION_ID.TEXIMAGE2D_PIXEL, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], 0);
            }
            else if (args[8] instanceof ArrayBuffer || ArrayBuffer.isView(args[8])) {
                var ab = args[8];
                var nAlignLength = this.getAlignLength(ab);
                this.add_iiiiiiiiii(40 + nAlignLength, FUNCTION_ID.TEXIMAGE2D_PIXEL, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]);
                this.wab(ab, ab.byteLength, nAlignLength);
            }
        }
    }
    texParameterf(target, pname, param) {
        this.add_iiiif(16, FUNCTION_ID.TEXPARAMETERF, target, pname, param);
    }
    texParameteri(target, pname, param) {
        this.add_iiiii(16, FUNCTION_ID.TEXPARAMETERI, target, pname, param);
    }
    texSubImage2D(_args) {
        var args = arguments;
        if (args.length == 7) {
            if (args[6]._nativeObj) {
                this.add_iiiiiiiii(32, FUNCTION_ID.TEXSUBIMAGE2D, args[0], args[1], args[2], args[3], args[4], args[5], args[6]._nativeObj.conchImgId);
            }
        }
        else if (args.length == 9) {
            if (args[8] == null) {
                this.add_iiiiiiiiiii(40, FUNCTION_ID.TEXSUBIMAGE2D_PIXEL, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], 0);
            }
            else if (args[8] instanceof ArrayBuffer || ArrayBuffer.isView(args[8])) {
                var ab = args[8];
                var nAlignLength = this.getAlignLength(ab);
                this.add_iiiiiiiiii(40, FUNCTION_ID.TEXSUBIMAGE2D_PIXEL, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]);
                this.wab(ab, ab.byteLength, nAlignLength);
            }
        }
    }
    uniform1f(location, x) {
        this.add_iiif(12, FUNCTION_ID.UNIFORM1F, location, x);
    }
    uniform1fv(location, values) {
        values = (values instanceof Array) ? new Float32Array(values) : values;
        this.uniform1fv_laya(location, values);
    }
    uniform1fv_laya(location, values) {
        var nAlignLength = this.getAlignLength(values);
        this.add_iii(12 + nAlignLength, FUNCTION_ID.UNIFORM1FV, location);
        this.wab(values, values.byteLength, nAlignLength);
    }
    uniform1i(location, x) {
        this.add_iiii(12, FUNCTION_ID.UNIFORM1I, location, x);
    }
    uniform1iv(location, values) {
        values = (values instanceof Array) ? new Int32Array(values) : values;
        this.uniform1iv_laya(location, values);
    }
    uniform1iv_laya(location, values) {
        var nAlignLength = this.getAlignLength(values);
        this.add_iii(12 + nAlignLength, FUNCTION_ID.UNIFORM1IV, location);
        this.wab(values, values.byteLength, nAlignLength);
    }
    uniform2f(location, x, y) {
        this.add_iiiff(16, FUNCTION_ID.UNIFORM2F, location, x, y);
    }
    uniform2fv(location, values) {
        values = (values instanceof Array) ? new Float32Array(values) : values;
        this.uniform2fv_laya(location, values);
    }
    uniform2fv_laya(location, values) {
        var nAlignLength = this.getAlignLength(values);
        this.add_iii(12 + nAlignLength, FUNCTION_ID.UNIFORM2FV, location);
        this.wab(values, values.byteLength, nAlignLength);
    }
    uniform2i(location, x, y) {
        this.add_iiiii(16, FUNCTION_ID.UNIFORM2I, location, x, y);
    }
    uniform2iv(location, values) {
        values = (values instanceof Array) ? new Int32Array(values) : values;
        this.uniform2iv_laya(location, values);
    }
    uniform2iv_laya(location, values) {
        var nAlignLength = this.getAlignLength(values);
        this.add_iii(12 + nAlignLength, FUNCTION_ID.UNIFORM2IV, location);
        this.wab(values, values.byteLength, nAlignLength);
    }
    uniform3f(location, x, y, z) {
        this.add_iiifff(20, FUNCTION_ID.UNIFORM3F, location, x, y, z);
    }
    uniform3fv(location, values) {
        values = (values instanceof Array) ? new Float32Array(values) : values;
        this.uniform3fv_laya(location, values);
    }
    uniform3fv_laya(location, values) {
        var nAlignLength = this.getAlignLength(values);
        this.add_iii(12 + nAlignLength, FUNCTION_ID.UNIFORM3FV, location);
        this.wab(values, values.byteLength, nAlignLength);
    }
    uniform3i(location, x, y, z) {
        this.add_iiiiii(20, FUNCTION_ID.UNIFORM3I, location, x, y, z);
    }
    uniform3iv(location, values) {
        values = (values instanceof Array) ? new Int32Array(values) : values;
        this.uniform3iv_laya(location, values);
    }
    uniform3iv_laya(location, values) {
        var nAlignLength = this.getAlignLength(values);
        this.add_iii(12 + nAlignLength, FUNCTION_ID.UNIFORM3IV, location);
        this.wab(values, values.byteLength, nAlignLength);
    }
    uniform4f(location, x, y, z, w) {
        this.add_iiiffff(24, FUNCTION_ID.UNIFORM4F, location, x, y, z, w);
    }
    uniform4fv(location, values) {
        values = (values instanceof Array) ? new Float32Array(values) : values;
        this.uniform4fv_laya(location, values);
    }
    uniform4fv_laya(location, values) {
        var nAlignLength = this.getAlignLength(values);
        this.add_iii(12 + nAlignLength, FUNCTION_ID.UNIFORM4FV, location);
        this.wab(values, values.byteLength, nAlignLength);
    }
    uniform4i(location, x, y, z, w) {
        this.add_iiiiiii(24, FUNCTION_ID.UNIFORM4I, location, x, y, z, w);
    }
    uniform4iv(location, values) {
        values = (values instanceof Array) ? new Int32Array(values) : values;
        this.uniform4iv_laya(location, values);
    }
    uniform4iv_laya(location, values) {
        var nAlignLength = this.getAlignLength(values);
        this.add_iii(12 + nAlignLength, FUNCTION_ID.UNIFORM4IV, location);
        this.wab(values, values.byteLength, nAlignLength);
    }
    uniformMatrix2fv(location, transpose, values) {
        values = (values instanceof Array) ? new Float32Array(values) : values;
        this.uniformMatrix2fv_laya(location, transpose, values);
    }
    uniformMatrix2fv_laya(location, transpose, value) {
        var nAlignLength = this.getAlignLength(value);
        this.add_iiii(16 + nAlignLength, FUNCTION_ID.UNIFORMMATRIX2FV, location, transpose);
        this.wab(value, value.byteLength, nAlignLength);
    }
    uniformMatrix3fv(location, transpose, values) {
        values = (values instanceof Array) ? new Float32Array(values) : values;
        this.uniformMatrix3fv_laya(location, transpose, values);
    }
    uniformMatrix3fv_laya(location, transpose, value) {
        var nAlignLength = this.getAlignLength(value);
        this.add_iiii(16 + nAlignLength, FUNCTION_ID.UNIFORMMATRIX3FV, location, transpose);
        this.wab(value, value.byteLength, nAlignLength);
    }
    uniformMatrix4fv(location, transpose, values) {
        values = (values instanceof Array) ? new Float32Array(values) : values;
        this.uniformMatrix4fv_laya(location, transpose, values);
    }
    uniformMatrix4fv_laya(location, transpose, value) {
        var nAlignLength = this.getAlignLength(value);
        this.add_iiii(20 + nAlignLength, FUNCTION_ID.UNIFORMMATRIX4FV, location, transpose);
        this.wab(value, value.byteLength, nAlignLength);
    }
    useProgram(program) {
        this.add_iii(8, FUNCTION_ID.USEPROGRAM, program ? program.id : 0);
    }
    validateProgram(program) {
        this.add_iii(8, FUNCTION_ID.VALIDATEPROGRAM, program.id);
    }
    vertexAttrib1f(indx, x) {
        this.add_iiif(12, FUNCTION_ID.VERTEXATTRIB1F, indx, x);
    }
    vertexAttrib1fv(indx, values) {
        var nAlignLength = this.getAlignLength(values);
        this.add_iii(12 + nAlignLength, FUNCTION_ID.VERTEXATTRIB1FV, indx);
        this.wab(values, values.byteLength, nAlignLength);
    }
    vertexAttrib2f(indx, x, y) {
        this.add_iiiff(16, FUNCTION_ID.VERTEXATTRIB2F, indx, x, y);
    }
    vertexAttrib2fv(indx, values) {
        var nAlignLength = this.getAlignLength(values);
        this.add_iii(12 + nAlignLength, FUNCTION_ID.VERTEXATTRIB2FV, indx);
        this.wab(values, values.byteLength, nAlignLength);
    }
    vertexAttrib3f(indx, x, y, z) {
        this.add_iiifff(20, FUNCTION_ID.VERTEXATTRIB3F, indx, x, y, z);
    }
    vertexAttrib3fv(indx, values) {
        var nAlignLength = this.getAlignLength(values);
        this.add_iii(12 + nAlignLength, FUNCTION_ID.VERTEXATTRIB3FV, indx);
        this.wab(values, values.byteLength, nAlignLength);
    }
    vertexAttrib4f(indx, x, y, z, w) {
        this.add_iiiffff(24, FUNCTION_ID.VERTEXATTRIB4F, indx, x, y, z, w);
    }
    vertexAttrib4fv(indx, values) {
        var nAlignLength = this.getAlignLength(values);
        this.add_iii(12 + nAlignLength, FUNCTION_ID.VERTEXATTRIB4FV, indx);
        this.wab(values, values.byteLength, nAlignLength);
    }
    vertexAttribPointer(indx, size, type, normalized, stride, offset) {
        this.add_iiiiiiii(28, FUNCTION_ID.VERTEXATTRIBPOINTER, indx, size, type, normalized, stride, offset);
    }
    viewport(x, y, width, height) {
        this.add_iiiiii(20, FUNCTION_ID.VIEWPORT, x, y, width, height);
    }
    configureBackBuffer(width, height, antiAlias, enableDepthAndStencil, wantsBestResolution) {
        enableDepthAndStencil = enableDepthAndStencil ? enableDepthAndStencil : true;
        wantsBestResolution = wantsBestResolution ? wantsBestResolution : false;
        console.log("configureBackBuffer can't support");
    }
    compressedTexImage2D(_args) {
        var args = arguments;
        var nAlignLength = this.getAlignLength(args[6]);
        this.add_iiiiiiii(28 + nAlignLength, FUNCTION_ID.COMPRESSEDTEXIMAGE2D, args[0], args[1], args[2], args[3], args[4], args[5]);
        this.wab(args[6], args[6].byteLength, nAlignLength);
    }
    compressedTexSubImage2D(_args) {
        var args = arguments;
        var nAlignLength = this.getAlignLength(args[7]);
        this.add_iiiiiiiii(32 + nAlignLength, FUNCTION_ID.COMPRESSEDTEXSUBIMAGE2D, args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
        this.wab(args[7], args[7].byteLength, nAlignLength);
    }
    createVertexArray() {
        var fakeID = this.createFakeID();
        this.add_iii(8, FUNCTION_ID.CREATEVERTEXARRAY, fakeID);
        return new WebGLVertextArray(fakeID);
    }
    bindVertexArray(vao) {
        this.add_iii(8, FUNCTION_ID.BINDVERTEXARRAY, vao ? vao.id : 0);
    }
    deleteVertexArray(vao) {
        this.deleteFakeID(vao.id);
        this.add_iii(8, FUNCTION_ID.DELETEVERTEXARRAYS, vao ? vao.id : 0);
    }
    isVertexArray(vao) {
        return vao.instanceof(WebGLVertextArray);
    }
    vertexAttribDivisor(index, divisor) {
        this.add_iiii(12, FUNCTION_ID.VERTEXATTRIBDIVISOR, index, divisor);
    }
    drawArraysInstanced(mode, first, count, instanceCount) {
        this.add_iiiiii(20, FUNCTION_ID.DRAWARRAYSINSTANCED, mode, first, count, instanceCount);
    }
    drawElementsInstanced(mode, count, type, offset, instanceCount) {
        this.add_iiiiiii(24, FUNCTION_ID.DRAWELEMENTSINSTANCED, mode, count, type, offset, instanceCount);
    }
    uniformMatrix2fvEx(location, transpose, value) {
        if (!value["_ptrID"]) {
            LayaGLContext.createArrayBufferRef(value, LayaGLContext.ARRAY_BUFFER_TYPE_DATA, true);
        }
        var nID = value["_ptrID"];
        LayaGLContext.syncBufferToRenderThread(value);
        this.add_iiiii(16, FUNCTION_ID.UNIFORMMATRIX2FVEX, location, transpose, nID);
    }
    uniformMatrix3fvEx(location, transpose, value) {
        if (!value["_ptrID"]) {
            LayaGLContext.createArrayBufferRef(value, LayaGLContext.ARRAY_BUFFER_TYPE_DATA, true);
        }
        var nID = value["_ptrID"];
        LayaGLContext.syncBufferToRenderThread(value);
        this.add_iiiii(16, FUNCTION_ID.UNIFORMMATRIX3FVEX, location, transpose, nID);
    }
    uniformMatrix4fvEx(location, transpose, value) {
        if (!value["_ptrID"]) {
            LayaGLContext.createArrayBufferRef(value, LayaGLContext.ARRAY_BUFFER_TYPE_DATA, true);
        }
        var nID = value["_ptrID"];
        LayaGLContext.syncBufferToRenderThread(value);
        this.add_iiiii(16, FUNCTION_ID.UNIFORMMATRIX4FVEX, location, transpose, nID);
    }
    addShaderUniform(one) {
        var funID = 0;
        var isArray = one.isArray;
        switch (one.type) {
            case GLCommandEncoder.INT:
                funID = isArray ? UNIFORM_TYPE.INTERIOR_UNIFORM1IV : UNIFORM_TYPE.INTERIOR_UNIFORM1I;
                break;
            case GLCommandEncoder.FLOAT:
                funID = isArray ? UNIFORM_TYPE.INTERIOR_UNIFORM1FV : UNIFORM_TYPE.INTERIOR_UNIFORM1F;
                break;
            case GLCommandEncoder.FLOAT_VEC2:
                funID = isArray ? UNIFORM_TYPE.INTERIOR_UNIFORM2FV : UNIFORM_TYPE.INTERIOR_UNIFORM2F;
                break;
            case GLCommandEncoder.FLOAT_VEC3:
                funID = isArray ? UNIFORM_TYPE.INTERIOR_UNIFORM3FV : UNIFORM_TYPE.INTERIOR_UNIFORM3F;
                break;
            case GLCommandEncoder.FLOAT_VEC4:
                funID = isArray ? UNIFORM_TYPE.INTERIOR_UNIFORM4FV : UNIFORM_TYPE.INTERIOR_UNIFORM4F;
                break;
            case GLCommandEncoder.SAMPLER_2D:
                funID = UNIFORM_TYPE.INTERIOR_UNIFORMSAMPLER_2D;
                break;
            case GLCommandEncoder.SAMPLER_CUBE:
                funID = UNIFORM_TYPE.INTERIOR_UNIFORMSAMPLER_CUBE;
                break;
            case GLCommandEncoder.FLOAT_MAT4:
                funID = UNIFORM_TYPE.INTERIOR_UNIFORMMATRIX4FV;
                break;
            case GLCommandEncoder.BOOL:
                funID = UNIFORM_TYPE.INTERIOR_UNIFORM1I;
                break;
            case GLCommandEncoder.FLOAT_MAT2:
                funID = UNIFORM_TYPE.INTERIOR_UNIFORMMATRIX2FV;
                break;
            case GLCommandEncoder.FLOAT_MAT3:
                funID = UNIFORM_TYPE.INTERIOR_UNIFORMMATRIX3FV;
                break;
            default:
                throw new Error("compile shader err!");
        }
        LayaGLContext.syncBufferToRenderThread(this._buffer);
        this.add_iiiiiii(24, FUNCTION_ID.ADDSHADERUNIFORM, funID, one.location, one.type, one.dataOffset, one.textureID);
    }
    uploadShaderUniforms(commandEncoder, data, type) {
        if (type == LayaGLContext.UPLOAD_SHADER_UNIFORM_TYPE_ID) {
            var dataID = data["_ptrID"];
            LayaGLContext.syncBufferToRenderThread(data);
            this.add_iiii(12, FUNCTION_ID.UPLOADSHADERUNIFORMS, commandEncoder._buffer["_ptrID"], dataID);
        }
        else {
            var nAlignLength = this.getAlignLength(data);
            this.add_iii(12 + nAlignLength, FUNCTION_ID.UPLOADSHADERUNIFORMS_BUFFER, commandEncoder._buffer["_ptrID"]);
            this.wab(data, data.byteLength, nAlignLength);
        }
        return 0;
    }
    createFakeID() {
        var frameCount = LayaGLContext.getFrameCount();
        var fakeArray = GLCommandEncoder._fakeArray;
        for (var i = 0, n = fakeArray.length; i < n; i++) {
            var fakeObj = fakeArray[i];
            if (fakeObj.id == -1 && fakeObj.frameCount != frameCount) {
                fakeObj.id = i;
                fakeObj.frameCount = frameCount;
                return i;
            }
        }
        var nID = ++GLCommandEncoder._fakeIDCount;
        fakeArray.push(new fakeIDObj(nID, frameCount));
        return nID;
    }
    deleteFakeID(nID) {
        var fakeObj = GLCommandEncoder._fakeArray[nID];
        fakeObj.id = -1;
        fakeObj.frameCount = LayaGLContext.getFrameCount();
    }
    useCommandEncoder(commandEncoder) {
        if (commandEncoder._isSyncToRenderThread) {
            LayaGLContext.syncBufferToRenderThread(commandEncoder);
        }
        var loc = this._idata[0];
        this.add_iii(8, FUNCTION_ID.USECOMMANDENCODER, commandEncoder.getPtrID());
        return loc;
    }
    getProgramParameterEx(vs, ps, define, pname) {
        return this._layagl.getProgramParameterEx(vs, ps, define, pname);
    }
    getActiveAttribEx(vs, ps, define, index) {
        return this._layagl.getActiveAttribEx(vs, ps, define, index);
    }
    getActiveUniformEx(vs, ps, define, index) {
        return this._layagl.getActiveUniformEx(vs, ps, define, index);
    }
    loadDataToReg(regNum, data, offset, size) {
        var nAlignLength = this.getAlignLength(data);
        this.add_iiiii(16 + nAlignLength, FUNCTION_ID.LOADDATATOREG, regNum, offset, size);
        this.wab(data, data.byteLength, nAlignLength);
    }
    loadDataToRegEx(regNum, dataID, offset, size) {
        this.add_iiiiii(20, FUNCTION_ID.LOADDATATOREGEX, regNum, dataID, offset, size);
    }
    ifLess0(regNum, statementNum) {
        this.add_iiii(12, FUNCTION_ID.IFLESS0, regNum, statementNum);
    }
    ifEqual0(regNum, statementNum) {
        this.add_iiii(12, FUNCTION_ID.IFEQUAL0, regNum, statementNum);
    }
    ifGreater0(regNum, statementNum) {
        this.add_iiii(12, FUNCTION_ID.IFGREATER0, regNum, statementNum);
    }
    ifLEqual0(regNum, statementNum) {
        this.add_iiii(12, FUNCTION_ID.IFLEQUAL0, regNum, statementNum);
    }
    ifGEqual0(regNum, statementNum) {
        this.add_iiii(12, FUNCTION_ID.IFGEQUAL0, regNum, statementNum);
    }
    ifGNotEqual0(regNum, statementNum) {
        this.add_iiii(12, FUNCTION_ID.IFGNOTEQUAL0, regNum, statementNum);
    }
    operateReg(regOut, reg1, reg2, size, operateType, dataType) {
        this.add_iiiiiiii(28, FUNCTION_ID.OPERATEREG, regOut, reg1, reg2, size, operateType, dataType);
    }
    store(dataID, offset, regID, size) {
        this.add_iiiiii(20, FUNCTION_ID.STORE, dataID, offset, regID, size);
    }
    getAlignLength(data) {
        var byteLength = data.byteLength;
        return (byteLength + 3) & 0xfffffffc;
    }
    getStrLength(str) {
        var ab = conch.strTobufer(str);
        return ab.byteLength;
    }
}
GLCommandEncoder.INT = 0x1404;
GLCommandEncoder.FLOAT = 0x1406;
GLCommandEncoder.FLOAT_VEC2 = 0x8B50;
GLCommandEncoder.FLOAT_VEC3 = 0x8B51;
GLCommandEncoder.FLOAT_VEC4 = 0x8B52;
GLCommandEncoder.INT_VEC2 = 0x8B53;
GLCommandEncoder.INT_VEC3 = 0x8B54;
GLCommandEncoder.INT_VEC4 = 0x8B55;
GLCommandEncoder.BOOL = 0x8B56;
GLCommandEncoder.BOOL_VEC2 = 0x8B57;
GLCommandEncoder.BOOL_VEC3 = 0x8B58;
GLCommandEncoder.BOOL_VEC4 = 0x8B59;
GLCommandEncoder.FLOAT_MAT2 = 0x8B5A;
GLCommandEncoder.FLOAT_MAT3 = 0x8B5B;
GLCommandEncoder.FLOAT_MAT4 = 0x8B5C;
GLCommandEncoder.SAMPLER_2D = 0x8B5E;
GLCommandEncoder.SAMPLER_CUBE = 0x8B60;
GLCommandEncoder._fakeIDCount = 0;
GLCommandEncoder._fakeArray = [new fakeIDObj(0, 0)];
GLCommandEncoder._locTable = new ProgramLocationTable();
class LayaGLContext {
    constructor(contextType) {
        this.width = 0;
        this.height = 0;
        this.canvas = null;
        this._currentCmdEncoder = null;
        this._saveCommandEncoder = new Array();
        this._currentContext = null;
        this._threadMode = LayaGLContext.THREAD_MODE_DOUBLE;
        this._curBindInfo = new BindInfo();
        this.DEPTH_BUFFER_BIT = 0x00000100;
        this.STENCIL_BUFFER_BIT = 0x00000400;
        this.COLOR_BUFFER_BIT = 0x00004000;
        this.POINTS = 0x0000;
        this.LINES = 0x0001;
        this.LINE_LOOP = 0x0002;
        this.LINE_STRIP = 0x0003;
        this.TRIANGLES = 0x0004;
        this.TRIANGLE_STRIP = 0x0005;
        this.TRIANGLE_FAN = 0x0006;
        this.ZERO = 0;
        this.ONE = 1;
        this.SRC_COLOR = 0x0300;
        this.ONE_MINUS_SRC_COLOR = 0x0301;
        this.SRC_ALPHA = 0x0302;
        this.ONE_MINUS_SRC_ALPHA = 0x0303;
        this.DST_ALPHA = 0x0304;
        this.ONE_MINUS_DST_ALPHA = 0x0305;
        this.DST_COLOR = 0x0306;
        this.ONE_MINUS_DST_COLOR = 0x0307;
        this.SRC_ALPHA_SATURATE = 0x0308;
        this.FUNC_ADD = 0x8006;
        this.BLEND_EQUATION = 0x8009;
        this.BLEND_EQUATION_RGB = 0x8009;
        this.BLEND_EQUATION_ALPHA = 0x883D;
        this.FUNC_SUBTRACT = 0x800A;
        this.FUNC_REVERSE_SUBTRACT = 0x800B;
        this.BLEND_DST_RGB = 0x80C8;
        this.BLEND_SRC_RGB = 0x80C9;
        this.BLEND_DST_ALPHA = 0x80CA;
        this.BLEND_SRC_ALPHA = 0x80CB;
        this.CONSTANT_COLOR = 0x8001;
        this.ONE_MINUS_CONSTANT_COLOR = 0x8002;
        this.CONSTANT_ALPHA = 0x8003;
        this.ONE_MINUS_CONSTANT_ALPHA = 0x8004;
        this.BLEND_COLOR = 0x8005;
        this.ARRAY_BUFFER = 0x8892;
        this.ELEMENT_ARRAY_BUFFER = 0x8893;
        this.ARRAY_BUFFER_BINDING = 0x8894;
        this.ELEMENT_ARRAY_BUFFER_BINDING = 0x8895;
        this.STREAM_DRAW = 0x88E0;
        this.STATIC_DRAW = 0x88E4;
        this.DYNAMIC_DRAW = 0x88E8;
        this.BUFFER_SIZE = 0x8764;
        this.BUFFER_USAGE = 0x8765;
        this.CURRENT_VERTEX_ATTRIB = 0x8626;
        this.FRONT = 0x0404;
        this.BACK = 0x0405;
        this.FRONT_AND_BACK = 0x0408;
        this.CULL_FACE = 0x0B44;
        this.BLEND = 0x0BE2;
        this.DITHER = 0x0BD0;
        this.STENCIL_TEST = 0x0B90;
        this.DEPTH_TEST = 0x0B71;
        this.SCISSOR_TEST = 0x0C11;
        this.POLYGON_OFFSET_FILL = 0x8037;
        this.SAMPLE_ALPHA_TO_COVERAGE = 0x809E;
        this.SAMPLE_COVERAGE = 0x80A0;
        this.INVALID_ENUM = 0x0500;
        this.INVALID_VALUE = 0x0501;
        this.INVALID_OPERATION = 0x0502;
        this.OUT_OF_MEMORY = 0x0505;
        this.CW = 0x0900;
        this.CCW = 0x0901;
        this.LINE_WIDTH = 0x0B21;
        this.ALIASED_POINT_SIZE_RANGE = 0x846D;
        this.ALIASED_LINE_WIDTH_RANGE = 0x846E;
        this.CULL_FACE_MODE = 0x0B45;
        this.FRONT_FACE = 0x0B46;
        this.DEPTH_RANGE = 0x0B70;
        this.DEPTH_WRITEMASK = 0x0B72;
        this.DEPTH_CLEAR_VALUE = 0x0B73;
        this.DEPTH_FUNC = 0x0B74;
        this.STENCIL_CLEAR_VALUE = 0x0B91;
        this.STENCIL_FUNC = 0x0B92;
        this.STENCIL_FAIL = 0x0B94;
        this.STENCIL_PASS_DEPTH_FAIL = 0x0B95;
        this.STENCIL_PASS_DEPTH_PASS = 0x0B96;
        this.STENCIL_REF = 0x0B97;
        this.STENCIL_VALUE_MASK = 0x0B93;
        this.STENCIL_WRITEMASK = 0x0B98;
        this.STENCIL_BACK_FUNC = 0x8800;
        this.STENCIL_BACK_FAIL = 0x8801;
        this.STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802;
        this.STENCIL_BACK_PASS_DEPTH_PASS = 0x8803;
        this.STENCIL_BACK_REF = 0x8CA3;
        this.STENCIL_BACK_VALUE_MASK = 0x8CA4;
        this.STENCIL_BACK_WRITEMASK = 0x8CA5;
        this.VIEWPORT = 0x0BA2;
        this.SCISSOR_BOX = 0x0C10;
        this.COLOR_CLEAR_VALUE = 0x0C22;
        this.COLOR_WRITEMASK = 0x0C23;
        this.UNPACK_ALIGNMENT = 0x0CF5;
        this.PACK_ALIGNMENT = 0x0D05;
        this.MAX_TEXTURE_SIZE = 0x0D33;
        this.MAX_VIEWPORT_DIMS = 0x0D3A;
        this.SUBPIXEL_BITS = 0x0D50;
        this.RED_BITS = 0x0D52;
        this.GREEN_BITS = 0x0D53;
        this.BLUE_BITS = 0x0D54;
        this.ALPHA_BITS = 0x0D55;
        this.DEPTH_BITS = 0x0D56;
        this.STENCIL_BITS = 0x0D57;
        this.POLYGON_OFFSET_UNITS = 0x2A00;
        this.POLYGON_OFFSET_FACTOR = 0x8038;
        this.TEXTURE_BINDING_2D = 0x8069;
        this.SAMPLE_BUFFERS = 0x80A8;
        this.SAMPLES = 0x80A9;
        this.SAMPLE_COVERAGE_VALUE = 0x80AA;
        this.SAMPLE_COVERAGE_INVERT = 0x80AB;
        this.COMPRESSED_TEXTURE_FORMATS = 0x86A3;
        this.DONT_CARE = 0x1100;
        this.FASTEST = 0x1101;
        this.NICEST = 0x1102;
        this.GENERATE_MIPMAP_HINT = 0x8192;
        this.BYTE = 0x1400;
        this.UNSIGNED_BYTE = 0x1401;
        this.SHORT = 0x1402;
        this.UNSIGNED_SHORT = 0x1403;
        this.INT = 0x1404;
        this.UNSIGNED_INT = 0x1405;
        this.FLOAT = 0x1406;
        this.DEPTH_COMPONENT = 0x1902;
        this.ALPHA = 0x1906;
        this.RGB = 0x1907;
        this.RGBA = 0x1908;
        this.LUMINANCE = 0x1909;
        this.LUMINANCE_ALPHA = 0x190A;
        this.UNSIGNED_SHORT_4_4_4_4 = 0x8033;
        this.UNSIGNED_SHORT_5_5_5_1 = 0x8034;
        this.UNSIGNED_SHORT_5_6_5 = 0x8363;
        this.FRAGMENT_SHADER = 0x8B30;
        this.VERTEX_SHADER = 0x8B31;
        this.MAX_VERTEX_ATTRIBS = 0x8869;
        this.MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB;
        this.MAX_VARYING_VECTORS = 0x8DFC;
        this.MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D;
        this.MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C;
        this.MAX_TEXTURE_IMAGE_UNITS = 0x8872;
        this.MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD;
        this.MAX_TEXTURE_MAX_ANISOTROPY_EXT = 34047;
        this.TEXTURE_MAX_ANISOTROPY_EXT = 34046;
        this.SHADER_TYPE = 0x8B4F;
        this.DELETE_STATUS = 0x8B80;
        this.LINK_STATUS = 0x8B82;
        this.VALIDATE_STATUS = 0x8B83;
        this.ATTACHED_SHADERS = 0x8B85;
        this.ACTIVE_UNIFORMS = 0x8B86;
        this.ACTIVE_ATTRIBUTES = 0x8B89;
        this.SHADING_LANGUAGE_VERSION = 0x8B8C;
        this.CURRENT_PROGRAM = 0x8B8D;
        this.NEVER = 0x0200;
        this.LESS = 0x0201;
        this.EQUAL = 0x0202;
        this.LEQUAL = 0x0203;
        this.GREATER = 0x0204;
        this.NOTEQUAL = 0x0205;
        this.GEQUAL = 0x0206;
        this.ALWAYS = 0x0207;
        this.KEEP = 0x1E00;
        this.REPLACE = 0x1E01;
        this.INCR = 0x1E02;
        this.DECR = 0x1E03;
        this.INVERT = 0x150A;
        this.INCR_WRAP = 0x8507;
        this.DECR_WRAP = 0x8508;
        this.VENDOR = 0x1F00;
        this.RENDERER = 0x1F01;
        this.VERSION = 0x1F02;
        this.NEAREST = 0x2600;
        this.LINEAR = 0x2601;
        this.NEAREST_MIPMAP_NEAREST = 0x2700;
        this.LINEAR_MIPMAP_NEAREST = 0x2701;
        this.NEAREST_MIPMAP_LINEAR = 0x2702;
        this.LINEAR_MIPMAP_LINEAR = 0x2703;
        this.TEXTURE_MAG_FILTER = 0x2800;
        this.TEXTURE_MIN_FILTER = 0x2801;
        this.TEXTURE_WRAP_S = 0x2802;
        this.TEXTURE_WRAP_T = 0x2803;
        this.TEXTURE_2D = 0x0DE1;
        this.TEXTURE = 0x1702;
        this.TEXTURE_CUBE_MAP = 0x8513;
        this.TEXTURE_BINDING_CUBE_MAP = 0x8514;
        this.TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515;
        this.TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516;
        this.TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517;
        this.TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518;
        this.TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519;
        this.TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A;
        this.MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C;
        this.TEXTURE0 = 0x84C0;
        this.TEXTURE1 = 0x84C1;
        this.TEXTURE2 = 0x84C2;
        this.TEXTURE3 = 0x84C3;
        this.TEXTURE4 = 0x84C4;
        this.TEXTURE5 = 0x84C5;
        this.TEXTURE6 = 0x84C6;
        this.TEXTURE7 = 0x84C7;
        this.TEXTURE8 = 0x84C8;
        this.TEXTURE9 = 0x84C9;
        this.TEXTURE10 = 0x84CA;
        this.TEXTURE11 = 0x84CB;
        this.TEXTURE12 = 0x84CC;
        this.TEXTURE13 = 0x84CD;
        this.TEXTURE14 = 0x84CE;
        this.TEXTURE15 = 0x84CF;
        this.TEXTURE16 = 0x84D0;
        this.TEXTURE17 = 0x84D1;
        this.TEXTURE18 = 0x84D2;
        this.TEXTURE19 = 0x84D3;
        this.TEXTURE20 = 0x84D4;
        this.TEXTURE21 = 0x84D5;
        this.TEXTURE22 = 0x84D6;
        this.TEXTURE23 = 0x84D7;
        this.TEXTURE24 = 0x84D8;
        this.TEXTURE25 = 0x84D9;
        this.TEXTURE26 = 0x84DA;
        this.TEXTURE27 = 0x84DB;
        this.TEXTURE28 = 0x84DC;
        this.TEXTURE29 = 0x84DD;
        this.TEXTURE30 = 0x84DE;
        this.TEXTURE31 = 0x84DF;
        this.ACTIVE_TEXTURE = 0x84E0;
        this.REPEAT = 0x2901;
        this.CLAMP_TO_EDGE = 0x812F;
        this.MIRRORED_REPEAT = 0x8370;
        this.FLOAT_VEC2 = 0x8B50;
        this.FLOAT_VEC3 = 0x8B51;
        this.FLOAT_VEC4 = 0x8B52;
        this.INT_VEC2 = 0x8B53;
        this.INT_VEC3 = 0x8B54;
        this.INT_VEC4 = 0x8B55;
        this.BOOL = 0x8B56;
        this.BOOL_VEC2 = 0x8B57;
        this.BOOL_VEC3 = 0x8B58;
        this.BOOL_VEC4 = 0x8B59;
        this.FLOAT_MAT2 = 0x8B5A;
        this.FLOAT_MAT3 = 0x8B5B;
        this.FLOAT_MAT4 = 0x8B5C;
        this.SAMPLER_2D = 0x8B5E;
        this.SAMPLER_CUBE = 0x8B60;
        this.VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622;
        this.VERTEX_ATTRIB_ARRAY_SIZE = 0x8623;
        this.VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624;
        this.VERTEX_ATTRIB_ARRAY_TYPE = 0x8625;
        this.VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A;
        this.VERTEX_ATTRIB_ARRAY_POINTER = 0x8645;
        this.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F;
        this.IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A;
        this.IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B;
        this.COMPILE_STATUS = 0x8B81;
        this.LOW_FLOAT = 0x8DF0;
        this.MEDIUM_FLOAT = 0x8DF1;
        this.HIGH_FLOAT = 0x8DF2;
        this.LOW_INT = 0x8DF3;
        this.MEDIUM_INT = 0x8DF4;
        this.HIGH_INT = 0x8DF5;
        this.FRAMEBUFFER = 0x8D40;
        this.RENDERBUFFER = 0x8D41;
        this.RGBA4 = 0x8056;
        this.RGB5_A1 = 0x8057;
        this.RGB565 = 0x8D62;
        this.DEPTH_COMPONENT16 = 0x81A5;
        this.STENCIL_INDEX = 0x1901;
        this.STENCIL_INDEX8 = 0x8D48;
        this.DEPTH_STENCIL = 0x84F9;
        this.RENDERBUFFER_WIDTH = 0x8D42;
        this.RENDERBUFFER_HEIGHT = 0x8D43;
        this.RENDERBUFFER_INTERNAL_FORMAT = 0x8D44;
        this.RENDERBUFFER_RED_SIZE = 0x8D50;
        this.RENDERBUFFER_GREEN_SIZE = 0x8D51;
        this.RENDERBUFFER_BLUE_SIZE = 0x8D52;
        this.RENDERBUFFER_ALPHA_SIZE = 0x8D53;
        this.RENDERBUFFER_DEPTH_SIZE = 0x8D54;
        this.RENDERBUFFER_STENCIL_SIZE = 0x8D55;
        this.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0;
        this.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1;
        this.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2;
        this.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3;
        this.COLOR_ATTACHMENT0 = 0x8CE0;
        this.DEPTH_ATTACHMENT = 0x8D00;
        this.STENCIL_ATTACHMENT = 0x8D20;
        this.DEPTH_STENCIL_ATTACHMENT = 0x821A;
        this.NONE = 0;
        this.FRAMEBUFFER_COMPLETE = 0x8CD5;
        this.FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6;
        this.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7;
        this.FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 0x8CD9;
        this.FRAMEBUFFER_UNSUPPORTED = 0x8CDD;
        this.FRAMEBUFFER_BINDING = 0x8CA6;
        this.RENDERBUFFER_BINDING = 0x8CA7;
        this.MAX_RENDERBUFFER_SIZE = 0x84E8;
        this.INVALID_FRAMEBUFFER_OPERATION = 0x0506;
        this.UNPACK_FLIP_Y_WEBGL = 0x9240;
        this.UNPACK_PREMULTIPLY_ALPHA_WEBGL = 0x9241;
        this.CONTEXT_LOST_WEBGL = 0x9242;
        this.UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243;
        this.BROWSER_DEFAULT_WEBGL = 0x9244;
        if (!LayaGLContext.instance) {
            LayaGLContext.__init__();
            LayaGLContext.instance = this;
        }
        else {
            console.log("LayaGL is already exist");
            return LayaGLContext.instance;
        }
        this._nativeObj = layagl;
        this._threadMode = this._nativeObj.getThreadMode();
        contextType = contextType.toLowerCase();
        if (contextType.indexOf("layagl") >= 0) {
            this._nativeObj.setSyncArrayBufferID(LayaGLContext._syncBufferList["_ptrID"]);
            this._nativeObj.setFrameAndSyncCountArrayBufferID(LayaGLContext._frameAndSyncCountBuffer["_ptrID"]);
            this._defaultEncoder = new GLCommandEncoder(this, 102400, 1280, false);
            this._currentCmdEncoder = this._defaultEncoder;
            this._saveCommandEncoder.push(this._currentCmdEncoder);
            this._nativeObj.setRootCommandEncoder(this._currentCmdEncoder._buffer["_ptrID"]);
        }
        else {
            this._nativeObj.setSyncArrayBufferID(LayaGLContext._syncBufferList["_ptrID"]);
            this._nativeObj.setFrameAndSyncCountArrayBufferID(LayaGLContext._frameAndSyncCountBuffer["_ptrID"]);
            this._defaultEncoder = new GLCommandEncoder(this, 102400, 1280, false);
            this._currentCmdEncoder = this._defaultEncoder;
            this._nativeObj.setRootCommandEncoder(this._defaultEncoder._buffer["_ptrID"]);
        }
    }
    static __init__() {
        LayaGLContext._syncBufferList = new Int32Array(LayaGLContext._syncBufferSize);
        LayaGLContext._syncBufferList["conchRef"] = conch.createArrayBufferRef(LayaGLContext._syncBufferList, LayaGLContext.ARRAY_BUFFER_TYPE_DATA, false, LayaGLContext.ARRAY_BUFFER_REF_REFERENCE);
        LayaGLContext._syncBufferList["_ptrID"] = LayaGLContext._syncBufferList["conchRef"].id;
        LayaGLContext._frameAndSyncCountBuffer = new Int32Array(2);
        LayaGLContext._frameAndSyncCountBuffer["conchRef"] = conch.createArrayBufferRef(LayaGLContext._frameAndSyncCountBuffer, LayaGLContext.ARRAY_BUFFER_TYPE_DATA, false, LayaGLContext.ARRAY_BUFFER_REF_REFERENCE);
        LayaGLContext._frameAndSyncCountBuffer["_ptrID"] = LayaGLContext._frameAndSyncCountBuffer["conchRef"].id;
        LayaGLContext._frameAndSyncCountBuffer[0] = 1;
        LayaGLContext._frameAndSyncCountBuffer[1] = 0;
        if (layagl.getThreadMode() > 1) {
            LayaGLContext.prototype.bindBuffer = LayaGLContext.prototype.bindBufferMutiThread;
            LayaGLContext.prototype.useProgram = LayaGLContext.prototype.useProgramMutiThread;
            GLCommandEncoder.prototype.getUniform = GLCommandEncoder.prototype.getUniformMutiThread;
        }
    }
    static createArrayBufferRef(arrayBuffer, type, syncRender) {
        var bufferConchRef = conch.createArrayBufferRef(arrayBuffer, type, syncRender, LayaGLContext.ARRAY_BUFFER_REF_REFERENCE);
        arrayBuffer["conchRef"] = bufferConchRef;
        arrayBuffer["_ptrID"] = bufferConchRef.id;
        return bufferConchRef;
    }
    static createArrayBufferRefs(arrayBuffer, type, syncRender, refType) {
        if (!arrayBuffer._refArray) {
            arrayBuffer._refArray = [];
            arrayBuffer._refNum = 1;
            arrayBuffer._refArray.length = 1;
            arrayBuffer.getRefNum = function () {
                return this._refNum;
            };
            arrayBuffer.clearRefNum = function () {
                this._refNum = 1;
            };
            arrayBuffer.getRefSize = function () {
                return this._refArray.length;
            };
            arrayBuffer.getPtrID = function (index) {
                index = index ? index : 0;
                return this._refArray[index].ptrID;
            };
        }
        var bufferConchRef = null;
        if (refType == LayaGLContext.ARRAY_BUFFER_REF_REFERENCE) {
            var refArray = arrayBuffer._refArray;
            if (!refArray[0]) {
                bufferConchRef = conch.createArrayBufferRef(arrayBuffer, type, syncRender, refType);
                refArray[0] = { "ref": bufferConchRef, "ptrID": bufferConchRef.id };
            }
        }
        else {
            if (arrayBuffer._refNum < arrayBuffer._refArray.length) {
                bufferConchRef = arrayBuffer._refArray[arrayBuffer._refNum].ref;
                var nPtrID = arrayBuffer.getPtrID(arrayBuffer._refNum);
                conch.syncArrayBufferDataToRuntime(nPtrID, bufferConchRef.isSyncToRender(), arrayBuffer);
            }
            else {
                bufferConchRef = conch.createArrayBufferRef(arrayBuffer, type, syncRender, refType);
                arrayBuffer._refArray.push({ "ref": bufferConchRef, "ptrID": bufferConchRef.id });
            }
            arrayBuffer._refNum++;
        }
        return bufferConchRef;
    }
    static getFrameCount() {
        return LayaGLContext._frameAndSyncCountBuffer[0];
    }
    static syncBufferToRenderThread(value, index = 0) {
        if (LayaGLContext.instance._threadMode == LayaGLContext.THREAD_MODE_SINGLE)
            return;
        var bNeedSync = false;
        if (!value._refArray) {
            if (value.frameCount != LayaGLContext._frameAndSyncCountBuffer[0]) {
                value.frameCount = LayaGLContext._frameAndSyncCountBuffer[0];
                bNeedSync = true;
            }
        }
        else {
            var obj = value._refArray[index];
            if (obj.frameCount != LayaGLContext._frameAndSyncCountBuffer[0]) {
                obj.frameCount = LayaGLContext._frameAndSyncCountBuffer[0];
                bNeedSync = true;
            }
        }
        if (bNeedSync) {
            if ((LayaGLContext._frameAndSyncCountBuffer[1] + 1) > LayaGLContext._syncBufferSize) {
                var pre = LayaGLContext._syncBufferList;
                var preConchRef = LayaGLContext._syncBufferList["conchRef"];
                var prePtrID = LayaGLContext._syncBufferList["_ptrID"];
                LayaGLContext._syncBufferSize += LayaGLContext._SYNC_ARRAYBUFFER_SIZE_;
                LayaGLContext._syncBufferList = new Int32Array(LayaGLContext._syncBufferSize);
                LayaGLContext._syncBufferList["conchRef"] = preConchRef;
                LayaGLContext._syncBufferList["_ptrID"] = prePtrID;
                pre && LayaGLContext._syncBufferList.set(pre, 0);
                conch.updateArrayBufferRef(LayaGLContext._syncBufferList["_ptrID"], false, LayaGLContext._syncBufferList);
            }
            var nID = value.getPtrID ? value.getPtrID(index) : value["_ptrID"];
            if (!nID) {
                alert("syncBufferToRenderThread id error");
                debugger;
            }
            LayaGLContext._syncBufferList[LayaGLContext._frameAndSyncCountBuffer[1]++] = nID;
        }
    }
    getDefaultCommandEncoder() {
        return this._defaultEncoder;
    }
    commit() {
        this._saveCommandEncoder.length = 0;
        this._currentCmdEncoder = this._defaultEncoder;
        this._saveCommandEncoder.push(this._currentCmdEncoder);
    }
    setBind(pname, buffer) {
        this._curBindInfo.setBind(pname, buffer);
    }
    getBind(pname) {
        return this._curBindInfo.getBind(pname);
    }
    addGlobalValueDefine(modifyType, type, size, defaultData) {
        return this._nativeObj.addGlobalValueDefine(modifyType, type, size, defaultData);
    }
    endGlobalValueDefine() {
        this._nativeObj.endGlobalValueDefine();
    }
    defineShaderMacro(macroString, uniformInfo) {
        var nID = LayaGLContext._shader_macro_id_;
        var sUniformInfo = "";
        var len = uniformInfo.length;
        for (var i = 0; i < len; i++) {
            sUniformInfo += uniformInfo[i].uname + "," + uniformInfo[i].id.toString() + ",";
        }
        this._nativeObj.defineShaderMacro(nID, macroString, sUniformInfo);
        LayaGLContext._shader_macro_id_ <<= 1;
        return nID;
    }
    setCanvasType(type) {
    }
    setSize(w, h) {
        if (!isNaN(w) && !isNaN(h)) {
            this.width = w;
            this.height = h;
            this._nativeObj.setSize(w, h);
        }
    }
    createCommandEncoder(reserveSize, adjustSize, isSyncToRenderThread) {
        reserveSize = reserveSize ? reserveSize : 128;
        adjustSize = adjustSize ? adjustSize : 64;
        isSyncToRenderThread = isSyncToRenderThread ? isSyncToRenderThread : false;
        var cmd = new GLCommandEncoder(this, reserveSize, adjustSize, isSyncToRenderThread);
        if (isSyncToRenderThread) {
            LayaGLContext.syncBufferToRenderThread(cmd);
        }
        return cmd;
    }
    beginCommandEncoding(commandEncoder) {
        commandEncoder = commandEncoder ? commandEncoder : this._defaultEncoder;
        this._saveCommandEncoder.push(commandEncoder);
        this._currentCmdEncoder = commandEncoder;
    }
    endCommandEncoding() {
        this._saveCommandEncoder.pop();
        this._currentCmdEncoder = this._saveCommandEncoder[this._saveCommandEncoder.length - 1];
    }
    getContextAttributes() {
        return this._currentCmdEncoder.getContextAttributes();
    }
    get drawingBufferWidth() {
        return this.canvas.width;
    }
    get drawingBufferHeight() {
        return this.canvas.height;
    }
    isContextLost() {
        this._currentCmdEncoder.isContextLost();
    }
    getSupportedExtensions() {
        return this._currentCmdEncoder.getSupportedExtensions();
    }
    getExtension(name) {
        return this._currentCmdEncoder.getExtension(name);
    }
    activeTexture(texture) {
        this._currentCmdEncoder.activeTexture(texture);
    }
    attachShader(program, shader) {
        this._currentCmdEncoder.attachShader(program, shader);
    }
    getAttachedShaders(program) {
        let ret = [];
        if (program.vsShader) {
            ret.push(program.vsShader);
        }
        if (program.psShader) {
            ret.push(program.psShader);
        }
        return ret;
    }
    bindAttribLocation(program, index, name) {
        this._currentCmdEncoder.bindAttribLocation(program, index, name);
    }
    bindBuffer(target, buffer) {
        this.setBind(target, buffer);
        this._currentCmdEncoder.bindBuffer(target, buffer);
    }
    bindBufferMutiThread(target, buffer) {
        this._currentCmdEncoder.bindBuffer(target, buffer);
    }
    bindFramebuffer(target, framebuffer) {
        this._currentCmdEncoder.bindFramebuffer(target, framebuffer);
        this.setBind(target, framebuffer);
    }
    bindRenderbuffer(target, renderbuffer) {
        this._currentCmdEncoder.bindRenderbuffer(target, renderbuffer);
        this.setBind(target, renderbuffer);
    }
    bindTexture(target, texture) {
        this._currentCmdEncoder.bindTexture(target, texture);
        this.setBind(target, texture);
    }
    useTexture(texture) {
        this._currentCmdEncoder.useTexture(texture);
    }
    blendColor(red, green, blue, alpha) {
        this._currentCmdEncoder.blendColor(red, green, blue, alpha);
    }
    blendEquation(mode) {
        this._currentCmdEncoder.blendEquation(mode);
    }
    blendEquationSeparate(modeRGB, modeAlpha) {
        this._currentCmdEncoder.blendEquationSeparate(modeRGB, modeAlpha);
    }
    blendFunc(sfactor, dfactor) {
        this._currentCmdEncoder.blendFunc(sfactor, dfactor);
    }
    blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha) {
        this._currentCmdEncoder.blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
    }
    bufferData(target, size, usage) {
        this._currentCmdEncoder.bufferData(target, size, usage);
    }
    bufferSubData(target, offset, data) {
        this._currentCmdEncoder.bufferSubData(target, offset, data);
    }
    checkFramebufferStatus(target) {
        return this._currentCmdEncoder.checkFramebufferStatus(target);
    }
    clear(mask) {
        this._currentCmdEncoder.clear(mask);
    }
    clearColor(red, green, blue, alpha) {
        this._currentCmdEncoder.clearColor(red, green, blue, alpha);
    }
    clearDepth(depth) {
        this._currentCmdEncoder.clearDepth(depth);
    }
    clearStencil(s) {
        this._currentCmdEncoder.clearStencil(s);
    }
    colorMask(red, green, blue, alpha) {
        this._currentCmdEncoder.colorMask(red, green, blue, alpha);
    }
    compileShader(shader) {
        this._currentCmdEncoder.compileShader(shader);
    }
    copyTexImage2D(target, level, internalformat, x, y, width, height, border) {
        this._currentCmdEncoder.copyTexImage2D(target, level, internalformat, x, y, width, height, border);
    }
    copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height) {
        this._currentCmdEncoder.copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
    }
    createBuffer() {
        return this._currentCmdEncoder.createBuffer();
    }
    createFramebuffer() {
        return this._currentCmdEncoder.createFramebuffer();
    }
    createProgram() {
        return this._currentCmdEncoder.createProgram();
    }
    createRenderbuffer() {
        return this._currentCmdEncoder.createRenderbuffer();
    }
    createShader(type) {
        return this._currentCmdEncoder.createShader(type);
    }
    createTexture() {
        return this._currentCmdEncoder.createTexture();
    }
    cullFace(mode) {
        this._currentCmdEncoder.cullFace(mode);
    }
    deleteBuffer(buffer) {
        this._currentCmdEncoder.deleteBuffer(buffer);
        buffer.id = -1;
    }
    deleteFramebuffer(framebuffer) {
        this._currentCmdEncoder.deleteFramebuffer(framebuffer);
        framebuffer.id = -1;
    }
    deleteProgram(program) {
        this._currentCmdEncoder.deleteProgram(program);
        program.id = -1;
    }
    deleteRenderbuffer(renderbuffer) {
        this._currentCmdEncoder.deleteRenderbuffer(renderbuffer);
        renderbuffer.id = -1;
    }
    deleteShader(shader) {
        this._currentCmdEncoder.deleteShader(shader);
        shader.id = -1;
        shader.src = null;
    }
    deleteTexture(texture) {
        this._currentCmdEncoder.deleteTexture(texture);
        texture.id = -1;
    }
    depthFunc(func) {
        this._currentCmdEncoder.depthFunc(func);
    }
    depthMask(flag) {
        this._currentCmdEncoder.depthMask(flag);
    }
    depthRange(zNear, zFar) {
        this._currentCmdEncoder.depthRange(zNear, zFar);
    }
    detachShader(program, shader) {
        this._currentCmdEncoder.detachShader(program, shader);
    }
    disable(cap) {
        this._currentCmdEncoder.disable(cap);
    }
    disableVertexAttribArray(index) {
        this._currentCmdEncoder.disableVertexAttribArray(index);
    }
    drawArrays(mode, first, count) {
        this._currentCmdEncoder.drawArrays(mode, first, count);
    }
    drawElements(mode, count, type, offset) {
        this._currentCmdEncoder.drawElements(mode, count, type, offset);
    }
    enable(cap) {
        this._currentCmdEncoder.enable(cap);
    }
    enableVertexAttribArray(index) {
        this._currentCmdEncoder.enableVertexAttribArray(index);
    }
    finish() {
        this._currentCmdEncoder.finish();
    }
    flush() {
        this._currentCmdEncoder.flush();
    }
    framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) {
        this._currentCmdEncoder.framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
        var frameBuffer = this.getBind(target);
        if (frameBuffer) {
            frameBuffer.setBind(attachment, renderbuffer);
        }
    }
    framebufferTexture2D(target, attachment, textarget, texture, level) {
        this._currentCmdEncoder.framebufferTexture2D(target, attachment, textarget, texture, level);
        var frameBuffer = this.getBind(target);
        if (frameBuffer) {
            frameBuffer.setBind(attachment, texture);
        }
    }
    frontFace(mode) {
        return this._currentCmdEncoder.frontFace(mode);
    }
    generateMipmap(target) {
        return this._currentCmdEncoder.generateMipmap(target);
    }
    getActiveAttrib(program, index) {
        return this._currentCmdEncoder.getActiveAttrib(program, index);
    }
    getActiveUniform(program, index) {
        return this._currentCmdEncoder.getActiveUniform(program, index);
    }
    getAttribLocation(program, name) {
        return this._currentCmdEncoder.getAttribLocation(program, name);
    }
    getParameter(pname) {
        return this._currentCmdEncoder.getParameter(pname);
    }
    getBufferParameter(target, pname) {
        return this._currentCmdEncoder.getBufferParameter(target, pname);
    }
    getError() {
        return this._currentCmdEncoder.getError();
    }
    getFramebufferAttachmentParameter(target, attachment, pname) {
        return this._currentCmdEncoder.getFramebufferAttachmentParameter(target, attachment, pname);
    }
    getProgramParameter(program, pname) {
        return this._currentCmdEncoder.getProgramParameter(program, pname);
    }
    getProgramInfoLog(program) {
        return this._currentCmdEncoder.getProgramInfoLog(program);
    }
    getRenderbufferParameter(target, pname) {
        return this._currentCmdEncoder.getRenderbufferParameter(target, pname);
    }
    getShaderPrecisionFormat(shaderType, precisionType) {
        return this._currentCmdEncoder.getShaderPrecisionFormat(shaderType, precisionType);
    }
    getShaderParameter(shader, pname) {
        return this._currentCmdEncoder.getShaderParameter(shader, pname);
    }
    getShaderInfoLog(shader) {
        return this._currentCmdEncoder.getShaderInfoLog(shader);
    }
    getShaderSource(shader) {
        return this._currentCmdEncoder.getShaderSource(shader);
    }
    getTexParameter(target, pname) {
        return this._currentCmdEncoder.getTexParameter(target, pname);
    }
    getUniform(program, location) {
        return this._currentCmdEncoder.getUniform(program, location);
    }
    getUniformLocation(program, name) {
        return this._currentCmdEncoder.getUniformLocation(program, name);
    }
    getVertexAttrib(index, pname) {
        return this._currentCmdEncoder.getVertexAttrib(index, pname);
    }
    getVertexAttribOffset(index, pname) {
        return this._currentCmdEncoder.getVertexAttribOffset(index, pname);
    }
    hnumber(target, mode) {
        this._currentCmdEncoder.hint(target, mode);
    }
    hint(target, mode) {
        this._currentCmdEncoder.hint(target, mode);
    }
    isBuffer(buffer) {
        this._currentCmdEncoder.isBuffer(buffer);
    }
    isEnabled(cap) {
        return this._currentCmdEncoder.isEnabled(cap);
    }
    isFramebuffer(framebuffer) {
        this._currentCmdEncoder.isFramebuffer(framebuffer);
    }
    isProgram(program) {
        this._currentCmdEncoder.isProgram(program);
    }
    isRenderbuffer(renderbuffer) {
        this._currentCmdEncoder.isRenderbuffer(renderbuffer);
    }
    isShader(shader) {
        this._currentCmdEncoder.isShader(shader);
    }
    isTexture(texture) {
        this._currentCmdEncoder.isTexture(texture);
    }
    lineWidth(width) {
        this._currentCmdEncoder.lineWidth(width);
    }
    linkProgram(program) {
        this._currentCmdEncoder.linkProgram(program);
    }
    pixelStorei(pname, param) {
        this._currentCmdEncoder.pixelStorei(pname, param);
    }
    polygonOffset(factor, units) {
        this._currentCmdEncoder.polygonOffset(factor, units);
    }
    readPixels(x, y, width, height, format, type, pixels) {
        this._currentCmdEncoder.readPixels(x, y, width, height, format, type, pixels);
    }
    readPixelsAsync(x, y, w, h, format, type, callBack) {
        this._currentCmdEncoder.readPixelsAsync(x, y, w, h, format, type, callBack);
    }
    renderbufferStorage(target, internalformat, width, height) {
        this._currentCmdEncoder.renderbufferStorage(target, internalformat, width, height);
    }
    sampleCoverage(value, invert) {
        this._currentCmdEncoder.sampleCoverage(value, invert);
    }
    scissor(x, y, width, height) {
        this._currentCmdEncoder.scissor(x, y, width, height);
    }
    shaderSource(shader, source) {
        this._currentCmdEncoder.shaderSource(shader, source);
    }
    stencilFunc(func, ref, mask) {
        this._currentCmdEncoder.stencilFunc(func, ref, mask);
    }
    stencilFuncSeparate(face, func, ref, mask) {
        this._currentCmdEncoder.stencilFuncSeparate(face, func, ref, mask);
    }
    stencilMask(mask) {
        this._currentCmdEncoder.stencilMask(mask);
    }
    stencilMaskSeparate(face, mask) {
        this._currentCmdEncoder.stencilMaskSeparate(face, mask);
    }
    stencilOp(fail, zfail, zpass) {
        this._currentCmdEncoder.stencilOp(fail, zfail, zpass);
    }
    stencilOpSeparate(face, fail, zfail, zpass) {
        this._currentCmdEncoder.stencilOpSeparate(face, fail, zfail, zpass);
    }
    texImage2D(_args) {
        var args = arguments;
        this._currentCmdEncoder.texImage2D.apply(this._currentCmdEncoder, args);
    }
    texParameterf(target, pname, param) {
        this._currentCmdEncoder.texParameterf(target, pname, param);
    }
    texParameteri(target, pname, param) {
        this._currentCmdEncoder.texParameteri(target, pname, param);
    }
    texSubImage2D(_args) {
        var args = arguments;
        this._currentCmdEncoder.texSubImage2D.apply(this._currentCmdEncoder, args);
    }
    uniform1f(location, x) {
        this._currentCmdEncoder.uniform1f(location, x);
    }
    uniform1fv(location, v) {
        this._currentCmdEncoder.uniform1fv(location, v);
    }
    uniform1i(location, x) {
        this._currentCmdEncoder.uniform1i(location, x);
    }
    uniform1iv(location, v) {
        this._currentCmdEncoder.uniform1iv(location, v);
    }
    uniform2f(location, x, y) {
        this._currentCmdEncoder.uniform2f(location, x, y);
    }
    uniform2fv(location, v) {
        this._currentCmdEncoder.uniform2fv(location, v);
    }
    uniform2i(location, x, y) {
        this._currentCmdEncoder.uniform2i(location, x, y);
    }
    uniform2iv(location, v) {
        this._currentCmdEncoder.uniform2iv(location, v);
    }
    uniform3f(location, x, y, z) {
        this._currentCmdEncoder.uniform3f(location, x, y, z);
    }
    uniform3fv(location, v) {
        this._currentCmdEncoder.uniform3fv(location, v);
    }
    uniform3i(location, x, y, z) {
        this._currentCmdEncoder.uniform3i(location, x, y, z);
    }
    uniform3iv(location, v) {
        this._currentCmdEncoder.uniform3iv(location, v);
    }
    uniform4f(location, x, y, z, w) {
        this._currentCmdEncoder.uniform4f(location, x, y, z, w);
    }
    uniform4fv(location, v) {
        this._currentCmdEncoder.uniform4fv(location, v);
    }
    uniform4i(location, x, y, z, w) {
        this._currentCmdEncoder.uniform4i(location, x, y, z, w);
    }
    uniform4iv(location, v) {
        this._currentCmdEncoder.uniform4iv(location, v);
    }
    uniformMatrix2fv(location, transpose, value) {
        this._currentCmdEncoder.uniformMatrix2fv(location, transpose, value);
    }
    uniformMatrix3fv(location, transpose, value) {
        this._currentCmdEncoder.uniformMatrix3fv(location, transpose, value);
    }
    uniformMatrix4fv(location, transpose, value) {
        this._currentCmdEncoder.uniformMatrix4fv(location, transpose, value);
    }
    useProgram(program) {
        this.setBind(this.CURRENT_PROGRAM, program);
        this._currentCmdEncoder.useProgram(program);
    }
    useProgramMutiThread(program) {
        this._currentCmdEncoder.useProgram(program);
    }
    validateProgram(program) {
        this._currentCmdEncoder.validateProgram(program);
    }
    vertexAttrib1f(indx, x) {
        this._currentCmdEncoder.vertexAttrib1f(indx, x);
    }
    vertexAttrib1fv(indx, values) {
        this._currentCmdEncoder.vertexAttrib1fv(indx, values);
    }
    vertexAttrib2f(indx, x, y) {
        this._currentCmdEncoder.vertexAttrib2f(indx, x, y);
    }
    vertexAttrib2fv(indx, values) {
        this._currentCmdEncoder.vertexAttrib2fv(indx, values);
    }
    vertexAttrib3f(indx, x, y, z) {
        this._currentCmdEncoder.vertexAttrib3f(indx, x, y, z);
    }
    vertexAttrib3fv(indx, values) {
        this._currentCmdEncoder.vertexAttrib3fv(indx, values);
    }
    vertexAttrib4f(indx, x, y, z, w) {
        this._currentCmdEncoder.vertexAttrib4f(indx, x, y, z, w);
    }
    vertexAttrib4fv(indx, values) {
        this._currentCmdEncoder.vertexAttrib4fv(indx, values);
    }
    vertexAttribPointer(indx, size, type, normalized, stride, offset) {
        this._currentCmdEncoder.vertexAttribPointer(indx, size, type, normalized, stride, offset);
    }
    viewport(x, y, width, height) {
        this._currentCmdEncoder.viewport(x, y, width, height);
    }
    configureBackBuffer(width, height, antiAlias, enableDepthAndStencil, wantsBestResolution) {
        enableDepthAndStencil = enableDepthAndStencil ? enableDepthAndStencil : true;
        wantsBestResolution = wantsBestResolution ? wantsBestResolution : false;
        this._currentCmdEncoder.configureBackBuffer(width, height, antiAlias, enableDepthAndStencil, wantsBestResolution);
    }
    compressedTexImage2D(_args) {
        var args = arguments;
        this._currentCmdEncoder.compressedTexImage2D.apply(this._currentCmdEncoder, args);
    }
    compressedTexSubImage2D(_args) {
        var args = arguments;
        this._currentCmdEncoder.compressedTexSubImage2D.apply(this._currentCmdEncoder, args);
    }
    createVertexArray() {
        return this._currentCmdEncoder.createVertexArray();
    }
    bindVertexArray(vao) {
        this._currentCmdEncoder.bindVertexArray(vao);
    }
    deleteVertexArray(vao) {
        this._currentCmdEncoder.deleteVertexArray(vao);
    }
    isVertexArray(vao) {
        return this._currentCmdEncoder.isVertexArray(vao);
    }
    vertexAttribDivisor(index, divisor) {
        this._currentCmdEncoder.vertexAttribDivisor(index, divisor);
    }
    drawArraysInstanced(mode, first, count, instanceCount) {
        this._currentCmdEncoder.drawArraysInstanced(mode, first, count, instanceCount);
    }
    drawElementsInstanced(mode, count, type, offset, instanceCount) {
        this._currentCmdEncoder.drawElementsInstanced(mode, count, type, offset, instanceCount);
    }
    uniformMatrix2fvEx(location, transpose, value) {
        this._currentCmdEncoder.uniformMatrix2fvEx(location, transpose, value);
    }
    uniformMatrix3fvEx(location, transpose, value) {
        this._currentCmdEncoder.uniformMatrix3fvEx(location, transpose, value);
    }
    uniformMatrix4fvEx(location, transpose, value) {
        this._currentCmdEncoder.uniformMatrix4fvEx(location, transpose, value);
    }
    addShaderUniform(one) {
        this._currentCmdEncoder.addShaderUniform(one);
    }
    uploadShaderUniforms(commandEncoder, data, type) {
        this._currentCmdEncoder.uploadShaderUniforms(commandEncoder, data, type);
        return 0;
    }
    useCommandEncoder(commandEncoder) {
        this._currentCmdEncoder.useCommandEncoder(commandEncoder);
    }
    loadDataToReg(regNum, data, offset, size) {
        this._currentCmdEncoder.loadDataToReg(regNum, data, offset, size);
    }
    loadDataToRegEx(regNum, dataID, offset, size) {
        this._currentCmdEncoder.loadDataToRegEx(regNum, dataID, offset, size);
    }
    ifLess0(regNum, statementNum) {
        this._currentCmdEncoder.ifLess0(regNum, statementNum);
    }
    ifEqual0(regNum, statementNum) {
        this._currentCmdEncoder.ifEqual0(regNum, statementNum);
    }
    ifGreater0(regNum, statementNum) {
        this._currentCmdEncoder.ifGreater0(regNum, statementNum);
    }
    ifLEqual0(regNum, statementNum) {
        this._currentCmdEncoder.ifLEqual0(regNum, statementNum);
    }
    ifGEqual0(regNum, statementNum) {
        this._currentCmdEncoder.ifGEqual0(regNum, statementNum);
    }
    ifGNotEqual0(regNum, statementNum) {
        this._currentCmdEncoder.ifGNotEqual0(regNum, statementNum);
    }
    operateReg(regOut, reg1, reg2, size, operateType, dataType) {
        this._currentCmdEncoder.operateReg(regOut, reg1, reg2, size, operateType, dataType);
    }
    store(dataID, offset, regID, size) {
        this._currentCmdEncoder.store(dataID, offset, regID, size);
    }
    setMainContextSize(width, height) {
        this._nativeObj.setMainContextSize(width, height);
    }
    getCurrentContext() {
        return this._currentContext;
    }
    getProgramParameterEx(vs, ps, define, pname) {
        return this._nativeObj.getProgramParameterEx(vs, ps, define, pname);
    }
    getActiveAttribEx(vs, ps, define, index) {
        return this._nativeObj.getActiveAttribEx(vs, ps, define, index);
    }
    getActiveUniformEx(vs, ps, define, index) {
        return this._nativeObj.getActiveUniformEx(vs, ps, define, index);
    }
    updateAnimationNodeWorldMatix(locPosition, locRotation, locScaling, parentIndices, outWorldMatrix) {
        return this._nativeObj.updateAnimationNodeWorldMatix(locPosition, locRotation, locScaling, parentIndices, outWorldMatrix);
    }
    computeSubSkinnedDataNative(worldMatrixs, worldMatrixIndex, inverseBindPoses, boneIndices, bindPoseInices, resultData) {
        return this._nativeObj.computeSubSkinnedDataNative(worldMatrixs, worldMatrixIndex, inverseBindPoses, boneIndices, bindPoseInices, resultData);
    }
    computeSubSkinnedData(worldMatrixs, worldMatrixIndex, inverseBindPoses, boneIndices, bindPoseInices, resultData) {
        return this._nativeObj.computeSubSkinnedData(worldMatrixs, worldMatrixIndex, inverseBindPoses, boneIndices, bindPoseInices, resultData);
    }
    culling(boundFrustumBuffer, cullingBuffer, cullingBufferIndices, cullingCount, cullingBufferResult) {
        return this._nativeObj.culling(boundFrustumBuffer, cullingBuffer, cullingBufferIndices, cullingCount, cullingBufferResult);
    }
    calcMatrixFromScaleSkewRotation(nArrayBufferID, matrixFlag, matrixResultID, x, y, pivotX, pivotY, scaleX, scaleY, skewX, skewY, rotate) {
        conch.calcMatrixFromScaleSkewRotation(nArrayBufferID, matrixFlag, matrixResultID, x, y, pivotX, pivotY, scaleX, scaleY, skewX, skewY, rotate);
    }
    setGLTemplate(type, templateID) {
        conch.setGLTemplate(type, templateID);
    }
    setEndGLTemplate(type, templateID) {
        conch.setEndGLTemplate(type, templateID);
    }
    matrix4x4Multiply(m1, m2, out) {
        conch.matrix4x4Multiply(m1, m2, out);
    }
    evaluateClipDatasRealTime(nodes, playCurTime, realTimeCurrentFrameIndexs, addtive, frontPlay) {
        conch.evaluateClipDatasRealTime(nodes, playCurTime, realTimeCurrentFrameIndexs, addtive, frontPlay);
    }
}
LayaGLContext._SYNC_ARRAYBUFFER_SIZE_ = 4096;
LayaGLContext._syncBufferSize = LayaGLContext._SYNC_ARRAYBUFFER_SIZE_;
LayaGLContext._tempGLEncoder = null;
LayaGLContext._shader_macro_id_ = 1;
LayaGLContext.THREAD_MODE_SINGLE = 1;
LayaGLContext.THREAD_MODE_DOUBLE = 2;
LayaGLContext.EXECUTE_JS_THREAD_BUFFER = 0;
LayaGLContext.EXECUTE_RENDER_THREAD_BUFFER = 1;
LayaGLContext.EXECUTE_COPY_TO_RENDER = 2;
LayaGLContext.EXECUTE_COPY_TO_RENDER3D = 3;
LayaGLContext.VALUE_OPERATE_ADD = 0;
LayaGLContext.VALUE_OPERATE_SUB = 1;
LayaGLContext.VALUE_OPERATE_MUL = 2;
LayaGLContext.VALUE_OPERATE_DIV = 3;
LayaGLContext.VALUE_OPERATE_M2_MUL = 4;
LayaGLContext.VALUE_OPERATE_M3_MUL = 5;
LayaGLContext.VALUE_OPERATE_M4_MUL = 6;
LayaGLContext.VALUE_OPERATE_M32_MUL = 7;
LayaGLContext.VALUE_OPERATE_SET = 8;
LayaGLContext.VALUE_OPERATE_M32_TRANSLATE = 9;
LayaGLContext.VALUE_OPERATE_M32_SCALE = 10;
LayaGLContext.VALUE_OPERATE_M32_ROTATE = 11;
LayaGLContext.VALUE_OPERATE_M32_SCALE_PIVOT = 12;
LayaGLContext.VALUE_OPERATE_M32_ROTATE_PIVOT = 13;
LayaGLContext.VALUE_OPERATE_M32_TRANSFORM_PIVOT = 14;
LayaGLContext.VALUE_OPERATE_BYTE4_COLOR_MUL = 15;
LayaGLContext.ARRAY_BUFFER_TYPE_DATA = 0;
LayaGLContext.ARRAY_BUFFER_TYPE_CMD = 1;
LayaGLContext.ARRAY_BUFFER_REF_REFERENCE = 0;
LayaGLContext.ARRAY_BUFFER_REF_COPY = 1;
LayaGLContext.UPLOAD_SHADER_UNIFORM_TYPE_ID = 0;
LayaGLContext.UPLOAD_SHADER_UNIFORM_TYPE_DATA = 1;
window["WebGLRenderingContext"] = LayaGLContext;
window["LayaGLContext"] = LayaGLContext;
window["ParamData"] = ParamData;
window["ProgramLocationTable"] = ProgramLocationTable;
window["GLCommandEncoder"] = GLCommandEncoder;
window["CallbackFuncObj"] = CallbackFuncObj;
class CSSStyleDeclaration {
    constructor() {
        this._transform = new Float32Array([1, 0, 0, 1, 0, 0]);
        this._styleNumber = 0;
    }
    get length() {
        return this._styleNumber;
    }
    getPropertyPriority(propertyName) {
        return '';
    }
    getPropertyValue(propertyName) {
        return '';
    }
    item(index) {
        return '';
    }
    removeProperty(propertyName) {
        return '';
    }
    setProperty(propertyName, value, priority) {
    }
    set left(l) {
        var nl = parseInt(l);
        this._htmlEle.clientLeft = nl;
    }
    set top(t) {
        var nt = parseInt(t);
        this._htmlEle.clientTop = nt;
    }
    set height(h) {
        var nh = parseInt(h);
        this._htmlEle.clientHeight = nh;
    }
    set width(w) {
        var nw = parseInt(w);
        this._htmlEle.clientWidth = nw;
    }
    set transform(trans) {
        var s1 = trans.split(/[(,)]/);
        if (s1 && s1.length > 2) {
            if (s1[0] === 'matrix') {
                if (s1.length >= 7) {
                    this._transform[0] = 1 * s1[1];
                    this._transform[1] = 1 * s1[2];
                    this._transform[2] = 1 * s1[3];
                    this._transform[3] = 1 * s1[4];
                    this._transform[4] = 1 * s1[5];
                    this._transform[5] = 1 * s1[6];
                    if (this._htmlEle && this._htmlEle.onCSS_Transform) {
                        this._htmlEle.onCSS_Transform(this._transform);
                    }
                }
                else if (s1[0] === 'scale') {
                    alert('css scale not implemented');
                }
            }
        }
    }
}
class HTMLElement extends Element {
    constructor() {
        super();
        this.style = new CSSStyleDeclaration();
        this.style._htmlEle = this;
    }
    onCSS_Transform(mat) { }
    ;
    onerror(ev) {
    }
    onload(ev) {
    }
}
window["HTMLElement"] = HTMLElement;
class HTMLDivElement extends HTMLElement {
    constructor() {
        super();
        this.tagName = "DIV";
    }
}
class HTMLScriptElement extends HTMLElement {
    constructor() {
        super();
        this.tagName = "SCRIPT";
    }
    set src(url) {
        var _t = this;
        this._src = location.resolve(url);
        console.log("HTMLScriptElement set src" + this._src);
        document.uploadScript({ "src": this._src, "obj": this });
    }
    get src() {
        return this._src;
    }
    set text(t) {
        this._text = t;
        document.uploadScript({ "text": this._text, "obj": this });
    }
    get text() {
        return this._text;
    }
}
class HTMLCanvasElement extends HTMLElement {
    constructor() {
        super();
        this._isFirst = false;
        this._tranform = null;
        this._hasTransform = false;
        this._clientRect = { left: 0, top: 0,  0, height: 0, right: 0, bottom: 0 };
        this.clientLeft;
        this.tagName = "CANVAS";
        this._width = HTMLCanvasElement.defaultWidth;
        this._height = HTMLCanvasElement.defaultHeight;
    }
    setFirst() {
        this._isFirst = true;
        if (this._context) {
            LayaGLContext.instance.canvas = this;
        }
    }
    getBoundingClientRect() {
        var cr = this._clientRect;
        if (this._hasTransform) {
            cr.width = this._width * this._tranform[0];
            cr.height = this._height * this._tranform[3];
            cr.left = this._tranform[4];
            cr.top = this._tranform[5];
            cr.right = cr.left + cr.width;
            cr.bottom = cr.left + cr.height;
        }
        else {
            cr.right = cr.width = this._width;
            cr.bottom = cr.height = this._height;
        }
        return cr;
    }
    getContext(contextType) {
        console.log("getContext type=" + contextType);
        if (!LayaGLContext.instance) {
            LayaGLContext.instance = new LayaGLContext(contextType);
        }
        if (!this._context) {
            this._context = new CanvasRenderingContext(this);
            if (this._width)
                this._context.setSize(this._width, this._height);
            if (this._isFirst) {
                LayaGLContext.instance.canvas = this;
            }
        }
        if (contextType.indexOf("webgl") >= 0) {
            LayaGLContext.instance.canvas = this;
            return LayaGLContext.instance;
        }
        else {
            return this._context;
        }
    }
    onCSS_Transform(mat) {
        this._tranform = mat;
        this._hasTransform = true;
        var e = new Event('csstransform');
        this.dispatchEvent(e);
        var sw = mat[0];
        var sh = mat[3];
        conchConfig.setScreenScale(sw, sh, mat[4], mat[5]);
        if (sw == 0 || sh == 0) {
            if (mat[4] > mat[5]) {
                console.warn("设置横竖屏错误! 请在初始html页面meta中设置screenorientation为横屏landscape");
            }
            else {
                console.warn("设置横竖屏错误! 请在初始html页面meta中设置screenorientation为竖屏portrait");
            }
        }
    }
    toDataURL(type) {
        return "";
    }
    setSize(w, h) {
        this._width = w;
        this._height = h;
        this._context && this._context.setSize(w, h);
    }
    set width(w) {
        if (this._isFirst && HTMLCanvasElement.RS) {
            this._w = w;
            return;
        }
        if (this._width != w) {
            this._width = w;
            this._context && this._context.setSize(this._width, this._height);
        }
    }
    get width() {
        return this._width;
    }
    set height(h) {
        if (this._isFirst && HTMLCanvasElement.RS) {
            this._h = h;
            return;
        }
        if (this._height != h) {
            this._height = h;
            this._context && this._context.setSize(this._width, this._height);
        }
    }
    get height() {
        return this._height;
    }
    get clientWidth() {
        return this._width;
    }
    get clientHeight() {
        return this._height;
    }
    set clientWidth(v) {
        this._width = v;
    }
    set clientHeight(v) {
        this._height = v;
    }
    toBase64(type, encoderOptions, callback) {
        if (this._context) {
            this._context.toBase64(type, encoderOptions, callback);
        }
    }
    getImageData(x, y, w, h, callBack) {
        if (this._context) {
            this._context.getImageData(x, y, w, h, callBack);
        }
    }
}
HTMLCanvasElement.defaultWidth = 300;
HTMLCanvasElement.defaultHeight = 150;
window.HTMLCanvasElement = HTMLCanvasElement;
class HTMLImageElement extends HTMLElement {
    constructor() {
        super();
        this._nativeObj = null;
        this.complete = false;
        this._enableMerageInAtlas = true;
        this.tagName = 'IMG';
        this._nativeObj = new conchImage();
        this._nativeObj.srcs = 0;
        this._nativeObj.obj = this;
    }
    set src(url) {
        this._nativeObj.onerror = this._nativeOnError;
        this._nativeObj.onload = this._nativeOnload;
        this._nativeObj.srcs = this._nativeObj.srcs || 0;
        if (this._nativeObj.srcs == 0) {
            this._nativeObj.obj = this;
        }
        this._nativeObj.srcs++;
        if (this.isBase64(url)) {
            let index = url.indexOf(';base64,');
            if (index != -1) {
                this._nativeObj.setBase64(url.substr(index + 8));
            }
        }
        else {
            url = location.resolve(url);
            this._nativeObj.setSrc(url);
        }
    }
    isBase64(url) {
        return url.startsWith('data:image/');
    }
    get src() {
        return this._nativeObj.src;
    }
    _nativeOnload() {
        this.srcs = this.srcs || 1;
        this.srcs--;
        var temp = this.obj;
        var e = new Event('load');
        temp.complete = true;
        e.target = this;
        temp.onload(e);
        temp.dispatchEvent(e);
        if (this.srcs == 0) {
            this.obj = null;
        }
    }
    _nativeOnError(e) {
        this.srcs = this.srcs || 1;
        this.srcs--;
        var temp = this.obj;
        var evt = new Event('error');
        evt.target = this;
        if (typeof (e) === 'object') {
            evt['extCode'] = e.extCode;
        }
        else
            evt['extCode'] = e;
        temp.onerror(evt);
        temp.dispatchEvent(evt);
        if (this.srcs == 0) {
            this.obj = null;
        }
    }
    get width() {
        if (this._nativeObj)
            return this._nativeObj.width;
        return 0;
    }
    get height() {
        if (this._nativeObj)
            return this._nativeObj.height;
        return 0;
    }
    get imgId() {
        return this._nativeObj.conchImgId;
    }
    putImageData(data, w, h) {
        this._nativeObj.putBitmapData(data, w, h);
    }
    setPremultiplyAlpha(b) {
        this._nativeObj.setPremultiplyAlpha(b);
    }
    conchDestroy() {
        this._nativeObj.destroy();
    }
    set enableMerageInAtlas(value) {
        this._enableMerageInAtlas = value;
        this._nativeObj.enableMerageInAtlas(value);
    }
    get enableMerageInAtlas() {
        return this._enableMerageInAtlas;
    }
    releaseTexture() {
        this._nativeObj.releaseTexture();
    }
}
window["HTMLImageElement"] = HTMLImageElement;
class HTMLInputElement extends HTMLElement {
    constructor() {
        super();
        this.tagName = "Input";
        this._nativeObj = new ConchInput();
        this.setLeft = this._nativeObj.setLeft.bind(this._nativeObj);
        this.setTop = this._nativeObj.setTop.bind(this._nativeObj);
        this.setWidth = this._nativeObj.setWidth.bind(this._nativeObj);
        this.setHeight = this._nativeObj.setHeight.bind(this._nativeObj);
        this.setOpacity = this._nativeObj.setOpacity.bind(this._nativeObj);
        this.setValue = this._nativeObj.setValue.bind(this._nativeObj);
        this.getValue = this._nativeObj.getValue.bind(this._nativeObj);
        this.setStyle = this._nativeObj.setStyle.bind(this._nativeObj);
        this.setVisible = this._nativeObj.setVisible.bind(this._nativeObj);
        this.focus = this._nativeObj.focus.bind(this._nativeObj);
        this.blur = this._nativeObj.blur.bind(this._nativeObj);
        this.setColor = this._nativeObj.setColor.bind(this._nativeObj);
        this.setFontSize = this._nativeObj.setFontSize.bind(this._nativeObj);
        this.setPos = this._nativeObj.setPos.bind(this._nativeObj);
        this.setSize = this._nativeObj.setSize.bind(this._nativeObj);
        this.setCursorPosition = this._nativeObj.setCursorPosition.bind(this._nativeObj);
        this.setScale = this._nativeObj.setScale.bind(this._nativeObj);
        this.setMaxLength = this._nativeObj.setMaxLength.bind(this._nativeObj);
        this.setType = this._nativeObj.setType.bind(this._nativeObj);
        this.setNumberOnly = this._nativeObj.setNumberOnly.bind(this._nativeObj);
        this.setRegular = this._nativeObj.setRegular.bind(this._nativeObj);
        this.setFont = this._nativeObj.setFont.bind(this._nativeObj);
        this.setMultiAble = this._nativeObj.setMultiAble.bind(this._nativeObj);
        this.setForbidEdit = this._nativeObj.setForbidEdit.bind(this._nativeObj);
        if (this._nativeObj.setBgColor)
            this.setBgColor = this._nativeObj.setBgColor.bind(this._nativeObj);
        else
            this.setBgColor = function (c) { };
    }
    set maxLength(v) {
        this.setMaxLength(v);
    }
    set left(v) {
        this._nativeObj.left = v;
    }
    get left() {
        return this._nativeObj.left;
    }
    set top(v) {
        this._nativeObj.top = v;
    }
    get top() {
        return this._nativeObj.top;
    }
    set width(v) {
        this._nativeObj.width = v;
    }
    get width() {
        return this._nativeObj.width;
    }
    set height(v) {
        this._nativeObj.height = v;
    }
    get height() {
        return this._nativeObj.height;
    }
    set opacity(v) {
        this._nativeObj.opacity = v;
    }
    get opacity() {
        return this._nativeObj.opacity;
    }
    get clientLeft() {
        return this._nativeObj.left;
    }
    set clientLeft(v) {
        this._nativeObj.left = v;
    }
    get clientTop() {
        return this._nativeObj.top;
    }
    set clientTop(v) {
        this._nativeObj.top = v;
    }
    set clientWidth(v) {
        this._nativeObj.width = v;
    }
    get clientWidth() {
        return this._nativeObj.width;
    }
    set clientHeight(v) {
        this._nativeObj.height = v;
    }
    get clientHeight() {
        return this._nativeObj.height;
    }
    set value(v) {
        this._nativeObj.value = v;
    }
    get value() {
        return this._nativeObj.value;
    }
    set visible(v) {
        this._nativeObj.visible = v;
    }
    get visible() {
        return this._nativeObj.visible;
    }
    addEventListener(type, listener, useCapture) {
        super.addEventListener(type, listener, useCapture);
        var _t = this;
        this._nativeObj.addEventListener(type, function (e) {
            var ev = new _lbEvent(type);
            ev.target = this;
            _t.dispatchEvent(ev);
        });
    }
}
var CanPlayTypeResult;
(function (CanPlayTypeResult) {
    CanPlayTypeResult["Empty"] = "";
    CanPlayTypeResult["Maybe"] = "maybe";
    CanPlayTypeResult["Probably"] = "probably";
})(CanPlayTypeResult || (CanPlayTypeResult = {}));
;
class HTMLMediaElement extends HTMLElement {
    constructor(NativeMediaCreator) {
        super();
        this._src = "";
        this._nativeObj = new NativeMediaCreator();
    }
    set src(val) {
        this._src = val;
        this._nativeObj.src = window.location.resolve(this._src);
    }
    get src() {
        return this._nativeObj.src;
    }
    get currentSrc() {
        return this._src;
    }
    canPlayType(type) {
        return CanPlayTypeResult.Empty;
    }
    load() {
    }
    set currentTime(v) {
        this._nativeObj.currentTime = v;
    }
    get currentTime() {
        return this._nativeObj.currentTime;
    }
    play() {
        this._nativeObj.play();
    }
    pause() {
        this._nativeObj.pause();
    }
    set autoplay(v) {
        this._nativeObj.autoplay = v;
    }
    get autoplay() {
        return this._nativeObj.autoplay;
    }
    set loop(v) {
        this._nativeObj.loop = v;
    }
    get loop() {
        return this._nativeObj.loop;
    }
    set volume(v) {
        this._nativeObj.volume = v;
    }
    get volume() {
        return this._nativeObj.volume;
    }
    set muted(v) {
        this._nativeObj.muted = v;
    }
    get muted() {
        return this._nativeObj.muted;
    }
}
class HTMLMetaElement extends HTMLElement {
    get httpEquiv() {
        return this["http-equiv"];
    }
    set name(n) {
        this._name = n;
        document._elements[n] = document._elements[n] || [];
        document._elements[n].push(this);
    }
    get name() {
        return this._name;
    }
    constructor() {
        super();
        this.tagName = "META";
    }
}
class HTMLAudioElement extends HTMLMediaElement {
    constructor() {
        super(ConchAudio);
        this.readyState = 0;
        this.tagName = "AUDIO";
    }
    setLoop(loop) {
        this._nativeObj.setLoop(loop);
    }
    stop() {
        this._nativeObj.stop();
    }
    set muted(v) {
        this._nativeObj.muted = v;
    }
    get muted() {
        return this._nativeObj.muted;
    }
    addEventListener(type, listener, useCapture) {
        super.addEventListener(type, listener, useCapture);
        var _t = this;
        this._nativeObj.addEventListener(type, function (e) {
            var ev = new _lbEvent(type);
            ev.target = this;
            if (type == "canplaythrough")
                _t.readyState = 4;
            _t.dispatchEvent(ev);
        });
    }
}
class HTMLVideoElement extends HTMLMediaElement {
    constructor() {
        super(ConchVideo);
        this._src = "";
        this.tagName = "VIDEO";
        this._nativeObj._setDispatchEventFunc(this._dispatchEventByType.bind(this));
        this._removeEventListener = this.removeEventListener;
        this.removeEventListener = this.removeEventListenerNew;
    }
    appendChild(node) {
        if (node.src) {
            this.src = node.src;
        }
        return super.appendChild(node);
    }
    get readyState() {
        return this._nativeObj.readyState;
    }
    canPlayType(val) {
        let result = this._nativeObj.canPlayType(val);
        return result ? CanPlayTypeResult.Maybe : CanPlayTypeResult.Empty;
    }
    get paused() { return this._nativeObj.paused; }
    get duration() { return this._nativeObj.duration; }
    get src() { return this._src; }
    set src(val) { super.src = val; }
    load() {
        this._nativeObj.load();
    }
    set width(val) { this._nativeObj.width = val; }
    get width() { return this._nativeObj.width; }
    set height(val) { this._nativeObj.height = val; }
    get height() { return this._nativeObj.height; }
    set videoWidth(val) { this._nativeObj.videoWidth = val; }
    get videoWidth() { return this._nativeObj.videoWidth; }
    set videoHeight(val) { this._nativeObj.videoHeight = val; }
    get videoHeight() { return this._nativeObj.videoHeight; }
    get clientLeft() {
        return this._nativeObj.x;
    }
    set clientLeft(val) {
        this._nativeObj.x = val;
    }
    get clientTop() {
        return this._nativeObj.y;
    }
    set clientTop(val) {
        this._nativeObj.y = val;
    }
    addEventListener(type, listener, useCapture) {
        super.addEventListener(type, listener, useCapture);
        this._nativeObj.addEvent(type);
    }
    removeEventListenerNew(type, listener, useCapture) {
        this._removeEventListener(type, listener, useCapture);
        this._nativeObj.removeEvent(type);
    }
    _dispatchEventByType(type) {
        var ev = new _lbEvent(type);
        ev.target = this;
        this._dispatchEvent(ev);
    }
    _destroy() {
        this._nativeObj._releaseHandler();
    }
}
window["HTMLVideoElement"] = HTMLVideoElement;
class HTMLBodyElement extends HTMLElement {
    constructor() {
        super();
        this.tagName = "BODY";
    }
    get clientHeight() {
        return window.innerHeight;
    }
    set clientHeight(h) {
    }
    get clientWidth() {
        return window.innerWidth;
    }
    set clientWidth(w) {
    }
    appendChild(newChild) {
        if (newChild instanceof HTMLCanvasElement) {
            newChild.setFirst();
        }
        return super.appendChild(newChild);
    }
}
class NodeList extends Array {
    constructor() {
        super();
    }
    item(index) {
        return this[index];
    }
}
class HTMLHeadElement extends HTMLElement {
    constructor() {
        super();
        this.tagName = 'head';
        this.__visible = false;
    }
}
class HTMLCollection extends Array {
    item(nameOrIndex, optionalIndex) {
        return this[nameOrIndex];
    }
    namedItem(name) {
        return null;
    }
}
class Document extends Node {
    constructor() {
        super();
        this.createMap = new Map();
        this._frameEndEvt = new Event('frameend');
        this.scriptTextList = [];
        this._loading = 0;
        this._evalNum = 0;
        this._eventPathCache = null;
        this.all = new HTMLCollection();
        this._elements = [];
        window.document = this;
        this.defaultView = window;
        var cm = this.createMap;
        cm.set('div', this.create_div);
        cm.set('img', this.create_img);
        cm.set('image', this.create_img);
        cm.set('canvas', this.create_canvas);
        cm.set('audio', this.create_audio);
        cm.set('input', this.create_input);
        cm.set('textarea', this.create_input);
        cm.set('video', this.create_video);
        cm.set('script', this.create_script);
        cm.set('meta', this.create_meta);
        var html = new HTMLElement();
        var ww = getInnerWidth();
        var wh = getInnerHeight();
        html.clientWidth = ww;
        html.clientHeight = wh;
        html.tagName = "HTML";
        html.ownerDocument = this;
        this.documentElement = html;
        this._topElement = html;
        this.appendChild(this.documentElement);
        var body = new HTMLBodyElement();
        body.ownerDocument = this;
        this.body = body;
        this.documentElement.appendChild(this.body);
        this.head = new HTMLHeadElement();
        this.documentElement.appendChild(this.head);
        this.dispatchEvent = this._dispatchEvent.bind(this);
        this._frameEndEvt.bubbles = false;
        this.nodeType = 9;
        this.location = window.location;
        var _t = this;
        var temp;
    }
    setReferrer(s) {
        this.referrer = s;
    }
    uploadScript(d) {
        var _t = this;
        d.i = this._loading;
        this._loading++;
        if (d.src) {
            console.log("_downloadAysn:temp.src" + d.src);
            window.downloadfile(d.src, false, function (data) {
                d._stext = data + "
//@ sourceURL=" + d.src;
                _t._downloadOk(d);
            }, function () {
                var e = new Event("error");
                e.target = e.currentTarget = d.obj;
                d.obj.onerror && d.obj.onerror(e);
                _t._downloadOk(d);
            });
        }
        else {
            d._stext = d.text;
            _t._downloadOk(d);
        }
    }
    _downloadOk(d) {
        this.scriptTextList[d.i] = d;
        for (var i = this._evalNum, len = this.scriptTextList.length; i < len; i++) {
            var t = this.scriptTextList[i];
            if (!t)
                return;
            console.log(">>>>>>>>>>>>>>>eval" + t.src);
            var t1 = Date.now();
            window.evalJS(t._stext);
            console.log(">>>>>>>>>>>>>>>>>eval take time:" + (Date.now() - t1));
            var e = new Event("load");
            e.target = e.currentTarget = t.obj;
            t.obj.onload && t.obj.onload(e);
            this._evalNum++;
        }
        if (this._loading == this._evalNum) {
            this._loading = this._evalNum = 0;
            this.scriptTextList.length = 0;
        }
    }
    pickElement(screenx, screeny) {
        return this._topElement;
    }
    createElement(tagName) {
        tagName = tagName.toLowerCase();
        var f = this.createMap.get(tagName);
        var ret = null;
        if (f) {
            ret = f.call(this);
        }
        else {
            return new div();
        }
        return ret;
    }
    createElementNS(tagName) {
        return this.createElement(tagName);
    }
    create_div() {
        var ret = new HTMLDivElement();
        ret.ownerDocument = this;
        return ret;
    }
    create_img() {
        var ret = new HTMLImageElement();
        ret.ownerDocument = this;
        return ret;
    }
    create_canvas() {
        var ret = new HTMLCanvasElement();
        ret.ownerDocument = this;
        return ret;
    }
    create_audio() {
        var ret = new HTMLAudioElement();
        ret.ownerDocument = this;
        return ret;
    }
    create_input() {
        var rs = new HTMLInputElement();
        rs.ownerDocument = this;
        return rs;
    }
    create_video() {
        var ret = new HTMLVideoElement();
        ret.ownerDocument = this;
        return ret;
    }
    create_script() {
        var ret = new HTMLScriptElement();
        ret.ownerDocument = this;
        return ret;
    }
    create_meta() {
        var ret = new HTMLMetaElement();
        ret.ownerDocument = this;
        return ret;
    }
    createDocumentFragment() {
        return new HTMLDivElement();
    }
    onframeend() {
        this._frameEndEvt.eventPhase = Event.AT_TARGET;
        super._fireEventListeners(this._frameEndEvt);
    }
    _dispatchEvent(evt) {
        var ancestores = null;
        if (evt.target)
            ancestores = evt.target.getAncestorsNode();
        if (ancestores == null || ancestores.length == 0) {
            return super._dispatchEvent(evt);
        }
        var ancLen = ancestores.length;
        evt.eventPhase = Event.CAPTURING_PHASE;
        var stop = (function () {
            window.dispatchEvent(evt);
            if (evt._propagationStopped)
                return true;
            for (var i = ancLen - 1; i >= 0; i--) {
                var cnode = ancestores[i];
                evt.currentTarget = cnode;
                cnode.fireEventListeners(evt);
                if (evt._propagationStopped) {
                    return true;
                }
            }
            return false;
        })();
        if (!stop) {
            evt.eventPhase = Event.AT_TARGET;
            evt.currentTarget = evt.target;
            stop = (function () {
                evt.target.fireEventListeners(evt);
                if (evt._propagationStopped)
                    return true;
                return false;
            })();
        }
        if (!stop && !evt.cancelable) {
            evt.eventPhase = Event.BUBBLING_PHASE;
            for (var i = 0; i < ancLen; i++) {
                var cnode = ancestores[i];
                evt.currentTarget = cnode;
                cnode.fireEventListeners(evt);
                if (evt._propagationStopped) {
                    stop = true;
                    break;
                }
            }
            if (!stop) {
                evt.currentTarget = window;
                window.dispatchEvent(evt);
            }
        }
        if (evt.preventDefault) {
        }
        return true;
    }
    set cookie(v) {
        var t = _Cookie.addCookie(v);
        if (t && _Cookie.pushCookie(t)) {
            _Cookie.flush();
        }
    }
    get cookie() {
        return _Cookie.toLocalString();
    }
    loadCookie() {
        this._cookiePath = window.localStorage.fileNamePre + "_cookie.txt";
        var temp = readFileSync(this._cookiePath, "utf8");
        _Cookie.init(temp);
        return true;
    }
    open(url, name, features, replace) {
        throw 'not implements';
    }
    getElementsByTagName(tagname) {
        var d = new NodeList();
        if ("body" == tagname)
            d.push(this.body);
        else if ("head" == tagname)
            d.push(this.head);
        return d;
    }
    onkeydown(ev) {
    }
    onkeypress(ev) {
    }
    onkeyup(ev) {
    }
    onmousedown(ev) {
    }
    onmousemove(ev) { }
    onmouseout(ev) { }
    onmouseover(ev) { }
    onmouseup(ev) { }
    onmousewheel(ev) { }
    ontouchcancel(ev) { }
    ontouchend(ev) { }
    ontouchmove(ev) { }
    ontouchstart(ev) { }
    getElementById(elementId) {
        for (var i = 0, sz = this.all.length; i < sz; i++) {
            var c = this.all[i];
            if (c.id === elementId)
                return c;
        }
        return null;
    }
    getElementsByClassName(classNames) {
        throw 'not implemented';
    }
    getElementsByName(name) {
        return document._elements[name] || [];
    }
    write(value) {
        console.log("The document don't support write function!!!");
    }
}
applyMixins(Document, [Node, GlobalEventHandlers, NodeSelector, DocumentEvent]);
class CloseEvent extends Event {
    constructor() {
        super('close');
    }
    initCloseEvent(typeArg, canBubbleArg, cancelableArg, wasCleanArg, codeArg, reasonArg) {
    }
}
class MessageEvent extends Event {
    constructor(type, eventInitDict) {
        super(type);
    }
    initMessageEvent(typeArg, canBubbleArg, cancelableArg, dataArg, originArg, lastEventIdArg, sourceArg) {
    }
}
class WebSocket extends EventTarget {
    constructor(url) {
        super();
        this._nativeObj = null;
        this._nativeObj = new ConchWebSocket(url);
        this._nativeObj._onmessage = (data) => {
            var evt = new MessageEvent('message');
            evt.data = data;
            evt.target = evt.currentTarget = this;
            this.onmessage && this.onmessage(evt);
        };
    }
    get binaryType() {
        return this._nativeObj.binaryType;
    }
    set binaryType(b) {
        this._nativeObj.binaryType = b;
    }
    get timegap() {
        return this._nativeObj.timegap;
    }
    set onopen(f) {
        this._nativeObj.onopen = function () {
            var e = new Event("open");
            e.target = e.currentTarget = this;
            f(e);
        };
    }
    set onclose(f) {
        this._nativeObj.onclose = f;
    }
    set onerror(f) {
        this._nativeObj.onerror = f;
    }
    close() {
        this._nativeObj.close();
    }
    send(msg) {
        this._nativeObj.send(msg);
    }
    get readyState() {
        return this._nativeObj.readyState;
    }
}
WebSocket.CLOSED = 3;
WebSocket.CLOSING = 2;
WebSocket.CONNECTING = 0;
WebSocket.OPEN = 1;
window.WebSocket = WebSocket;
class DOMParser {
    constructor() {
        this._parser = new _DOMParser();
    }
    set src(s) {
        this._src = location.resolve(s);
        this._parser.src = this._src;
    }
    get src() {
        return this._src;
    }
    set onload(callback) {
        this._parser._onload = callback;
        this._parser.onload = this.nativeObjOnload;
    }
    nativeObjOnload() {
        this._onload();
    }
    get onload() {
        return this._parser._onload;
    }
    set onerror(callback) {
        this._parser._onerror = callback;
        this._parser.onerror = this.nativeObjOnerror;
    }
    nativeObjOnerror() {
        this._onerror();
    }
    get onerror() {
        return this._parser._onerror;
    }
    static initXMl(xml) {
        var result;
        if (!xml) {
            var temp = new _jsXmlNode();
            temp.nodeName = "parsererror";
            temp.textContent = "parsererror error";
            result = new _jsXmlNode();
            result.childNodes[0] = temp;
            return result;
        }
        result = new _jsXmlNode();
        result.nodeName = xml.nodeName;
        result.nodeValue = xml.nodeValue;
        result.nodeType = 1;
        if (result.nodeName == "#cdata-section") {
            result.nodeType = 3;
            result.nodeName = "#text";
        }
        result.textContent = xml.textContent;
        var attrs = xml.attributes;
        for (var i = 0, sz1 = attrs.length; i < sz1; i++) {
            var attr = attrs[i];
            var key = attr.nodeName;
            var tempAttr = new _jsXmlAttr(key, attr.nodeValue);
            result.attributes[i] = tempAttr;
            result.attributes[key] = tempAttr;
        }
        var childs = xml.childNodes;
        for (var i = 0, sz1 = childs.length; i < sz1; i++) {
            var chd = childs[i];
            var nodeName = chd.nodeName;
            result.childNodes[i] = DOMParser.initXMl(chd);
        }
        return result;
    }
    parseFromString(s, t) {
        var xml = this._parser.parseFromString(s, t);
        var root = new _jsXmlDocument();
        root.childNodes[0] = DOMParser.initXMl(xml.childNodes[0]);
        return root;
    }
    getResult() {
        if (!this._result) {
            this._result = new _jsXmlDocument();
            this._result.childNodes[0] = DOMParser.initXMl(this._parser.getResult().childNodes[0]);
        }
        return this._result;
    }
}
window["DOMParser"] = DOMParser;
class _jsXmlAttr {
    constructor(key, value) {
        this.nodeName = key;
        this.nodeValue = this.textContent = value;
    }
    get value() {
        return this.nodeValue;
    }
}
class _jsXmlNode extends _jsXmlAttr {
    get firstChild() {
        return this.childNodes ? this.childNodes[0] : null;
    }
    constructor() {
        super("", "");
        this.childNodes = [];
        this.childNodes["item"] = function (i) {
            return this[i];
        };
        this.attributes = [];
    }
    getElementsByTagName(name) {
        var result = [];
        if (this.nodeName == name)
            result.push(this);
        else {
            for (var i = 0, n = this.childNodes.length; i < n; i++) {
                var son = this.childNodes[i];
                result = result.concat(son.getElementsByTagName(name));
            }
        }
        return result;
    }
    getAttribute(name) {
        var attr = this.attributes[name];
        return attr ? attr["nodeValue"] : "";
    }
}
class _jsXmlDocument extends _jsXmlNode {
}
var GL_CAPS;
(function (GL_CAPS) {
    GL_CAPS[GL_CAPS["NONE"] = 0] = "NONE";
    GL_CAPS[GL_CAPS["TEXTURE_COMPRESSION_PVR"] = 2] = "TEXTURE_COMPRESSION_PVR";
    GL_CAPS[GL_CAPS["TEXTURE_COMPRESSION_ETC1"] = 4] = "TEXTURE_COMPRESSION_ETC1";
    GL_CAPS[GL_CAPS["TEXTURE_COMPRESSION_ETC2"] = 8] = "TEXTURE_COMPRESSION_ETC2";
    GL_CAPS[GL_CAPS["TEXTURE_TPG"] = 32] = "TEXTURE_TPG";
    GL_CAPS[GL_CAPS["INSTANCEING"] = 64] = "INSTANCEING";
})(GL_CAPS || (GL_CAPS = {}));
var _window = new _Window();
window.getComputedStyle = function (ele, parm) {
    return null;
};
window.pageXOffset = window.pageYOffset = 0;
window.localStorage = new Storage();
window.sessionStorage = new WindowSessionStorage();
var location = window.location = new Location;
if (conchConfig.getOS() == "Conch-ios") {
    window.console = new Console();
}
else {
    window.console = console || new Console;
}
window.addEventListener = _window.addEventListener.bind(_window);
window.removeEventListener = _window.removeEventListener.bind(_window);
window.dispatchEvent = _window.dispatchEvent.bind(_window);
window.document = new Document();
window.layaDoc = window.document;
window.crypto = new Crypto();
window.devicePixelRatio = 1.0;
var Image = window.Image = HTMLImageElement;
var Audio = window.Audio = HTMLAudioElement;
window.requestAnimationFrame = requestAnimationFrame;
window.cancelAnimationFrame = cancelAnimationFrame;
var parent = window.parent = window;
var frames = window.frames = null;
var navigator = window.navigator = new Navigator();
window.open = (url, target, features, replace) => {
    createProcess('scripts/index.js', url);
    return this;
};
var onload = window.onload = null;
function printstack() {
    var e = new Error();
    alert(e.stack);
}
var div = HTMLDivElement;
window.layabox = {
    devinfo: (function getDevInfo() {
        var devi = conchConfig.getDeviceInfo();
        window.console.log(devi);
        return JSON.parse(devi);
    })(),
    getDeviceInfo: function () { return this.devinfo; }
};
window.layaHtml5 = { File: File };
var _$innerWidth = getInnerWidth();
var _$innerHeight = getInnerHeight();
var _$devicePixelRatio = getDevicePixelRatio();
Object.defineProperty(window, 'innerWidth', { get: function () { return _$innerWidth; } });
Object.defineProperty(window, 'innerHeight', { get: function () { return _$innerHeight; } });
Object.defineProperty(window, 'outerWidth', { get: function () { return _$innerWidth; } });
Object.defineProperty(window, 'outerHeight', { get: function () { return _$innerHeight; } });
Object.defineProperty(window, 'devicePixelRatio', { get: function () { return _$devicePixelRatio; } });
conch.setOnResize(function (w, h) {
    _$innerWidth = w;
    _$innerHeight = h;
    window.console.log(">>>>>>>>>>>>>>>>innerWidth:" + _$innerWidth + "innerHeight:" + _$innerHeight);
    var evt = new UIEvent('resize');
    evt.view = window;
    document._dispatchEvent(evt);
    window.dispatchEvent(evt);
});
conch.config = conchConfig;
class Screen {
    get width() {
        return _$innerWidth;
    }
    get height() {
        return _$innerHeight;
    }
}
window.screen = new Screen();
window.onresize = function (e) {
};
conch.onerror = function (message, filename, lineno, colno, error) {
    if (window.onerror) {
        var ln = decodeTemp(lineno);
        var cn = decodeTemp(colno);
        var er = decodeTemp(error);
        var mg = decodeTemp(message);
        var fn = decodeTemp(filename);
        var e = {
            message: decodeTemp(message),
            stack: er,
            name: ""
        };
        window.onerror(mg == "undefined" ? undefined : mg, fn == "undefined" ? undefined : fn, ln != "undefined" ? parseInt(ln) : undefined, cn != "undefined" ? parseInt(cn) : undefined, e);
    }
};
Object.defineProperty(window, 'onerror', { set: function (fun) {
        conch.__onerror = fun;
        showAlertOnJsException(false);
    }, get: function () {
        return conch.__onerror;
    } });
var document = window.document;
var addEventListener = window.addEventListener.bind(this);
var dispatchEvent = window.dispatchEvent.bind(this);
var removeEventListener = window.removeEventListener.bind(this);
var clearInterval = window.clearInterval = _window.clearInterval;
var clearTimeout = window.clearTimeout = _window.clearTimeout;
var setInterval = window.setInterval = _window.setInterval;
var setTimeout = window.setTimeout = _window.setTimeout;
Object.defineProperty(window, 'runtime', { get: function () { return true; } });
window.postMessage = function (data, d) {
    if (typeof (data) == "object")
        data = JSON.stringify(data);
    conch.callWebviewJS("window.__getMessemage", encodeURIComponent(data), "");
};
window.postRuntimeMessage = function (d) {
    if (typeof (d) == "object")
        d = JSON.stringify(d);
    d = decodeURIComponent(d);
    var e = new MessageEvent('message');
    e.data = JSON.parse(d);
    e.target = window;
    var s = new RegExp("(http|file|https)://([^/:]*)(:(\d+)|)([^?]+)(.*|)");
    var rs = s.exec(document.referrer);
    if (rs) {
        e.origin = rs[1] + "://" + rs[2] + rs[3];
    }
    window.dispatchEvent(e);
};
window.SetupWebglContext = function () { };
window.downloadfile = function (url, force, onok, onerr) {
    if (force) {
        url = (function (url) {
            var ret = url;
            if (url.indexOf('?') < 0) {
                ret = url + '?rnd=' + Math.random();
            }
            else {
                ret = url + '&downloadrnd' + Math.random().toString().substr(2) + '=1';
            }
            return ret;
        })(url);
    }
    var file = new window.layaHtml5.File(url);
    var filereader = new FileReader();
    filereader.onload = function () { onok && onok(filereader.result); };
    filereader.onerror = function () { onerr && onerr(); };
    filereader.readAsText(file);
};
if (window.navigator.platform != "windows")
    window["ontouchstart"] = null;
window['GL_CAPS'] = GL_CAPS;
window.focus = function () { };
var nMem = conchConfig.getTotalMem();
if (nMem <= 524288) {
    conchConfig.atlasNum = 10;
    conchConfig.maxTextureMemSize = 64 * 1024 * 1024;
}
else if (nMem > 524288 && nMem <= 1048576) {
    conchConfig.atlasNum = 16;
    conchConfig.maxTextureMemSize = 84 * 1024 * 1024;
}
else if (nMem > 1048576) {
    conchConfig.atlasNum = 20;
    conchConfig.maxTextureMemSize = 128 * 1024 * 1024;
}
class Performance {
    now() {
        return tmGetCurms();
    }
}
window["Performance"] = Performance;
window.performance = new Performance();
(function () {
    'use strict';
    class AppInfo {
    }
    ;
    var appobj = null;
    try {
        appobj = JSON.parse(conch.readFileFromAsset('app.json', 'utf8'));
        if (appobj) {
            require(appobj.mainjs);
        }
    }
    catch (e) {
        require('index');
    }
})();

})(window);

JNI OnAppPause

JNI OnAppResume

打包资源: layadcc F:ProjectsLayaboxProjectsLayaDCCTest1in -cache -url http://xx.xx.xx.xx/LayaDCCTest1/index.js

allfiles.txt 所有的资源文件的相对路径

/fileconfig.json    
/Image/img_scretarea_1.png    
/index.html    
/index.js        
/js/bundle.js    
/libs/laya.ani.js    
/libs/laya.core.js    
/libs/laya.d3.js    
/libs/laya.effect.js    
/libs/laya.filter.js    
/libs/laya.html.js    
/libs/laya.particle.js    
/libs/laya.physics.js    
/libs/laya.ui.js    
/libs/laya.webgl.js    
/libs/laya.wxmini.js    
/libs/worker.js    
/res/atlas/.rec    
/unpack.json    
/version.json    

assetsid.txt 本次dcc统计的整个资源包的校验码

8b75c2391e9fe2039439ac30a06cd10a

filetable.bin dcc主文件,里面是每个文件的校验值

梯?
    
   8b75c2391e9fe2039439ac30a06cd10a裣G   啎?}9VBK"阺|nq?潷4鰆U?穓?謟�@n餪?<?眠WJk眀�穢L掤苹 襯0?襍涛択嘢4爔J:€悶嶆@︺*H綤[HN:u钫鴯?R扌+頼V栥SD曉薎Dx|E锼抷GdD归QgE,O??   

filetable.txt 文件格式的dcc文件, 除了前三行,每一行代表一个文件和对应的校验值,与allfiles.txt正好对应起来,即第4行对应的文件是allfiles.txt的第一行

ffeeffee 1
8b75c239 1e9fe203
9439ac30 a06cd10a
470bcff1 6
31a49586 565c397d
ea224b42 716e7c73
a79d20b7 556af634
6ab7299a dd20307
f7a87ad6 60f06e40
9f3c27b7 57dfc327
b16b1a4a 52a30762
924c78b7 bbc6f2
b43072d2 e53d23d
6b92cecc 8345387
3a4a78a0 9080191a
40e68d9e 482ae3a6
485b4bbe ee753a4e
b68df8d5 d0de521c
566dee2b 4453e396
49cbd495 457c7844
7992cbef 440e6447
5116e9b9 4f2c4567
fe0aee13 6

filetable1.txt 这个文件不再使用

470bcff1 6
31a49586 565c397d
ea224b42 525e6c7d
a79d20b7 b2ad0be9
6ab7299a 3a1825dc
f7a87ad6 5b55f944
9f3c27b7 c6e02268
b16b1a4a 8ef40cef
924c78b7 ebc13590
b43072d2 c302ec9f
6b92cecc 46b2a9b8
3a4a78a0 c4afa7df
40e68d9e a6198e1b
485b4bbe e3ad4aeb
b68df8d5 41ea5fb9
566dee2b 95c0730
49cbd495 457c7844
7992cbef 440e6447
5116e9b9 4f2c4567
fe0aee13 6

更新资源: 在资源目录里 输入 layadcc .

update文件夹里的内容

如果资源文件夹里的内容没有变化, 则上述5个文件内容和第一次打包生成的这5个同名文件的内容是一样的

单个文件有修改,会影响 assetsid.txt的校验值, filetable.txt里的修改过的文件的校验值

Native release-v2.1.0, release-v2.0.2 有bug 不能更新  cache里存在的文件

Native release-v2.0.1 可以正常运行

二次开发　　https://ldc2.layabox.com/doc/?nav=zh-ts-6-2-1

MainUI.ts

private OnLoad() {
    Laya.Browser.window.MainUI = this;

    if (Laya.Browser.window.conch) {
        let bridge = Laya.PlatformClass.createClass("demo.JSBridge");
        alert(bridge.call("Test1"));
    }
}

MainActivity.java

ConchJNI.RunJS("if (window.MainUI) { window.MainUI.Pause(); }");
ConchJNI.RunJS("if (window.MainUI) { window.MainUI.Resume(); }");



JSBridge.java

public static String Test1() {
    return "Hello World";
}


        

JSBridge.java

import android.os.Vibrator



    public static void Vibrator() {
        Vibrator vibrator = (Vibrator)mMainActivity.getSystemService(Service.VIBRATOR_SERVICE);
        vibrator.vibrate(15);
    }

MainActivity.java

    protected void onPause()
    {
        super.onPause();
        if(isLoad) {
            mPlugin.game_plugin_onPause();
            ConchJNI.RunJS("if (window.GamePause) { window.GamePause(); }");
        }
    }
    //------------------------------------------------------------------------------
    protected void onResume()
    {
        super.onResume();
        if(isLoad) {
            mPlugin.game_plugin_onResume();
            ConchJNI.RunJS("if (window.GameResume) { window.GameResume(); }");
        }
    }

window.loadingView.loading(0);

Android:

err_cache_miss　　<uses-permission android:name="android.permission.INTERNET" />

@android:style/Theme.NoTitleBar.Fullscreen

Activity AppCompatActivity

    @Override
    @TargetApi(Build.VERSION_CODES.M)
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getWindow().requestFeature(Window.FEATURE_NO_TITLE);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);

        JSBridge.mMainActivity = this;
        mSplashDialog = new SplashDialog(this);
        mSplashDialog.showSplash();

        this.requestPermissions(new String[]{Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE}, 1);

app/build.gradle

    minSdkVersion 14
    targetSdkVersion 22
    versionCode int
    versionName "xxxx"


app/src/main/assets/config.ini
    IsHandleUpdateAPK = 1/0
    ApkUpdateUrl = url(version.xml)
    
http://xxxxx/version.xml
    
    <update>
        <versionCode>1</versionCode>
        <name>test</name>
        <version>xxxxx</version>
        <url>xxxxxxx/apk</url>
    </update>


app/src/main/layaair/autoupdateversion/UpdateCallback
    checkUpdateCompleted
        
        AutoUpdateAPK.onUpdateEnd(3);
        System.exit(0);

小米8se 不能安装 Android Studio  需要关闭 MIUI优化