@vyr/engine 0.0.1

package/src/actor/StyleActor.ts

@@ -0,0 +1,96 @@
+import { Asset } from "../asset"
+import { Actor } from "./Actor"
+import { StyleDescriptor } from "../descriptor"
+import { StyleInterpreter } from "../interpreter"
+
+interface RuleObjects extends Array<{ name: string, value: string }> { }
+
+class StyleActor extends Actor {
+    private _styleCollection = new Map<string, RuleObjects>()
+    private _className: string[] = []
+
+    getStyleValue() {
+        const styles: string[] = []
+
+        const entries = this._styleCollection.entries()
+        for (const [selectorText, rules] of entries) {
+            const style: string[] = []
+            style.push(`${selectorText}{`)
+            if (rules.length === 0) {
+                style.push('/* 如果需要样式，在这里添加 */')
+            } else {
+                for (const rule of rules) {
+                    style.push(`${rule.name}:${rule.value};`)
+                }
+            }
+            style.push(`}`)
+            styles.push(style.join('\n'))
+        }
+
+        return styles
+    }
+
+    getClassName() {
+        return [...this._className]
+    }
+
+    updateRule(sheet: CSSStyleSheet) {
+        let count = 0
+        for (const rule of sheet.cssRules) {
+            if (rule instanceof CSSStyleRule) {
+                const styleObjects = this._styleCollection.get(rule.selectorText)
+                if (styleObjects === undefined) continue
+
+                count++
+                rule.style.cssText = ''
+                for (const styleObject of styleObjects) {
+                    rule.style.setProperty(styleObject.name, styleObject.value)
+                }
+
+                if (count === 2) return true
+            }
+        }
+        return false
+    }
+
+    update(descriptor: StyleDescriptor, className: string) {
+        this._className.length = 0
+        this._styleCollection.clear()
+
+        let inherit = Asset.get<StyleDescriptor>(descriptor.inherit)
+        if (inherit) {
+            const graphics = Actor.getGraphics(this)
+            const interpreter = graphics.getInterpreter<StyleInterpreter>(inherit)
+            this._className.push(interpreter.className)
+        }
+        this._className.push(className)
+
+        const rules: RuleObjects = []
+        for (const rule of descriptor.rules) {
+            if (rule.inherit === true) continue
+            const value = rule.getValue()
+            rules.push({ name: rule.name, value })
+        }
+        this._styleCollection.set(`.${className}`, rules)
+
+        const hover: RuleObjects = []
+        for (const rule of descriptor.hoverRules) {
+            if (rule.inherit === true) continue
+            const value = rule.getValue()
+            hover.push({ name: rule.name, value })
+        }
+        this._styleCollection.set(`.${className}:hover`, hover)
+
+        const active: RuleObjects = []
+        for (const rule of descriptor.activeRules) {
+            if (rule.inherit === true) continue
+            const value = rule.getValue()
+            active.push({ name: rule.name, value })
+        }
+        this._styleCollection.set(`.${className}.${StyleDescriptor.activeName}`, active)
+    }
+}
+
+export {
+    StyleActor
+}

package/src/actor/index.ts

@@ -0,0 +1,8 @@
+export * from './Actor'
+export * from './StyleActor'
+export * from './AnimationUnitActor'
+export * from './FragmentActor'
+export * from './HTMActor'
+export * from './DivActor'
+export * from './HTMServiceActor'
+export * from './HTMTransformControllerActor'

package/src/asset/Asset.ts

@@ -0,0 +1,271 @@
+import { language } from "../locale"
+import { Category } from "../Category"
+import { DatasetDescriptor, Descriptor } from "../descriptor"
+import { AsyncTask } from "../AsyncTask"
+import { Scriptable } from '../Scriptable'
+import { AssetGraph } from "./AssetGraph"
+
+type JsonAsset = { [k: string]: any }
+type RawAsset = HTMLImageElement | ImageBitmap | HTMLAudioElement | AudioBuffer | HTMLVideoElement | string | JsonAsset
+type StaticFactory = (url: string, forced?: boolean) => Promise<any>
+type DescriptorProvider = () => Promise<Descriptor>
+type ScriptableProvider = () => Promise<{ default: typeof Scriptable }>
+type AssetProperty = { url: string }
+type AssetPropertyCollection<T extends AssetProperty = AssetProperty> = T[]
+
+const privateState = {
+    requestpPrefix: ['http://', 'https://'],
+    assetCache: new Map<string, RawAsset | Descriptor>(),
+    idToUrlCache: new Map<string, string>(),
+    providerCollection: new Map<string, DescriptorProvider | ScriptableProvider>(),
+    assetFactoryCollection: new Map<string, StaticFactory>(),
+    taskCollection: new Map<string, AsyncTask>(),
+    activeAssets: [] as string[],
+    parseStatus(url: string) {
+        const urlClips = url.split('/')
+        const name = urlClips[urlClips.length - 1]
+        if (name === undefined) return null
+
+        return Category.parseName(name.split('?')[0])
+    }
+}
+
+class Asset {
+    static baseUrl = ''
+    static graph = new AssetGraph()
+
+    static fetch(url: string, params?: any) {
+        return new Promise<Response>(async (resolve, reject) => {
+            const res = await fetch(url, params)
+            res.ok ? resolve(res) : reject(url)
+        })
+    }
+
+    static dumpCache() {
+        return [...privateState.assetCache.entries()]
+    }
+
+    static createVirtualUrl(fileName: string) {
+        return `/virtual:/${fileName}`
+    }
+
+    static provider(url: string, provider: DescriptorProvider | ScriptableProvider) {
+        privateState.providerCollection.set(url, provider)
+    }
+
+    static hasProvider(url: string) {
+        return privateState.providerCollection.has(url)
+    }
+
+    /**注册资产的生成器 */
+    static register(category: string, factory: StaticFactory) {
+        privateState.assetFactoryCollection.set(category, factory)
+    }
+
+    static joinUrl(url: string) {
+        for (const pre of privateState.requestpPrefix) {
+            if (url.indexOf(pre) > -1) return url
+        }
+        return `${Asset.baseUrl}${url}`
+    }
+
+    /**加载指定的资产文件
+     * 
+     * 场景资产会自动根据`manifest`文件加载场景初始化时所需的所有资产，除此之外的其他资产仅加载它本身。
+     * 
+     */
+    static load<U extends keyof SnowAssets>(url: U, forced?: boolean): Promise<void[]>
+    static load(url: string, forced?: boolean): Promise<void[]>
+    static async load(url: string | string[], forced = false) {
+        const urls = Array.isArray(url) ? url : [url]
+
+        const tasks: Promise<void>[] = []
+
+        for (const assetUrl of urls) {
+            if (!assetUrl) continue
+
+            const cacheAsset = this.get(assetUrl)
+            if (forced === false && cacheAsset !== null) continue
+
+            const factoryingTask = privateState.taskCollection.get(assetUrl)
+            if (factoryingTask) {
+                tasks.push(factoryingTask.done())
+                continue
+            }
+
+            const status = privateState.parseStatus(assetUrl)
+            if (status === null) continue
+
+            let factory = privateState.assetFactoryCollection.get(status.category)
+            if (factory === undefined) throw language.get('asset.load.fail', { category: status.category })
+
+            const task = new AsyncTask(async () => {
+                const asset = await factory(assetUrl, forced)
+                this.set(assetUrl, asset)
+            })
+            privateState.taskCollection.set(assetUrl, task)
+
+            tasks.push(task.run())
+
+            try {
+                await task.done()
+            } catch (error) {
+                console.log(error)
+            } finally {
+                privateState.taskCollection.delete(assetUrl)
+            }
+        }
+
+        return Promise.all(tasks)
+    }
+
+    static unload<U extends keyof SnowAssets>(url: U): void
+    static unload(url: string): void
+    static unload(url: string) {
+        const asset = this.get(url)
+        if (asset === null) return
+        privateState.assetCache.delete(url)
+    }
+
+    /**等待当前的资产文件加载完毕 */
+    static readly() {
+        const tasks = privateState.taskCollection.values()
+        const waits = []
+        for (const task of tasks) {
+            waits.push(task.done())
+        }
+        return Promise.all(waits)
+    }
+
+    static get<U extends keyof SnowAssets>(url: U): SnowAssets[U]
+    static get<T extends SnowAssets[keyof SnowAssets] = SnowAssets[keyof SnowAssets]>(url: keyof SnowAssets): T
+    static get<T extends RawAsset | Descriptor | null = Descriptor | null>(url: string): T
+    static get<T extends RawAsset | Descriptor | null = Descriptor | null>(url: string) {
+        return (privateState.assetCache.get(url) ?? null) as T
+    }
+
+    static set(url: string, asset: RawAsset | Descriptor) {
+        if (privateState.assetCache.has(url)) console.log(url, language.get('asset.already.exists'))
+        privateState.assetCache.set(url, asset)
+        if (asset instanceof Descriptor) {
+            privateState.idToUrlCache.set(asset.uuid, url)
+            this.graph.create(url)
+        }
+    }
+
+    static getTask(url: string) {
+        return privateState.taskCollection.get(url) ?? null
+    }
+
+    static getUrlByUuid(uuid: string) {
+        return privateState.idToUrlCache.get(uuid) ?? ''
+    }
+
+    static activate(...urls: string[]) {
+        privateState.activeAssets.push(...urls)
+    }
+
+    static free() {
+        privateState.activeAssets.length = 0
+    }
+
+    static async loadAll(url: string, forced = false, record: string[] = []) {
+        await Asset.load(url, forced)
+        Asset.graph.create(url)
+
+        record.push(url)
+        const dependencide = Asset.graph.getDependencide(url)
+
+        const tasks: Promise<void>[] = []
+        for (const dep of dependencide.all) {
+            if (record.includes(dep)) continue
+            const subForced = Asset.get(dep) ? false : true
+            tasks.push(this.loadAll(dep, subForced, record))
+        }
+
+        await Promise.all(tasks)
+    }
+}
+
+export { Asset, JsonAsset, RawAsset, DescriptorProvider, ScriptableProvider, AssetProperty, AssetPropertyCollection, privateState }
+
+const getAssetByProvider = async (url: string) => {
+    const scriptableProvider = privateState.providerCollection.get(url)
+    if (scriptableProvider === undefined) return null
+    return await scriptableProvider() as unknown as any
+}
+
+const factoryDescriptor = async (url: string) => {
+    const preset = await getAssetByProvider(url)
+    if (preset !== null) return preset
+    const res = await Asset.fetch(Asset.joinUrl(url))
+    const text = await res.text()
+    const asset = Descriptor.create(Descriptor.deserialization(text))
+    return asset
+}
+Asset.register(Category.style, factoryDescriptor)
+Asset.register(Category.material, factoryDescriptor)
+Asset.register(Category.geometry, factoryDescriptor)
+Asset.register(Category.texture, factoryDescriptor)
+Asset.register(Category.prefab, factoryDescriptor)
+Asset.register(Category.routine, factoryDescriptor)
+
+const factoryDataset = async (url: string) => {
+    const asset = await factoryDescriptor(url) as DatasetDescriptor
+    if (asset.auto) await asset.fetch()
+    return asset
+}
+
+Asset.register(Category.dataset, factoryDataset)
+
+const factoryJson = async (url: string) => {
+    const res = await Asset.fetch(Asset.joinUrl(url))
+    const text = await res.text()
+    return Descriptor.deserialization(text)
+}
+Asset.register(Category.json, factoryJson)
+
+const factoryScene = (url: string, forced?: boolean) => {
+    return new Promise<Descriptor>(async (resolve, reject) => {
+        const sceneUrl = Asset.joinUrl(url)
+        try {
+            const res = await Asset.fetch(sceneUrl)
+
+            const scene = await res.text()
+
+            const sceneDes = Descriptor.create(Descriptor.deserialization(scene))
+
+            resolve(sceneDes)
+        } catch (error) {
+            reject(error)
+        }
+    })
+}
+Asset.register(Category.scene, factoryScene)
+
+const factoryScript = (url: string) => {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const module = await getAssetByProvider(url)
+            if (module === null) return reject(language.get('asset.provider.notFound', { url }))
+
+            /**
+            * Class constructor { ClassName } cannot be invoked without 'new'
+            * 
+            * 将代码的编译目标(webpack、ts、vite等配置文件)调整为es6
+            */
+            const scriptable = new module.default(url)
+            await scriptable.ready()
+            resolve(scriptable)
+        } catch (error) {
+            reject(error)
+        }
+    })
+}
+Asset.register(Category.ts, factoryScript)
+
+const factoryOther = async (url: string) => {
+    const res = await Asset.fetch(Asset.joinUrl(url))
+    return await res.arrayBuffer()
+}
+Asset.register(Category.other, factoryOther)

package/src/asset/AssetGraph.ts

@@ -0,0 +1,246 @@
+import { Asset } from "./Asset"
+import { Category } from "../Category"
+import { ArrayUtils } from "../ArrayUtils"
+import { ObjectPool } from "../ObjectPool";
+import { Descriptor } from "../descriptor";
+
+interface Edge {
+    key: string
+    asset: string
+    category: string
+}
+
+interface Port {
+    descriptor: string
+    edges: Edge[]
+}
+
+interface Cell {
+    url: string
+    uuid: string
+    ports: Port[]
+}
+
+interface UrlCell {
+    url: string
+    cells: Cell[]
+}
+
+type Provider<T extends Descriptor = Descriptor> = (descriptor: T, port: Port) => void
+
+const privateState = {
+    providerCollection: new Map<string, Provider>(),
+}
+
+class Dependencide {
+    all: string[] = []
+    descriptor: string[] = []
+    prefab: string[] = []
+    dataset: string[] = []
+    style: string[] = []
+    routine: string[] = []
+    texture: string[] = []
+    material: string[] = []
+    geometry: string[] = []
+
+    add(type: keyof Dependencide, url: string) {
+        const collection = this[type] as string[]
+        if (collection === undefined) return console.warn(type, url)
+        collection.push(url)
+        this.descriptor.push(url)
+    }
+
+    foreach(cb: (url: string) => void) {
+        for (const url of this.dataset) cb(url)
+        for (const url of this.style) cb(url)
+        for (const url of this.routine) cb(url)
+        for (const url of this.texture) cb(url)
+        for (const url of this.material) cb(url)
+        for (const url of this.geometry) cb(url)
+    }
+
+    clear() {
+        this.all.length = 0
+        this.descriptor.length = 0
+        this.prefab.length = 0
+        this.dataset.length = 0
+        this.style.length = 0
+        this.routine.length = 0
+        this.texture.length = 0
+        this.material.length = 0
+        this.geometry.length = 0
+    }
+}
+
+/**资产关系图，表示资产和资产之间的依赖关系 */
+class AssetGraph {
+
+    private static build(descriptor: Descriptor, port: Port) {
+        let Prototype = descriptor.constructor as typeof Descriptor
+        while (Prototype.prototype instanceof ObjectPool) {
+            const provider = privateState.providerCollection.get(Prototype.type)
+            Prototype = Object.getPrototypeOf(Prototype)
+            if (provider === undefined) continue
+            provider(descriptor, port)
+        }
+    }
+
+    static register<T extends Descriptor = Descriptor>(type: string, provider: Provider<T>) {
+        privateState.providerCollection.set(type, provider as Provider)
+    }
+
+    static get(descriptor: Descriptor, ports: Port[] = []) {
+
+        const port: Port = { descriptor: descriptor.uuid, edges: [] }
+        this.build(descriptor, port)
+        if (port.edges.length > 0) ports.push(port)
+
+        return ports
+    }
+
+    /**依赖项集合 */
+    private _dependencideCollection = new Map<string, Cell>()
+    /**依赖者集合 */
+    private _dependentCollection = new Map<string, Cell[]>()
+
+    protected getDescriptor(url: string) {
+        return Asset.get<Descriptor | null>(url)
+    }
+
+    protected compiler(url: string) {
+        const cell: Cell = { url, uuid: '', ports: [] }
+        const descriptor = this.getDescriptor(url)
+        if (descriptor instanceof Descriptor) {
+            cell.uuid = descriptor.uuid
+            this.build(descriptor, cell.ports)
+        }
+        return cell
+    }
+
+    protected setCell(asset: string, cell: Cell) {
+        let collection = this._dependentCollection.get(asset)
+        if (collection === undefined) {
+            collection = [cell]
+            this._dependentCollection.set(asset, collection)
+        } else {
+            ArrayUtils.insert(collection, cell)
+        }
+    }
+
+    protected deleteCell(asset: string, cell: Cell) {
+        let collection = this._dependentCollection.get(asset)
+        if (collection === undefined) return
+        ArrayUtils.remove(collection, cell)
+    }
+
+    protected collection(asset: string, dependencide: Dependencide, isDescriptor: boolean, category: keyof Dependencide) {
+        const index = dependencide.all.indexOf(asset)
+        if (index > -1) return
+        dependencide.all.push(asset)
+        if (isDescriptor) dependencide.add(category, asset)
+        this.getDependencide(asset, dependencide)
+    }
+
+    get(url: string) {
+        return this._dependencideCollection.get(url) ?? null
+    }
+
+    /**创建资产的依赖关系图 */
+    create(url: string) {
+        this.delete(url)
+
+        const cell = this.compiler(url)
+        this._dependencideCollection.set(url, cell)
+
+        for (const port of cell.ports) {
+            for (const edge of port.edges) {
+                this.setCell(edge.asset, cell)
+            }
+        }
+    }
+
+    build(descriptor: Descriptor, ports: Port[] = []) {
+        descriptor.traverse(sub => { AssetGraph.get(sub, ports) })
+        return ports
+    }
+
+    /**更新资产的依赖关系图 */
+    update(url: string) {
+        this.delete(url)
+        this.create(url)
+    }
+
+    /**将资产从依赖关系图中删除 */
+    delete(url: string) {
+        const cell = this._dependencideCollection.get(url)
+        if (cell === undefined) return
+        this._dependencideCollection.delete(url)
+
+        for (const port of cell.ports) {
+            for (const edge of port.edges) {
+                this.deleteCell(edge.asset, cell)
+            }
+        }
+    }
+
+    /**获取Ports所依赖的全部资产
+     * - 0 获取所有资产
+     * - 1 仅获取描述器资产
+     */
+    getDependencidesByPorts(ports: Port[], dependencide = new Dependencide()) {
+        if (ports.length === 0) return dependencide
+        for (const port of ports) {
+            for (const edge of port.edges) {
+                const isDescriptor = Category.isDescriptor(edge.category, 'category')
+                this.collection(edge.asset, dependencide, isDescriptor, edge.category as keyof Dependencide)
+            }
+        }
+        return dependencide
+    }
+
+    /**获取指定资产所依赖的全部资产
+     * - 0 获取所有资产
+     * - 1 仅获取描述器资产
+     */
+    getDependencide(url: string, dependencide = new Dependencide()) {
+        const cell = this._dependencideCollection.get(url)
+        if (cell === undefined) return dependencide
+        this.getDependencidesByPorts(cell.ports, dependencide)
+        return dependencide
+    }
+
+    /**获取指定资产的所有依赖者 */
+    getDependents(url: string) {
+        return this._dependentCollection.get(url) ?? []
+    }
+
+    getUrlCells(urls: string[], urlCells: UrlCell[] = []) {
+        for (const url of urls) {
+            const cells = this.getDependents(url)
+            if (cells.length > 0) urlCells.push({ url, cells })
+        }
+        return urlCells
+    }
+
+    forEdge(cell: Cell, cb: (port: Port, edge: Edge) => void) {
+        for (const port of cell.ports) {
+            for (const edge of port.edges) cb(port, edge)
+        }
+    }
+
+    hasAssetReference(port: Port, url: string) {
+        for (const edge of port.edges) {
+            if (Array.isArray(edge.asset)) {
+                for (const asset of edge.asset) {
+                    if (asset === url) return true
+                }
+            } else {
+                if (edge.asset === url) return true
+            }
+        }
+
+        return false
+    }
+}
+
+export { Edge, Port, Cell, UrlCell, Dependencide, AssetGraph }

package/src/asset/index.ts

@@ -0,0 +1,2 @@
+export * from './Asset'
+export * from './AssetGraph'

package/src/descriptor/AnimationUnitDescriptor.ts

@@ -0,0 +1,65 @@
+import { DeserializationObject } from "../Serialization"
+import { Descriptor } from "./Descriptor"
+
+interface FrameData {
+    type: string
+    startValue: Array<string | number | boolean> | number | string
+    endValue: Array<string | number | boolean> | number | string
+}
+
+interface NumberFrameData extends FrameData {
+    type: 'number' | 'boolean'
+    startValue: number
+    endValue: number
+}
+
+interface VectorFrameData extends FrameData {
+    type: 'vector2' | 'vector3' | 'euler'
+    startValue: number[]
+    endValue: number[]
+}
+
+interface ColorFrameData extends FrameData {
+    type: 'color'
+    startValue: string
+    endValue: string
+}
+
+type AnimationFrameData = NumberFrameData | VectorFrameData | ColorFrameData
+
+class AnimationUnitDescriptor extends Descriptor {
+    static type = 'AnimationUnit'
+
+    play: boolean
+    duration: number
+    /**循环次数 */
+    count: number
+    /**循环模式
+     * 
+     *  - 1 顺序循环
+     *  - 2 往返循环
+     */
+    mode: number
+    startTime: number
+    path: string
+    frameData: AnimationFrameData
+
+    constructor(descriptor: Partial<DeserializationObject<AnimationUnitDescriptor>> = {}) {
+        super(descriptor)
+        this.play = descriptor.play ?? false
+        this.duration = descriptor.duration ?? 0
+        this.count = descriptor.count ?? Infinity
+        this.mode = descriptor.mode ?? 1
+        this.startTime = descriptor.startTime ?? 0
+        this.path = descriptor.path ?? ''
+        this.frameData = descriptor.frameData ? Descriptor.deepClone<AnimationFrameData>(descriptor.frameData) : { type: 'vector2', startValue: [], endValue: [] } as VectorFrameData
+    }
+}
+Descriptor.register(AnimationUnitDescriptor)
+
+export {
+    NumberFrameData,
+    VectorFrameData,
+    AnimationFrameData,
+    AnimationUnitDescriptor
+}

package/src/descriptor/CameraDescriptor.ts

@@ -0,0 +1,12 @@
+import { DeserializationObject } from "../Serialization"
+import { NodeDescriptor } from "./NodeDescriptor"
+
+class CameraDescriptor extends NodeDescriptor {
+    static type = 'Camera'
+
+    constructor(descriptor: Partial<DeserializationObject<CameraDescriptor>> = {}) {
+        super(descriptor)
+    }
+}
+
+export { CameraDescriptor }