@vyr/engine 0.0.1

package/src/descriptor/HTMLTransformControllerDescriptor.ts

@@ -0,0 +1,34 @@
+import { DeserializationObject } from "../Serialization"
+import { ControllerDescriptor } from "./ControllerDescriptor"
+import { UpdateArgs } from "./Descriptor"
+
+interface HTMLTransformControllerChangeArgs extends UpdateArgs {
+    event: {
+        type: string
+        target: string
+    }
+}
+
+class HTMLTransformControllerDescriptor extends ControllerDescriptor {
+    static type = 'HTMLTransformController'
+
+    /**控制器的摄像机 */
+    camera: string
+    /**控制器的模式 */
+    mode: string
+    /**控制器的目标 */
+    target: string
+    /**控制器触发事件时执行的脚本依赖 */
+    event: string
+
+    constructor(descriptor: Partial<DeserializationObject<HTMLTransformControllerDescriptor>> = {}) {
+        super(descriptor)
+        this.camera = descriptor.camera ?? ''
+        this.mode = descriptor.mode ?? ''
+        this.target = descriptor.target ?? ''
+        this.event = descriptor.event ?? ''
+    }
+}
+ControllerDescriptor.register(HTMLTransformControllerDescriptor)
+
+export { HTMLTransformControllerChangeArgs, HTMLTransformControllerDescriptor }

package/src/descriptor/NodeDescriptor.ts

@@ -0,0 +1,32 @@
+import { Euler, Vector3 } from "../math"
+import { DeserializationObject } from "../Serialization"
+import { Descriptor } from "./Descriptor"
+
+class NodeDescriptor extends Descriptor {
+    static type = 'Node'
+    readonly scale: Vector3
+    readonly position: Vector3
+    readonly rotation: Euler
+    layer = 0
+    visible = true
+    renderOrder = 0
+    castShadow = false
+    receiveShadow = false
+
+    constructor(descriptor: Partial<DeserializationObject<NodeDescriptor>> = {}) {
+        super(descriptor)
+        this.scale = descriptor.scale ? Vector3.create(descriptor.scale) : Vector3.create(1, 1, 1)
+        this.position = Vector3.create(descriptor.position)
+        this.rotation = Euler.create(descriptor.rotation)
+        this.layer = descriptor.layer ?? 0
+        this.visible = descriptor.visible ?? true
+        this.renderOrder = descriptor.renderOrder ?? 0
+        this.castShadow = descriptor.castShadow ?? false
+        this.receiveShadow = descriptor.receiveShadow ?? false
+    }
+}
+Descriptor.register(NodeDescriptor)
+
+export {
+    NodeDescriptor
+}

package/src/descriptor/PrefabDescriptor.ts

@@ -0,0 +1,53 @@
+import { DeserializationObject } from "../Serialization"
+import { Descriptor } from "./Descriptor"
+
+class PrefabeDescriptor extends Descriptor {
+    static type = 'Prefab'
+
+    static add(parent: Descriptor, sub: Descriptor) {
+        parent.add(sub)
+
+        const instanceCollection = this.getInstanceCollection(parent.uuid)
+        if (instanceCollection === null) return
+        for (const instance of instanceCollection) {
+            const instanceDescriptor = this.get<Descriptor>(instance)
+            instanceDescriptor.add(sub.clone(true))
+        }
+    }
+
+    static remove(parent: Descriptor, sub: Descriptor) {
+        parent.remove(sub)
+
+        const instanceCollection = this.getInstanceCollection(sub.uuid)
+        if (instanceCollection === null) return
+        for (const instance of instanceCollection) {
+            const instanceDescriptor = this.get<Descriptor>(instance)
+            const ancestor = instanceDescriptor.traceAncestor(false)
+            if (ancestor.parent === null) continue
+            ancestor.parent.remove(instanceDescriptor)
+        }
+    }
+
+    static update(descriptor: Descriptor) {
+        descriptor.setNeedsUpdate()
+
+        const instanceCollection = this.getInstanceCollection(descriptor.uuid)
+        if (instanceCollection === null) return
+        for (const instance of instanceCollection) {
+            const instanceDescriptor = this.get<Descriptor>(instance)
+            instanceDescriptor.syncWith(descriptor)
+            instanceDescriptor.setNeedsUpdate()
+        }
+    }
+
+    category: 'html' | 'scene'
+
+    constructor(descriptor: Partial<DeserializationObject<PrefabeDescriptor>> = {}) {
+        super(descriptor)
+        this.category = descriptor.category ?? 'html'
+    }
+}
+
+Descriptor.register(PrefabeDescriptor)
+
+export { PrefabeDescriptor }

package/src/descriptor/PrefabInstanceDescriptor.ts

@@ -0,0 +1,32 @@
+import { DeserializationObject } from "../Serialization"
+import { Descriptor } from "./Descriptor"
+import { PrefabeDescriptor } from "./PrefabDescriptor"
+
+class PrefabInstanceDescriptor extends Descriptor {
+    static type = 'PrefabInstance'
+
+    static fromPrefab(url: string, descriptor: PrefabeDescriptor) {
+        const clone = Descriptor.cloneAndFixReferences(descriptor)
+
+        const prefabInstance = new PrefabInstanceDescriptor({
+            name: clone.name ? `${clone.name}-prefab` : 'prefab',
+            interactions: clone.interactions,
+            prefab: clone.prefab,
+            url,
+        })
+        prefabInstance.add(...clone.children)
+
+        return prefabInstance
+    }
+
+    readonly url: string
+
+    constructor(descriptor: Partial<DeserializationObject<PrefabInstanceDescriptor>> = {}) {
+        super(descriptor)
+        this.url = descriptor.url ?? ''
+    }
+}
+
+Descriptor.register(PrefabInstanceDescriptor)
+
+export { PrefabInstanceDescriptor }

package/src/descriptor/RoutineDescriptor.ts

@@ -0,0 +1,54 @@
+import { DeserializationObject } from "../Serialization";
+import { Descriptor, InteractionInput, UpdateArgs } from ".";
+
+interface RoutineNode {
+    id: string
+    label: string
+    position: { x: number; y: number }
+    routine: string
+    url: string
+    input: InteractionInput
+}
+
+interface RoutineMapper {
+    source: string
+    target: string
+}
+
+interface RoutineUpdateArgs<T = InteractionInput> extends UpdateArgs {
+    input: {
+        previous: string
+        default: T
+        user: T
+    }
+}
+
+class RoutineDescriptor extends Descriptor {
+    static type = 'Routine'
+    roots: string[]
+    nodes: RoutineNode[]
+    mappers: RoutineMapper[]
+
+    constructor(descriptor: Partial<DeserializationObject<RoutineDescriptor>> = {}) {
+        super(descriptor)
+        this.roots = descriptor.roots ? Descriptor.deepClone(descriptor.roots) : []
+        this.nodes = descriptor.nodes ? Descriptor.deepClone(descriptor.nodes) : []
+        this.mappers = descriptor.mappers ? Descriptor.deepClone(descriptor.mappers) : []
+    }
+
+    addNode(nodes: RoutineNode[]) {
+        const count = nodes.length
+        const max = count - 1
+        for (let i = 0; i < count; i++) {
+            const node = nodes[i]
+            this.nodes.push(node)
+            if (i < max) {
+                this.mappers.push({ source: node.id, target: nodes[i + 1].id })
+            }
+        }
+    }
+}
+Descriptor.register(RoutineDescriptor)
+
+
+export { RoutineNode, RoutineMapper, RoutineUpdateArgs, RoutineDescriptor }

package/src/descriptor/ServiceDescriptor.ts

@@ -0,0 +1,32 @@
+import { DeserializationObject } from "../Serialization"
+import { DefaultStyleColor, StyleColor } from "../Color"
+import { Descriptor } from "./Descriptor"
+import { HTMLDescriptor } from "./HTMLDescriptor"
+
+abstract class ServiceDescriptor extends HTMLDescriptor {
+    static type = 'Service'
+
+    backgroundColor: StyleColor
+
+    /**
+     * 获取当前描述器节点的父服务节点
+     * 
+     * 注意：若你需要在渲染流程中获取父服务节点，你应该调用`Graphics`的同名方法，因为一些动态节点可能并未直接被插入到节点树中。
+     */
+    static traceService(descriptor: Descriptor | null): ServiceDescriptor | null {
+        if (descriptor === null) return null
+        if (descriptor instanceof ServiceDescriptor) {
+            return descriptor instanceof ServiceDescriptor ? descriptor : null
+        } else {
+            const ancestor = descriptor.traceAncestor(false)
+            return this.traceService(ancestor.parent)
+        }
+    }
+
+    constructor(descriptor: Partial<DeserializationObject<ServiceDescriptor>> = {}) {
+        super(descriptor)
+        this.backgroundColor = descriptor.backgroundColor ? DefaultStyleColor.create(descriptor.backgroundColor) : new DefaultStyleColor({ opacity: 0 })
+    }
+}
+
+export { ServiceDescriptor }

package/src/descriptor/ServiceSchedulerDescriptor.ts

@@ -0,0 +1,32 @@
+import { Vector2, Vector3 } from "../math";
+import { DeserializationObject } from "../Serialization"
+import { Descriptor } from "./Descriptor"
+import { ServiceDescriptor } from "./ServiceDescriptor";
+
+interface RayIntersection {
+  object: Descriptor
+  distance: number
+  point: Vector3
+  normal: Vector2 | null
+  uv: Vector2 | null
+  uv1: Vector2 | null
+  faceIndex: number | null
+  instanceId: number | null
+}
+
+class ServiceSchedulerDescriptor extends Descriptor {
+  static type = 'ServiceScheduler'
+  /**调度器的默认调度脚本 */
+  declare children: ServiceDescriptor[]
+  /**调度器渲染场景时使用的相机 */
+  camera: string
+
+  constructor(descriptor: Partial<DeserializationObject> = {}) {
+    super(descriptor)
+    this.camera = descriptor.camera ?? ''
+  }
+}
+
+Descriptor.register(ServiceSchedulerDescriptor)
+
+export { RayIntersection, ServiceSchedulerDescriptor }

package/src/descriptor/StyleDescriptor.ts

@@ -0,0 +1,213 @@
+import { DeserializationObject } from "../Serialization"
+import { BasicStyleColor, DefaultStyleColor, StyleColor } from "../Color"
+import { Descriptor } from "./Descriptor"
+
+class StyleShadow {
+    /**阴影类型
+     * - 0 box-shadow
+     * - 1 text-shadow
+     */
+    type: number
+    /** 阴影颜色 */
+    color: DefaultStyleColor
+    /** 阴影是否内嵌 */
+    inset: boolean
+    /** 阴影水平偏移 */
+    offsetX: number
+    /** 阴影垂直偏移 */
+    offsetY: number
+    /** 阴影模糊半径 */
+    blur: number
+    /** 阴影扩展半径 */
+    spread: number
+
+    constructor(shadow: Partial<DeserializationObject<StyleShadow>> = {}) {
+        this.type = shadow.type ?? 0
+        this.color = new DefaultStyleColor(shadow.color)
+        this.inset = shadow.inset ?? false
+        this.offsetX = shadow.offsetX ?? 0
+        this.offsetY = shadow.offsetY ?? 0
+        this.blur = shadow.blur ?? 0
+        this.spread = shadow.spread ?? 0
+    }
+
+    getStyleValue(unit = 'px') {
+        if (this.type === 0) {
+            const inset = this.inset ? 'inset' : ''
+            return `${inset} ${this.offsetX}${unit} ${this.offsetY}${unit} ${this.blur}${unit} ${this.spread}${unit} ${this.color.getColor()}`
+        } else {
+            return ` ${this.offsetX}${unit} ${this.offsetY}${unit} ${this.spread}${unit} ${this.color.getColor()}`
+        }
+    }
+}
+
+class StyleSpacing {
+    left: number
+    top: number
+    right: number
+    bottom: number
+
+    constructor(border: Partial<DeserializationObject<StyleSpacing>> = {}) {
+        this.left = border.left ?? 0
+        this.top = border.top ?? 0
+        this.right = border.right ?? 0
+        this.bottom = border.bottom ?? 0
+    }
+
+    getStyleValue(unit = 'px') {
+        return `${this.top}${unit} ${this.right}${unit} ${this.bottom}${unit} ${this.left}${unit}`
+    }
+}
+
+type StyleRuleType = StyleColor | StyleShadow | StyleSpacing | number | string
+
+class StyleRule<T extends StyleRuleType = StyleRuleType> {
+    static clone(rule: DeserializationObject<StyleRule>) {
+        let value: StyleRuleType
+        if (['box-shadow', 'text-shadow'].includes(rule.name)) {
+            //@ts-ignore
+            value = new StyleShadow(rule.value)
+        } else if (['background', 'border-color', 'color'].includes(rule.name)) {
+            //@ts-ignore
+            value = BasicStyleColor.create(rule.value)
+        } else if (['border-width', 'padding', 'margin'].includes(rule.name)) {
+            //@ts-ignore
+            value = new StyleSpacing(rule.value)
+        } else {
+            value = rule.value
+        }
+        return new StyleRule(rule.name, value, rule.inherit, rule.unit)
+    }
+
+    name: string
+    value: T
+    inherit: boolean
+    unit: string
+
+    constructor(name: string, value: T, inherit: boolean = false, unit = '') {
+        this.name = name
+        this.value = value
+        this.inherit = inherit
+        this.unit = unit
+    }
+
+    getValue() {
+        if (this.value instanceof BasicStyleColor) {
+            return this.value.getColor()
+        } else if (this.value instanceof StyleShadow) {
+            return this.value.getStyleValue(this.unit)
+        } else if (this.value instanceof StyleSpacing) {
+            return this.value.getStyleValue(this.unit)
+        } else if (this.name === 'transition') {
+            return `all ${this.value}s`
+        } else {
+            return this.value + this.unit
+        }
+    }
+}
+
+let _basicStyle: StyleDescriptor | null = null
+class StyleDescriptor extends Descriptor {
+    static type = 'Style'
+    static basicName = 'vyr_basic_style'
+    static activeName = 'vyr_active_style'
+    static get basicStyle() {
+        if (_basicStyle === null) {
+            _basicStyle = new StyleDescriptor({ name: 'basic', rules: [] })
+            const rules = StyleDescriptor.generateRule(false)
+            for (const rule of rules) _basicStyle.addRule(rule)
+        }
+        return _basicStyle
+    }
+    static generateRule = (inherit = true) => {
+        const rules: StyleRule[] = []
+        rules.push(new StyleRule('cursor', 'default', inherit))
+        rules.push(new StyleRule('padding', new StyleSpacing(), inherit, 'px'))
+        rules.push(new StyleRule('box-sizing', 'border-box', inherit))
+        rules.push(new StyleRule('overflow-x', 'visible', inherit))
+        rules.push(new StyleRule('overflow-y', 'visible', inherit))
+        rules.push(new StyleRule('vertical-align', 'baseline', inherit))
+
+        rules.push(new StyleRule('transition', 0.5, inherit))
+
+        rules.push(new StyleRule('background', new DefaultStyleColor({ opacity: 0 }), inherit))
+        rules.push(new StyleRule('background-blend-mode', 'normal', inherit))
+        rules.push(new StyleRule('background-clip', 'border-box', inherit))
+
+        rules.push(new StyleRule('box-shadow', new StyleShadow({ type: 0 }), inherit, 'px'))
+        rules.push(new StyleRule('text-shadow', new StyleShadow({ type: 1 }), inherit, 'px'))
+
+        rules.push(new StyleRule('border-style', 'solid', inherit))
+        rules.push(new StyleRule('border-color', new DefaultStyleColor(), inherit))
+        rules.push(new StyleRule('border-width', new StyleSpacing(), inherit, 'px'))
+
+        rules.push(new StyleRule('color', new DefaultStyleColor({ value: '#000000' }), inherit))
+        rules.push(new StyleRule('font-size', 16, inherit, 'px'))
+        rules.push(new StyleRule('text-align', 'left', inherit))
+        rules.push(new StyleRule('font-weight', 'normal', inherit))
+        rules.push(new StyleRule('line-height', 1.2, inherit))
+        rules.push(new StyleRule('font-style', 'normal', inherit))
+        rules.push(new StyleRule('text-decoration', 'none', inherit))
+        rules.push(new StyleRule('letter-spacing', 0, inherit, 'px'))
+        rules.push(new StyleRule('white-space', 'normal', inherit))
+        rules.push(new StyleRule('font-family', 'unset', inherit))
+
+        return rules
+    }
+
+    /**样式继承 */
+    inherit: string
+    /**样式规则 */
+    readonly rules: StyleRule[]
+    readonly hoverRules: StyleRule[]
+    readonly activeRules: StyleRule[]
+
+    constructor(descriptor: Partial<DeserializationObject<StyleDescriptor>> = {}) {
+        super(descriptor)
+        this.inherit = descriptor.inherit ?? ''
+
+        if (Array.isArray(descriptor.rules)) {
+            this.rules = []
+            for (const rule of descriptor.rules) this.addRule(StyleRule.clone(rule), this.rules)
+        } else {
+            this.rules = StyleDescriptor.generateRule(true)
+        }
+
+        if (Array.isArray(descriptor.hoverRules)) {
+            this.hoverRules = []
+            for (const rule of descriptor.hoverRules) this.addRule(StyleRule.clone(rule), this.hoverRules)
+        } else {
+            this.hoverRules = StyleDescriptor.generateRule(true)
+        }
+
+        if (Array.isArray(descriptor.activeRules)) {
+            this.activeRules = []
+            for (const rule of descriptor.activeRules) this.addRule(StyleRule.clone(rule), this.activeRules)
+        } else {
+            this.activeRules = StyleDescriptor.generateRule(true)
+        }
+    }
+
+    addRule(rule: StyleRule, rules = this.rules) {
+        for (const item of rules) {
+            if (rule.name === item.name) return
+        }
+        rules.push(rule)
+    }
+
+    removeRule(rule: StyleRule, rules = this.rules) {
+        for (let i = 0; i < rules.length; i++) {
+            const item = this.rules[i]
+            if (rule.name !== item.name) continue
+            rules.splice(i, 1)
+            return
+        }
+    }
+
+    clearRule(rules = this.rules) {
+        rules.length = 0
+    }
+}
+Descriptor.register(StyleDescriptor)
+
+export { StyleShadow, StyleSpacing, StyleRuleType, StyleRule, StyleDescriptor }

package/src/descriptor/index.ts

@@ -0,0 +1,17 @@
+export * from './Descriptor'
+export * from './DatasetDescriptor'
+export * from './StyleDescriptor'
+export * from './PrefabDescriptor'
+export * from './RoutineDescriptor'
+export * from './PrefabInstanceDescriptor'
+export * from './DynamicDescriptor'
+export * from './HTMLDescriptor'
+export * from './DivDescriptor'
+export * from './NodeDescriptor'
+export * from './CameraDescriptor'
+export * from './AnimationUnitDescriptor'
+export * from './ControllerDescriptor'
+export * from './HTMLTransformControllerDescriptor'
+export * from './ServiceDescriptor'
+export * from './HTMLServiceDescriptor'
+export * from './ServiceSchedulerDescriptor'

package/src/graphics/Collection.ts

@@ -0,0 +1,25 @@
+import { Unit } from "./Unit"
+
+class UnitCollection {
+    private readonly instanceCollection = new Map<string, Unit>()
+
+    set(unit: Unit) {
+        this.instanceCollection.set(unit.uuid, unit)
+    }
+
+    delete(uuid: string) {
+        this.instanceCollection.delete(uuid)
+    }
+
+    get(uuid: string) {
+        return this.instanceCollection.get(uuid)
+    }
+
+    values() {
+        return [...this.instanceCollection.values()]
+    }
+}
+
+export {
+    UnitCollection
+}

package/src/graphics/Compilation.ts

@@ -0,0 +1,82 @@
+import { Engine } from "../Engine";
+import { Graphics } from "./Graphics";
+import { Asset } from "../asset";
+import { AnimationUnitDescriptor, ServiceSchedulerDescriptor, UpdateArgs } from "../descriptor";
+
+class Compilation {
+    private collection = new Map<string, Graphics>()
+
+    get(scheduler: ServiceSchedulerDescriptor) {
+        return (this.collection.get(scheduler.uuid) ?? null) as Graphics
+    }
+
+    listen(scheduler: ServiceSchedulerDescriptor, engine: Engine) {
+        const url = Asset.getUrlByUuid(scheduler.uuid)
+        if (url) {
+            let graphics = this.collection.get(scheduler.uuid)
+            if (graphics === undefined) {
+                graphics = new Graphics(url, scheduler, engine)
+                this.collection.set(scheduler.uuid, graphics)
+            }
+            graphics.listen({ delta: 0 })
+
+            return graphics
+        }
+    }
+
+    unlisten(scheduler: ServiceSchedulerDescriptor, engine: Engine) {
+        const graphics = this.collection.get(scheduler.uuid)
+        if (graphics === undefined) return
+        graphics.unlisten({ delta: 0 })
+        this.collection.delete(scheduler.uuid)
+    }
+
+    process(engine: Engine, args: UpdateArgs) {
+        Asset.free()
+
+        const collection = this.collection.values()
+
+        for (const graphics of collection) {
+
+            graphics.process(args)
+
+            graphics.clear(args)
+
+            engine.trigger(AnimationUnitDescriptor.type, args)
+
+            this.beforeRender(args)
+            engine.trigger('beforeRender', args)
+
+            this.render(args)
+
+            this.afterRender(args)
+            engine.trigger('afterRender', args)
+        }
+    }
+
+    beforeRender(args: UpdateArgs) {
+        const collection = this.collection.values()
+        for (const graphics of collection) graphics.beforeRender(args)
+    }
+
+    render(args: UpdateArgs) {
+        const collection = this.collection.values()
+        for (const graphics of collection) graphics.render(args)
+    }
+
+    afterRender(args: UpdateArgs) {
+        const collection = this.collection.values()
+        for (const graphics of collection) graphics.afterRender(args)
+    }
+
+    clear(engine: Engine) {
+        const collection = this.collection.values()
+        for (const graphics of collection) {
+            this.unlisten(graphics.scheduler, engine)
+        }
+    }
+}
+
+export {
+    Compilation
+}