@vyr/cli 0.0.11 → 0.0.13

package/output/engine/src/interpreter/HTMLTransformControllerInterpreter.ts

@@ -0,0 +1,40 @@
+import { Descriptor, HTMLTransformControllerDescriptor } from "../descriptor"
+import { HTMLTransformControllerActor } from "../actor"
+import { Interpreter } from "./Interpreter"
+
+class HTMLTransformControllerInterpreter extends Interpreter {
+    static type = HTMLTransformControllerDescriptor.type
+
+    protected createActor(descriptor: HTMLTransformControllerDescriptor) {
+        const actor = new HTMLTransformControllerActor()
+        return actor
+    }
+
+    update(descriptor: HTMLTransformControllerDescriptor) {
+        super.update(descriptor)
+        const actor = this.getActor<HTMLTransformControllerActor>(descriptor)
+        actor.update(descriptor)
+    }
+
+    mount(descriptor: HTMLTransformControllerDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        super.mount(descriptor, parentInterpreter, parentDescriptor)
+        this.getActor<HTMLTransformControllerActor>(descriptor)
+    }
+
+    unmount(descriptor: HTMLTransformControllerDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        const actor = this.getActor<HTMLTransformControllerActor>(descriptor)
+        actor.unlisten()
+
+        super.unmount(descriptor, parentInterpreter, parentDescriptor)
+    }
+
+    free(descriptor: HTMLTransformControllerDescriptor) {
+        const actor = this.getActor<HTMLTransformControllerActor>(descriptor)
+        actor.dispose()
+        super.free(descriptor)
+    }
+}
+Interpreter.register(HTMLTransformControllerInterpreter)
+
+
+export { HTMLTransformControllerInterpreter }

package/output/engine/src/interpreter/Interpreter.ts

@@ -0,0 +1,69 @@
+import { language } from '../locale'
+import { Actor } from '../actor'
+import { Unit, PickupObject, Graphics } from "../graphics"
+import { Descriptor } from "../descriptor"
+
+const privateState = {
+    factory: false,
+    classCollection: new Map<string, typeof Interpreter>(),
+    actorCollection: new Map<Interpreter, Actor>(),
+}
+
+/**
+ * 对描述进行解释，不同的扩展对每个描述都有不同的解释器
+ * 
+ * 警告：解释器在实现时不能对自身的描述器直接进行引用，从而导致描述器始终存在引用而无法被垃圾回收机制回收。
+ */
+class Interpreter {
+    static type = 'Interpreter'
+    static register(DerivedClass: typeof Interpreter) {
+        privateState.classCollection.set(DerivedClass.type, DerivedClass)
+    }
+    /**获取注册的派生类 */
+    static getClass<T extends typeof Interpreter>(type: string) {
+        return (privateState.classCollection.get(type) ?? null) as T | null
+    }
+
+    readonly unit
+    readonly graphics
+
+    constructor(unit: Unit, graphics: Graphics) {
+        if (privateState.factory === false) throw language.get('interpreter.new.fail')
+        this.unit = unit
+        this.graphics = graphics
+    }
+
+    protected createActor(descriptor: Descriptor) {
+        return new Actor()
+    }
+
+    /**使用描述器获取代理对象，若代理对象不存在则会使用描述器创建一个代理对象 */
+    getActor<T extends Actor = Actor>(descriptor: Descriptor): T {
+        let actor = privateState.actorCollection.get(this)
+        if (actor !== undefined) return actor as T
+        actor = this.createActor(descriptor)
+        Actor.seGraphics(actor, this.graphics)
+        privateState.actorCollection.set(this, actor)
+        return actor as T
+    }
+
+    /**使用描述更新节点 */
+    update(descriptor: Descriptor,) { }
+
+    /**将节点挂载到场景 */
+    mount(descriptor: Descriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) { }
+
+    /**将节点从场景中卸载 */
+    unmount(descriptor: Descriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) { }
+
+    free(descriptor: Descriptor) {
+        const actor = privateState.actorCollection.get(this)
+        if (actor === undefined) return
+        Actor.seGraphics(actor, this.graphics)
+        privateState.actorCollection.delete(this)
+    }
+
+    pickup(descriptor: Descriptor, result: PickupObject[]) { }
+}
+
+export { Interpreter, privateState }

package/output/engine/src/interpreter/PrefaInterpreter.ts

@@ -0,0 +1,11 @@
+import { PrefabeDescriptor } from "../descriptor";
+import { FragmentInterpreter } from "./FragmentInterpreter";
+
+class PrefaInterpreter extends FragmentInterpreter {
+    static type = PrefabeDescriptor.type
+}
+FragmentInterpreter.register(PrefaInterpreter)
+
+export {
+    PrefaInterpreter
+}

package/output/engine/src/interpreter/PrefabInstanceInterpreter.ts

@@ -0,0 +1,12 @@
+import { PrefabInstanceDescriptor } from "../descriptor";
+import { FragmentInterpreter } from "./FragmentInterpreter";
+
+class PrefabInstanceInterpreter extends FragmentInterpreter {
+    static type = PrefabInstanceDescriptor.type
+
+}
+FragmentInterpreter.register(PrefabInstanceInterpreter)
+
+export {
+    PrefabInstanceInterpreter
+}

package/output/engine/src/interpreter/ServiceInterpreter.ts

@@ -0,0 +1,24 @@
+import { ServiceDescriptor } from "../descriptor";
+import { PickupObject } from "../graphics";
+import { Interpreter } from "./Interpreter";
+
+class ServiceInterpreter extends Interpreter {
+  static type = ServiceDescriptor.type
+
+  clear(service: ServiceDescriptor) { }
+
+  beforeRender(service: ServiceDescriptor) { }
+
+  render(service: ServiceDescriptor) { }
+
+  afterRender(service: ServiceDescriptor) { }
+
+  beforePickup(mouse: { x: number; y: number }, rect: DOMRect) { }
+
+  orderBy(result: PickupObject[]) { }
+}
+Interpreter.register(ServiceInterpreter)
+
+export {
+  ServiceInterpreter
+}

package/output/engine/src/interpreter/ServiceSchedulerInterpreter.ts

@@ -0,0 +1,42 @@
+import { Descriptor, ServiceSchedulerDescriptor } from "../descriptor"
+import { DivActor } from "../actor"
+import { Interpreter } from "./Interpreter"
+
+class ServiceSchedulerInterpreter extends Interpreter {
+  static type = ServiceSchedulerDescriptor.type
+
+  protected createActor(descriptor: Descriptor) {
+    const actor = new DivActor(descriptor.uuid)
+    return actor
+  }
+
+  private resize = () => { }
+  private unresize = () => { }
+
+  install(descriptor: ServiceSchedulerDescriptor) {
+    const actor = this.getActor<DivActor>(descriptor)
+    const wrapper = actor.getWrapper()
+
+    this.graphics.engine.DOM.appendChild(wrapper)
+
+    this.resize = () => {
+      wrapper.style.width = this.graphics.engine.DOM.clientWidth + 'px'
+      wrapper.style.height = this.graphics.engine.DOM.clientHeight + 'px'
+      actor.DOM.style.width = '100%'
+      actor.DOM.style.height = '100%'
+    }
+    const uuid = this.graphics.engine.inputSystem.listen('resize', this.resize, { target: window })
+    this.unresize = () => this.graphics.engine.inputSystem.unlisten(uuid)
+    this.resize()
+  }
+
+  uninstall(descriptor: ServiceSchedulerDescriptor) {
+    this.unresize()
+    const actor = this.getActor<DivActor>(descriptor)
+    const wrapper = actor.getWrapper()
+    wrapper.remove()
+  }
+}
+Interpreter.register(ServiceSchedulerInterpreter)
+
+export { ServiceSchedulerInterpreter }

package/output/engine/src/interpreter/StyleInterpreter.ts

@@ -0,0 +1,66 @@
+import { Descriptor, StyleDescriptor } from "../descriptor";
+import { StyleActor } from "../actor";
+import { Graphics, Unit } from "../graphics";
+import { Interpreter } from "./Interpreter";
+
+let _sheet: CSSStyleSheet | null = null
+
+class StyleInterpreter extends Interpreter {
+    static type = StyleDescriptor.type
+    static get sheet() {
+        if (_sheet === null) {
+            const style = document.createElement('style')
+            style.setAttribute('type', 'text/css')
+            document.head.appendChild(style)
+            _sheet = style.sheet as CSSStyleSheet
+        }
+        return _sheet as CSSStyleSheet
+    }
+    static insertRule(styles: string[]) {
+        for (const style of styles) this.sheet.insertRule(style, StyleInterpreter.sheet.cssRules.length)
+    }
+
+    readonly className
+
+    constructor(unit: Unit, graphics: Graphics) {
+        super(unit, graphics)
+        this.className = `vyr_${unit.uuid}`
+    }
+
+    protected createActor(descriptor: StyleDescriptor) {
+        return new StyleActor()
+    }
+
+    update(descriptor: StyleDescriptor) {
+        super.update(descriptor)
+
+        const actor = this.getActor<StyleActor>(descriptor)
+        actor.update(descriptor, this.className)
+
+        if (actor.updateRule(StyleInterpreter.sheet) === true) return
+
+        const styleValues = actor.getStyleValue()
+        StyleInterpreter.insertRule(styleValues)
+    }
+
+    free(descriptor: Descriptor) {
+        const selectorTexts = [`.${this.className}`, `.${this.className}:hover`]
+        for (let i = StyleInterpreter.sheet.cssRules.length - 1; i >= 0; i--) {
+            const rule = StyleInterpreter.sheet.cssRules[i]
+            if (rule instanceof CSSStyleRule) {
+                const i = selectorTexts.indexOf(rule.selectorText)
+                if (i > -1) {
+                    StyleInterpreter.sheet.deleteRule(i)
+                    selectorTexts.splice(i, 1)
+                    if (selectorTexts.length === 0) return
+                }
+            }
+        }
+        super.free(descriptor)
+    }
+}
+Interpreter.register(StyleInterpreter)
+
+export {
+    StyleInterpreter
+}

package/output/engine/src/interpreter/index.ts

@@ -0,0 +1,13 @@
+export { Interpreter } from './Interpreter'
+export * from './DatasetInterpreter'
+export * from './StyleInterpreter'
+export * from './AnimationUnitInterpreter'
+export * from './FragmentInterpreter'
+export * from './DynamicInterpreter'
+export * from './PrefaInterpreter'
+export * from './PrefabInstanceInterpreter'
+export * from "./DivInterpreter";
+export * from "./HTMLTransformControllerInterpreter";
+export * from './ServiceInterpreter'
+export * from "./HTMLServiceInterpreter";
+export * from './ServiceSchedulerInterpreter'

package/output/engine/src/locale/Language.ts

@@ -0,0 +1,10 @@
+import { Locale } from "@vyr/locale";
+import { zhCnLanguageProvider, ZhCNLanguageProvider } from "./LanguageProvider";
+
+Locale.register(zhCnLanguageProvider)
+
+const language = Locale.getLanguage<ZhCNLanguageProvider>(zhCnLanguageProvider.name)
+
+export {
+    language
+}

package/output/engine/src/locale/LanguageProvider.ts

@@ -0,0 +1,52 @@
+import { LanguageProvider } from '@vyr/locale'
+
+interface ZhCNLanguageProvider extends LanguageProvider {
+    'asyncTask.task.was.cancelled': string
+    'asset.load.fail': string
+    'asset.already.exists': string
+    'asset.provider.notFound': string
+    'descriptor.notRegister': string
+    'descriptor.insert.uuid.notFound': string
+    'descriptor.insert.target.notFound': string
+    'descriptor.syncWith.fail': string
+    'interpreter.new.fail': string
+    'graphics.interpreter.notRegister': string
+    'graphics.unit.notFound': string
+    'engine.run.container.notFound': string
+    'engine.switch.url.notFound': string
+
+    '/virtual:/preset/net/http.ts': string
+    '/virtual:/preset/dataset/update.ts': string
+    '/virtual:/preset/dataset/compile.ts': string
+    '/virtual:/preset/scheduler/switch.ts': string
+    '/virtual:/preset/graphics/invoke.ts': string
+}
+
+const zhCnLanguageProvider: ZhCNLanguageProvider = {
+    id: 'zh_CN',
+    name: '@vyr/engine',
+    'asyncTask.task.was.cancelled': '任务已取消',
+    'asset.load.fail': '资产加载失败：未注册 {{category}} 类别的工厂方法',
+    'asset.already.exists': '已存在同名资产，覆盖可能导致异常',
+    'asset.provider.notFound': '未找到资源提供方：{{url}}',
+    'descriptor.notRegister': '未注册描述器：{{type}}',
+    'descriptor.insert.uuid.notFound': '节点不存在：${uuid}',
+    'descriptor.insert.target.notFound': '目标节点不存在：${target}',
+    'descriptor.syncWith.fail': '只能从同类型实例同步属性',
+    'interpreter.new.fail': '请使用静态 create 方法创建实例',
+    'graphics.interpreter.notRegister': '未注册解释器：{{type}}',
+    'graphics.unit.notFound': '单元不存在：{{uuid}}',
+    'engine.run.container.notFound': '挂载节点不存在',
+    'engine.switch.url.notFound': '切换失败，无法获资产地址！',
+
+    '/virtual:/preset/net/http.ts': '网络请求',
+    '/virtual:/preset/dataset/update.ts': '更新数据集',
+    '/virtual:/preset/dataset/compile.ts': '组合数据集',
+    '/virtual:/preset/scheduler/switch.ts': '切换场景',
+    '/virtual:/preset/graphics/invoke.ts': '调用交互',
+}
+
+export {
+    ZhCNLanguageProvider,
+    zhCnLanguageProvider,
+}

package/output/engine/src/locale/index.ts

@@ -0,0 +1,2 @@
+export * from './LanguageProvider'
+export * from './Language'

package/output/engine/src/math/Euler.ts

@@ -0,0 +1,303 @@
+import { DeserializationObject } from "../Serialization"
+import { clamp } from './utils';
+import { Quaternion } from './Quaternion';
+import { Matrix4 } from './Matrix4';
+import { Vector3 } from './Vector3'
+
+const _matrix = /*@__PURE__*/ new Matrix4();
+const _quaternion = /*@__PURE__*/ new Quaternion();
+
+type EulerOrder = 'XYZ' | 'YXZ' | 'ZXY' | 'ZYX' | 'YZX' | 'XZY';
+
+/**
+ * A class representing Euler angles.
+ *
+ * Euler angles describe a rotational transformation by rotating an object on
+ * its various axes in specified amounts per axis, and a specified axis
+ * order.
+ *
+ * Iterating through an instance will yield its components (x, y, z,
+ * order) in the corresponding order.
+ *
+ * ```js
+ * const a = new Euler( 0, 1, 1.57, 'XYZ' );
+ * const b = new Vector3( 1, 0, 1 );
+ * b.applyEuler(a);
+ * ```
+ */
+class Euler {
+    static create(euler?: number | DeserializationObject<Euler>, y?: number, z?: number, order?: EulerOrder) {
+        if (euler === undefined) return new Euler()
+
+        if (typeof euler === 'number') {
+            return new Euler(euler as number, y, z, order)
+        } else {
+            return new Euler(euler.x, euler.y, euler.z, euler.order)
+        }
+    }
+
+    /**
+     * The default Euler angle order.
+     *
+     * @static
+     * @default 'XYZ'
+     */
+    static readonly DEFAULT_ORDER: EulerOrder = 'XYZ';
+
+    x: number;
+    y: number;
+    z: number;
+    order: EulerOrder;
+
+    /**
+     * Constructs a new euler instance.
+     *
+     * @param x - The angle of the x axis in radians.
+     * @param y - The angle of the y axis in radians.
+     * @param z - The angle of the z axis in radians.
+     * @param order - A string representing the order that the rotations are applied.
+     */
+    constructor(x: number = 0, y: number = 0, z: number = 0, order: EulerOrder = Euler.DEFAULT_ORDER) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.order = order;
+    }
+
+    /**
+     * Sets the Euler components.
+     *
+     * @param x - The angle of the x axis in radians.
+     * @param y - The angle of the y axis in radians.
+     * @param z - The angle of the z axis in radians.
+     * @param order - A string representing the order that the rotations are applied.
+     * @return A reference to this Euler instance.
+     */
+    set(x: number, y: number, z: number, order: EulerOrder = this.order): Euler {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.order = order;
+
+
+        return this;
+    }
+
+    /**
+     * Returns a new Euler instance with copied values from this instance.
+     *
+     * @return A clone of this instance.
+     */
+    clone(): Euler {
+        return new (this.constructor as typeof Euler)(this.x, this.y, this.z, this.order);
+    }
+
+    /**
+     * Copies the values of the given Euler instance to this instance.
+     *
+     * @param euler - The Euler instance to copy.
+     * @return A reference to this Euler instance.
+     */
+    copy(euler: Euler): Euler {
+        this.x = euler.x;
+        this.y = euler.y;
+        this.z = euler.z;
+        this.order = euler.order;
+
+
+        return this;
+    }
+
+    /**
+     * Sets the angles of this Euler instance from a pure rotation matrix.
+     *
+     * @param m - A 4x4 matrix of which the upper 3x3 of matrix is a pure rotation matrix (i.e. unscaled).
+     * @param order - A string representing the order that the rotations are applied.
+     * @return A reference to this Euler instance.
+     */
+    setFromRotationMatrix(m: Matrix4, order: EulerOrder = this.order): Euler {
+        const te = m.elements;
+        const m11 = te[0],
+            m12 = te[4],
+            m13 = te[8];
+        const m21 = te[1],
+            m22 = te[5],
+            m23 = te[9];
+        const m31 = te[2],
+            m32 = te[6],
+            m33 = te[10];
+
+        switch (order) {
+            case 'XYZ':
+                this.y = Math.asin(clamp(m13, -1, 1));
+
+                if (Math.abs(m13) < 0.9999999) {
+                    this.x = Math.atan2(-m23, m33);
+                    this.z = Math.atan2(-m12, m11);
+                } else {
+                    this.x = Math.atan2(m32, m22);
+                    this.z = 0;
+                }
+                break;
+
+            case 'YXZ':
+                this.x = Math.asin(-clamp(m23, -1, 1));
+
+                if (Math.abs(m23) < 0.9999999) {
+                    this.y = Math.atan2(m13, m33);
+                    this.z = Math.atan2(m21, m22);
+                } else {
+                    this.y = Math.atan2(-m31, m11);
+                    this.z = 0;
+                }
+                break;
+
+            case 'ZXY':
+                this.x = Math.asin(clamp(m32, -1, 1));
+
+                if (Math.abs(m32) < 0.9999999) {
+                    this.y = Math.atan2(-m31, m33);
+                    this.z = Math.atan2(-m12, m22);
+                } else {
+                    this.y = 0;
+                    this.z = Math.atan2(m21, m11);
+                }
+                break;
+
+            case 'ZYX':
+                this.y = Math.asin(-clamp(m31, -1, 1));
+
+                if (Math.abs(m31) < 0.9999999) {
+                    this.x = Math.atan2(m32, m33);
+                    this.z = Math.atan2(m21, m11);
+                } else {
+                    this.x = 0;
+                    this.z = Math.atan2(-m12, m22);
+                }
+                break;
+
+            case 'YZX':
+                this.z = Math.asin(clamp(m21, -1, 1));
+
+                if (Math.abs(m21) < 0.9999999) {
+                    this.x = Math.atan2(-m23, m22);
+                    this.y = Math.atan2(-m31, m11);
+                } else {
+                    this.x = 0;
+                    this.y = Math.atan2(m13, m33);
+                }
+                break;
+
+            case 'XZY':
+                this.z = Math.asin(-clamp(m12, -1, 1));
+
+                if (Math.abs(m12) < 0.9999999) {
+                    this.x = Math.atan2(m32, m22);
+                    this.y = Math.atan2(m13, m11);
+                } else {
+                    this.x = Math.atan2(-m23, m33);
+                    this.y = 0;
+                }
+                break;
+
+            default:
+                console.warn('Euler: .setFromRotationMatrix() encountered an unknown order: ' + order);
+        }
+
+        this.order = order;
+
+        return this;
+    }
+
+    /**
+     * Sets the angles of this Euler instance from a normalized quaternion.
+     *
+     * @param q - A normalized Quaternion.
+     * @param order - A string representing the order that the rotations are applied.
+     * @return A reference to this Euler instance.
+     */
+    setFromQuaternion(q: Quaternion, order?: EulerOrder): Euler {
+        _matrix.makeRotationFromQuaternion(q);
+        return this.setFromRotationMatrix(_matrix, order);
+    }
+
+    /**
+     * Sets the angles of this Euler instance from the given vector.
+     *
+     * @param v - The vector.
+     * @param order - A string representing the order that the rotations are applied.
+     * @return A reference to this Euler instance.
+     */
+    setFromVector3(v: Vector3, order: EulerOrder = this.order): Euler {
+        return this.set(v.x, v.y, v.z, order);
+    }
+
+    /**
+     * Resets the euler angle with a new order by creating a quaternion from this
+     * euler angle and then setting this euler angle with the quaternion and the
+     * new order.
+     *
+     * Warning: This discards revolution information.
+     *
+     * @param newOrder - A string representing the new order that the rotations are applied.
+     * @return A reference to this Euler instance.
+     */
+    reorder(newOrder: EulerOrder): Euler {
+        _quaternion.setFromEuler(this);
+        return this.setFromQuaternion(_quaternion, newOrder);
+    }
+
+    /**
+     * Returns `true` if this Euler instance is equal with the given one.
+     *
+     * @param euler - The Euler instance to test for equality.
+     * @return Whether this Euler instance is equal with the given one.
+     */
+    equals(euler: Euler): boolean {
+        return euler.x === this.x && euler.y === this.y && euler.z === this.z && euler.order === this.order;
+    }
+
+    /**
+     * Sets this Euler instance's components to values from the given array. The first three
+     * entries of the array are assign to the x,y and z components. An optional fourth entry
+     * defines the Euler order.
+     *
+     * @param array - An array holding the Euler component values.
+     * @return A reference to this Euler instance.
+     */
+    fromArray(array: [number, number, number, EulerOrder?] | number[]): Euler {
+        this.x = array[0];
+        this.y = array[1];
+        this.z = array[2];
+        if (array[3] !== undefined) this.order = array[3] as EulerOrder;
+
+
+        return this;
+    }
+
+    /**
+     * Writes the components of this Euler instance to the given array. If no array is provided,
+     * the method returns a new instance.
+     *
+     * @param array - The target array holding the Euler components.
+     * @param offset - Index of the first element in the array.
+     * @return The Euler components.
+     */
+    toArray(array: (number | EulerOrder)[] = [], offset: number = 0): (number | EulerOrder)[] {
+        array[offset] = this.x;
+        array[offset + 1] = this.y;
+        array[offset + 2] = this.z;
+        array[offset + 3] = this.order;
+
+        return array;
+    }
+
+    *[Symbol.iterator](): Generator<number | EulerOrder> {
+        yield this.x;
+        yield this.y;
+        yield this.z;
+        yield this.order;
+    }
+}
+
+export { Euler };