@vyr/three-remote 0.0.1

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@vyr/three-remote",
+  "version": "0.0.1",
+  "description": "",
+  "main": "./src/index.ts",
+  "author": "",
+  "sideEffects": true,
+  "license": "MIT",
+  "dependencies": {
+    "@vyr/locale": "0.0.1",
+    "@vyr/engine": "0.0.1",
+    "@vyr/remote": "0.0.1",
+    "@vyr/three": "0.0.1"
+  },
+  "files": [
+    "package.json",
+    "src/"
+  ],
+  "vyr": {
+    "type": "remote",
+    "order": 1000
+  }
+}

package/src/Cache.ts

@@ -0,0 +1,65 @@
+import { CameraDescriptor, Asset } from "@vyr/engine"
+import { Collection } from "@vyr/remote"
+import { AmbientLightDescriptor, BoxGeometryDescriptor, DirectionalLightDescriptor, LightDescriptor, MeshBasicMaterialDescriptor, PerspectiveCameraDescriptor, PlaneGeometryDescriptor, SphereGeometryDescriptor } from "@vyr/three"
+
+class Cache {
+    private _camera: CameraDescriptor | null = null
+    get camera() {
+        if (this._camera === null) {
+            this._camera = new PerspectiveCameraDescriptor()
+        }
+        return this._camera
+    }
+
+    private _light: LightDescriptor | null = null
+    get light() {
+        if (this._light === null) {
+            this._light = new AmbientLightDescriptor({ color: '#2d2d2d' })
+            this._light.add(new DirectionalLightDescriptor({ position: { x: -100, y: 100, z: 0 } }))
+        }
+        return this._light
+    }
+
+    readonly materialUrl = Asset.createVirtualUrl('remote/asset/material/basic.material.json')
+    private _material: MeshBasicMaterialDescriptor | null = null
+    get material() {
+        if (this._material === null) {
+            this._material = new MeshBasicMaterialDescriptor()
+        }
+        return this._material
+    }
+
+    readonly boxUrl = Asset.createVirtualUrl('remote/asset/material/box.geometry.json')
+    private _box: BoxGeometryDescriptor | null = null
+    get box() {
+        if (this._box === null) {
+            this._box = new BoxGeometryDescriptor()
+        }
+        return this._box
+    }
+    readonly sphereUrl = Asset.createVirtualUrl('remote/asset/material/sphere.geometry.json')
+    private _sphere: SphereGeometryDescriptor | null = null
+    get sphere() {
+        if (this._sphere === null) {
+            this._sphere = new SphereGeometryDescriptor()
+        }
+        return this._sphere
+    }
+    readonly planeUrl = Asset.createVirtualUrl('remote/asset/material/plane.geometry.json')
+    private _plane: PlaneGeometryDescriptor | null = null
+    get plane() {
+        if (this._plane === null) {
+            this._plane = new PlaneGeometryDescriptor()
+        }
+        return this._plane
+    }
+
+    orbitCollection = new Collection()
+    transformCollection = new Collection()
+}
+
+const cache = new Cache()
+
+export {
+    cache
+}

package/src/ChangeScriptable.ts

@@ -0,0 +1,31 @@
+import { Descriptor, Graphics, Scriptable, ServiceDescriptor } from "@vyr/engine";
+import { TransformControllerChangeArgs, TransformControllerDescriptor } from '@vyr/three'
+import { RemoteProcess, Job } from '@vyr/remote'
+import { cache } from "./Cache"
+
+class ChangeScriptable extends Scriptable {
+
+    execute(descriptor: TransformControllerDescriptor, graphics: Graphics, args: TransformControllerChangeArgs) {
+        const process = RemoteProcess.get(graphics.engine)
+        if (process === null) return
+
+        const target = Descriptor.get(args.event.target) as Descriptor
+        const service = ServiceDescriptor.traceService(target)
+        if (service) {
+            const orbit = cache.orbitCollection.get(service)
+            if (orbit) {
+                if (args.event.type === 'mousedown') {
+                    orbit.enabled = false
+                } else if (args.event.type === 'mouseup') {
+                    orbit.enabled = true
+                }
+                orbit.setNeedsUpdate()
+            }
+        }
+
+        const params = { eventType: args.event.type, target: args.event.target, descriptor: target.clone(false) }
+        process.bridge.send(new Job.invoke.transform.Response(params))
+    }
+}
+
+export default ChangeScriptable

package/src/RemoteExecutor.ts

@@ -0,0 +1,295 @@
+import { Asset, Descriptor, DeserializationObject, HTMLDescriptor, NodeDescriptor, PrefabeDescriptor, ServiceDescriptor, ServiceSchedulerDescriptor, Unit, UpdateArgs, Vector3 as _V3 } from '@vyr/engine'
+import { GeometryDescriptor, MaterialDescriptor, MeshDescriptor, NodeActor, OrbitControllerActor, OrbitControllerDescriptor, ParticleDescriptor, PerspectiveCameraDescriptor, PointsDescriptor, PointsMaterialDescriptor, SceneServiceDescriptor, SpriteDescriptor, SpriteMaterialDescriptor, TextureDescriptor, TransformControllerDescriptor, THREE } from '@vyr/three'
+import { RemoteExecutor as _RemoteExecutor, Job, RemoteProcess } from '@vyr/remote'
+import { checkParentValidity, flyTo, getControllerByService, getGraphics, getTransformEvent, lookAt, resize, updateModelByScheduler, updateOtherUpdateJob } from './utils'
+import { cache } from './Cache'
+
+class RemoteExecutor extends _RemoteExecutor {
+    async loadByAsset(task: InstanceType<typeof Job['asset']['load']['Task']>) {
+        await super.loadByAsset(task)
+        if (this.process.config.invoke) {
+            flyTo(this.process.scheduler.uuid, this.process)
+            updateModelByScheduler(this.process.scheduler, this.process)
+        }
+    }
+    async loadByScene(task: InstanceType<(typeof Job)['scene']['load']['Task']>) {
+        await super.loadByScene(task)
+        flyTo(this.process.scheduler.uuid, this.process)
+        updateModelByScheduler(this.process.scheduler, this.process)
+    }
+
+    async transformByInvoke(task: InstanceType<(typeof Job)['invoke']['transform']['Task']>) {
+        const transforms = cache.transformCollection.values()
+        for (const item of transforms) {
+            item.target = ''
+            item.mode = ''
+            item.enabled = false
+            item.setNeedsUpdate()
+        }
+
+        const target = Descriptor.get<Descriptor>(task.params.target)
+        let service = ServiceDescriptor.traceService(target)
+        if (service === null) return
+
+        if (target instanceof HTMLDescriptor && checkParentValidity(target)) {
+            if (service instanceof SceneServiceDescriptor) {
+                const ancestor = service.traceAncestor(false)
+                service = ServiceDescriptor.traceService(ancestor.parent)
+            }
+            super.transformByInvoke(task, service)
+        } else {
+            super.clearHTMLTransform()
+
+            const transform = cache.transformCollection.get<TransformControllerDescriptor>(service)
+            if (transform === null) return
+
+            const enabled = ['translate', 'rotate', 'scale'].includes(task.params.mode)
+            if (enabled) {
+                transform.target = task.params.target
+                transform.mode = task.params.mode
+                transform.enabled = true
+            }
+
+            if (target instanceof NodeDescriptor) lookAt(target, this.process)
+        }
+    }
+    async orbitByInvoke(task: InstanceType<(typeof Job)['invoke']['orbit']['Task']>) {
+        const orbits = cache.orbitCollection.values()
+        for (const orbit of orbits) {
+            orbit.enablePan = task.params.enablePan
+            orbit.screenSpacePanning = task.params.screenSpacePanning
+            orbit.setNeedsUpdate()
+        }
+    }
+    protected async getProperties(task: InstanceType<typeof Job['invoke']['properties']['Task']>,) {
+        let properties
+        const descriptor = Descriptor.get<Descriptor>(task.params.uuid)
+        const graphics = getGraphics(descriptor, this.process)
+        if (graphics === null) return
+
+        let targetUuid
+        if (task.params.type === 'getCurrentCamera') {
+            targetUuid = cache.camera.uuid
+        } else {
+            targetUuid = task.params.uuid
+        }
+
+        const target = Descriptor.get<Descriptor>(targetUuid)
+        if (target === null) return
+
+        properties = Descriptor.deepClone(target)
+
+        const response = new Job.invoke.properties.Response({ type: 'get', properties })
+        this.process.bridge.send(response)
+    }
+    protected async setProperties(task: InstanceType<typeof Job['invoke']['properties']['Task']>) {
+        const descriptor = Descriptor.get<Descriptor>(task.params.uuid)
+        const graphics = getGraphics(descriptor, this.process)
+        if (graphics === null) return
+
+        let targetUuid
+        if (task.params.type === 'setCurrentCamera') {
+            targetUuid = cache.camera.uuid
+        } else {
+            targetUuid = task.params.uuid
+        }
+
+        const target = Descriptor.get<Descriptor>(targetUuid)
+        if (descriptor instanceof NodeDescriptor && target instanceof NodeDescriptor) {
+            target.position.x = descriptor.position.x
+            target.position.y = descriptor.position.y
+            target.position.z = descriptor.position.z
+            target.scale.x = descriptor.scale.x
+            target.scale.y = descriptor.scale.y
+            target.scale.z = descriptor.scale.z
+            target.rotation.x = descriptor.rotation.x
+            target.rotation.y = descriptor.rotation.y
+            target.rotation.z = descriptor.rotation.z
+            target.setNeedsUpdate()
+        }
+
+        if (descriptor instanceof PerspectiveCameraDescriptor) {
+            const controller = getControllerByService(descriptor)
+            if (controller === null || controller.orbit === null) return
+            const args = { delta: 0 }
+            const camera = graphics.getActor<NodeActor>(descriptor, args)
+            camera.object.updateMatrixWorld(true)
+            const forward = camera.object.getWorldDirection(new THREE.Vector3())
+            const lookAtPosition = new THREE.Vector3()
+                .copy(camera.object.position)
+                .add(forward.multiplyScalar(1)).negate()
+            const orbitActor = graphics.getActor<OrbitControllerActor>(controller.orbit, args)
+            orbitActor.controls.setLookAt(
+                camera.object.position.x,
+                camera.object.position.y,
+                camera.object.position.z,
+                lookAtPosition.x,
+                lookAtPosition.y,
+                lookAtPosition.z,
+            )
+        }
+    }
+    async propertiesByInvoke(task: InstanceType<(typeof Job)['invoke']['properties']['Task']>) {
+        ['get', 'getCurrentCamera'].includes(task.params.type) ? this.getProperties(task) : this.setProperties(task)
+    }
+    async animationByInvoke(task: InstanceType<(typeof Job)['invoke']['animation']['Task']>) {
+        super.animationByInvoke(task)
+    }
+
+    resetTransformByRemoveJob(target: Descriptor) {
+        let service = ServiceDescriptor.traceService(target)
+        if (service === null) return
+
+        if (target instanceof HTMLDescriptor) {
+            if (service instanceof SceneServiceDescriptor) {
+                const ancestor = service.traceAncestor(false)
+                service = ServiceDescriptor.traceService(ancestor.parent)
+            }
+            super.resetTransformByRemoveJob(target, service)
+        } else {
+            const transform = cache.transformCollection.get<TransformControllerDescriptor>(service)
+            if (transform === null) return
+
+            if (transform.target === target.uuid) {
+                transform.target = ''
+                transform.enabled = false
+                transform.setNeedsUpdate()
+            }
+        }
+    }
+    updateOtherUpdateJob(target: Descriptor, deserialization: DeserializationObject<Descriptor>) {
+        let service = ServiceDescriptor.traceService(target)
+
+        if (target instanceof HTMLDescriptor) {
+            if (service instanceof SceneServiceDescriptor) {
+                const ancestor = service.traceAncestor(false)
+                service = ServiceDescriptor.traceService(ancestor.parent)
+            }
+            super.updateOtherUpdateJob(target, deserialization, service)
+        } else {
+            updateOtherUpdateJob(target, deserialization, service, this.process)
+        }
+    }
+
+    protected getRenderObject(url: string, descriptor: Descriptor) {
+        cache.material.map = ''
+        const mesh = new MeshDescriptor()
+        if (descriptor instanceof MaterialDescriptor) {
+            let target: (MeshDescriptor | SpriteDescriptor | PointsDescriptor | ParticleDescriptor) = mesh
+            if (descriptor instanceof PointsMaterialDescriptor) {
+                target = new PointsDescriptor()
+                target.geometry = cache.sphereUrl
+                Asset.set(cache.sphereUrl, cache.sphere)
+            } else if (descriptor instanceof SpriteMaterialDescriptor) {
+                target = new SpriteDescriptor()
+            } else {
+                target.geometry = cache.boxUrl
+                Asset.set(cache.boxUrl, cache.box)
+            }
+
+            target.material = url
+            return target
+        } else if (descriptor instanceof GeometryDescriptor) {
+            mesh.material = cache.materialUrl
+            mesh.geometry = url
+            Asset.set(cache.materialUrl, cache.material)
+        } else if (descriptor instanceof TextureDescriptor) {
+            cache.material.map = url
+            mesh.material = cache.materialUrl
+            mesh.geometry = cache.planeUrl
+            Asset.set(cache.materialUrl, cache.material)
+            Asset.set(cache.planeUrl, cache.plane)
+        }
+        return mesh
+    }
+    onLoadAsset(url: string, descriptor: Descriptor, scheduler: ServiceSchedulerDescriptor) {
+        super.onLoadAsset(url, descriptor, scheduler)
+        if (descriptor instanceof HTMLDescriptor) {
+            return
+        } else if (descriptor instanceof NodeDescriptor) {
+            const service = new SceneServiceDescriptor()
+            service.add(descriptor)
+            service.add(cache.light)
+            scheduler.add(service)
+        } else if (descriptor instanceof PrefabeDescriptor && descriptor.category === 'scene') {
+            const service = new SceneServiceDescriptor()
+            service.add(descriptor)
+            service.add(cache.light)
+            scheduler.add(service)
+        } else {
+            const service = new SceneServiceDescriptor()
+            service.add(this.getRenderObject(url, descriptor))
+            service.add(cache.light)
+            scheduler.add(service)
+        }
+    }
+    onAddService(service: ServiceDescriptor) {
+        super.onAddService(service)
+        if (service instanceof SceneServiceDescriptor) {
+            let transform = cache.transformCollection.get(service)
+            if (transform == null) {
+                transform = new TransformControllerDescriptor({ enabled: false, selectable: false })
+                cache.transformCollection.set(service, transform)
+                transform.camera = cache.camera.uuid
+                transform.event = getTransformEvent()
+            }
+            service.add(transform as TransformControllerDescriptor)
+
+            let orbit = cache.orbitCollection.get(service)
+            if (orbit === null) {
+                orbit = new OrbitControllerDescriptor({ enabled: true, selectable: false, draggingSmoothTime: 0, smoothTime: 0, restThreshold: 0, dollyToCursor: false })
+                cache.orbitCollection.set(service, orbit)
+                orbit.camera = cache.camera.uuid
+            }
+            service.add(orbit as OrbitControllerDescriptor)
+        }
+    }
+    onRemoveService(service: ServiceDescriptor) {
+        super.onRemoveService(service)
+        if (service instanceof SceneServiceDescriptor) {
+            const transform = cache.transformCollection.get<TransformControllerDescriptor>(service)
+            if (transform !== null) {
+                cache.transformCollection.delete(service)
+                service.remove(transform)
+            }
+
+            const orbit = cache.orbitCollection.get<OrbitControllerDescriptor>(service)
+            if (orbit !== null) {
+                cache.orbitCollection.delete(service)
+                service.remove(orbit)
+            }
+        }
+    }
+    onUpdateScheduler(unit: Unit, args: UpdateArgs) {
+        const descriptor = Descriptor.get<Descriptor>(unit.uuid)
+        const service = cache.transformCollection.getByMap<TransformControllerDescriptor>(descriptor)
+            ?? cache.orbitCollection.getByMap<OrbitControllerDescriptor>(descriptor)
+
+        if (service !== null) {
+            //@ts-ignore
+            window['__VYR_RUNTIME.DISABLED_INPUT'] = false
+        }
+
+        super.onUpdateScheduler(unit, args)
+    }
+
+    enhance(process: RemoteProcess) {
+        super.enhance(process, (scheduler) => {
+            Object.defineProperty(scheduler, 'camera', { get() { return cache.camera.uuid }, set() { } })
+        })
+    }
+
+    async listen() {
+        const transformEvent = getTransformEvent()
+        Asset.provider(transformEvent, () => import('./ChangeScriptable'))
+        Asset.load(transformEvent)
+
+        window.addEventListener('resize', resize(this.process))
+
+        await super.listen()
+    }
+}
+
+export {
+    RemoteExecutor
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+import { RemoteProcess } from '@vyr/remote'
+import { RemoteExecutor } from './RemoteExecutor'
+
+const setup = (process: RemoteProcess) => {
+    process.setExecutor(new RemoteExecutor(process))
+}
+RemoteProcess.register(setup)
+
+export { setup }
+export * from './locale'

package/src/locale/Language.ts

@@ -0,0 +1,10 @@
+import { Locale } from "@vyr/locale";
+import { zhCnLanguageProvider, ZhCNLanguageProvider } from "./LanguageProvider";
+
+Locale.register(zhCnLanguageProvider)
+
+const language = Locale.getLanguage<ZhCNLanguageProvider>(zhCnLanguageProvider.name)
+
+export {
+    language
+}

package/src/locale/LanguageProvider.ts

@@ -0,0 +1,15 @@
+import { LanguageProvider } from '@vyr/locale'
+
+interface ZhCNLanguageProvider extends LanguageProvider {
+    
+}
+
+const zhCnLanguageProvider: ZhCNLanguageProvider = {
+    id: 'zh_CN',
+    name: '@vyr/three-remote',
+}
+
+export {
+    ZhCNLanguageProvider,
+    zhCnLanguageProvider,
+}

package/src/locale/index.ts

@@ -0,0 +1,2 @@
+export * from './LanguageProvider'
+export * from './Language'

package/src/shims-vue.d.ts

@@ -0,0 +1,4 @@
+declare module '*.vue' {
+  const component: DefineComponent<{}, {}, any>
+  export default component
+}

package/src/utils/flyto.ts

@@ -0,0 +1,103 @@
+import { CameraDescriptor, Graphics, Descriptor, NodeDescriptor, ServiceDescriptor, ServiceSchedulerDescriptor, UpdateArgs, Vector3 as _V3 } from "@vyr/engine"
+import { NodeActor, OrbitControllerActor, OrbitControllerDescriptor, TransformControllerDescriptor, THREE } from "@vyr/three"
+import { RemoteProcess } from "@vyr/remote"
+import { cache } from "../Cache"
+
+const rawVector3 = new THREE.Vector3(0, 0, 0)
+const emptyBox = new THREE.Box3()
+const getBox3 = (descriptor: Descriptor, graphics: Graphics, args: UpdateArgs) => {
+    const box3 = new THREE.Box3()
+    // const ignore: Descriptor[] = []
+    // if (instance) ignore.push(instance.orbit, instance.transform)
+    descriptor.traverse(sub => {
+        const actor = graphics.getActor<NodeActor<THREE.Object3D>>(sub, args)
+        if (actor instanceof NodeActor) {
+            if (actor.object.visible === false) return true
+            box3.expandByObject(actor.object)
+            return true
+        }
+    }, true)
+    return box3
+}
+const getControllerByService = (target: Descriptor) => {
+    const service = ServiceDescriptor.traceService(target)
+    if (service instanceof ServiceDescriptor) {
+        const orbit = cache.orbitCollection.get<OrbitControllerDescriptor>(service)
+        const transform = cache.transformCollection.get<TransformControllerDescriptor>(service)
+        return { transform, orbit }
+    }
+    return null
+}
+const getFlyInfo = (descriptor: Descriptor, graphics: Graphics, args: UpdateArgs) => {
+    const box3 = getBox3(descriptor, graphics, args)
+
+    if (box3.equals(emptyBox)) return null
+
+    const sphere = box3.getBoundingSphere(new THREE.Sphere())
+    const cameraActor = graphics.getActor<NodeActor<THREE.PerspectiveCamera>>(cache.camera, args)
+
+    const fov = THREE.MathUtils.degToRad(cameraActor.object.fov)
+    const fovHorizontal = 2 * Math.atan(Math.tan(fov / 2) * cameraActor.object.aspect)
+
+    const distanceV = sphere.radius / Math.tan(fov / 2);
+    const distanceH = sphere.radius / Math.tan(fovHorizontal / 2);
+    const distance = Math.max(distanceV, distanceH) * 1.05
+
+    const location = new THREE.Vector3().copy(sphere.center)
+    location.add(new THREE.Vector3(0, 0.5, 1).normalize().multiplyScalar(distance))
+
+    const position = rawVector3.equals(location) && rawVector3.equals(sphere.center) ? new THREE.Vector3(0, 0, 5) : location
+
+    return {
+        position,
+        lookAt: sphere.center
+    }
+}
+const flyToTarget = (descriptor: Descriptor, graphics: Graphics, args: UpdateArgs, orbit: OrbitControllerDescriptor | null) => {
+    const flyInfo = getFlyInfo(descriptor, graphics, args)
+    if (flyInfo === null) return
+
+    cache.camera.position.set(flyInfo.position.x, flyInfo.position.y, flyInfo.position.z)
+    cache.camera.setNeedsUpdate()
+    if (!orbit) return
+
+    const orbitActor = graphics.getActor<OrbitControllerActor>(orbit, args)
+    orbitActor.controls.setLookAt(
+        flyInfo.position.x,
+        flyInfo.position.y,
+        flyInfo.position.z,
+        flyInfo.lookAt.x,
+        flyInfo.lookAt.y,
+        flyInfo.lookAt.z,
+    )
+}
+const flyTo = (uuid: string, process: RemoteProcess) => {
+    const descriptor = Descriptor.get<NodeDescriptor>(uuid)
+    if (descriptor === null) return
+    const cameraDescriptor = Descriptor.get<CameraDescriptor>(process.scheduler.camera)
+    if (cameraDescriptor === null) return
+
+    const services: Descriptor[] = []
+    if (descriptor instanceof ServiceSchedulerDescriptor) {
+        RemoteProcess.getServices(descriptor, services)
+    } else if (descriptor instanceof ServiceDescriptor) {
+        services.push(descriptor)
+    }
+
+    const graphics = process.engine.getGraphics(process.scheduler)
+    const args = { delta: 0 }
+
+    if (services.length === 0) {
+        const controller = getControllerByService(descriptor)
+        if (controller === null) return
+        flyToTarget(descriptor, graphics, args, controller.orbit)
+    } else {
+        for (const service of services) {
+            const controller = getControllerByService(service)
+            if (controller === null) return
+            flyToTarget(descriptor, graphics, args, controller.orbit)
+        }
+    }
+}
+
+export { getControllerByService, getFlyInfo, flyToTarget, flyTo }

package/src/utils/index.ts

@@ -0,0 +1,92 @@
+import { Descriptor, DynamicDescriptor, Generate, HTMLDescriptor, NodeDescriptor, PrefabeDescriptor, PrefabInstanceDescriptor, ServiceSchedulerDescriptor } from "@vyr/engine"
+import { RemoteProcess } from "@vyr/remote"
+import { HTMLConvertDescriptor, NodeActor, OrbitControllerActor, THREE } from "@vyr/three"
+import { cache } from "../Cache"
+import { getControllerByService, getFlyInfo } from './flyto'
+
+let transformEvent = ''
+const getTransformEvent = () => {
+    if (transformEvent === '') {
+        transformEvent = `TransformController/event/${Generate.uuid()}.ts`
+    }
+
+    return transformEvent
+}
+
+const getParent = (descriptor: Descriptor): Descriptor | boolean | null => {
+    const ancestor = descriptor.traceAncestor(false)
+    if (ancestor.parent === null) {
+        return null
+    } else if (ancestor.parent instanceof HTMLDescriptor) {
+        return ancestor.parent
+    } else if (ancestor.parent instanceof DynamicDescriptor) {
+        return getParent(ancestor.parent)
+    } else if (ancestor.parent instanceof PrefabeDescriptor) {
+        const nextParent = getParent(ancestor.parent)
+        return nextParent === null ? true : nextParent
+    } else if (ancestor.parent instanceof PrefabInstanceDescriptor) {
+        return getParent(ancestor.parent)
+    } else if (ancestor.parent instanceof HTMLConvertDescriptor) {
+        return null
+    } else if (ancestor.parent instanceof NodeDescriptor) {
+        return ancestor.parent
+    } else {
+        return null
+    }
+}
+const checkParentValidity = (html: HTMLDescriptor) => {
+    const parent = getParent(html)
+    if (parent === null) {
+        return false
+    } else if (parent instanceof HTMLDescriptor) {
+        return true
+    } else if (parent instanceof NodeDescriptor) {
+        return false
+    } else {
+        return true
+    }
+}
+
+const getGraphics = (descriptor: Descriptor, process: RemoteProcess) => {
+    const ancestor = descriptor.traceAncestor(true)
+    const scheduler = ancestor.collection[ancestor.collection.length - 1] as ServiceSchedulerDescriptor
+    return scheduler instanceof ServiceSchedulerDescriptor ? process.engine.getGraphics(scheduler) : null
+}
+
+const resize = (process: RemoteProcess) => {
+    return () => {
+        const graphics = process.engine.getGraphics(process.scheduler)
+        if (graphics == null) return
+        const interpreter = graphics.getInterpreter(cache.camera)
+        const actor = interpreter.getActor<NodeActor<THREE.PerspectiveCamera>>(cache.camera, { delta: 0 })
+        actor.object.aspect = process.engine.DOM.clientWidth / process.engine.DOM.clientHeight
+        actor.object.updateProjectionMatrix()
+    }
+}
+
+const lookAt = (target: Descriptor, process: RemoteProcess) => {
+    const controller = getControllerByService(target)
+    if (controller === null) return
+    const args = { delta: 0 }
+    const graphics = process.engine.getGraphics(process.scheduler)
+    const flyInfo = getFlyInfo(target, graphics, args)
+    if (flyInfo === null) return
+    if (!controller.orbit) return
+
+    const orbitActor = graphics.getActor<OrbitControllerActor>(controller.orbit, args)
+    orbitActor.controls.setTarget(
+        flyInfo.lookAt.x,
+        flyInfo.lookAt.y,
+        flyInfo.lookAt.z,
+    )
+}
+
+export {
+    getTransformEvent,
+    checkParentValidity,
+    getGraphics,
+    resize,
+    lookAt,
+}
+export * from './update'
+export * from './flyto'

package/src/utils/update.ts

@@ -0,0 +1,92 @@
+import { Asset, Descriptor, DeserializationObject, observer, ServiceDescriptor, ServiceSchedulerDescriptor } from "@vyr/engine"
+import { TextureDescriptor, TransformControllerDescriptor, ModelDescriptor, AnimationActionDescriptor, SceneServiceDescriptor, SceneServiceActor, THREE } from "@vyr/three"
+import { Job, RemoteProcess } from "@vyr/remote"
+import { cache } from "../Cache"
+
+const updateAnimationAction = async (uuid: string, url: string, process: RemoteProcess) => {
+    const animations: string[] = []
+    if (url) {
+        const currentUrl = `${url}?${uuid}`
+        Asset.load(currentUrl)
+        await Asset.readly()
+        const model = Asset.get<THREE.Object3D>(currentUrl)
+        for (const animation of model.animations) {
+            animations.push(animation.name)
+        }
+    }
+    process.bridge.send(new Job.invoke.animation.Response({ type: 'action', uuid: uuid, animations }))
+}
+
+const updateSceneService = (target: SceneServiceDescriptor, deserialization: DeserializationObject<SceneServiceDescriptor>, process: RemoteProcess) => {
+    if (target.shadowMapType === deserialization.shadowMapType) return
+    const args = { delta: 0 }
+    const graphics = process.engine.getGraphics(process.scheduler)
+    const actor = graphics.getActor<SceneServiceActor>(target, args)
+    if (actor === null) return
+    actor.pipeline.resetState()
+    actor.scene.traverse(sub => {
+        if (sub instanceof THREE.Light && sub.shadow) {
+            sub.shadow.map?.dispose(); // 释放旧的阴影贴图
+            sub.shadow.map = null;     // 强制重新创建
+        }
+        //@ts-ignore
+        const material = sub.material
+        if (material instanceof THREE.Material) {
+            material.needsUpdate = true //强制更新材质
+        }
+    })
+}
+
+const updateModel = async (target: ModelDescriptor, deserialization: DeserializationObject<ModelDescriptor>, process: RemoteProcess) => {
+    if (target.url === deserialization.url) return
+    updateAnimationAction(target.uuid, deserialization.url, process)
+
+    if (deserialization.url) {
+        Asset.load(`${deserialization.url}?${deserialization.uuid}`)
+        await Asset.readly()
+        process.engine.listen('afterRender', () => {
+            for (const actionDescriptor of target.children) {
+                if (actionDescriptor instanceof AnimationActionDescriptor) {
+                    actionDescriptor.setNeedsUpdate()
+                }
+            }
+        }, { once: true })
+    }
+}
+
+const updateModelByScheduler = (scheduler: ServiceSchedulerDescriptor, process: RemoteProcess) => {
+    scheduler.traverse(sub => {
+        if (sub instanceof ModelDescriptor) {
+            updateAnimationAction(sub.uuid, sub.url, process)
+        }
+    })
+}
+
+const updateTexture = (target: TextureDescriptor, deserialization: DeserializationObject<TextureDescriptor>, process: RemoteProcess) => {
+    if (target.url === deserialization.url) return
+    const args = { delta: 0 }
+    const graphics = process.engine.getGraphics(process.scheduler)
+    const unit = graphics.getUnit(target.uuid)
+    if (unit === null) return
+    graphics.doFree(unit, args)
+    graphics.addRoot(unit.queue.url, target)
+    observer.trigger('updateDeps', { self: target.uuid })
+}
+
+const updateOtherUpdateJob = (target: Descriptor, deserialization: DeserializationObject<Descriptor>, service: ServiceDescriptor | null, process: RemoteProcess) => {
+    if (target instanceof TextureDescriptor) {
+        updateTexture(target, deserialization as TextureDescriptor, process)
+    } else if (target instanceof ModelDescriptor) {
+        updateModel(target, deserialization as ModelDescriptor, process)
+    } else if (target instanceof SceneServiceDescriptor) {
+        updateSceneService(target, deserialization as SceneServiceDescriptor, process)
+    }
+    if (service === null) return
+    const transform = cache.transformCollection.get<TransformControllerDescriptor>(service)
+    if (transform === null) return
+    if (transform.target === target.uuid) {
+        process.engine.listen('afterRender', () => transform.setNeedsUpdate(), { once: true })
+    }
+}
+
+export { updateModelByScheduler, updateOtherUpdateJob }