@vyr/engine 0.0.1

package/src/descriptor/ControllerDescriptor.ts

@@ -0,0 +1,16 @@
+import { DeserializationObject } from "../Serialization"
+import { Descriptor } from "./Descriptor"
+
+class ControllerDescriptor extends Descriptor {
+    static type = 'Controller'
+
+    /**控制器是否响应用户的操作 */
+    enabled: boolean
+
+    constructor(descriptor: Partial<DeserializationObject<ControllerDescriptor>> = {}) {
+        super(descriptor)
+        this.enabled = descriptor.enabled ?? false
+    }
+}
+
+export { ControllerDescriptor }

package/src/descriptor/DatasetDescriptor.ts

@@ -0,0 +1,92 @@
+import { Asset } from "../asset";
+import { observer } from "../graphics/Observer";
+import { DeserializationObject } from "../Serialization";
+import { Descriptor } from "./Descriptor";
+
+interface Data {
+    [k: string]: any
+}
+
+class DatasetDescriptor extends Descriptor {
+    static type = 'Dataset'
+
+    static getData<T = Data>(dataset: string) {
+        const descriptor = Asset.get(dataset)
+        if (descriptor instanceof DatasetDescriptor) {
+            return descriptor.getData() as T
+        } else {
+            return null
+        }
+    }
+    static getCollection<T = Data>(dataset: string): T[] {
+        const data = this.getData<T>(dataset)
+
+        if (!data) return []
+
+        return Array.isArray(data) ? data : [data]
+    }
+
+    private _extraData: Data = {}
+    private _data!: Data
+    defaultData: Data
+    url: string
+    auto: boolean
+
+    constructor(descriptor: Partial<DeserializationObject<DatasetDescriptor>> = {}) {
+        super(descriptor)
+        this.defaultData = descriptor.defaultData === undefined ? {} : Descriptor.deepClone(descriptor.defaultData)
+        this.url = descriptor.url ?? ''
+        this.auto = descriptor.auto ?? true
+        this._updateData(this.defaultData)
+    }
+
+    async fetch() {
+        if (!this.url) return
+        try {
+            const res = await Asset.fetch(Asset.joinUrl(this.url))
+            const data = await res.json()
+
+            if (Object.hasOwn(data, 'data')) {
+                if (data.data !== null && typeof data.data === 'object') this.setData(data.data)
+            } else {
+                this.setData(data)
+            }
+        } catch (error) {
+            console.warn(error)
+        }
+    }
+
+    private _updateData(data: Data) {
+        this._data = data
+    }
+
+    getData<T extends Data | null = Data | null>() {
+        return (this._data ?? null) as T
+    }
+
+    setData(data: Data) {
+        this._updateData(data)
+
+        observer.trigger('updateDeps', { self: this.uuid })
+    }
+
+    setExtraData(data: Data) {
+        this._extraData = data
+    }
+
+    getExtraData<T extends Data = Data>() {
+        return this._extraData as T
+    }
+
+    toJSON() {
+        const { _data, _extraData, ...rest } = this;
+        return rest;
+    }
+}
+
+Descriptor.register(DatasetDescriptor)
+
+export {
+    Data,
+    DatasetDescriptor
+}

package/src/descriptor/Descriptor.ts

@@ -0,0 +1,415 @@
+import { language } from '../locale'
+import { listenInstance, ObjectPool } from '../ObjectPool'
+import { ArrayUtils } from '../ArrayUtils'
+import { Generate } from '../Generate'
+import { Traverser } from '../Traverser'
+import { ObjectUtils } from '../ObjectUtils'
+import { DeserializationObject, Serialization, SerializationObject } from '../Serialization'
+import { AssetProperty, AssetPropertyCollection } from '../asset'
+import { observer } from '../graphics/Observer'
+
+/**描述器祖先节点 */
+interface DescriptorAncestor<T extends Descriptor = Descriptor> {
+    parent: T | null,
+    uuids: string[]
+    collection: Descriptor[]
+}
+
+/**当前描述器节点的邻接关系 */
+interface DescriptorAdjacency {
+    /**当前节点的父节点 */
+    parent: string
+    /**当前节点的前一个节点 */
+    prev: string
+    /**当前节点的后一个节点 */
+    next: string
+}
+
+interface DescriptorPrefab {
+    root: string
+    uuid: string
+}
+
+interface UpdateArgs {
+    delta: number
+}
+
+interface VariabConfig {
+    type: 'key' | 'custom'
+    enabled: boolean
+    value: string
+}
+
+interface DescriptorVariables {
+    [k: string]: VariabConfig
+}
+interface InteractionInput {
+    [param: string]: {
+        type?: 'data' | string
+        value: any
+    }
+}
+
+interface InteractionInputCollection {
+    [id: string]: InteractionInput
+}
+
+interface InteractionProperty extends AssetProperty {
+    uuid: string
+    type: string
+    inputs: InteractionInputCollection
+}
+
+interface InteractionPropertyCollection extends AssetPropertyCollection<InteractionProperty> { }
+
+const privateState = {
+    classCollection: new Map<string, typeof Descriptor>(),
+    prefabToInstanceCollection: new Map<string, string[]>(),
+    instanceToPrefabCollection: new Map<string, string>(),
+    refGraph: new Map<string, string>(),
+    getParent: <T extends Descriptor = Descriptor>(uuid: string) => {
+        const parent = privateState.refGraph.get(uuid)
+        if (parent === undefined) return null
+        return Descriptor.get<T>(parent)
+    },
+    setPrefabInstance(instance: Descriptor) {
+        if (instance.prefab === false) return
+
+        let instanceCollection = this.prefabToInstanceCollection.get(instance.prefab.uuid)
+        if (instanceCollection === undefined) {
+            instanceCollection = []
+            this.prefabToInstanceCollection.set(instance.prefab.uuid, instanceCollection)
+        }
+
+        ArrayUtils.insert(instanceCollection, instance.uuid)
+        this.instanceToPrefabCollection.set(instance.uuid, instance.prefab.uuid)
+    },
+    markclone: (descriptor: Descriptor, root: string, map: Map<string, Descriptor>, childs: Descriptor[]) => {
+        const clone = descriptor.clone(false)
+        map.set(descriptor.uuid, clone)
+        if (clone.interactions.length > 0) childs.push(clone)
+
+        if (clone.prefab === false) {
+            clone.prefab = { root, uuid: descriptor.uuid }
+        }
+
+        for (const sub of descriptor.children) {
+            const child = privateState.markclone(sub, root, map, childs)
+            clone.add(child)
+        }
+
+        return clone
+    }
+}
+
+
+/**
+ * 描述引擎所使用的场景、资产对象
+ * 
+ * 每一个派生类的需要重新定义该类的静态属性`type`
+ * 
+ * 描述器不能使用浏览器环境特有API，因为服务端也会使用描述器
+ * 
+ * 不建议将一个描述器作为另一个描述器的属性，若要保持引用关系，将描述器的uuid作为属性即可
+ */
+class Descriptor extends ObjectPool {
+    static type = 'Descriptor'
+    /**注册描述器的派生类 */
+    static register(DerivedClass: typeof Descriptor) {
+        privateState.classCollection.set(DerivedClass.type, DerivedClass)
+    }
+    /**获取注册的派生类 */
+    static getClass<T extends typeof Descriptor>(type: string) {
+        return (privateState.classCollection.get(type) ?? null) as T | null
+    }
+    /**使用数据动态的创建描述器 */
+    static create<T extends Descriptor = Descriptor>(descriptor: Partial<DeserializationObject<Descriptor>>) {
+        const Class = this.getClass(descriptor.type ?? Descriptor.type)
+        if (Class === null) throw language.get('descriptor.notRegister', { type: descriptor.type })
+        return new Class(descriptor) as T
+    }
+    /**将对象序列化成json字符 */
+    static serialization(descriptor: SerializationObject) {
+        return Serialization.stringify(descriptor)
+    }
+    /**将json字符反序列化成对象 */
+    static deserialization<T = any>(str: string) {
+        return Serialization.parse(str) as T
+    }
+    /**深度克隆传入的JSON对象 */
+    static deepClone<T = any>(descriptor: SerializationObject) {
+        return Serialization.deepClone<T>(descriptor)
+    }
+    /**修复引用关系 */
+    static fixReferences(childs: Descriptor[], map: Map<string, Descriptor>) {
+        for (const child of childs) {
+            for (const interaction of child.interactions) {
+                const keys = Object.keys(interaction.inputs)
+                for (const key of keys) {
+                    const input = interaction.inputs[key]
+                    const attrs = Object.keys(input)
+                    for (const attr of attrs) {
+                        const cur = input[attr]
+                        const clone = map.get(cur.value)
+                        if (clone === undefined) continue
+                        cur.value = clone.uuid
+                    }
+                }
+            }
+        }
+    }
+    /**创建镜像副本并修复引用关系 */
+    static cloneAndFixReferences(descriptor: Descriptor) {
+        const map = new Map()
+        const childs: Descriptor[] = []
+        const clone = privateState.markclone(descriptor, descriptor.uuid, map, childs)
+        this.fixReferences(childs, map)
+
+        return clone
+    }
+
+    static getPrefab(uuid: string) {
+        return privateState.instanceToPrefabCollection.get(uuid) ?? null
+    }
+    static getInstanceCollection(uuid: string) {
+        return privateState.prefabToInstanceCollection.get(uuid) ?? null
+    }
+
+    readonly type: string
+    readonly children: Descriptor[]
+    generatedBy = ''
+    name: string
+    dataset: string
+    variables: DescriptorVariables
+    interactions: InteractionPropertyCollection
+    selectable: boolean
+    prefab: DescriptorPrefab | false
+
+    constructor(descriptor: Partial<DeserializationObject<Descriptor>> = {}) {
+        super(descriptor.uuid)
+
+        this.type = (this.constructor as typeof Descriptor).type
+        this.name = descriptor.name ?? ''
+        this.dataset = descriptor.dataset ?? ''
+        this.variables = descriptor.variables ? Descriptor.deepClone(descriptor.variables) : {}
+        this.interactions = descriptor.interactions ? Descriptor.deepClone(descriptor.interactions) : []
+        this.selectable = descriptor.selectable ?? true
+        this.prefab = descriptor.prefab ? Descriptor.deepClone(descriptor.prefab) : false
+        //@ts-ignore
+        this.children = []
+
+        privateState.setPrefabInstance(this)
+
+        if (Array.isArray(descriptor.children) && descriptor.children.length > 0) {
+            for (const subDescriptor of descriptor.children) this.add(Descriptor.create(subDescriptor))
+        }
+    }
+
+    protected beenInstantiated(instance: Descriptor): void {
+        instance.clear()
+    }
+
+    /**将`descriptor`添加到此节点中*/
+    add(...descriptor: Descriptor[]) {
+
+        for (const sub of descriptor) {
+            if (this.children.indexOf(sub) > -1) continue
+
+            const ancestor = sub.traceAncestor(false)
+            if (ancestor.parent !== null) ancestor.parent.remove(sub)
+
+            this.children.push(sub)
+            privateState.refGraph.set(sub.uuid, this.uuid)
+
+            observer.trigger('add', { self: sub.uuid, puid: this.uuid })
+        }
+    }
+    /**将`descriptor`从此节点中移除*/
+    remove(...descriptor: Descriptor[]) {
+        for (const sub of descriptor) {
+            for (let i = 0; i < this.children.length; i++) {
+                if (this.children[i].uuid !== sub.uuid) continue
+
+                observer.trigger('remove', { self: sub.uuid, puid: this.uuid })
+
+                this.children.splice(i, 1)
+                privateState.refGraph.delete(sub.uuid)
+                break
+            }
+        }
+    }
+    /**
+     * 追踪描述器的祖先节点
+     * @param all 追踪全部的祖先节点，默认为true
+     */
+    traceAncestor<T extends Descriptor = Descriptor>(all = true, depth = Infinity) {
+        let parent = privateState.getParent<T>(this.uuid)
+        const ancestor: DescriptorAncestor<T> = { parent, uuids: [], collection: [] }
+        if (parent === null) return ancestor
+
+        ancestor.collection.push(parent)
+        ancestor.uuids.push(parent.uuid)
+
+        if (all === true) {
+            let count = 1
+            parent = privateState.getParent(parent.uuid) as T
+            while (parent && count < depth) {
+                count++
+                ancestor.collection.push(parent)
+                ancestor.uuids.push(parent.uuid)
+                parent = privateState.getParent(parent.uuid) as T
+            }
+        }
+
+        return ancestor
+    }
+
+    /**将`uuid`节点插入到`target`节点中。*/
+    insert(uuid: string, target: string) {
+        const insertNode = Descriptor.get<Descriptor>(uuid)
+        if (insertNode === null) return console.warn(language.get('descriptor.insert.uuid.notFound', { uuid }))
+
+        const targetNode = Descriptor.get<Descriptor>(target)
+        if (targetNode === null) return console.warn(language.get('descriptor.insert.target.notFound', { target }))
+
+        const ancestor = insertNode.traceAncestor(false)
+        if (ancestor.parent) ancestor.parent.remove(insertNode)
+        targetNode.add(insertNode)
+    }
+
+    /**将`uuid`节点插入到`target`节点前。 */
+    insertBefore(uuid: string, target: string, offset = 0) {
+        const insertNode = Descriptor.get<Descriptor>(uuid)
+        if (insertNode === null) return console.warn(language.get('descriptor.insert.uuid.notFound', { uuid }))
+
+        const targetNode = Descriptor.get<Descriptor>(target)
+        if (targetNode === null) return console.warn(language.get('descriptor.insert.target.notFound', { target }))
+        const targetAncestor = targetNode.traceAncestor(false)
+        if (targetAncestor.parent === null) return
+        const targetParent = targetAncestor.parent
+
+        const insertAncestor = insertNode.traceAncestor(false)
+        if (insertAncestor.parent !== null) insertAncestor.parent.remove(insertNode)
+
+        let index = -1
+
+        for (let i = 0; i < targetParent.children.length; i++) {
+            const sub = targetParent.children[i]
+            if (sub === targetNode) index = i + offset;
+            observer.trigger('remove', { self: sub.uuid, puid: targetParent.uuid })
+        }
+
+        targetParent.children.splice(index, 0, insertNode)
+        privateState.refGraph.set(insertNode.uuid, targetParent.uuid)
+
+        for (const sub of targetParent.children) {
+            observer.trigger('add', { self: sub.uuid, puid: targetParent.uuid })
+        }
+    }
+    /**将`uuid`节点插入到`target`节点后。 */
+    insertAfter(uuid: string, target: string) {
+        return this.insertBefore(uuid, target, 1)
+    }
+
+    /**获取当前节点的邻接节点 */
+    getAdjacent() {
+        const adjacent: DescriptorAdjacency = {
+            parent: '',
+            prev: '',
+            next: '',
+        }
+        const ancestor = this.traceAncestor(false)
+        if (ancestor.parent === null) return adjacent
+
+        adjacent.parent = ancestor.parent.uuid
+        const i = ancestor.parent.children.indexOf(this)
+        if (i > 0) adjacent.prev = ancestor.parent.children[i - 1].uuid
+        if (i < ancestor.parent.children.length - 1) adjacent.next = ancestor.parent.children[i + 1].uuid
+
+        return adjacent
+    }
+
+    /**
+     * 克隆一个新的描述器
+     * 
+     * 注意，该方法返回的描述器与原描述器uuid不相同
+     * @param recursive 是否遍历克隆子节点，默认为true
+     */
+    clone<T extends Descriptor = Descriptor>(recursive = true) {
+        const uuid = Generate.uuid()
+        const self = Descriptor.create<T>({ ...this, uuid, children: undefined }) as T
+        if (recursive === false) return self
+        for (const sub of this.children) self.add(sub.clone(recursive))
+        return self
+    }
+    /**从同类型的对象上同步属性，不同步`uuid`、`children`和`type` */
+    syncWith(descriptor: DeserializationObject<Descriptor>, ignore: string[] = []) {
+        if (this.type !== descriptor.type) return console.warn(language.get('descriptor.syncWith.fail'))
+
+        const source = Descriptor.create({ ...descriptor, type: this.type, uuid: undefined, children: undefined }) as DeserializationObject
+        delete source['uuid']
+        delete source['type']
+        delete source['children']
+        delete source['prefab']
+        delete source['generatedBy']
+
+        for (const key of ignore) delete source[key]
+
+        Object.assign(this, source)
+    }
+    /**
+     * 遍历所有节点
+     * @param cb 遍历每个节点执行的回调
+     * @param terminated 遍历是否可以被终止，默认false
+     */
+    traverse<T extends Descriptor = Descriptor, D extends T | null = T | null>(cb: (sub: T, parent: D) => true | void, terminated = false, defaultParent: D = null as D) {
+        if (terminated) {
+            Traverser.preTerminated(this as unknown as T, cb, defaultParent)
+        } else {
+            Traverser.pre(this as unknown as T, cb, defaultParent)
+        }
+    }
+    /**将子描述器全部移除 */
+    clear() {
+        this.remove(...this.children)
+    }
+
+    /**将对象序列化成json字符 */
+    serialization() {
+        return Descriptor.serialization(this)
+    }
+
+    equals(descriptor: DeserializationObject<Descriptor>, ignore: string[] = ['children']) {
+        return ObjectUtils.equals(this, descriptor, ignore)
+    }
+
+    setNeedsUpdate() {
+        observer.trigger('update', { self: this.uuid })
+    }
+}
+Descriptor.register(Descriptor)
+
+listenInstance('free', (uuid: string) => {
+    observer.trigger('free', { self: uuid })
+    privateState.refGraph.delete(uuid)
+    const prefab = privateState.instanceToPrefabCollection.get(uuid)
+    if (prefab === undefined) return
+    privateState.instanceToPrefabCollection.delete(uuid)
+    const instanceCollection = privateState.prefabToInstanceCollection.get(uuid)
+    if (instanceCollection === undefined) return
+    ArrayUtils.remove(instanceCollection, uuid)
+})
+
+export {
+    Descriptor,
+    UpdateArgs,
+    DescriptorAdjacency,
+    DescriptorAncestor,
+    DescriptorPrefab,
+    VariabConfig,
+    DescriptorVariables,
+    InteractionInput,
+    InteractionInputCollection,
+    InteractionProperty,
+    InteractionPropertyCollection,
+}

package/src/descriptor/DivDescriptor.ts

@@ -0,0 +1,18 @@
+import { DeserializationObject } from "../Serialization"
+import { HTMLDescriptor } from "./HTMLDescriptor"
+
+class DivDescriptor extends HTMLDescriptor {
+  static type = 'Div'
+
+  text: string
+  backroundIamge: string
+
+  constructor(descriptor: Partial<DeserializationObject<DivDescriptor>> = {}) {
+    super(descriptor)
+    this.text = descriptor.text ?? ''
+    this.backroundIamge = descriptor.backroundIamge ?? ''
+  }
+}
+HTMLDescriptor.register(DivDescriptor)
+
+export { DivDescriptor }

package/src/descriptor/DynamicDescriptor.ts

@@ -0,0 +1,27 @@
+import { DeserializationObject } from "../Serialization"
+import { Descriptor } from "./Descriptor"
+
+class DynamicDescriptor extends Descriptor {
+    static type = 'Dynamic'
+
+    url: string
+    /** 数据集配置
+     * - 1 使用节点自身的数据集
+     * - 2 使用父节点数据集的属性
+     */
+    dataConfig: number
+    /**根节点数据集属性的路径 */
+    dataPath: string
+
+    constructor(descriptor: Partial<DeserializationObject<DynamicDescriptor>> = {}) {
+        super(descriptor)
+        this.url = descriptor.url ?? ''
+        this.dataConfig = descriptor.dataConfig ?? 1
+        this.dataPath = descriptor.dataPath ?? ''
+    }
+}
+Descriptor.register(DynamicDescriptor)
+
+export {
+    DynamicDescriptor
+}

package/src/descriptor/HTMLDescriptor.ts

@@ -0,0 +1,87 @@
+import { Vector2 } from "../math"
+import { DeserializationObject } from "../Serialization"
+import { Descriptor } from "./Descriptor"
+import { StyleSpacing } from "./StyleDescriptor"
+
+interface HTMLStyle {
+    [k: string]: string
+}
+
+class HTMLDescriptor extends Descriptor {
+    static type = 'HTML'
+
+    visible: boolean
+    active: boolean
+    style: string
+    display: string
+    flexWrap: string
+    flexDirection: string
+    justifyContent: string
+    alignItems: string
+    alignContent: string
+    margin: StyleSpacing
+    /** 项目的放大比例，定义在分配多余空间时项目的放大能力，默认0(不放大) */
+    flexGrow: number
+    /**宽度
+     * - -1 宽度根据内容自适应 
+     */
+    width: number
+    wUnit: string
+    calcWidth: number
+    /**高度
+   * - -1 高度根据内容自适应 
+   */
+    height: number
+    hUnit: string
+    calcHeight: number
+
+    position: string
+    location: Vector2
+
+    xAxis: 'left' | 'right'
+    xUnit: string
+
+    yAxis: 'top' | 'bottom'
+    yUnit: string
+
+    translate: Vector2
+
+    opacity: number
+    zIndex: string
+
+    constructor(descriptor: Partial<DeserializationObject<HTMLDescriptor>> = {}) {
+        super(descriptor)
+
+        this.visible = descriptor.visible ?? true
+        this.active = descriptor.active ?? false
+        this.style = descriptor.style ?? ''
+        this.display = descriptor.display ?? 'block'
+        this.flexWrap = descriptor.flexWrap ?? 'nowrap'
+        this.flexDirection = descriptor.flexDirection ?? 'row'
+        this.justifyContent = descriptor.justifyContent ?? 'flex-start'
+        this.alignItems = descriptor.alignItems ?? 'stretch'
+        this.alignContent = descriptor.alignContent ?? 'stretch'
+        this.flexGrow = descriptor.flexGrow ?? 0
+        this.margin = new StyleSpacing(descriptor.margin)
+
+        this.width = descriptor.width ?? 100
+        this.wUnit = descriptor.wUnit ?? 'px'
+        this.calcWidth = descriptor.calcWidth ?? 0
+        this.calcHeight = descriptor.calcHeight ?? 0
+        this.height = descriptor.height ?? 100
+        this.hUnit = descriptor.hUnit ?? 'px'
+        this.position = descriptor.position ?? 'static'
+        this.location = Vector2.create(descriptor.location)
+        this.xAxis = descriptor.xAxis ?? 'left'
+        this.xUnit = descriptor.xUnit ?? 'px'
+        this.yAxis = descriptor.yAxis ?? 'top'
+        this.yUnit = descriptor.yUnit ?? 'px'
+
+        this.translate = Vector2.create(descriptor.translate)
+
+        this.opacity = descriptor.opacity ?? 1
+        this.zIndex = descriptor.zIndex ?? 'auto'
+    }
+}
+
+export { HTMLStyle, HTMLDescriptor }

package/src/descriptor/HTMLServiceDescriptor.ts

@@ -0,0 +1,19 @@
+import { DeserializationObject } from "../Serialization"
+import { ServiceDescriptor } from "./ServiceDescriptor"
+
+class HTMLServiceDescriptor extends ServiceDescriptor {
+    static type = 'HTMLService'
+
+    constructor(descriptor: Partial<DeserializationObject<HTMLServiceDescriptor>> = {}) {
+        super(descriptor)
+        this.width = descriptor.width ?? 100
+        this.wUnit = descriptor.wUnit ?? '%'
+        this.height = descriptor.height ?? 100
+        this.hUnit = descriptor.hUnit ?? '%'
+        this.position = descriptor.position ?? 'absolute'
+    }
+}
+
+ServiceDescriptor.register(HTMLServiceDescriptor)
+
+export { HTMLServiceDescriptor }