[編集モード] ThreeJS利用プラグイン(JSプラグイン)

Javascriptの有名な3DライブラリであるThreeJSをなでしこv3から利用する為のプラグイン。必要になったつど命令を追加しているので、命令数はあまり多くない。

/**
 * Type declare and utility class for ThreeJS(r165.1dev)
 */
class ThreeUtil {
    static isDisporsal(obj) {
        return 'dispose' in obj && typeof obj['dispose'] === 'function';
    }
    static isMesh(obj) {
        return 'isMesh' in obj && obj['isMesh'] === true;
    }
    static disposeOneMaterial(material) {
        for (const propKey of Object.keys(material)) {
            const prop = material[propKey];
            if (ThreeUtil.isDisporsal(prop)) {
                prop.dispose();
            }
        }
        material.dispose();
    }
    static disposeChildObject(obj) {
        while (obj.children.length > 0) {
            this.disposeChildObject(obj.children[0]);
            obj.remove(obj.children[0]);
        }
        if (ThreeUtil.isMesh(obj)) {
            if (obj.geometry) {
                obj.geometry.dispose();
            }
            if (obj.material) {
                if (Array.isArray(obj.material)) {
                    for (const material of obj.material) {
                        ThreeUtil.disposeOneMaterial(material);
                    }
                }
                else {
                    ThreeUtil.disposeOneMaterial(obj.material);
                }
            }
        }
    }
}

/**
 * PluginWeykThree
 */

class WeykThreeSystem {
    static getInstance(sys) {
        if (WeykThreeSystem.instance === undefined) {
            WeykThreeSystem.instance = new WeykThreeSystem(sys);
        }
        const i = WeykThreeSystem.instance;
        i.instanceCount += 1;
        return WeykThreeSystem.instance;
    }
    constructor(sys) {
        this.instanceCount = 0;
        this.sys = sys;
        this.three = null;
        this.threeExt = {};
        this._scene = null;
        this._camera = null;
        this._renderer = null;
        this._scene_list = [];
        this.propMap = {
            'シャドー': 'shadow',
            'シャドーマップ': 'shadowMap',
            'カメラ': 'camera'
        };
    }
    clearAll() {
        console.log('[THREEJS] clearAll');
        // シーンに存在する要素を全部削除して解放
        for (const scene of this._scene_list) {
            if (scene !== null) {
                ThreeUtil.disposeChildObject(scene);
            }
        }
        this._scene = null;
        this._camera = null;
        this._scene_list = [];
    }
    setupRenderer(to) {
        const three = this.getThree();
        let renderer = null;
        if (to instanceof this.three.WebGLRenderer) {
            renderer = to;
        }
        else {
            if (to instanceof HTMLCanvasElement) {
                renderer = new three.WebGLRenderer({ antialias: false, alpha: true, canvas: to });
                renderer.setSize(to.width, to.height);
            }
            else {
                to = to;
                renderer = new three.WebGLRenderer({ antialias: false, alpha: true });
                renderer.setSize(to.clientWidth, to.clientHeight);
                to.appendChild(renderer.domElement);
            }
            renderer.setPixelRatio(window.devicePixelRatio);
        }
        this._renderer = renderer;
        return this._renderer;
    }
    parseVec3(xyz) {
        const three = this.getThree();
        let V;
        if (xyz instanceof three.Vector3) {
            V = xyz;
        }
        else if (xyz === null || typeof xyz === 'undefined') {
            V = new three.Vector3();
        }
        else {
            const pos = this.parsePos(xyz);
            if (pos === null) {
                return null;
            }
            V = new three.Vector3(pos.x, pos.y, pos.z);
        }
        return V;
    }
    isLazyXYZ(xyz) {
        return xyz != null && 'x' in xyz && 'y' in xyz && 'z' in xyz;
    }
    isLazyXYZW(xyzw) {
        return xyzw != null && 'x' in xyzw && 'y' in xyzw && 'z' in xyzw && 'w' in xyzw;
    }
    parsePos(xyz) {
        let pos = { x: 0, y: 0, z: 0 };
        if (Array.isArray(xyz) && xyz.length === 3) {
            pos.x = xyz[0];
            pos.y = xyz[1];
            pos.z = xyz[2];
        }
        else if (this.isLazyXYZ(xyz)) {
            pos.x = (typeof xyz.x === 'function') ? xyz.x() : xyz.x;
            pos.y = (typeof xyz.y === 'function') ? xyz.y() : xyz.y;
            pos.z = (typeof xyz.z === 'function') ? xyz.z() : xyz.z;
        }
        else {
            pos = null;
        }
        return pos;
    }
    parseQuat(xyzw) {
        let quat = { x: 0, y: 0, z: 0, w: 0 };
        if (Array.isArray(xyzw) && xyzw.length === 4) {
            quat.x = xyzw[0];
            quat.y = xyzw[1];
            quat.z = xyzw[2];
            quat.w = xyzw[3];
        }
        else if (this.isLazyXYZW(xyzw)) {
            quat.x = (typeof xyzw.x === 'function') ? xyzw.x() : xyzw.x;
            quat.y = (typeof xyzw.y === 'function') ? xyzw.y() : xyzw.y;
            quat.z = (typeof xyzw.z === 'function') ? xyzw.z() : xyzw.z;
            quat.w = (typeof xyzw.w === 'function') ? xyzw.w() : xyzw.w;
        }
        else {
            quat = null;
        }
        return quat;
    }
    resolveProp(obj, keylist) {
        const propMap = this.propMap;
        Object.keys(keylist).forEach(index => {
            let key = keylist[index];
            if (obj != null) {
                if (propMap[key] != null) {
                    key = propMap[key];
                }
                if (key != null) {
                    obj = obj[key];
                }
            }
        });
        return obj;
    }
    checkThree() {
        return this.three !== null;
    }
    setThree(three) {
        this.three = three;
        return this.getThree();
    }
    mergeThreeExt(obj) {
        return Object.assign(this.threeExt, obj);
    }
    getThreeExt() {
        return this.threeExt;
    }
    getThree() {
        if (this.three === null) {
            if (this.sys.__getSysVar('THREE') !== null) {
                this.three = this.sys.__getSysVar('THREE');
            }
            else if (typeof window.THREE !== 'undefined') {
                this.three = window.THREE;
            }
        }
        if (this.three === null) {
            throw new Error('three.module.jsが読み込まれていません');
        }
        if (this.sys.__getSysVar('THREE') === null) {
            this.sys.__setSysVar('THREE', this.three);
        }
        return this.three;
    }
    static getManager(sys) {
        if (!sys.tags.weykthree) {
            throw new Error('本プラグインが初期化されていません');
        }
        return sys.tags.weykthree;
    }
    static getEnv(sys) {
        const weykthree = WeykThreeSystem.getManager(sys);
        const three = weykthree.getThree();
        return [weykthree, three];
    }
}
const PluginWeykThree = {
    'meta': {
        type: 'const',
        value: {
            pluginName: 'plugin_weykthree', // プラグインの名前
            description: '3Dグラフィクス描画プラグイン', // プラグインの説明
            pluginVersion: '3.6.0', // プラグインのバージョン
            nakoRuntime: ['wnako'], // 対象ランタイム
            nakoVersion: '3.6.0' // 要求なでしこバージョン
        }
    },
    '初期化': {
        type: 'func',
        josi: [],
        pure: true,
        fn: function (sys) {
            if (sys.tags.weykthree) {
                return;
            }
            const threeSystem = WeykThreeSystem.getInstance(sys);
            sys.tags.weykthree = threeSystem;
            // オブジェクトを初期化
            sys.__setSysVar('THREE', null);
        }
    },
    // @定数・変数
    'THREE': { type: 'const', value: '' }, // @THREE
    'TJSベースURL': { type: 'var', value: 'https://cdn.jsdelivr.net/npm/three@0.127.0' }, // @TJSべーすURL
    'TJSライブラリ名': { type: 'var', value: 'three.module.js' }, // @TJSらいぶらりめい
    // @ライブラリ・プラグイン
    'TJSライブラリ読込': {
        type: 'func',
        josi: [],
        asyncFn: true,
        pure: true,
        fn: async function (sys) {
            const weykthree = WeykThreeSystem.getManager(sys);
            if (!weykthree.checkThree() && window.THREE == null && sys.__getSysVar('THREE') === null) {
                const baseUrl = sys.__getSysVar('TJSベースURL');
                const libname = sys.__getSysVar('TJSライブラリ名');
                const moduleUrl = baseUrl === '' ? libname : (baseUrl + '/build/' + libname);
                const promise = import(moduleUrl);
                promise.then(module => {
                    weykthree.setThree(module);
                    return true;
                });
                return await promise;
            }
            else {
                weykthree.getThree();
                return true;
            }
        }
    },
    'TJSライブラリ読込後': {
        type: 'func',
        josi: [['に']],
        pure: true,
        fn: function (callback, sys) {
            const weykthree = WeykThreeSystem.getManager(sys);
            if (!weykthree.checkThree() && window.THREE == null && sys.__getSysVar('THREE') === null) {
                const baseUrl = sys.__getSysVar('TJSベースURL');
                const libname = sys.__getSysVar('TJSライブラリ名');
                const moduleUrl = baseUrl === '' ? libname : (baseUrl + '/build/' + libname);
                const promise = import(moduleUrl);
                promise.then(module => {
                    weykthree.setThree(module);
                    callback();
                });
            }
            else {
                weykthree.getThree();
                callback();
            }
        },
        return_none: true
    },
    'TJSプラグイン読込': {
        type: 'func',
        josi: [['を']],
        asyncFn: true,
        pure: true,
        fn: async function (plugins, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const l = plugins.length;
            if (l === 0) {
                return;
            }
            const baseUrl = sys.__getSysVar('TJSベースURL');
            const totalPromise = new Promise((resolve, reject) => {
                const callbacks = (function (total) {
                    let countTotal = 0;
                    let countSuccess = 0;
                    return function (success) {
                        countTotal += 1;
                        if (success) {
                            countSuccess += 1;
                        }
                        if (countTotal === total) {
                            if (countTotal === countSuccess) {
                                resolve();
                            }
                            else {
                                reject(new Error(`読み込みに失敗したプラグインがありました(成功:${countSuccess}/全体:${countTotal})`));
                            }
                        }
                    };
                })(l);
                for (const name of plugins) {
                    const pluginUrl = baseUrl === '' ? name : (baseUrl + '/examples/jsm/' + name);
                    const promise = import(pluginUrl);
                    promise.then(module => {
                        weykthree.mergeThreeExt(module);
                        callbacks(true);
                    });
                    promise.catch(err => {
                        console.log(err);
                        callbacks(false);
                    });
                }
            });
            return totalPromise;
        }
    },
    'TJSプラグイン読込後': {
        type: 'func',
        josi: [['に'], ['を']],
        pure: true,
        fn: function (callback, plugins, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const l = plugins.length;
            if (l === 0) {
                callback();
                return;
            }
            const baseUrl = sys.__getSysVar('TJSベースURL');
            const callbacks = (function (callback, total) {
                let count = 0;
                return function (success) {
                    count += 1;
                    if (count === total) {
                        callback();
                    }
                };
            })(callback, l);
            for (let i = 0; i < l; i++) {
                const name = plugins[i];
                const pluginUrl = baseUrl === '' ? name : (baseUrl + '/examples/jsm/' + name);
                const promise = import(pluginUrl);
                promise.then(module => {
                    weykthree.mergeThreeExt(module);
                    callbacks(true);
                });
                promise.catch(err => {
                    console.log(err);
                    callbacks(false);
                });
            }
        },
        return_none: true
    },
    'TJS待': {
        type: 'func',
        josi: [['を']],
        asyncFn: true,
        pure: true,
        fn: function (p, sys) {
            return p;
        }
    },
    // @ThreeJS操作
    'TJS全消去': {
        type: 'func',
        josi: [],
        pure: true,
        fn: function (sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            weykthree.clearAll();
        },
        return_none: true
    },
    'TJS描画準備': {
        type: 'func',
        josi: [['に', 'へ']],
        pure: true,
        fn: function (to, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (typeof to === 'string') {
                to = document.querySelector(to) || document.getElementById(to);
            }
            if (!to) {
                throw new Error('TJS描画準備に指定した描画先の要素がありません。指定に誤りがあります');
            }
            return weykthree.setupRenderer(to);
        }
    },
    'TJS描画先取得': {
        type: 'func',
        josi: [['の', 'から']],
        pure: true,
        fn: function (renderer, sys) {
            WeykThreeSystem.getEnv(sys);
            return renderer.domElement;
        }
    },
    'TJS描画': {
        type: 'func',
        josi: [['に'], ['を'], ['で']],
        pure: true,
        fn: function (renderer, scene, camera, sys) {
            WeykThreeSystem.getEnv(sys);
            renderer.render(scene, camera);
        },
        return_none: true
    },
    'TJSシーン作成': {
        type: 'func',
        josi: [],
        pure: true,
        fn: function (sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const scene = new three.Scene();
            if (scene === null) {
                throw new Error('シーンを作成できません');
            }
            weykthree._scene = scene;
            weykthree._scene_list.push(scene);
            return scene;
        }
    },
    'TJSグループ作成': {
        type: 'func',
        josi: [],
        pure: true,
        fn: function (sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const group = new three.Group();
            if (group === null) {
                throw new Error('グループを作成できません');
            }
            return group;
        }
    },
    'TJS背景設定': {
        type: 'func',
        josi: [['に', 'へ'], ['を']],
        pure: true,
        fn: function (scene, obj, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const color = obj instanceof three.Color ? obj : new three.Color(obj);
            scene.background = color;
        },
        return_none: true
    },
    'TJS霧効果設定': {
        type: 'func',
        josi: [['に', 'へ'], ['を']],
        pure: true,
        fn: function (scene, fog, sys) {
            WeykThreeSystem.getEnv(sys);
            scene.fog = fog;
        },
        return_none: true
    },
    'TJSクリア': {
        type: 'func',
        josi: [['を']],
        pure: true,
        fn: function (renderer, sys) {
            WeykThreeSystem.getEnv(sys);
            renderer.clear();
        },
        return_none: true
    },
    'TJSクリア色設定': {
        type: 'func',
        josi: [['に', 'へ'], ['を']],
        pure: true,
        fn: function (renderer, color, sys) {
            WeykThreeSystem.getEnv(sys);
            renderer.setClearColor(color);
        },
        return_none: true
    },
    'TJSクリア透過設定': {
        type: 'func',
        josi: [['に', 'へ'], ['を']],
        pure: true,
        fn: function (renderer, alpha, sys) {
            WeykThreeSystem.getEnv(sys);
            renderer.setClearAlpha(alpha);
        },
        return_none: true
    },
    'TJS影処理有効': {
        type: 'func',
        josi: [['の', 'を']],
        pure: true,
        fn: function (renderer, sys) {
            WeykThreeSystem.getEnv(sys);
            renderer.shadowMap.enabled = true;
        },
        return_none: true
    },
    'TJS影処理無効': {
        type: 'func',
        josi: [['の', 'を']],
        pure: true,
        fn: function (renderer, sys) {
            WeykThreeSystem.getEnv(sys);
            renderer.shadowMap.enabled = false;
        },
        return_none: true
    },
    'TJS影処理取得': {
        type: 'func',
        josi: [['の', 'から']],
        pure: true,
        fn: function (renderer, sys) {
            WeykThreeSystem.getEnv(sys);
            return renderer.shadowMap.enabled;
        }
    },
    // @基本型操作
    'TJS四元数作成': {
        type: 'func',
        josi: [],
        pure: true,
        fn: function (sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            return new three.Quaternion();
        }
    },
    'TJS四元数アングル取得': {
        type: 'func',
        josi: [['から'], ['の']],
        pure: true,
        fn: function (qua, xyz, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const pos = weykthree.parsePos(xyz);
            if (pos === null) {
                throw new Error(`方向を配列で指定してください([x, y, z]:${typeof xyz}:${xyz.length})`);
            }
            const q = new three.Quaternion(pos.x, pos.y, pos.z, 0);
            const angle = qua.angleTo(q);
            return angle;
        }
    },
    'TJSVec3': {
        type: 'func',
        josi: [['の', 'で', 'から']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (opts == null) {
                return new three.Vector3();
            }
            const pos = weykthree.parsePos(opts);
            if (pos === null) {
                throw new Error('Vector3の作成の際に不明な引数が指定されました');
            }
            return new three.Vector3(pos.x, pos.y, pos.z);
        }
    },
    'TJSVec2設定': {
        type: 'func',
        josi: [['の'], ['に'], ['を']],
        pure: true,
        fn: function (obj, props, xy, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (obj != null) {
                obj = weykthree.resolveProp(obj, props);
            }
            else {
                obj = props;
            }
            if (Array.isArray(xy) && xy.length === 2) {
                obj.set(xy[0], xy[1]);
            }
            else if (xy != null && 'x' in xy && 'y' in xy) {
                obj.set(xy.x, xy.y);
            }
            else {
                throw new Error('Vector2への設定の際に不明な引数が指定されました');
            }
        },
        return_none: true
    },
    'TJS加算': {
        type: 'func',
        josi: [['に'], ['を']],
        pure: true,
        fn: function (v, a, sys) {
            WeykThreeSystem.getEnv(sys);
            v.add(a);
        },
        return_none: true
    },
    'TJSスカラー乗算': {
        type: 'func',
        josi: [['に'], ['を']],
        pure: true,
        fn: function (v, a, sys) {
            WeykThreeSystem.getEnv(sys);
            v.multiplyScalar(a);
        },
        return_none: true
    },
    'TJS四元数適用': {
        type: 'func',
        josi: [['に'], ['を']],
        pure: true,
        fn: function (obj, xyzw, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const quat = weykthree.parseQuat(xyzw);
            if (quat === null) {
                throw new Error(`四元数を配列で指定してください([x, y, z, w]:${typeof xyzw}:${xyzw.length})`);
            }
            const Q = new three.Quaternion(quat.x, quat.y, quat.z, quat.w);
            obj.applyQuaternion(Q);
        },
        return_none: true
    },
    'TJSマトリクス適用': {
        type: 'func',
        josi: [['に'], ['を']],
        pure: true,
        fn: function (obj, mat, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (obj instanceof THREENS.Vector2) {
                if (mat instanceof three.Matrix3) {
                    obj.applyMatrix3(mat);
                }
                else {
                    throw new Error('Vector2に適用するマトリクスはMatrix3を指定してください');
                }
            }
            else {
                if (mat instanceof three.Matrix4) {
                    obj.applyMatrix4(mat);
                }
                else {
                    throw new Error('Vector3/Object3Dに適用するマトリクスはMatrix4を指定してください');
                }
            }
        },
        return_none: true
    },
    // @共通操作
    'TJS位置設定': {
        type: 'func',
        josi: [['を'], ['に']],
        pure: true,
        fn: function (obj, xyz, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const pos = weykthree.parsePos(xyz);
            if (pos === null) {
                throw new Error(`座標を配列で指定してください([x, y, z]:${typeof xyz}:${xyz.length})`);
            }
            obj.position.set(pos.x, pos.y, pos.z);
        },
        return_none: true
    },
    'TJS位置取得': {
        type: 'func',
        josi: [['から', 'の']],
        pure: true,
        fn: function (obj, sys) {
            WeykThreeSystem.getEnv(sys);
            return obj.position;
        }
    },
    'TJSワールド位置取得': {
        type: 'func',
        josi: [['から', 'の'], ['に', 'へ']],
        pure: true,
        fn: function (obj, pos, sys) {
            WeykThreeSystem.getEnv(sys);
            obj.getWorldPosition(pos);
        },
        return_none: true
    },
    'TJSワールドマトリクス取得': {
        type: 'func',
        josi: [['から', 'の']],
        pure: true,
        fn: function (obj, sys) {
            WeykThreeSystem.getEnv(sys);
            return obj.matrixWorld;
        }
    },
    'TJS四元数設定': {
        type: 'func',
        josi: [['を'], ['に']],
        pure: true,
        fn: function (obj, xyzw, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const quat = weykthree.parseQuat(xyzw);
            if (quat === null) {
                throw new Error(`四元数を配列で指定してください([x, y, z, w]:${typeof xyzw}:${xyzw.length})`);
            }
            obj.quaternion.set(quat.x, quat.y, quat.z, quat.w);
        },
        return_none: true
    },
    'TJS四元数取得': {
        type: 'func',
        josi: [['から', 'の']],
        pure: true,
        fn: function (obj, sys) {
            WeykThreeSystem.getEnv(sys);
            return obj.quaternion;
        }
    },
    'TJSワールド四元数取得': {
        type: 'func',
        josi: [['から', 'の'], ['に', 'へ']],
        pure: true,
        fn: function (obj, quat, sys) {
            WeykThreeSystem.getEnv(sys);
            obj.getWorldQuaternion(quat);
        },
        return_none: true
    },
    'TJSワールド方向取得': {
        type: 'func',
        josi: [['から', 'の'], ['に', 'へ']],
        pure: true,
        fn: function (obj, vec, sys) {
            WeykThreeSystem.getEnv(sys);
            obj.getWorldDirection(vec);
        },
        return_none: true
    },
    'TJSサイズ設定': {
        type: 'func',
        josi: [['に'], ['を', 'へ']],
        pure: true,
        fn: function (obj, size, sys) {
            WeykThreeSystem.getEnv(sys);
            if (typeof obj.setSize !== 'function') {
                throw new Error('指定したオブジェクトはsetSizeを持っていません');
            }
            if (!Array.isArray(size) || size.length !== 2) {
                throw new Error('設定するサイズを配列で指定してください([w,h])');
            }
            obj.setSize(size[0], size[1]);
        },
        return_none: true
    },
    'TJS拡大': {
        type: 'func',
        josi: [['を'], ['で', 'に']],
        pure: true,
        fn: function (obj, scale, sys) {
            WeykThreeSystem.getEnv(sys);
            if (typeof obj.scale !== 'function') {
                throw new Error('指定したオブジェクトはscaleを持っていません');
            }
            if (!Array.isArray(scale) || scale.length !== 3) {
                throw new Error('拡大する倍率を配列で指定してください([x,y,z])');
            }
            obj.scale(scale[0], scale[1], scale[2]);
        },
        return_none: true
    },
    'TJS移動': {
        type: 'func',
        josi: [['を'], ['で', 'に'], ['だけ']],
        pure: true,
        fn: function (obj, axis, distance, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (distance == null) {
                axis = weykthree.parsePos(axis);
                if (axis == null) {
                    throw new Error('移動する先を配列で指定してください([x,y,z])');
                }
                obj.translate(axis.x, axis.y, axis.z);
            }
            else {
                axis = weykthree.parseVec3(axis);
                if (axis == null) {
                    throw new Error('移動する方向(軸)を配列で指定してください([x,y,z])');
                }
                obj.translateOnAxis(axis, distance);
            }
        },
        return_none: true
    },
    'TJS表示': {
        type: 'func',
        josi: [['を']],
        pure: true,
        fn: function (obj, sys) {
            WeykThreeSystem.getEnv(sys);
            obj.visible = true;
        },
        return_none: true
    },
    'TJS非表示': {
        type: 'func',
        josi: [['を']],
        pure: true,
        fn: function (obj, sys) {
            WeykThreeSystem.getEnv(sys);
            obj.visible = false;
        },
        return_none: true
    },
    'TJS有効化': {
        type: 'func',
        josi: [['の', 'を']],
        pure: true,
        fn: function (obj, sys) {
            WeykThreeSystem.getEnv(sys);
            if (typeof obj.enabled === 'undefined') {
                throw new Error('指定したオブジェクトはenabledを持っていません');
            }
            obj.enabled = true;
        },
        return_none: true
    },
    'TJS無効化': {
        type: 'func',
        josi: [['の', 'を']],
        pure: true,
        fn: function (obj, sys) {
            WeykThreeSystem.getEnv(sys);
            if (typeof obj.enabled === 'undefined') {
                throw new Error('指定したオブジェクトはenabledを持っていません');
            }
            obj.enabled = false;
        },
        return_none: true
    },
    'TJSトラバース': {
        type: 'func',
        josi: [['に'], ['を']],
        pure: true,
        fn: function (callback, obj, sys) {
            WeykThreeSystem.getEnv(sys);
            if (typeof obj.traverse !== 'function') {
                throw new Error('指定したオブジェクトはtraverseを持っていません');
            }
            obj.traverse(callback);
        },
        return_none: true
    },
    'TJS影受設定': {
        type: 'func',
        josi: [['に'], ['を']],
        pure: true,
        fn: function (obj, flag, sys) {
            WeykThreeSystem.getEnv(sys);
            if (typeof obj.receiveShadow === 'undefined') {
                throw new Error('指定したオブジェクトはreceiveShadowを持っていません');
            }
            obj.receiveShadow = !!flag;
        },
        return_none: true
    },
    'TJS影受取得': {
        type: 'func',
        josi: [['から', 'の']],
        pure: true,
        fn: function (obj, sys) {
            WeykThreeSystem.getEnv(sys);
            if (typeof obj.receiveShadow === 'undefined') {
                throw new Error('指定したオブジェクトはreceiveShadowを持っていません');
            }
            return obj.receiveShadow;
        }
    },
    'TJS影投設定': {
        type: 'func',
        josi: [['に'], ['を']],
        pure: true,
        fn: function (obj, flag, sys) {
            WeykThreeSystem.getEnv(sys);
            if (typeof obj.castShadow === 'undefined') {
                throw new Error('指定したオブジェクトはcastShadowを持っていません');
            }
            obj.castShadow = !!flag;
        },
        return_none: true
    },
    'TJS影投取得': {
        type: 'func',
        josi: [['から', 'の']],
        pure: true,
        fn: function (obj, sys) {
            WeykThreeSystem.getEnv(sys);
            if (typeof obj.castShadow === 'undefined') {
                throw new Error('指定したオブジェクトはcastShadowを持っていません');
            }
            return obj.castShadow;
        }
    },
    'TJS登場': {
        type: 'func',
        josi: [['に'], ['を']],
        pure: true,
        fn: function (scene, obj, sys) {
            WeykThreeSystem.getEnv(sys);
            scene.add(obj);
        },
        return_none: true
    },
    'TJS退場': {
        type: 'func',
        josi: [['から'], ['を']],
        pure: true,
        fn: function (scene, obj, sys) {
            WeykThreeSystem.getEnv(sys);
            scene.remove(obj);
        },
        return_none: true
    },
    'TJS自主退場': {
        type: 'func',
        josi: [['を', 'が']],
        pure: true,
        fn: function (obj, sys) {
            WeykThreeSystem.getEnv(sys);
            if (typeof obj.removeFromParent !== 'function') {
                throw new Error('指定したオブジェクトはremoveFromParentを持っていません');
            }
            obj.removeFromParent();
        },
        return_none: true
    },
    // @カメラ
    'TJS透視投影カメラ作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (param, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (!Array.isArray(param) || param.length !== 4) {
                throw new Error('カメラの仕様を配列で指定してください([視野角(度), アスペクト比, 最近距離, 最遠距離])');
            }
            const camera = new three.PerspectiveCamera(param[0], param[1], param[2], param[3]);
            if (camera === null) {
                throw new Error('透視投影カメラを作成できません');
            }
            weykthree._camera = camera;
            return camera;
        }
    },
    'TJS環境撮影カメラ作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (param, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (!Array.isArray(param) || param.length !== 3) {
                throw new Error('カメラの仕様を配列で指定してください([最近距離, 最遠距離, 環境撮影用レンダーターゲット])');
            }
            const camera = new three.CubeCamera(param[0], param[1], param[2]);
            if (camera === null) {
                throw new Error('環境撮影カメラを作成できません');
            }
            return camera;
        }
    },
    'TJSカメラ上方設定': {
        type: 'func',
        josi: [['を'], ['に']],
        pure: true,
        fn: function (camera, vec, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            let dir;
            if (typeof vec === 'string') {
                if (vec === '+X')
                    dir = [1.0, 0.0, 0.0];
                else if (vec === '-X')
                    dir = [-1.0, 0.0, 0.0];
                else if (vec === '+Y')
                    dir = [0.0, 1.0, 0.0];
                else if (vec === '-Y')
                    dir = [0.0, -1.0, 0.0];
                else if (vec === '+Z')
                    dir = [0.0, 0.0, 1.0];
                else if (vec === '-Z')
                    dir = [0.0, 0.0, -1.0];
                else {
                    throw new Error('カメラの上方向を表す文字列が正しくありません。文字列もしくは単位ベクトルの配列で指定してください("+","-"と"X","Y","Z"の組み合わせ or [x, y, z])');
                }
            }
            else {
                const pos = weykthree.parsePos(vec);
                if (pos === null) {
                    throw new Error('カメラの上方向を表す文字列が正しくありません。文字列もしくは単位ベクトルの配列で指定してください("+","-"と"X","Y","Z"の組み合わせ or [x, y, z])');
                }
                dir = [pos.x, pos.y, pos.z];
            }
            camera.up.x = dir[0];
            camera.up.y = dir[1];
            camera.up.z = dir[2];
        }
    },
    'TJS投影マトリクス更新': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (camera, sys) {
            WeykThreeSystem.getEnv(sys);
            if (typeof camera.updateProjectionMatrix !== 'function') {
                throw new Error('指定したオブジェクトはupdateProjectionMatrixを持っていません');
            }
            camera.updateProjectionMatrix();
        },
        return_none: true
    },
    'TJS視点設定': {
        type: 'func',
        josi: [['を'], ['に', 'へ']],
        pure: true,
        fn: function (camera, at, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const pos = weykthree.parsePos(at);
            if (pos === null) {
                throw new Error('カメラを向ける先の座標を指定してください([x,y,z])');
            }
            camera.lookAt(pos.x, pos.y, pos.z);
        },
        return_none: true
    },
    'TJSカメラ最近距離設定': {
        type: 'func',
        josi: [['の'], ['に'], ['を']],
        pure: true,
        fn: function (obj, camera, near, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (!('near' in camera)) {
                obj = weykthree.resolveProp(obj, camera);
            }
            obj.near = near;
        },
        return_none: true
    },
    'TJSカメラ矩形距離設定': {
        type: 'func',
        josi: [['の'], ['に'], ['を']],
        pure: true,
        fn: function (obj, camera, rect, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (!('left' in camera)) {
                obj = weykthree.resolveProp(obj, camera);
            }
            if (Array.isArray(rect) && rect.length === 4) {
                obj.left = rect[0];
                obj.top = rect[1];
                obj.right = rect[2];
                obj.bottom = rect[3];
            }
            else if ('left' in rect) {
                obj.left = rect.left;
                obj.top = rect.top;
                obj.right = rect.right;
                obj.bottom = rect.bottom;
            }
            else {
                throw new Error('矩形の指定が正しくありません。要素４つの配列([left, top, right, bottom])で指定して下さい');
            }
        },
        return_none: true
    },
    'TJSカメラ最遠距離設定': {
        type: 'func',
        josi: [['の'], ['に'], ['を']],
        pure: true,
        fn: function (obj, camera, far, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (!('far' in camera)) {
                obj = weykthree.resolveProp(obj, camera);
            }
            obj.far = far;
        },
        return_none: true
    },
    'TJSカメラ視野角設定': {
        type: 'func',
        josi: [['の'], ['に'], ['を']],
        pure: true,
        fn: function (obj, camera, angle, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (!('angle' in camera)) {
                obj = weykthree.resolveProp(obj, camera);
            }
            obj.angle = angle;
        },
        return_none: true
    },
    'TJS環境撮影用レンダーターゲット作成': {
        type: 'func',
        josi: [['を'], ['で']],
        pure: true,
        fn: function (size, opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            return new three.WebGLCubeRenderTarget(size, opts);
        }
    },
    'TJS環境カメラ撮影': {
        type: 'func',
        josi: [['に'], ['を'], ['で']],
        pure: true,
        fn: function (renderer, scene, camera, sys) {
            WeykThreeSystem.getEnv(sys);
            if (typeof camera.update !== 'function') {
                throw new Error('指定した対象はupdateを持っていません');
            }
            camera.update(renderer, scene);
        },
        return_none: true
    },
    // @光源・シャドー光源
    'TJS環境光源作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (color, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            return new three.AmbientLight(color);
        }
    },
    'TJS点光源作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (param, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (!Array.isArray(param) || param.length !== 4) {
                throw new Error('点光源の仕様を配列で指定してください([色, 強度, 到達距離, 減衰率])');
            }
            return new three.PointLight(param[0], param[1], param[2], param[3]);
        }
    },
    'TJS平行光源作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (param, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (!Array.isArray(param) || param.length !== 2) {
                throw new Error('平行光源の仕様を配列で指定してください([色, 強度])');
            }
            return new three.DirectionalLight(param[0], param[1]);
        }
    },
    'TJSスポット光源作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (param, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (!Array.isArray(param) || param.length !== 6) {
                throw new Error('スポット光源の仕様を配列で指定してください([色, 強度, 到達距離, 放射角, 拡散減衰率, 距離減衰係数])');
            }
            return new three.SpotLight(param[0], param[1], param[2], param[3], param[4], param[5]);
        }
    },
    'TJSマップサイズ設定': {
        type: 'func',
        josi: [['の'], ['に'], ['を']],
        pure: true,
        fn: function (obj, lightshadow, wh, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (!Array.isArray(wh) || wh.length !== 2) {
                throw new Error('サイズは[幅,高さ]の形の要素２個の配列で指定して下さい');
            }
            if (!('mapSize' in lightshadow)) {
                obj = weykthree.resolveProp(obj, lightshadow);
            }
            obj.mapSize.width = wh[0];
            obj.mapSize.height = wh[1];
        },
        return_none: true
    },
    // @構造(ジオメトリ)に対する操作
    'TJS属性設定': {
        type: 'func',
        josi: [['の'], ['に'], ['を']],
        pure: true,
        fn: function (geometory, attr, buf, sys) {
            WeykThreeSystem.getEnv(sys);
            geometory.setAttribute(attr, buf);
        },
        return_none: true
    },
    'TJSインデックス設定': {
        type: 'func',
        josi: [['に'], ['を']],
        pure: true,
        fn: function (geometory, index, sys) {
            WeykThreeSystem.getEnv(sys);
            geometory.setIndex(index);
        },
        return_none: true
    },
    'TJS境界箱計算': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (geometory, sys) {
            WeykThreeSystem.getEnv(sys);
            geometory.computeBoundingBox();
        },
        return_none: true
    },
    'TJS境界球計算': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (geometory, sys) {
            WeykThreeSystem.getEnv(sys);
            geometory.computeBoundingSphere();
        },
        return_none: true
    },
    'TJS法線計算': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (geometory, sys) {
            WeykThreeSystem.getEnv(sys);
            geometory.computeVertexNormals();
        },
        return_none: true
    },
    'TJS回転': {
        type: 'func',
        josi: [['を'], ['で'], ['だけ']],
        pure: true,
        fn: function (geometory, axis, radius, sys) {
            WeykThreeSystem.getEnv(sys);
            if (axis === 'X' || axis === 'x') {
                geometory.rotateX(radius);
            }
            else if (axis === 'Y' || axis === 'y') {
                geometory.rotateY(radius);
            }
            else if (axis === 'Z' || axis === 'z') {
                geometory.rotateZ(radius);
            }
            else {
                throw new Error('回転の軸はXかYかZを指定して下さい');
            }
        },
        return_none: true
    },
    // @属性バッファ・バッファ
    'TJS属性バッファ作成': {
        type: 'func',
        josi: [['から', 'を'], ['の', 'で']],
        pure: true,
        fn: function (ary, num, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            return new three.BufferAttribute(ary, num);
        }
    },
    'TJSインターリーブバッファ作成': {
        type: 'func',
        josi: [['から', 'を'], ['の', 'で']],
        pure: true,
        fn: function (ary, stride, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            return new three.InterleavedBuffer(ary, stride);
        }
    },
    'TJSインターリーブ属性作成': {
        type: 'func',
        josi: [['で'], ['から'], ['の']],
        pure: true,
        fn: function (buf, off, num, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            return new three.InterleavedBufferAttribute(buf, num, off);
        }
    },
    'TJS変更有無設定': {
        type: 'func',
        josi: [['に'], ['を']],
        pure: true,
        fn: function (buf, opt, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            let type = opt;
            if (typeof type === 'string') {
                if (opt === '頻繁' || opt === '動的' || opt === '有り' || opt === '有' || opt === 'Dynamic' || opt === 'DynamicDrawUsage') {
                    type = three['DynamicDrawUsage'];
                }
                else if (opt === '静的' || opt === '無し' || opt === '無' || opt === 'Static' || opt === 'StaticDrawUsage') {
                    type = three['StaticDrawUsage'];
                }
                else {
                    type = null;
                }
            }
            buf.setUsage(type);
        },
        return_none: true
    },
    // @基本構造(ジオメトリ)
    'TJS空構造作成': {
        type: 'func',
        josi: [],
        pure: true,
        fn: function (sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            return new three.BufferGeometry();
        }
    },
    'TJS板作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const width = opts['幅'] || opts['W'] || opts['width'] || 1.0;
            const height = opts['高さ'] || opts['H'] || 1.0;
            const widthSegments = opts['横分割数'] || opts['heightSegments'] || 1;
            const heightSegments = opts['縦分割数'] || opts['heightSegments'] || 1;
            const isBuffered = opts['バッファ'] || opts['buffer'] || false;
            // @ts-ignore
            if (isBuffered && typeof three.PlaneBufferGeometry !== 'undefined') {
                // @ts-ignore
                return new three.PlaneBufferGeometry(width, height, widthSegments, heightSegments);
            }
            return new three.PlaneGeometry(width, height, widthSegments, heightSegments);
        }
    },
    'TJS箱作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const width = opts['幅'] || opts['W'] || opts['width'] || 1.0;
            const height = opts['高さ'] || opts['高'] || opts['H'] || opts['height'] || 1.0;
            const depth = opts['奥行'] || opts['D'] || opts['depth'] || 1.0;
            const widthSegments = opts['横分割数'] || opts['heightSegments'] || 1;
            const heightSegments = opts['縦分割数'] || opts['heightSegments'] || 1;
            const depthSegments = opts['奥行分割数'] || opts['depthSegments'] || 1;
            const isBuffered = opts['バッファ'] || opts['buffer'] || false;
            // @ts-ignore
            if (isBuffered && typeof three.BoxBufferGeometry !== 'undefined') {
                // @ts-ignore
                return new three.BoxBufferGeometry(width, height, depth, widthSegments, heightSegments, depthSegments);
            }
            return new three.BoxGeometry(width, height, depth, widthSegments, heightSegments, depthSegments);
        }
    },
    'TJS球体作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const radius = opts['半径'] || opts['R'] || opts['radius'] || 1.0;
            const widthSegments = opts['横分割数'] || opts['widthSegments'] || 8;
            const heightSegments = opts['縦分割数'] || opts['heightSegments'] || 6;
            const phiStart = opts['横開始位置'] || opts['phiStart'] || 0;
            const phiLength = opts['横長'] || opts['phiLength'] || (Math.PI * 2);
            const thettaStart = opts['縦開始位置'] || opts['thettaStart'] || 0;
            const thetaLength = opts['縦長'] || opts['thetaLength'] || (Math.PI * 2);
            const isBuffered = opts['バッファ'] || opts['buffer'] || false;
            // @ts-ignore
            if (isBuffered && typeof three.SphereBufferGeometry !== 'undefined') {
                // @ts-ignore
                return new three.SphereBufferGeometry(radius, widthSegments, heightSegments, phiStart, phiLength, thettaStart, thetaLength);
            }
            return new three.SphereGeometry(radius, widthSegments, heightSegments, phiStart, phiLength, thettaStart, thetaLength);
        }
    },
    'TJSシリンダ体作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const radiusTop = opts['上半径'] || opts['天半径'] || opts['radiusTop'] || opts['半径'] || opts['R'] || opts['radius'] || 1.0;
            const radiusBottom = opts['下半径'] || opts['底半径'] || opts['radiusBottom'] || opts['半径'] || opts['R'] || opts['radius'] || 1.0;
            const height = opts['高'] || opts['縦'] || opts['height'] || 1.0;
            const radialSegments = opts['円分割数'] || opts['radialSegments'] || 8;
            const heightSegments = opts['縦分割数'] || opts['heightSegments'] || 1;
            const openEnd = !!(opts['上下開放'] || opts['openEnd'] || false);
            const thetaStart = opts['円開始位置'] || opts['thetaStart'] || 0;
            const thetaLength = opts['円長'] || opts['thetaLength'] || (Math.PI * 2);
            const isBuffered = opts['バッファ'] || opts['buffer'] || false;
            // @ts-ignore
            if (isBuffered && typeof three.CylinderBufferGeometry !== 'undefined') {
                // @ts-ignore
                return new three.CylinderBufferGeometry(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnd, thetaStart, thetaLength);
            }
            return new three.CylinderGeometry(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnd, thetaStart, thetaLength);
        }
    },
    // @マテリアル(質感)
    'TJS基本表面材質作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            return new three.MeshBasicMaterial(opts);
        }
    },
    'TJS拡散反射材質作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            return new three.MeshLambertMaterial(opts);
        }
    },
    'TJS光沢拡散反射材質作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            return new three.MeshPhongMaterial(opts);
        }
    },
    'TJS標準材質作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            return new three.MeshStandardMaterial(opts);
        }
    },
    'TJSシェーダ材質作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            return new three.ShaderMaterial(opts);
        }
    },
    // @メッシュ(質感＋構造)
    'TJSメッシュ作成': {
        type: 'func',
        josi: [['と'], ['の']],
        pure: true,
        fn: function (geo, mat, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            return new three.Mesh(geo, mat);
        }
    },
    'TJS点メッシュ作成': {
        type: 'func',
        josi: [['と'], ['の']],
        pure: true,
        fn: function (geo, mat, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            return new three.Points(geo, mat);
        }
    },
    // @テクスチャ
    'TJSテクスチャローダ作成': {
        type: 'func',
        josi: [['を', 'の', 'で']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const path = opts['パス'] || opts['path'] || undefined;
            const loader = new three.TextureLoader();
            if (path) {
                loader.setPath(path);
            }
            return loader;
        }
    },
    'TJSテクスチャ読込': {
        type: 'func',
        josi: [['を']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const path = opts['パス'] || opts['path'] || undefined;
            const url = opts['URL'] || opts['url'] || '';
            if (typeof url !== 'string') {
                throw new Error('画像のURLを１つ指定してください');
            }
            const ctl = new three.TextureLoader();
            if (path) {
                ctl.setPath(path);
            }
            return ctl.load(url);
        }
    },
    'TJSテクスチャ保障読込': {
        type: 'func',
        josi: [['を']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const path = opts['パス'] || opts['path'] || undefined;
            const url = opts['URL'] || opts['url'] || '';
            if (typeof url !== 'string') {
                throw new Error('画像のURLを１つ指定してください');
            }
            const ctl = new three.TextureLoader();
            if (path) {
                ctl.setPath(path);
            }
            return ctl.loadAsync(url);
        },
        return_none: false
    },
    'TJS立方体テクスチャ読込': {
        type: 'func',
        josi: [['を']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const path = opts['パス'] || opts['path'] || undefined;
            const url = opts['URL'] || opts['url'];
            if (!Array.isArray(url) || url.length !== 6) {
                throw new Error('画像のURLを配列で6個指定してください(URL:[url1,url2,url3,url4,url5,url6])');
            }
            const ctl = new three.CubeTextureLoader();
            if (path) {
                ctl.setPath(path);
            }
            return ctl.load(url);
        }
    },
    'TJS立方体テクスチャ保障読込': {
        type: 'func',
        josi: [['を']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const path = opts['パス'] || opts['path'] || undefined;
            const url = opts['URL'] || opts['url'];
            if (!Array.isArray(url) || url.length !== 6) {
                throw new Error('画像のURLを配列で6個指定してください(URL:[url1,url2,url3,url4,url5,url6])');
            }
            const ctl = new three.CubeTextureLoader();
            if (path) {
                ctl.setPath(path);
            }
            return ctl.loadAsync(url);
        }
    },
    'TJSキャンバステクスチャ作成': {
        type: 'func',
        josi: [['を']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const canvas = opts['キャンバス'] || opts['CANVAS'] || opts['canvas'] || undefined;
            if (typeof canvas === 'undefined') {
                throw new Error('キャンバスを指定して下さい');
            }
            return new three.CanvasTexture(canvas);
        },
        return_none: false
    },
    'TJS読込': {
        type: 'func',
        josi: [['から'], ['を']],
        pure: true,
        fn: function (loader, url, sys) {
            WeykThreeSystem.getEnv(sys);
            return new Promise((resolve) => {
                loader.load(url, resolve);
            });
        }
    },
    'TJS保障読込': {
        type: 'func',
        josi: [['から'], ['を']],
        pure: true,
        fn: function (loader, url, sys) {
            WeykThreeSystem.getEnv(sys);
            return loader.loadAsync(url);
        }
    },
    // @フォッグ
    'TJSフォッグ作成': {
        type: 'func',
        josi: [['で'], ['から'], ['までの']],
        pure: true,
        fn: function (color, near, far, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            return new three.Fog(color, near, far);
        }
    },
    // @レイキャスタ
    'TJSレイキャスタ作成': {
        type: 'func',
        josi: [['を']],
        pure: true,
        fn: function (sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            return new three.Raycaster();
        }
    },
    'TJSカメラ起点レイ': {
        type: 'func',
        josi: [['で'], ['に', 'を'], ['から']],
        pure: true,
        fn: function (raycaster, coords, camera, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            let V;
            if (coords instanceof three.Vector2) {
                V = coords;
            }
            else if ('x' in coords && 'y' in coords) {
                V = new three.Vector2(coords.x, coords.y);
            }
            else if (Array.isArray(coords) && coords.length === 2) {
                V = new three.Vector2(coords[0], coords[1]);
            }
            else {
                throw new Error('レイを飛ばす位置を-1.0から+1.0に正規化した要素２個の配列で指定して下さい');
            }
            raycaster.setFromCamera(V, camera);
        },
        return_none: true
    },
    'TJSレイ命中取得': {
        type: 'func',
        josi: [['で'], ['に']],
        pure: true,
        fn: function (raycaster, obj, sys) {
            WeykThreeSystem.getEnv(sys);
            return raycaster.intersectObject(obj);
        }
    },
    'TJSレイ命中一覧取得': {
        type: 'func',
        josi: [['で'], ['に']],
        pure: true,
        fn: function (raycaster, lists, sys) {
            WeykThreeSystem.getEnv(sys);
            return raycaster.intersectObjects(lists);
        }
    },
    'TJSレイ原点取得': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (raycaster, sys) {
            WeykThreeSystem.getEnv(sys);
            return raycaster.ray.origin;
        }
    },
    'TJSレイ方向取得': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (raycaster, sys) {
            WeykThreeSystem.getEnv(sys);
            return raycaster.ray.direction;
        }
    },
    // @アニメーション
    'TJSアニメーションミキサー作成': {
        type: 'func',
        josi: [['の', 'から']],
        pure: true,
        fn: function (model, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            return new three.AnimationMixer(model);
        }
    },
    'TJSクリップアクション取得': {
        type: 'func',
        josi: [['から'], ['の']],
        pure: true,
        fn: function (mixer, clip, sys) {
            WeykThreeSystem.getEnv(sys);
            return mixer.clipAction(clip);
        }
    },
    'TJSアクション比重設定': {
        type: 'func',
        josi: [['に'], ['を']],
        pure: true,
        fn: function (act, w, sys) {
            WeykThreeSystem.getEnv(sys);
            act.setEffectiveWeight(w);
        },
        return_none: true
    },
    'TJSアクション再生時間倍率設定': {
        type: 'func',
        josi: [['に'], ['を']],
        pure: true,
        fn: function (act, w, sys) {
            WeykThreeSystem.getEnv(sys);
            act.setEffectiveTimeScale(w);
        },
        return_none: true
    },
    'TJSアクション再生': {
        type: 'func',
        josi: [['を']],
        pure: true,
        fn: function (act, sys) {
            WeykThreeSystem.getEnv(sys);
            act.play();
        },
        return_none: true
    },
    'TJSアクション停止': {
        type: 'func',
        josi: [['を']],
        pure: true,
        fn: function (act, sys) {
            WeykThreeSystem.getEnv(sys);
            act.stop();
        },
        return_none: true
    },
    // @ローダー
    'TJSGLTFローダ作成': {
        type: 'func',
        josi: [['を']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const threeExt = weykthree.getThreeExt();
            if (typeof threeExt.GLTFLoader === 'undefined') {
                throw new Error('GLTFLoader.jsが読み込まれていません');
            }
            const path = opts['パス'] || opts['path'] || undefined;
            const draco = opts['DRACO'] || opts['draco'] || undefined;
            const loader = new threeExt.GLTFLoader();
            if (path) {
                loader.setPath(path);
            }
            if (draco) {
                loader.setDRACOLoader(draco);
            }
            return loader;
        }
    },
    'TJSGLTF保障読込': {
        type: 'func',
        josi: [['を']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const threeExt = weykthree.getThreeExt();
            if (typeof threeExt.GLTFLoader === 'undefined') {
                throw new Error('GLTFLoader.jsが読み込まれていません');
            }
            const path = opts['パス'] || opts['PATH'] || opts['path'] || undefined;
            const url = opts['URL'] || opts['url'] || '';
            const draco = opts['DRACO'] || opts['draco'] || undefined;
            if (typeof url !== 'string') {
                throw new Error('glTFモデルのURLを１つ指定してください');
            }
            const loader = new threeExt.GLTFLoader();
            if (path) {
                loader.setPath(path);
            }
            if (draco) {
                loader.setDRACOLoader(draco);
            }
            return loader.loadAsync(url);
        }
    },
    'TJSMD2複合キャラクタローダ作成': {
        type: 'func',
        josi: [],
        pure: true,
        fn: function (sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const threeExt = weykthree.getThreeExt();
            if (typeof threeExt.MD2CharacterComplex === 'undefined') {
                throw new Error('MD2CharacterComplex.jsが読み込まれていません');
            }
            return new threeExt.MD2CharacterComplex();
        }
    },
    // @コントローラ
    'TJS衛星軌道コントローラ作成': {
        type: 'func',
        josi: [['に'], ['の']],
        pure: true,
        fn: function (camera, dom, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const threeExt = weykthree.getThreeExt();
            if (typeof threeExt.OrbitControls === 'undefined') {
                throw new Error('OrbitControls.jsが読み込まれていません');
            }
            if (dom instanceof three.WebGLRenderer) {
                dom = dom.domElement;
            }
            return new threeExt.OrbitControls(camera, dom);
        }
    },
    'TJS一人称視点コントローラ作成': {
        type: 'func',
        josi: [['に'], ['の']],
        pure: true,
        fn: function (camera, dom, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const threeExt = weykthree.getThreeExt();
            if (typeof threeExt.FirstPersonControls === 'undefined') {
                throw new Error('FirstPersonControls.jsが読み込まれていません');
            }
            if (dom instanceof three.WebGLRenderer) {
                dom = dom.domElement;
            }
            return new threeExt.FirstPersonControls(camera, dom);
        }
    },
    'TJS飛行視点コントローラ作成': {
        type: 'func',
        josi: [['に'], ['の']],
        pure: true,
        fn: function (camera, dom, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const threeExt = weykthree.getThreeExt();
            if (typeof threeExt.FlyControls === 'undefined') {
                throw new Error('FlyControls.jsが読み込まれていません');
            }
            if (dom instanceof three.WebGLRenderer) {
                dom = dom.domElement;
            }
            return new threeExt.FlyControls(camera, dom);
        }
    },
    'TJS更新': {
        type: 'func',
        josi: [['の', 'を'], ['で']],
        pure: true,
        fn: function (control, delta, sys) {
            WeykThreeSystem.getEnv(sys);
            control.update(delta);
        },
        return_none: true
    },
    // @効果
    'TJS両目効果作成': {
        type: 'func',
        josi: [['に']],
        pure: true,
        fn: function (renderer, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const treeExt = weykthree.getThreeExt();
            if (typeof treeExt.StereoEffect === 'undefined') {
                throw new Error('StereoEffect.jsが読み込まれていません');
            }
            return new treeExt.StereoEffect(renderer);
        }
    },
    // @ヘルパ
    'TJS軸線ヘルパ作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (len, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (typeof three.AxesHelper === 'undefined') {
                throw Error('AXESヘルパの機能が見当たりません。');
            }
            return new three.AxesHelper(len);
        }
    },
    'TJSグリッドヘルパ作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (typeof three.GridHelper === 'undefined') {
                throw Error('Gridヘルパの機能が見当たりません。');
            }
            const size = opts['サイズ'] || opts['範囲'] || opts['size'] || 10;
            const divisions = opts['分割数'] || opts['divisions'] || 10;
            const colorCenterLine = opts['軸線色'] || opts['colorCenterLine'] || 0x444444;
            const colorGrid = opts['グリッド色'] || opts['colorGrid'] || 0x88888;
            return new three.GridHelper(size, divisions, colorCenterLine, colorGrid);
        }
    },
    'TJS矢印ヘルパ作成': {
        type: 'func',
        josi: [['の']],
        pure: true,
        fn: function (opts, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            if (typeof three.ArrowHelper === 'undefined') {
                throw Error('ARROWヘルパの機能が見当たりません。');
            }
            const dir = opts['方向'] || opts['向き'] || opts['向'] || opts['dir'] || new three.Vector3(0, 0, 1);
            const origin = opts['起点'] || opts['原点'] || opts['origin'] || new three.Vector3(0, 0, 0);
            const color = opts['色'] || opts['color'] || 0xffff00;
            const len = opts['長さ'] || opts['長'] || opts['length'] || 1;
            return new three.ArrowHelper(dir, origin, len, color);
        }
    },
    'TJS矢印方向設定': {
        type: 'func',
        josi: [['に'], ['を']],
        pure: true,
        fn: function (helper, dir, sys) {
            WeykThreeSystem.getEnv(sys);
            helper.setDirection(dir);
        },
        return_none: true
    },
    'TJSスケルトン付複製': {
        type: 'func',
        josi: [['の', 'を', 'から']],
        pure: true,
        fn: function (obj, sys) {
            const [weykthree, three] = WeykThreeSystem.getEnv(sys);
            const treeExt = weykthree.getThreeExt();
            if (typeof treeExt.SkeletonUtils === 'undefined') {
                throw Error('スケルトンユーティリティの機能が見当たりません。');
            }
            return treeExt.SkeletonUtils.clone(obj);
        },
        return_none: false
    }
};
// ブラウザからscriptタグで取り込んだ時、自動で登録する
if (typeof navigator === 'object' && typeof navigator.nako3 === 'object') {
    navigator.nako3.addPluginObject('PluginWeykThree', PluginWeykThree);
}

デバッグ × キャンバス: 幅 × 高

🍯 なでしこ3貯蔵庫

[編集モード] ThreeJS利用プラグイン(JSプラグイン)

素材のアップロード