@vyr/three-remote 0.0.33 → 0.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vyr/three-remote",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "description": "",
   "main": "./src/index.ts",
   "author": "",

package/src/Cache.ts

@@ -1,55 +1,55 @@
-import { CameraDescriptor, Asset } from "@vyr/engine"
+import { Camera, Asset } from "@vyr/engine"
 import { Collection } from "@vyr/remote"
-import { AmbientLightDescriptor, BoxGeometryDescriptor, DirectionalLightDescriptor, LightDescriptor, MeshBasicMaterialDescriptor, PerspectiveCameraDescriptor, PlaneGeometryDescriptor, SphereGeometryDescriptor } from "@vyr/three"
+import { AmbientLight, BoxGeometry, DirectionalLight, Light, MeshBasicMaterial, PerspectiveCamera, PlaneGeometry, SphereGeometry } from "@vyr/three"
 
-class Cache {
-    private _camera: CameraDescriptor | null = null
+export class Cache {
+    private _camera: Camera | null = null
     get camera() {
         if (this._camera === null) {
-            this._camera = new PerspectiveCameraDescriptor()
+            this._camera = new PerspectiveCamera()
         }
         return this._camera
     }
 
-    private _light: LightDescriptor | null = null
+    private _light: Light | 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 } }))
+            this._light = new AmbientLight({ color: '#2d2d2d' })
+            this._light.add(new DirectionalLight({ 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
+    private _material: MeshBasicMaterial | null = null
     get material() {
         if (this._material === null) {
-            this._material = new MeshBasicMaterialDescriptor()
+            this._material = new MeshBasicMaterial()
         }
         return this._material
     }
 
     readonly boxUrl = Asset.createVirtualUrl('remote/asset/material/box.geometry.json')
-    private _box: BoxGeometryDescriptor | null = null
+    private _box: BoxGeometry | null = null
     get box() {
         if (this._box === null) {
-            this._box = new BoxGeometryDescriptor()
+            this._box = new BoxGeometry()
         }
         return this._box
     }
     readonly sphereUrl = Asset.createVirtualUrl('remote/asset/material/sphere.geometry.json')
-    private _sphere: SphereGeometryDescriptor | null = null
+    private _sphere: SphereGeometry | null = null
     get sphere() {
         if (this._sphere === null) {
-            this._sphere = new SphereGeometryDescriptor()
+            this._sphere = new SphereGeometry()
         }
         return this._sphere
     }
     readonly planeUrl = Asset.createVirtualUrl('remote/asset/material/plane.geometry.json')
-    private _plane: PlaneGeometryDescriptor | null = null
+    private _plane: PlaneGeometry | null = null
     get plane() {
         if (this._plane === null) {
-            this._plane = new PlaneGeometryDescriptor()
+            this._plane = new PlaneGeometry()
         }
         return this._plane
     }
@@ -58,8 +58,4 @@ class Cache {
     transformCollection = new Collection()
 }
 
-const cache = new Cache()
-
-export {
-    cache
-}
+export const cache = new Cache()

package/src/ChangeScriptable.ts

@@ -1,30 +1,34 @@
-import { Descriptor, Graphics, Scriptable, ServiceDescriptor } from "@vyr/engine";
-import { TransformControllerChangeArgs } from '@vyr/three'
+import z from "zod";
+import { Descriptor, Graphics, Scriptable, traceService } from "@vyr/engine";
 import { RemoteProcess, Job } from '@vyr/remote'
 import { cache } from "./Cache"
+import { getTransformEvent } from "./utils";
 
-class ChangeScriptable extends Scriptable {
-    execute(graphics: Graphics, args: TransformControllerChangeArgs) {
+export class ChangeScriptable extends Scriptable {
+    static id = getTransformEvent()
+    static inputSchame = z.object({
+        type: z.enum(['mousedown', 'mouseup', 'change']),
+        target: z.string(),
+    })
+    execute(graphics: Graphics, trigger: string, input: z.infer<ChangeScriptable['inputSchame']>) {
         const process = RemoteProcess.get(graphics.engine)
         if (process === null) return
 
-        const target = Descriptor.get(args.event.target) as Descriptor
-        const service = ServiceDescriptor.traceService(target)
+        const target = Descriptor.get(input.target) as Descriptor
+        const service = traceService(target)
         if (service) {
             const orbit = cache.orbitCollection.get(service)
             if (orbit) {
-                if (args.event.type === 'mousedown') {
+                if (input.type === 'mousedown') {
                     orbit.enabled = false
-                } else if (args.event.type === 'mouseup') {
+                } else if (input.type === 'mouseup') {
                     orbit.enabled = true
                 }
                 orbit.setNeedsUpdate()
             }
         }
 
-        const params = { eventType: args.event.type, target: args.event.target, descriptor: target.clone(false) }
+        const params = { eventType: input.type, target: input.target, descriptor: target.clone(false) }
         process.bridge.send(new Job.invoke.transform.Response(params))
     }
-}
-
-export default ChangeScriptable
+}

package/src/RemoteExecutor.ts

@@ -1,23 +1,17 @@
-import { Asset, Descriptor, DeserializationObject, HTMLDescriptor, NodeDescriptor, PrefabeDescriptor, ServiceDescriptor, ServiceSchedulerDescriptor, Unit, 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 { Asset, Descriptor, DeserializationObject, Node, Service, Scene, Unit, Vector3 as _V3, traceService, isHTML, Scriptable } from '@vyr/engine'
+import { Mesh, NodeActor, OrbitControllerActor, OrbitController, Particle, PerspectiveCamera, Points, PointsMaterial, Scene3DService, Sprite, SpriteMaterial, Texture, TransformController, THREE, geometry, material } 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 { checkParentValidity, flyTo, getControllerByService, getGraphics, getTransformEvent, lookAt, resize, updateModelByScene, updateOtherUpdateJob } from './utils'
 import { cache } from './Cache'
 
-class RemoteExecutor extends _RemoteExecutor {
+export 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)
+            flyTo(this.process.scene.uuid, this.process)
+            updateModelByScene(this.process.scene, 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) {
@@ -28,19 +22,19 @@ class RemoteExecutor extends _RemoteExecutor {
         }
 
         const target = Descriptor.get<Descriptor>(task.params.target)
-        let service = ServiceDescriptor.traceService(target)
+        let service = traceService(target)
         if (service === null) return
 
-        if (target instanceof HTMLDescriptor && checkParentValidity(target)) {
-            if (service instanceof SceneServiceDescriptor) {
+        if (isHTML(target) && checkParentValidity(target)) {
+            if (service instanceof Scene3DService) {
                 const ancestor = service.traceAncestor(false)
-                service = ServiceDescriptor.traceService(ancestor.parent)
+                service = traceService(ancestor.parent)
             }
             super.transformByInvoke(task, service)
         } else {
             super.clearHTMLTransform()
 
-            const transform = cache.transformCollection.get<TransformControllerDescriptor>(service)
+            const transform = cache.transformCollection.get<TransformController>(service)
             if (transform === null) return
 
             const enabled = ['translate', 'rotate', 'scale'].includes(task.params.mode)
@@ -50,7 +44,7 @@ class RemoteExecutor extends _RemoteExecutor {
                 transform.enabled = true
             }
 
-            if (target instanceof NodeDescriptor) lookAt(target, this.process)
+            if (target instanceof Node) lookAt(target, this.process)
         }
     }
     async orbitByInvoke(task: InstanceType<(typeof Job)['invoke']['orbit']['Task']>) {
@@ -95,7 +89,7 @@ class RemoteExecutor extends _RemoteExecutor {
         }
 
         const target = Descriptor.get<Descriptor>(targetUuid)
-        if (descriptor instanceof NodeDescriptor && target instanceof NodeDescriptor) {
+        if (descriptor instanceof Node && target instanceof Node) {
             target.position.x = descriptor.position.x
             target.position.y = descriptor.position.y
             target.position.z = descriptor.position.z
@@ -108,7 +102,7 @@ class RemoteExecutor extends _RemoteExecutor {
             target.setNeedsUpdate()
         }
 
-        if (descriptor instanceof PerspectiveCameraDescriptor) {
+        if (descriptor instanceof PerspectiveCamera) {
             const controller = getControllerByService(descriptor)
             if (controller === null || controller.orbit === null) return
             const interpreter = graphics.getInterpreter(descriptor)
@@ -138,17 +132,17 @@ class RemoteExecutor extends _RemoteExecutor {
     }
 
     resetTransformByRemoveJob(target: Descriptor) {
-        let service = ServiceDescriptor.traceService(target)
+        let service = traceService(target)
         if (service === null) return
 
-        if (target instanceof HTMLDescriptor) {
-            if (service instanceof SceneServiceDescriptor) {
+        if (isHTML(target)) {
+            if (service instanceof Scene3DService) {
                 const ancestor = service.traceAncestor(false)
-                service = ServiceDescriptor.traceService(ancestor.parent)
+                service = traceService(ancestor.parent)
             }
             super.resetTransformByRemoveJob(target, service)
         } else {
-            const transform = cache.transformCollection.get<TransformControllerDescriptor>(service)
+            const transform = cache.transformCollection.get<TransformController>(service)
             if (transform === null) return
 
             if (transform.target === target.uuid) {
@@ -159,12 +153,12 @@ class RemoteExecutor extends _RemoteExecutor {
         }
     }
     updateOtherUpdateJob(target: Descriptor, deserialization: DeserializationObject<Descriptor>) {
-        let service = ServiceDescriptor.traceService(target)
+        let service = traceService(target)
 
-        if (target instanceof HTMLDescriptor) {
-            if (service instanceof SceneServiceDescriptor) {
+        if (isHTML(target)) {
+            if (service instanceof Scene3DService) {
                 const ancestor = service.traceAncestor(false)
-                service = ServiceDescriptor.traceService(ancestor.parent)
+                service = traceService(ancestor.parent)
             }
             super.updateOtherUpdateJob(target, deserialization, service)
         } else {
@@ -174,15 +168,15 @@ class RemoteExecutor extends _RemoteExecutor {
 
     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()
+        const mesh = new Mesh()
+        if (material.isMaterial(descriptor)) {
+            let target: (Mesh | Sprite | Points | Particle) = mesh
+            if (descriptor instanceof PointsMaterial) {
+                target = new Points()
                 target.geometry = cache.sphereUrl
                 Asset.set(cache.sphereUrl, cache.sphere)
-            } else if (descriptor instanceof SpriteMaterialDescriptor) {
-                target = new SpriteDescriptor()
+            } else if (descriptor instanceof SpriteMaterial) {
+                target = new Sprite()
             } else {
                 target.geometry = cache.boxUrl
                 Asset.set(cache.boxUrl, cache.box)
@@ -190,11 +184,11 @@ class RemoteExecutor extends _RemoteExecutor {
 
             target.material = url
             return target
-        } else if (descriptor instanceof GeometryDescriptor) {
+        } else if (geometry.isGeometry(descriptor)) {
             mesh.material = cache.materialUrl
             mesh.geometry = url
             Asset.set(cache.materialUrl, cache.material)
-        } else if (descriptor instanceof TextureDescriptor) {
+        } else if (descriptor instanceof Texture) {
             cache.material.map = url
             mesh.material = cache.materialUrl
             mesh.geometry = cache.planeUrl
@@ -203,94 +197,84 @@ class RemoteExecutor extends _RemoteExecutor {
         }
         return mesh
     }
-    onLoadAsset(url: string, descriptor: Descriptor, scheduler: ServiceSchedulerDescriptor) {
-        super.onLoadAsset(url, descriptor, scheduler)
-        if (descriptor instanceof HTMLDescriptor) {
+    onLoadAsset(url: string, descriptor: Descriptor, scene: Scene) {
+        super.onLoadAsset(url, descriptor, scene)
+        if (isHTML(descriptor)) {
             return
-        } else if (descriptor instanceof NodeDescriptor) {
-            const service = new SceneServiceDescriptor()
+        } else if (descriptor instanceof Node) {
+            const service = new Scene3DService()
             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)
+            scene.add(service)
         } else {
-            const service = new SceneServiceDescriptor()
+            const service = new Scene3DService()
             service.add(this.getRenderObject(url, descriptor))
             service.add(cache.light)
-            scheduler.add(service)
+            scene.add(service)
         }
     }
-    onAddService(service: ServiceDescriptor) {
+    onAddService(service: Service) {
         super.onAddService(service)
-        if (service instanceof SceneServiceDescriptor) {
+        if (service instanceof Scene3DService) {
             let transform = cache.transformCollection.get(service)
             if (transform == null) {
-                transform = new TransformControllerDescriptor({ enabled: false, selectable: false })
+                transform = new TransformController({ enabled: false, selectable: false })
                 cache.transformCollection.set(service, transform)
                 transform.camera = cache.camera.uuid
                 transform.event = getTransformEvent()
             }
-            service.add(transform as TransformControllerDescriptor)
+            service.add(transform as TransformController)
 
             let orbit = cache.orbitCollection.get(service)
             if (orbit === null) {
-                orbit = new OrbitControllerDescriptor({ enabled: true, selectable: false, draggingSmoothTime: 0, smoothTime: 0, restThreshold: 0, dollyToCursor: false })
+                orbit = new OrbitController({ 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)
+            service.add(orbit as OrbitController)
         }
     }
-    onRemoveService(service: ServiceDescriptor) {
+    onRemoveService(service: Service) {
         super.onRemoveService(service)
-        if (service instanceof SceneServiceDescriptor) {
-            const transform = cache.transformCollection.get<TransformControllerDescriptor>(service)
+        if (service instanceof Scene3DService) {
+            const transform = cache.transformCollection.get<TransformController>(service)
             if (transform !== null) {
                 cache.transformCollection.delete(service)
                 service.remove(transform)
             }
 
-            const orbit = cache.orbitCollection.get<OrbitControllerDescriptor>(service)
+            const orbit = cache.orbitCollection.get<OrbitController>(service)
             if (orbit !== null) {
                 cache.orbitCollection.delete(service)
                 service.remove(orbit)
             }
         }
     }
-    onUpdateScheduler(unit: Unit) {
+    onUpdateScene(unit: Unit) {
         const descriptor = Descriptor.get<Descriptor>(unit.uuid)
-        const service = cache.transformCollection.getByMap<TransformControllerDescriptor>(descriptor)
-            ?? cache.orbitCollection.getByMap<OrbitControllerDescriptor>(descriptor)
+        const service = cache.transformCollection.getByMap<TransformController>(descriptor)
+            ?? cache.orbitCollection.getByMap<OrbitController>(descriptor)
 
         if (service !== null) {
             //@ts-ignore
             window['__VYR_RUNTIME.DISABLED_INPUT'] = false
         }
 
-        super.onUpdateScheduler(unit)
+        super.onUpdateScene(unit)
     }
 
     enhance(process: RemoteProcess) {
         super.enhance(process, (graphics) => {
-            Object.defineProperty(graphics.scheduler, 'camera', { get() { return cache.camera.uuid }, set() { } })
+            Object.defineProperty(graphics.scene, 'camera', { get() { return cache.camera.uuid }, set() { } })
         })
     }
 
     async listen() {
-        const transformEvent = getTransformEvent()
-        Asset.setProvider(transformEvent, () => import('./ChangeScriptable'))
-        Asset.load(transformEvent)
+        const { ChangeScriptable } = await import('./ChangeScriptable')
+        Scriptable.register(ChangeScriptable)
 
         window.addEventListener('resize', resize(this.process))
 
         await super.listen()
     }
-}
-
-export {
-    RemoteExecutor
 }

package/src/index.ts

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

package/src/locale/Language.ts

@@ -3,8 +3,4 @@ import { zhCnLanguageProvider, ZhCNLanguageProvider } from "./LanguageProvider";
 
 Locale.register(zhCnLanguageProvider)
 
-const language = Locale.getLanguage<ZhCNLanguageProvider>(zhCnLanguageProvider.name)
-
-export {
-    language
-}
+export const language = Locale.getLanguage<ZhCNLanguageProvider>(zhCnLanguageProvider.name)

package/src/locale/LanguageProvider.ts

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

package/src/utils/flyto.ts

@@ -1,11 +1,11 @@
-import { CameraDescriptor, Graphics, Descriptor, NodeDescriptor, ServiceDescriptor, ServiceSchedulerDescriptor, Vector3 as _V3 } from "@vyr/engine"
-import { NodeActor, OrbitControllerActor, OrbitControllerDescriptor, TransformControllerDescriptor, THREE } from "@vyr/three"
+import { Camera, Graphics, Descriptor, Node, Scene, isService, traceService, Vector3 as _V3 } from "@vyr/engine"
+import { NodeActor, OrbitControllerActor, OrbitController, TransformController, 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) => {
+export const getBox3 = (descriptor: Descriptor, graphics: Graphics) => {
     const box3 = new THREE.Box3()
     // const ignore: Descriptor[] = []
     // if (instance) ignore.push(instance.orbit, instance.transform)
@@ -19,16 +19,18 @@ const getBox3 = (descriptor: Descriptor, graphics: Graphics) => {
     }, 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)
+
+export const getControllerByService = (target: Descriptor) => {
+    const service = traceService(target)
+    if (isService(service)) {
+        const orbit = cache.orbitCollection.get<OrbitController>(service)
+        const transform = cache.transformCollection.get<TransformController>(service)
         return { transform, orbit }
     }
     return null
 }
-const getFlyInfo = (descriptor: Descriptor, graphics: Graphics) => {
+
+export const getFlyInfo = (descriptor: Descriptor, graphics: Graphics) => {
     const box3 = getBox3(descriptor, graphics)
 
     if (box3.equals(emptyBox)) return null
@@ -53,7 +55,8 @@ const getFlyInfo = (descriptor: Descriptor, graphics: Graphics) => {
         lookAt: sphere.center
     }
 }
-const flyToTarget = (descriptor: Descriptor, graphics: Graphics, orbit: OrbitControllerDescriptor | null) => {
+
+export const flyToTarget = (descriptor: Descriptor, graphics: Graphics, orbit: OrbitController | null) => {
     const flyInfo = getFlyInfo(descriptor, graphics)
     if (flyInfo === null) return
 
@@ -71,20 +74,21 @@ const flyToTarget = (descriptor: Descriptor, graphics: Graphics, orbit: OrbitCon
         flyInfo.lookAt.z,
     )
 }
-const flyTo = (uuid: string, process: RemoteProcess) => {
-    const descriptor = Descriptor.get<NodeDescriptor>(uuid)
+
+export const flyTo = (uuid: string, process: RemoteProcess) => {
+    const descriptor = Descriptor.get<Node>(uuid)
     if (descriptor === null) return
-    const cameraDescriptor = Descriptor.get<CameraDescriptor>(process.scheduler.camera)
+    const cameraDescriptor = Descriptor.get<Camera>(process.scene.camera)
     if (cameraDescriptor === null) return
 
     const services: Descriptor[] = []
-    if (descriptor instanceof ServiceSchedulerDescriptor) {
+    if (descriptor instanceof Scene) {
         RemoteProcess.getServices(descriptor, services)
-    } else if (descriptor instanceof ServiceDescriptor) {
+    } else if (isService(descriptor)) {
         services.push(descriptor)
     }
 
-    const graphics = process.engine.getGraphics(process.scheduler)
+    const graphics = process.engine.getGraphics(process.scene)
 
     if (services.length === 0) {
         const controller = getControllerByService(descriptor)
@@ -97,6 +101,4 @@ const flyTo = (uuid: string, process: RemoteProcess) => {
             flyToTarget(descriptor, graphics, controller.orbit)
         }
     }
-}
-
-export { getControllerByService, getFlyInfo, flyToTarget, flyTo }
+}

package/src/utils/index.ts

@@ -1,11 +1,11 @@
-import { Descriptor, DynamicDescriptor, Generate, HTMLDescriptor, NodeDescriptor, PrefabeDescriptor, PrefabInstanceDescriptor, ServiceSchedulerDescriptor } from "@vyr/engine"
+import { Descriptor, Generate, HTML, isHTML, Node, Scene } from "@vyr/engine"
 import { RemoteProcess } from "@vyr/remote"
-import { HTMLConvertDescriptor, NodeActor, OrbitControllerActor, THREE } from "@vyr/three"
+import { HTMLConvert, NodeActor, OrbitControllerActor, THREE } from "@vyr/three"
 import { cache } from "../Cache"
 import { getControllerByService, getFlyInfo } from './flyto'
 
 let transformEvent = ''
-const getTransformEvent = () => {
+export const getTransformEvent = () => {
     if (transformEvent === '') {
         transformEvent = `TransformController/event/${Generate.uuid()}.ts`
     }
@@ -17,45 +17,38 @@ const getParent = (descriptor: Descriptor): Descriptor | boolean | null => {
     const ancestor = descriptor.traceAncestor(false)
     if (ancestor.parent === null) {
         return null
-    } else if (ancestor.parent instanceof HTMLDescriptor) {
+    } else if (isHTML(ancestor.parent)) {
         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) {
+    } else if (ancestor.parent instanceof HTMLConvert) {
         return null
-    } else if (ancestor.parent instanceof NodeDescriptor) {
+    } else if (ancestor.parent instanceof Node) {
         return ancestor.parent
     } else {
         return null
     }
 }
-const checkParentValidity = (html: HTMLDescriptor) => {
+export const checkParentValidity = (html: HTML) => {
     const parent = getParent(html)
     if (parent === null) {
         return false
-    } else if (parent instanceof HTMLDescriptor) {
+    } else if (isHTML(parent)) {
         return true
-    } else if (parent instanceof NodeDescriptor) {
+    } else if (parent instanceof Node) {
         return false
     } else {
         return true
     }
 }
 
-const getGraphics = (descriptor: Descriptor, process: RemoteProcess) => {
+export 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 scene = ancestor.collection[ancestor.collection.length - 1] as Scene
+    return scene instanceof Scene ? process.engine.getGraphics(scene) : null
 }
 
-const resize = (process: RemoteProcess) => {
+export const resize = (process: RemoteProcess) => {
     return () => {
-        const graphics = process.engine.getGraphics(process.scheduler)
+        const graphics = process.engine.getGraphics(process.scene)
         if (graphics == null) return
         const interpreter = graphics.getInterpreter(cache.camera)
         const actor = interpreter.getActor<NodeActor<THREE.PerspectiveCamera>>(cache.camera)
@@ -64,10 +57,10 @@ const resize = (process: RemoteProcess) => {
     }
 }
 
-const lookAt = (target: Descriptor, process: RemoteProcess) => {
+export const lookAt = (target: Descriptor, process: RemoteProcess) => {
     const controller = getControllerByService(target)
     if (controller === null) return
-    const graphics = process.engine.getGraphics(process.scheduler)
+    const graphics = process.engine.getGraphics(process.scene)
     const flyInfo = getFlyInfo(target, graphics)
     if (flyInfo === null) return
     if (!controller.orbit) return
@@ -80,12 +73,5 @@ const lookAt = (target: Descriptor, process: RemoteProcess) => {
     )
 }
 
-export {
-    getTransformEvent,
-    checkParentValidity,
-    getGraphics,
-    resize,
-    lookAt,
-}
 export * from './update'
 export * from './flyto'

package/src/utils/update.ts

@@ -1,9 +1,9 @@
-import { Asset, Descriptor, DeserializationObject, observer, ServiceDescriptor, ServiceSchedulerDescriptor } from "@vyr/engine"
-import { TextureDescriptor, TransformControllerDescriptor, ModelDescriptor, AnimationActionDescriptor, SceneServiceDescriptor, SceneServiceActor, THREE } from "@vyr/three"
+import { Asset, Descriptor, DeserializationObject, observer, Service, Scene } from "@vyr/engine"
+import { Texture, TransformController, Model, AnimationAction, Scene3DService, Scene3DServiceActor, THREE } from "@vyr/three"
 import { Job, RemoteProcess } from "@vyr/remote"
 import { cache } from "../Cache"
 
-const updateAnimationAction = async (uuid: string, url: string, process: RemoteProcess) => {
+export const updateAnimationAction = async (uuid: string, url: string, process: RemoteProcess) => {
     const animations: string[] = []
     if (url) {
         const currentUrl = `${url}?${uuid}`
@@ -17,10 +17,10 @@ const updateAnimationAction = async (uuid: string, url: string, process: RemoteP
     process.bridge.send(new Job.invoke.animation.Response({ type: 'action', uuid: uuid, animations }))
 }
 
-const updateSceneService = (target: SceneServiceDescriptor, deserialization: DeserializationObject<SceneServiceDescriptor>, process: RemoteProcess) => {
+export const updateSceneService = (target: Scene3DService, deserialization: DeserializationObject<Scene3DService>, process: RemoteProcess) => {
     if (target.shadowMapType === deserialization.shadowMapType) return
-    const graphics = process.engine.getGraphics(process.scheduler)
-    const actor = graphics.getActor<SceneServiceActor>(target)
+    const graphics = process.engine.getGraphics(process.scene)
+    const actor = graphics.getActor<Scene3DServiceActor>(target)
     if (actor === null) return
     actor.pipeline.resetState()
     actor.scene.traverse(sub => {
@@ -36,7 +36,7 @@ const updateSceneService = (target: SceneServiceDescriptor, deserialization: Des
     })
 }
 
-const updateModel = async (target: ModelDescriptor, deserialization: DeserializationObject<ModelDescriptor>, process: RemoteProcess) => {
+export const updateModel = async (target: Model, deserialization: DeserializationObject<Model>, process: RemoteProcess) => {
     if (target.url === deserialization.url) return
     updateAnimationAction(target.uuid, deserialization.url, process)
 
@@ -45,7 +45,7 @@ const updateModel = async (target: ModelDescriptor, deserialization: Deserializa
         await Asset.readly()
         process.engine.listen('afterRender', () => {
             for (const actionDescriptor of target.children) {
-                if (actionDescriptor instanceof AnimationActionDescriptor) {
+                if (actionDescriptor instanceof AnimationAction) {
                     actionDescriptor.setNeedsUpdate()
                 }
             }
@@ -53,17 +53,17 @@ const updateModel = async (target: ModelDescriptor, deserialization: Deserializa
     }
 }
 
-const updateModelByScheduler = (scheduler: ServiceSchedulerDescriptor, process: RemoteProcess) => {
-    scheduler.traverse(sub => {
-        if (sub instanceof ModelDescriptor) {
+export const updateModelByScene = (scene: Scene, process: RemoteProcess) => {
+    scene.traverse(sub => {
+        if (sub instanceof Model) {
             updateAnimationAction(sub.uuid, sub.url, process)
         }
     })
 }
 
-const updateTexture = (target: TextureDescriptor, deserialization: DeserializationObject<TextureDescriptor>, process: RemoteProcess) => {
+export const updateTexture = (target: Texture, deserialization: DeserializationObject<Texture>, process: RemoteProcess) => {
     if (target.url === deserialization.url) return
-    const graphics = process.engine.getGraphics(process.scheduler)
+    const graphics = process.engine.getGraphics(process.scene)
     const unit = graphics.getUnit(target.uuid)
     if (unit === null) return
     graphics.doFree(unit)
@@ -71,20 +71,18 @@ const updateTexture = (target: TextureDescriptor, deserialization: Deserializati
     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)
+export const updateOtherUpdateJob = (target: Descriptor, deserialization: DeserializationObject<Descriptor>, service: Service | null, process: RemoteProcess) => {
+    if (target instanceof Texture) {
+        updateTexture(target, deserialization as Texture, process)
+    } else if (target instanceof Model) {
+        updateModel(target, deserialization as Model, process)
+    } else if (target instanceof Scene3DService) {
+        updateSceneService(target, deserialization as Scene3DService, process)
     }
     if (service === null) return
-    const transform = cache.transformCollection.get<TransformControllerDescriptor>(service)
+    const transform = cache.transformCollection.get<TransformController>(service)
     if (transform === null) return
     if (transform.target === target.uuid) {
         process.engine.listen('afterRender', () => transform.setNeedsUpdate(), { once: true })
     }
-}
-
-export { updateModelByScheduler, updateOtherUpdateJob }
+}