@vyr/engine 0.0.1

package/src/math/index.ts

@@ -0,0 +1,5 @@
+export * from './Vector2'
+export * from './Vector3'
+export * from './Euler'
+export * from './Quaternion'
+export * from './Matrix4'

package/src/math/utils.ts

@@ -0,0 +1,17 @@
+/**
+ * Clamps the given value between min and max.
+ *
+ * @param {number} value - The value to clamp.
+ * @param {number} min - The min value.
+ * @param {number} max - The max value.
+ * @return {number} The clamped value.
+ */
+function clamp(value: number, min: number, max: number) {
+
+    return Math.max(min, Math.min(max, value));
+
+}
+
+export {
+    clamp
+}

package/src/preset/execute/dataset/index.ts

@@ -0,0 +1 @@
+export * as update from './update'

package/src/preset/execute/dataset/update.ts

@@ -0,0 +1,52 @@
+import { language } from "../../../locale";
+import { Asset } from "../../../asset";
+import { DatasetDescriptor, Descriptor, RoutineNode, UpdateArgs } from "../../../descriptor";
+import { Graphics } from "../../../graphics";
+import { Scriptable } from "../../../Scriptable";
+import { Category } from "../../../Category";
+
+const scriptable = Asset.createVirtualUrl('preset/dataset/update.ts')
+class ExecuteScriptable extends Scriptable {
+    async execute(descriptor: Descriptor, graphics: Graphics, args: UpdateArgs) {
+        //@ts-ignore
+        const { input, result } = args
+        const dataset = input?.user?.url.value ?? input.default.url.value
+
+        const previous = result.get(input.previous)
+        const datasetDescriptor = Asset.get<DatasetDescriptor>(dataset)
+        if (datasetDescriptor instanceof DatasetDescriptor) {
+            if (previous) datasetDescriptor.setData(previous)
+        }
+
+        return {}
+    }
+}
+Asset.provider(scriptable, async () => ({ default: ExecuteScriptable }))
+
+const createExecuteInput = (args: any = {}) => {
+    const input = {
+        url: { value: args.url ?? '', type: Category.dataset }
+    }
+
+    return input
+}
+
+const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
+    const executeNode: RoutineNode = {
+        id: options.id,
+        label: language.get(scriptable as any),
+        position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
+        routine: 'Execute',
+        url: scriptable,
+        input: createExecuteInput(options.input)
+    }
+    return executeNode
+}
+
+export {
+    scriptable,
+    createExecuteInput,
+    createExecuteNode,
+}
+
+

package/src/preset/execute/graphics/index.ts

@@ -0,0 +1 @@
+export * as invoke from './invoke'

package/src/preset/execute/graphics/invoke.ts

@@ -0,0 +1,49 @@
+import { language } from "../../../locale";
+import { Asset } from "../../../asset";
+import { Descriptor, RoutineNode, UpdateArgs } from "../../../descriptor";
+import { Graphics } from "../../../graphics";
+import { Scriptable } from "../../../Scriptable";
+
+const scriptable = Asset.createVirtualUrl('preset/graphics/invoke.ts')
+class ExecuteScriptable extends Scriptable {
+    async execute(descriptor: Descriptor, graphics: Graphics, args: UpdateArgs) {
+        //@ts-ignore
+        const { input } = args
+        const interaction = input?.user?.interaction.value ?? input.default.interaction.value
+        const target = input?.user?.target.value ?? input.default.target.value
+        const targetDescriptor = Descriptor.get<Descriptor>(target)
+        if (interaction && targetDescriptor) {
+            graphics.invoke(interaction, targetDescriptor)
+        }
+    }
+}
+Asset.provider(scriptable, async () => ({ default: ExecuteScriptable }))
+
+const createExecuteInput = (args: any = {}) => {
+    const input = {
+        target: { value: args.target ?? '' },
+        interaction: { value: args.interaction ?? '' },
+    }
+
+    return input
+}
+
+const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
+    const executeNode: RoutineNode = {
+        id: options.id,
+        label: language.get(scriptable as any),
+        position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
+        routine: 'Execute',
+        url: scriptable,
+        input: createExecuteInput(options.input)
+    }
+    return executeNode
+}
+
+export {
+    scriptable,
+    createExecuteInput,
+    createExecuteNode,
+}
+
+

package/src/preset/execute/index.ts

@@ -0,0 +1,4 @@
+export * as net from './net'
+export * as dataset from './dataset'
+export * as scheduler from './scheduler'
+export * as graphics from './graphics'

package/src/preset/execute/net/index.ts

@@ -0,0 +1 @@
+export * as request from './request'

package/src/preset/execute/net/request.ts

@@ -0,0 +1,103 @@
+import { language } from "../../../locale";
+import { Asset } from "../../../asset";
+import { Descriptor, RoutineNode, UpdateArgs } from "../../../descriptor";
+import { Graphics } from "../../../graphics";
+import { Scriptable } from "../../../Scriptable";
+
+enum RequestType {
+    GET = 'GET',
+    POST = 'POST',
+    PUT = 'PUT',
+    DELETE = 'DELETE',
+}
+
+const scriptable = Asset.createVirtualUrl('preset/net/request.ts')
+class ExecuteScriptable extends Scriptable {
+
+    joinUrl(url: string, requestData: any) {
+        const urlObj = new URL(url);
+
+        // 直接将requestData添加到urlObj的searchParams中
+        Object.entries(requestData).forEach(([key, value]) => {
+            if (value !== null && value !== undefined) {
+                urlObj.searchParams.set(key, String(value));
+            }
+        });
+
+        return urlObj.toString()
+    }
+
+    async execute(descriptor: Descriptor, graphics: Graphics, args: UpdateArgs) {
+        //@ts-ignore
+        const { input, result } = args
+        let url = input?.user?.url.value ?? input.default.url.value
+        const type: string = input?.user?.type.value ?? input.default.type.value
+        const data: string = input?.user?.data.value ?? input.default.data.value
+
+        const requestData: { [k: string]: any } = {}
+        const keys: string[] = []
+        if (data.trim().length === 0) {
+            keys.push(...result.keys())
+        } else {
+            keys.push(...data.split(','))
+        }
+
+        for (const key of keys) {
+            const value = result.get(key)
+            Object.assign(requestData, value ?? {})
+        }
+
+        url = url.replace(/\${(\w+)}/g, (match: any, key: string) => {
+            return requestData.hasOwnProperty(key) ? requestData[key] : match;
+        })
+
+        const config = {
+            method: type,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        }
+        let res
+        if (type === RequestType.GET) {
+            res = await fetch(this.joinUrl(url, requestData), config)
+        } else {
+            res = await fetch(url, { ...config, body: JSON.stringify(requestData) })
+        }
+
+        const json = await res.json()
+
+        return json
+    }
+}
+Asset.provider(scriptable, async () => ({ default: ExecuteScriptable }))
+
+const createExecuteInput = (args: any = {}) => {
+    const input = {
+        url: { value: args.url ?? '' },
+        type: { value: args.type ?? '' },
+        data: { value: args.data ?? '' },
+    }
+
+    return input
+}
+
+const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
+    const executeNode: RoutineNode = {
+        id: options.id,
+        label: language.get(scriptable as any),
+        position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
+        routine: 'Execute',
+        url: scriptable,
+        input: createExecuteInput(options.input)
+    }
+    return executeNode
+}
+
+export {
+    scriptable,
+    RequestType,
+    createExecuteInput,
+    createExecuteNode,
+}
+
+

package/src/preset/execute/scheduler/index.ts

@@ -0,0 +1 @@
+export * as switch from './switch'

package/src/preset/execute/scheduler/switch.ts

@@ -0,0 +1,46 @@
+import { language } from "../../../locale";
+import { Asset } from "../../../asset";
+import { Descriptor, RoutineNode, ServiceSchedulerDescriptor, UpdateArgs } from "../../../descriptor";
+import { Graphics } from "../../../graphics";
+import { Scriptable } from "../../../Scriptable";
+
+const scriptable = Asset.createVirtualUrl('preset/scheduler/switch.ts')
+class ExecuteScriptable extends Scriptable {
+    async execute(descriptor: Descriptor, graphics: Graphics, args: UpdateArgs) {
+        //@ts-ignore
+        const scene = args.input?.user?.url.value
+        if (!scene) return
+        await Asset.loadAll(scene)
+        const scheduler = Asset.get<ServiceSchedulerDescriptor>(scene)
+        graphics.engine.switch(scheduler)
+    }
+}
+Asset.provider(scriptable, async () => ({ default: ExecuteScriptable }))
+
+const createExecuteInput = (args: any = {}) => {
+    const input = {
+        url: { value: args.url ?? '' },
+    }
+
+    return input
+}
+
+const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
+    const executeNode: RoutineNode = {
+        id: options.id,
+        label: language.get(scriptable as any),
+        position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
+        routine: 'Execute',
+        url: scriptable,
+        input: createExecuteInput(options.input)
+    }
+    return executeNode
+}
+
+export {
+    scriptable,
+    createExecuteInput,
+    createExecuteNode,
+}
+
+

package/src/preset/index.ts

@@ -0,0 +1,7 @@
+import * as executePreset from './execute'
+import * as routinePreset from './routine'
+
+export {
+    executePreset,
+    routinePreset
+}

package/src/preset/routine/graphics/index.ts

@@ -0,0 +1 @@
+export * as invoke from "./invoke"

package/src/preset/routine/graphics/invoke.ts

@@ -0,0 +1,27 @@
+import { Asset } from "../../../asset";
+import { RoutineDescriptor } from "../../../descriptor";
+import { graphics } from "../../execute"
+
+const url = Asset.createVirtualUrl('preset/graphics/invoke.routine.json')
+const nodes = {
+    invoke: 'invoke'
+}
+let _currentRoutine: RoutineDescriptor | null = null
+const routineProvider = async () => {
+    if (_currentRoutine === null) {
+        _currentRoutine = new RoutineDescriptor()
+        const invokeNode = graphics.invoke.createExecuteNode({ id: nodes.invoke })
+        _currentRoutine.nodes.push(invokeNode)
+        _currentRoutine.roots.push(invokeNode.id)
+    }
+    return _currentRoutine
+}
+
+Asset.provider(url, routineProvider)
+
+export {
+    url,
+    nodes,
+}
+
+

package/src/preset/routine/index.ts

@@ -0,0 +1,2 @@
+export * as scheduler from './scheduler'
+export * as graphics from './graphics'

package/src/preset/routine/scheduler/index.ts

@@ -0,0 +1 @@
+export * as switch from "./switch"

package/src/preset/routine/scheduler/switch.ts

@@ -0,0 +1,27 @@
+import { Asset } from "../../../asset";
+import { RoutineDescriptor } from "../../../descriptor";
+import { scheduler } from "../../execute"
+
+const url = Asset.createVirtualUrl('preset/scheduler/switch.routine.json')
+const nodes = {
+    switch: 'switch',
+}
+let _currentRoutine: RoutineDescriptor | null = null
+const routineProvider = async () => {
+    if (_currentRoutine === null) {
+        _currentRoutine = new RoutineDescriptor()
+        const switchNode = scheduler.switch.createExecuteNode({ id: nodes.switch })
+        _currentRoutine.nodes.push(switchNode)
+        _currentRoutine.roots.push(switchNode.id)
+    }
+    return _currentRoutine
+}
+
+Asset.provider(url, routineProvider)
+
+export {
+    url,
+    nodes,
+}
+
+

package/src/setup/index.ts

@@ -0,0 +1,17 @@
+import { StyleDescriptor } from "../descriptor"
+import { StyleInterpreter } from "../interpreter"
+import { StyleActor } from "../actor"
+
+let needSetupStyle = false
+const setupStyle = () => {
+    if (needSetupStyle === true) return
+    needSetupStyle = true
+    const actor = new StyleActor()
+    actor.update(StyleDescriptor.basicStyle, StyleDescriptor.basicName)
+    const styleValues = actor.getStyleValue()
+    StyleInterpreter.insertRule(styleValues)
+}
+
+export {
+    setupStyle
+}

package/src/utils/AssetProvider.ts

@@ -0,0 +1,72 @@
+import { Descriptor, DynamicDescriptor, PrefabInstanceDescriptor, RoutineDescriptor, HTMLDescriptor, StyleDescriptor, InteractionProperty, RoutineNode } from "../descriptor"
+import { AssetGraph, Port } from "../asset"
+import { Category } from "../Category"
+
+const interactionExecutor = (interaction: InteractionProperty, path: string, port: Port) => {
+    const keys = Object.keys(interaction.inputs)
+    for (const key of keys) {
+        const input = interaction.inputs[key]
+        const params = Object.keys(input)
+        for (const param of params) {
+            const value = input[param]
+            if (value.type === undefined || Category.isDescriptor(value.type, 'category') === false) continue
+            if (value.value) port.edges.push({ key: `${path}.inputs.${key}.${param}.value`, category: value.type, asset: value.value })
+        }
+    }
+}
+const routineNodeExecutor = (node: RoutineNode, path: string, port: Port) => {
+    const params = Object.keys(node.input)
+    for (const param of params) {
+        const value = node.input[param]
+        if (value.type === undefined || Category.isDescriptor(value.type, 'category') === false) continue
+        if (value.value) port.edges.push({ key: `${path}.input.${param}.value`, category: value.type, asset: value.value })
+    }
+}
+
+const DescriptorProvider = (descriptor: Descriptor, port: Port) => {
+    if (descriptor.interactions.length > 0) {
+        for (let i = 0; i < descriptor.interactions.length; i++) {
+            const interaction = descriptor.interactions[i]
+            if (interaction.url) {
+                interactionExecutor(interaction, `interactions[${i}]`, port)
+                port.edges.push({ key: `interactions[${i}].url`, category: Category.routine, asset: interaction.url })
+            }
+        }
+    }
+    if (descriptor.dataset) port.edges.push({ key: 'dataset', category: Category.dataset, asset: descriptor.dataset })
+}
+
+const StyleDescriptorProvider = (descriptor: StyleDescriptor, port: Port) => {
+    if (descriptor.inherit) port.edges.push({ key: 'inherit', category: Category.style, asset: descriptor.inherit })
+}
+
+const RoutineDescriptorProvider = (descriptor: RoutineDescriptor, port: Port) => {
+    if (descriptor.nodes.length > 0) {
+        for (let i = 0; i < descriptor.nodes.length; i++) {
+            const node = descriptor.nodes[i]
+            if (node.url) {
+                routineNodeExecutor(node, `nodes[${i}]`, port)
+                port.edges.push({ key: `nodes[${i}].url`, category: Category.ts, asset: node.url })
+            }
+        }
+    }
+}
+
+const HTMLDescriptorProvider = (descriptor: HTMLDescriptor, port: Port) => {
+    if (descriptor.style) port.edges.push({ key: 'style', category: Category.style, asset: descriptor.style })
+}
+
+const DynamicDescriptorProvider = (descriptor: DynamicDescriptor, port: Port) => {
+    if (descriptor.url) port.edges.push({ key: 'url', category: Category.prefab, asset: descriptor.url })
+}
+
+const PrefabInstanceDescriptorProvider = (descriptor: PrefabInstanceDescriptor, port: Port) => {
+    if (descriptor.url) port.edges.push({ key: 'url', category: Category.prefab, asset: descriptor.url })
+}
+
+AssetGraph.register(Descriptor.type, DescriptorProvider)
+AssetGraph.register(StyleDescriptor.type, StyleDescriptorProvider)
+AssetGraph.register(RoutineDescriptor.type, RoutineDescriptorProvider)
+AssetGraph.register(HTMLDescriptor.type, HTMLDescriptorProvider)
+AssetGraph.register(DynamicDescriptor.type, DynamicDescriptorProvider)
+AssetGraph.register(PrefabInstanceDescriptor.type, PrefabInstanceDescriptorProvider)

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './AssetProvider'