@vyr/engine 0.0.1

package/src/interpreter/ServiceSchedulerInterpreter.ts

@@ -0,0 +1,42 @@
+import { Descriptor, ServiceSchedulerDescriptor, UpdateArgs } from "../descriptor"
+import { DivActor } from "../actor"
+import { Interpreter } from "./Interpreter"
+
+class ServiceSchedulerInterpreter extends Interpreter {
+  static type = ServiceSchedulerDescriptor.type
+
+  protected createActor(descriptor: Descriptor, args: UpdateArgs) {
+    const actor = new DivActor(descriptor.uuid)
+    return actor
+  }
+
+  private resize = () => { }
+  private unresize = () => { }
+
+  install(descriptor: ServiceSchedulerDescriptor, args: UpdateArgs) {
+    const actor = this.getActor<DivActor>(descriptor, args)
+    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, args: UpdateArgs) {
+    this.unresize()
+    const actor = this.getActor<DivActor>(descriptor, args)
+    const wrapper = actor.getWrapper()
+    wrapper.remove()
+  }
+}
+Interpreter.register(ServiceSchedulerInterpreter)
+
+export { ServiceSchedulerInterpreter }

package/src/interpreter/StyleInterpreter.ts

@@ -0,0 +1,66 @@
+import { Descriptor, StyleDescriptor, UpdateArgs } 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, args: UpdateArgs) {
+        return new StyleActor()
+    }
+
+    update(descriptor: StyleDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+
+        const actor = this.getActor<StyleActor>(descriptor, args)
+        actor.update(descriptor, this.className)
+
+        if (actor.updateRule(StyleInterpreter.sheet) === true) return
+
+        const styleValues = actor.getStyleValue()
+        StyleInterpreter.insertRule(styleValues)
+    }
+
+    free(descriptor: Descriptor, args: UpdateArgs) {
+        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, args)
+    }
+}
+Interpreter.register(StyleInterpreter)
+
+export {
+    StyleInterpreter
+}

package/src/interpreter/index.ts

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

package/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/src/locale/LanguageProvider.ts

@@ -0,0 +1,48 @@
+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
+
+    '/virtual:/preset/net/request.ts': string
+    '/virtual:/preset/dataset/update.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': '挂载节点不存在',
+
+    '/virtual:/preset/net/request.ts': '网络请求',
+    '/virtual:/preset/dataset/update.ts': '更新数据集',
+    '/virtual:/preset/scheduler/switch.ts': '切换场景',
+    '/virtual:/preset/graphics/invoke.ts': '调用交互',
+}
+
+export {
+    ZhCNLanguageProvider,
+    zhCnLanguageProvider,
+}

package/src/locale/index.ts

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

package/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 };