@vyr/engine 0.0.1

package/src/Listener.ts

@@ -0,0 +1,59 @@
+type DeafultCallback = (...args: any[]) => any
+type CallbackCollection<T extends {} = {}> = { [k: string]: DeafultCallback } & T
+
+interface listenOptions {
+  once?: boolean
+  insertIndex?: number
+}
+
+class Listener<T extends {} = {}> {
+  private registrys: any = {}
+
+  listen<K extends keyof T>(type: K, callback: T[K], options?: listenOptions): () => void
+  listen(type: string, callback: DeafultCallback, options?: listenOptions): () => void
+  listen<K extends keyof T>(type: K | string, callback?: T[K], options: listenOptions = {}) {
+
+    let register = this.registrys[type]
+    if (register === undefined) {
+      register = []
+      this.registrys[type] = register
+    }
+    const insertIndex = options.insertIndex === undefined ? register.length : options.insertIndex
+
+    const row = register.find((r: any) => r.callback === callback)
+    if (!row) register.splice(insertIndex, 0, { once: options.once ?? false, callback })
+    const unlisten = () => this.unlisten(type as any, callback)
+    return unlisten
+  }
+
+  unlisten<K extends keyof T>(type: K, callback: T[K]): void
+  unlisten(type: string, callback: DeafultCallback): void
+  unlisten<K extends keyof T>(type: K, callback: T[K]) {
+    let registry = this.registrys[type]
+    if (registry === undefined) return
+
+    for (let i = 0; i < registry.length; i++) {
+      if (registry[i].callback !== callback) continue
+
+      registry.splice(i, 1)
+      if (registry.length === 0) delete this.registrys[type]
+      return
+    }
+  }
+
+  trigger<K extends keyof T>(type: K, ...args: Parameters<CallbackCollection<T>[K]>): void
+  trigger(type: string, ...args: any[]): void
+  trigger<K extends keyof T>(type: K, ...args: Parameters<CallbackCollection<T>[K]>) {
+    let registry = this.registrys[type]
+    if (registry === undefined) return //console.warn(`无法触发该事件 ${type as string}`)
+
+    if (registry.length === 0) return
+
+    registry = [...this.registrys[type]]
+    for (let i = 0; i < registry.length; i++) {
+      registry[i].callback(...args as any)
+      if (registry[i].once === true) this.unlisten(type, registry[i].callback)
+    }
+  }
+}
+export { Listener }

package/src/ObjectPool.ts

@@ -0,0 +1,84 @@
+import { Generate } from "./Generate"
+
+const privateState = {
+  instances: new Map<string, WeakRef<ObjectPool>>(),
+  freeWatcher: [] as Array<(uuid: string) => void>,
+  monitoring: () => {
+    let currentIndex = 0
+
+    const loop = () => {
+      setTimeout(loop, 5000)
+
+      const uuids = [...privateState.instances.keys()]
+      const total = uuids.length
+
+      if (currentIndex >= total) currentIndex = 0
+
+      let count = 0
+      let startIndex = currentIndex
+      const startTime = performance.now()
+
+      while (count < 500 && performance.now() - startTime < 5) {
+        if (startIndex >= total) break
+        count++
+        const uuid = uuids[startIndex++]
+        ObjectPool.get(uuid) === null ? destroyInstance(uuid) : currentIndex++
+      }
+    }
+
+    loop()
+  },
+}
+
+const listenInstance = (type: 'free', watcher: (uuid: string) => void) => {
+  switch (type) {
+    case 'free':
+      privateState.freeWatcher.push(watcher)
+      break;
+    default:
+      break;
+  }
+}
+
+/**将实例销毁并回收相关资源 */
+const destroyInstance = (uuid: string) => {
+  const instance = privateState.instances.get(uuid)
+  if (instance === undefined) return
+  for (const free of privateState.freeWatcher) free(uuid)
+  privateState.instances.delete(uuid)
+}
+
+/**对象池
+ * 
+ * 以`uuid`为标识，同一个`uuid`只会存在一个实例
+ */
+class ObjectPool {
+  /**获取缓存实例 */
+  static get<T extends ObjectPool | null = ObjectPool | null>(uuid: string) {
+    const instance = privateState.instances.get(uuid)
+    if (instance === undefined) return null as T
+    return (instance.deref() ?? null) as T
+  }
+
+  readonly uuid!: string
+  /**
+   * @param uuid 实例的唯一标识
+   */
+  constructor(uuid = Generate.uuid()) {
+    const instance = ObjectPool.get(uuid)
+    if (instance !== null) {
+      instance.beenInstantiated(instance)
+      return instance
+    }
+    this.uuid = uuid
+
+    privateState.instances.set(uuid, new WeakRef(this))
+  }
+
+  /**若在初始化时发现已存在相同uuid的实例，则会调用该方法 */
+  protected beenInstantiated(instance: ObjectPool) { }
+}
+
+privateState.monitoring()
+
+export { listenInstance, destroyInstance, ObjectPool }

package/src/ObjectUtils.ts

@@ -0,0 +1,49 @@
+import { ArrayUtils } from "./ArrayUtils"
+class ObjectUtils {
+
+    static equals(left: { [k: string]: any }, right: { [k: string]: any }, ignore: string[] = []) {
+        const keys = Object.keys(left)
+        const rkeys = Object.keys(right)
+        if (keys.length !== rkeys.length) return false
+        const rset = new Set(rkeys)
+        for (const key of keys) {
+            if (rset.has(key) === false) return false
+            if (ignore.includes(key)) continue
+
+            const value = left[key]
+            const t = typeof value
+
+            if (t === 'string' || t === 'boolean' || t === 'number' || t === 'bigint' || t === 'undefined' || t === 'symbol' || t === null) {
+                if (value !== right[key]) return false
+            }
+
+            if (Array.isArray(value)) {
+                if (ArrayUtils.equals(value, right[key], ignore) == false) return false
+                continue
+            }
+
+            if (t === 'object') {
+                if (ObjectUtils.equals(value, right[key], ignore) === false) return false
+                continue
+            }
+        }
+
+        return true
+    }
+
+    static parseKey(key: string) {
+        return key.split('.').filter(clip => clip !== '')
+    }
+    
+    static getValueByKey(target: { [k: string]: any }, key: string) {
+        if (!target) return
+        const keys = this.parseKey(key)
+        for (const key of keys) {
+            target = target[key]
+            if (target === undefined) return
+        }
+        return target
+    }
+}
+
+export { ObjectUtils }

package/src/Scriptable.ts

@@ -0,0 +1,27 @@
+import { Descriptor, UpdateArgs } from "./descriptor"
+import { Graphics } from "./graphics/Graphics"
+
+/**
+ * 可编程脚本(脚本不会在服务端实例化)
+ */
+class Scriptable {
+    readonly uuid
+    /**脚本文件的url路径 */
+    get url() {
+        return this.uuid
+    }
+
+    constructor(url: string) {
+        this.uuid = url
+    }
+
+    /**脚本的准备事件，该方法在脚本被实例化后立即执行
+     * 
+     * 一般在该事件中进行脚本的准备工作，如从服务端获取资源或数据
+     */
+    async ready() { }
+
+    execute(descriptor: Descriptor, graphics: Graphics, args: UpdateArgs): any { }
+}
+
+export { Scriptable }

package/src/Serialization.ts

@@ -0,0 +1,49 @@
+interface SerializationObject {
+  [k: string]: any
+}
+
+type DeserializationObject<T extends { [k: string]: any } = { [k: string]: any }> = {
+  -readonly [K in keyof T as T[K] extends Function ? never : K]:
+  T[K] extends Array<infer U>
+  ? U extends { [k: string]: any }
+  ? Array<DeserializationObject<U>>
+  : T[K]
+  : T[K] extends object
+  ? DeserializationObject<T[K]>
+  : T[K]
+};
+
+const privateRules = [
+  { parse: Infinity, stringify: '__vyr_infinity+__', },
+  { parse: -Infinity, stringify: '__vyr_infinity-__', },
+]
+
+const privateToStringify = (key: string, value: any) => {
+  for (const rule of privateRules) {
+    if (rule.parse === value) return rule.stringify
+  }
+  return value
+}
+const privateToJson = (key: string, value: any) => {
+  for (const rule of privateRules) {
+    if (rule.stringify === value) return rule.parse
+  }
+  return value
+}
+
+class Serialization {
+
+  static stringify(obj: SerializationObject) {
+    return JSON.stringify(obj, privateToStringify)
+  }
+
+  static parse(str: string) {
+    return JSON.parse(str, privateToJson) as DeserializationObject
+  }
+
+  static deepClone<T extends any = any>(obj: SerializationObject) {
+    return this.parse(this.stringify(obj)) as T
+  }
+}
+
+export { SerializationObject, DeserializationObject, Serialization }

package/src/Traverser.ts

@@ -0,0 +1,39 @@
+interface TraverseNode {
+    children: TraverseNode[]
+}
+interface PreItem<T extends TraverseNode = TraverseNode> {
+    parent: T | null
+    des: T
+}
+
+/**遍历器 */
+class Traverser {
+
+    /**前序遍历 */
+    static pre<T extends TraverseNode = TraverseNode, D extends T | null = null>(descriptor: T, cb: (sub: T, parent: D) => void, defaultParent: D = null as D) {
+        const whileQuaua: PreItem<T>[] = [{ parent: defaultParent, des: descriptor }]
+
+        while (whileQuaua.length > 0) {
+            const item = whileQuaua.pop() as PreItem<T>
+            cb(item.des, item.parent as D)
+            for (let i = item.des.children.length - 1; i >= 0; i--) {
+                whileQuaua.push({ parent: item.des, des: item.des.children[i] as T })
+            }
+        }
+    }
+
+    /**前序遍历且可以终止 */
+    static preTerminated<T extends TraverseNode = TraverseNode, D extends T | null = null>(descriptor: T, cb: (sub: T, parent: D) => true | void, defaultParent: D = null as D) {
+        const whileQuaua: PreItem<T>[] = [{ parent: defaultParent, des: descriptor }]
+
+        while (whileQuaua.length > 0) {
+            const item = whileQuaua.pop() as PreItem<T>
+            if (cb(item.des, item.parent as D) === true) continue
+            for (let i = item.des.children.length - 1; i >= 0; i--) {
+                whileQuaua.push({ parent: item.des, des: item.des.children[i] as T })
+            }
+        }
+    }
+}
+
+export { Traverser }

package/src/actor/Actor.ts

@@ -0,0 +1,28 @@
+import { Graphics } from '../graphics/Graphics'
+
+const privateState = {
+    idBuilder: 0,
+    collection: new Map<number, Graphics>()
+}
+
+class Actor {
+    static seGraphics(actor: Actor, graphics: Graphics) {
+        privateState.collection.set(actor.id, graphics)
+    }
+    static getGraphics<T extends Graphics = Graphics>(actor: Actor) {
+        return (privateState.collection.get(actor.id) ?? null) as T
+    }
+    static deleteGraphics(actor: Actor) {
+        privateState.collection.delete(actor.id)
+    }
+    readonly id = privateState.idBuilder++
+    object?: any
+
+    add(actor: Actor) { }
+
+    remove(actor: Actor) { }
+}
+
+export {
+    Actor,
+}

package/src/actor/AnimationUnitActor.ts

@@ -0,0 +1,289 @@
+import { Euler, Quaternion, Vector2, Vector3 } from "../math"
+import { AnimationUnitDescriptor, Descriptor, UpdateArgs } from "../descriptor"
+import { AnimationUnitInterpreter } from "../interpreter"
+import { Graphics } from "../graphics"
+import { ObjectUtils } from '../ObjectUtils'
+import { Color } from '../Color'
+import { Actor } from "./Actor"
+
+abstract class AnimationUnitActor extends Actor {
+    static parse(descriptor: AnimationUnitDescriptor) {
+        switch (descriptor.frameData.type) {
+            case 'number':
+                return new NumberAnimationUnitargetActor(descriptor, descriptor.frameData.startValue, descriptor.frameData.endValue)
+            case 'vector2':
+                return new Vector2AnimationUnitargetActor(descriptor, new Vector2(...descriptor.frameData.startValue), new Vector2(...descriptor.frameData.endValue))
+            case 'vector3':
+                return new Vector3AnimationUnitargetActor(descriptor, new Vector3(...descriptor.frameData.startValue), new Vector3(...descriptor.frameData.endValue))
+            case 'euler':
+                return new EulerAnimationUnitargetActor(descriptor, new Euler(...descriptor.frameData.startValue), new Euler(...descriptor.frameData.endValue))
+            case 'boolean':
+                return new BooleanAnimationUnitargetActor(descriptor, descriptor.frameData.startValue, descriptor.frameData.endValue)
+            case 'color':
+                return new ColorAnimationUnitargetActor(descriptor, new Color(descriptor.frameData.startValue), new Color(descriptor.frameData.endValue))
+        }
+    }
+
+    play: boolean
+    startTime: number
+    duration: number
+    mode: number
+    path: string
+    keys: string[]
+    count: number
+    uptime: number
+    unlisten!: () => void
+    target!: Descriptor
+    rawValue!: any
+
+    constructor(descriptor: AnimationUnitDescriptor) {
+        super()
+        this.play = descriptor.play
+        this.startTime = descriptor.startTime
+        this.duration = descriptor.duration
+        this.mode = descriptor.mode
+        this.path = descriptor.path
+        this.keys = ObjectUtils.parseKey(descriptor.path)
+        this.count = descriptor.count
+        this.uptime = 0
+    }
+
+    listen(graphics: Graphics) {
+        graphics.engine.listen('afterRender', this.update)
+        this.unlisten = () => {
+            graphics.engine.unlisten('afterRender', this.update)
+            this.reset()
+        }
+    }
+
+    setTarget(descriptor: Descriptor) {
+        this.target = descriptor
+        let rawValue = descriptor as any
+        for (const key of this.keys) {
+            rawValue = rawValue[key]
+            if (rawValue === undefined) return
+        }
+        this.rawValue = Descriptor.deepClone(rawValue)
+    }
+
+    getRadio(radio: number, count: number) {
+        if (this.mode === 2) {
+            radio = (count % 2 === 1) ? 1 - radio : radio
+        }
+        return radio
+    }
+
+    abstract setValue(radio: number): void
+
+    traverseWithTailCallback(set: (target: any, key: string) => void) {
+        let target: { [k: string]: any } = this.target
+        const count = this.keys.length - 1
+        for (let i = 0; i <= count; i++) {
+            if (i === count) {
+                const key = this.keys[i]
+                if (target[key] === undefined) return
+                set(target, key)
+                this.target.setNeedsUpdate()
+            } else {
+                target = target[this.keys[i]]
+                if (!target) return
+            }
+        }
+    }
+
+    update = (args: UpdateArgs) => {
+        if (AnimationUnitInterpreter.enabled === false) return
+        if (this.play === false) return
+        const uptime = this.uptime + args.delta
+
+        const count = (this.uptime - this.startTime) / this.duration
+        if (count > this.count) {
+            this.uptime = uptime
+            return
+        }
+
+        const currentTime = uptime - this.startTime
+        if (currentTime < 0) {
+            this.uptime = uptime
+            return
+        }
+
+        const currentCount = currentTime / this.duration
+
+        let radio
+        if (currentCount > this.count) {
+            if (this.mode === 2) {
+                radio = this.count % 2 === 1 ? 1 : 0
+            } else {
+                radio = 1
+            }
+        } else {
+            radio = this.getRadio(currentCount % 1, Math.floor(currentCount))
+        }
+        this.setValue(radio)
+        this.uptime = uptime
+    }
+
+    reset(time = 0) {
+        this.uptime = 0
+        this.traverseWithTailCallback((target, key) => {
+            target[key] = Descriptor.deepClone(this.rawValue)
+        })
+        this.update({ delta: time })
+    }
+}
+
+class NumberAnimationUnitargetActor extends AnimationUnitActor {
+    startValue
+    distance
+
+    constructor(descriptor: AnimationUnitDescriptor, startValue: number, endValue: number) {
+        super(descriptor)
+        this.startValue = startValue
+        this.distance = endValue - startValue
+    }
+
+    setValue(radio: number) {
+        const value = this.startValue + this.distance * radio
+        this.traverseWithTailCallback((target, key) => {
+            target[key] = value
+        })
+    }
+}
+
+let _vector2: Vector2 | null = null
+class Vector2AnimationUnitargetActor extends AnimationUnitActor {
+    static get vector() {
+        if (_vector2 === null) {
+            _vector2 = new Vector2()
+        }
+        return _vector2
+    }
+    startValue: Vector2
+    endValue: Vector2
+    constructor(descriptor: AnimationUnitDescriptor, startValue: Vector2, endValue: Vector2) {
+        super(descriptor)
+        this.startValue = startValue
+        this.endValue = endValue
+    }
+
+    setValue(radio: number) {
+        this.traverseWithTailCallback((target, key) => {
+            Vector2AnimationUnitargetActor.vector.lerpVectors(this.startValue, this.endValue, radio)
+            target[key].x = Vector2AnimationUnitargetActor.vector.x
+            target[key].y = Vector2AnimationUnitargetActor.vector.y
+        })
+    }
+}
+
+let _vector3: Vector3 | null = null
+class Vector3AnimationUnitargetActor extends AnimationUnitActor {
+    static get vector() {
+        if (_vector3 === null) {
+            _vector3 = new Vector3()
+        }
+        return _vector3
+    }
+    declare startValue: Vector3
+    declare endValue: Vector3
+    constructor(descriptor: AnimationUnitDescriptor, startValue: Vector3, endValue: Vector3) {
+        super(descriptor)
+        this.startValue = startValue
+        this.endValue = endValue
+    }
+    setValue(radio: number) {
+        this.traverseWithTailCallback((target, key) => {
+            Vector3AnimationUnitargetActor.vector.lerpVectors(this.startValue, this.endValue, radio)
+            target[key].x = Vector3AnimationUnitargetActor.vector.x
+            target[key].y = Vector3AnimationUnitargetActor.vector.y
+            target[key].z = Vector3AnimationUnitargetActor.vector.z
+        })
+    }
+}
+
+let _euler: Euler | null = null
+let _startQuat: Quaternion | null = null
+let _endQuat: Quaternion | null = null
+class EulerAnimationUnitargetActor extends AnimationUnitActor {
+    static get euler() {
+        if (_euler === null) {
+            _euler = new Euler()
+        }
+        return _euler
+    }
+    static get startQuat() {
+        if (_startQuat === null) {
+            _startQuat = new Quaternion()
+        }
+        return _startQuat
+    }
+    static get endQuat() {
+        if (_endQuat === null) {
+            _endQuat = new Quaternion()
+        }
+        return _endQuat
+    }
+    declare startValue: Euler
+    declare endValue: Euler
+    constructor(descriptor: AnimationUnitDescriptor, startValue: Euler, endValue: Euler) {
+        super(descriptor)
+        this.startValue = startValue
+        this.endValue = endValue
+    }
+    setValue(radio: number) {
+        this.traverseWithTailCallback((target, key) => {
+            EulerAnimationUnitargetActor.startQuat.setFromEuler(this.startValue)
+            EulerAnimationUnitargetActor.endQuat.setFromEuler(this.endValue)
+            EulerAnimationUnitargetActor.startQuat.slerp(EulerAnimationUnitargetActor.endQuat, radio)
+            EulerAnimationUnitargetActor.euler.setFromQuaternion(EulerAnimationUnitargetActor.startQuat)
+            target[key].x = EulerAnimationUnitargetActor.euler.x
+            target[key].y = EulerAnimationUnitargetActor.euler.y
+            target[key].y = EulerAnimationUnitargetActor.euler.y
+            target[key].order = EulerAnimationUnitargetActor.euler.order
+        })
+    }
+}
+
+class BooleanAnimationUnitargetActor extends AnimationUnitActor {
+    declare startValue: number
+    declare endValue: number
+    constructor(descriptor: AnimationUnitDescriptor, startValue: number, endValue: number) {
+        super(descriptor)
+        this.startValue = startValue
+        this.endValue = endValue
+    }
+    setValue(radio: number) {
+        switch (radio) {
+            case 0:
+                this.traverseWithTailCallback((target, key) => {
+                    target[key] = this.startValue
+                })
+                break
+            case 1:
+                this.traverseWithTailCallback((target, key) => {
+                    target[key] = this.endValue
+                })
+                break
+        }
+    }
+}
+
+class ColorAnimationUnitargetActor extends AnimationUnitActor {
+    declare startValue: Color
+    declare endValue: Color
+    constructor(descriptor: AnimationUnitDescriptor, startValue: Color, endValue: Color) {
+        super(descriptor)
+        this.startValue = startValue
+        this.endValue = endValue
+    }
+    setValue(radio: number) {
+        this.traverseWithTailCallback((target, key) => {
+            const currentValue = Color.mix(this.startValue, this.endValue, radio)
+            target[key] = currentValue.toHexString()
+        })
+    }
+}
+
+export {
+    AnimationUnitActor
+}

package/src/actor/DivActor.ts

@@ -0,0 +1,70 @@
+import { DivDescriptor, StyleDescriptor, UpdateArgs } from "../descriptor"
+import { Actor } from "./Actor"
+import { HTMLActor } from "./HTMActor"
+
+class DivActor extends HTMLActor {
+    private _text: Text | null = null
+    get text() {
+        if (this._text === null) {
+            this._text = document.createTextNode('')
+        }
+        return this._text
+    }
+    private _wrapper: HTMLElement | null = null
+    readonly DOM
+
+    constructor(uuid: string) {
+        super(uuid)
+        this.DOM = this.createDOM()
+        const wrapper = this.getWrapper()
+        wrapper.appendChild(this.DOM)
+    }
+
+    protected createWrapper() {
+        const wrapper = document.createElement('div')
+        wrapper.setAttribute('class', HTMLActor.className)
+        wrapper.setAttribute(HTMLActor.uuidKey, this.uuid)
+        return wrapper
+    }
+
+    getWrapper() {
+        if (this._wrapper === null) {
+            this._wrapper = this.createWrapper()
+        }
+
+        return this._wrapper
+    }
+
+    add(actor: Actor) {
+        if (actor instanceof HTMLActor) {
+            const wrapper = actor.getWrapper()
+            if (wrapper === null) return
+            if (this.DOM.contains(wrapper)) return
+            this.DOM.appendChild(wrapper)
+        }
+    }
+
+    remove(actor: Actor) {
+        if (actor instanceof HTMLActor) {
+            const wrapper = actor.getWrapper()
+            if (wrapper === null) return
+            if (this.DOM.contains(wrapper)) this.DOM.removeChild(wrapper)
+        }
+    }
+
+    update(descriptor: DivDescriptor, args: UpdateArgs) {
+        const wrapper = this.getWrapper()
+        const style = this.getWrapperStyle(descriptor, args)
+        this.setHTMLStyle(wrapper, style)
+        this.setHTMLInteraction(wrapper, descriptor, args)
+        this.setHTMLStyle(this.DOM, this.getLayoutStyle(descriptor, args))
+        const styleClass = [...this.getStyleClass(descriptor, args)]
+        if (descriptor.active) styleClass.push(StyleDescriptor.activeName)
+        this.setStyleClass(this.DOM, styleClass)
+        this.DOM.style.backgroundImage = descriptor.backroundIamge ? `url(${descriptor.backroundIamge})` : ''
+        this.text.textContent = descriptor.text
+        if (this.DOM.contains(this.text) === false) this.DOM.appendChild(this.text)
+    }
+}
+
+export { DivActor }